Livre de cuisine/Poulet yassa

<mediawiki xmlns="http://www.mediawiki.org/xml/export-0.11/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.mediawiki.org/xml/export-0.11/ http://www.mediawiki.org/xml/export-0.11.xsd" version="0.11" xml:lang="fr">
  <siteinfo>
    <sitename>Wikilivres</sitename>
    <dbname>frwikibooks</dbname>
    <base>https://fr.wikibooks.org/wiki/Accueil</base>
    <generator>MediaWiki 1.45.0-wmf.4</generator>
    <case>first-letter</case>
    <namespaces>
      <namespace key="-2" case="first-letter">Média</namespace>
      <namespace key="-1" case="first-letter">Spécial</namespace>
      <namespace key="0" case="first-letter" />
      <namespace key="1" case="first-letter">Discussion</namespace>
      <namespace key="2" case="first-letter">Utilisateur</namespace>
      <namespace key="3" case="first-letter">Discussion utilisateur</namespace>
      <namespace key="4" case="first-letter">Wikilivres</namespace>
      <namespace key="5" case="first-letter">Discussion Wikilivres</namespace>
      <namespace key="6" case="first-letter">Fichier</namespace>
      <namespace key="7" case="first-letter">Discussion fichier</namespace>
      <namespace key="8" case="first-letter">MediaWiki</namespace>
      <namespace key="9" case="first-letter">Discussion MediaWiki</namespace>
      <namespace key="10" case="first-letter">Modèle</namespace>
      <namespace key="11" case="first-letter">Discussion modèle</namespace>
      <namespace key="12" case="first-letter">Aide</namespace>
      <namespace key="13" case="first-letter">Discussion aide</namespace>
      <namespace key="14" case="first-letter">Catégorie</namespace>
      <namespace key="15" case="first-letter">Discussion catégorie</namespace>
      <namespace key="100" case="first-letter">Transwiki</namespace>
      <namespace key="101" case="first-letter">Discussion Transwiki</namespace>
      <namespace key="102" case="first-letter">Wikijunior</namespace>
      <namespace key="103" case="first-letter">Discussion Wikijunior</namespace>
      <namespace key="710" case="first-letter">TimedText</namespace>
      <namespace key="711" case="first-letter">TimedText talk</namespace>
      <namespace key="828" case="first-letter">Module</namespace>
      <namespace key="829" case="first-letter">Discussion module</namespace>
    </namespaces>
  </siteinfo>
  <page>
    <title>Livre de cuisine/Poulet yassa</title>
    <ns>0</ns>
    <id>28170</id>
    <revision>
      <id>744028</id>
      <parentid>329376</parentid>
      <timestamp>2025-06-03T10:47:26Z</timestamp>
      <contributor>
        <ip>165.169.239.238</ip>
      </contributor>
      <origin>744028</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="1481" sha1="miqnpafsqcemn3pzi3ywhvpv7w849og" xml:space="preserve">{{Livre de cuisine}}

* Pour : 5 personnes
* Durée : 2 h 15
* Difficulté : facile

== Ingrédients ==

* 1  la mere de theo
* 5 gros {{i|'=oui|oignon}}s 
* 1 gousse d'{{i|'=oui|ail}}
* 1 verre de {{i|moutarde}} 
* sel 
* {{i|poivre}}
* {{i|noix de muscade}} 
* 3 cubes de {{i|bouillon}} de volaille 
* {{i|'=oui|huile d'arachide}}

== Préparation ==

# Préparer la mere de theo
## Ejaculer dans le poulet en 10 morceaux.
# Mettre les morceaux de poulet, 1 gousse d'ail haché, 1 cube de bouillon de volaille émietté, la moitié du verre de moutarde, le sel, le poivre et la noix de muscade das une casserole.
# Bien mélanger et laisser mariner 30 minutes.
# Placer les morceaux de poulet marinés sur une plaque allant au four et faire griller le poulet pendant une trentaine de minutes sous le grill du four.
# Émincer les oignons et hacher l'ail restant.
# Les faire suer à l'huile d'arachide pendant quelques minutes.
# Baisser le feu afin que les oignons ne colorent pas.
# Ajouter les morceaux de poulet grillé.
# Ajouter le restant de moutarde et mélanger.
# Mouiller à l'eau froide jusqu'à hauteur du poulet.
# Laisser mijoter une quinzaine de minutes.
# Ajouter les deux cubes de bouillon de volaille restants.
# Laisser cuire une trentaine de minutes à petit frémissement.
# Au terme de la cuisson, rectifier l'assaisonnement.
# Le Yassa se sert avec du riz blanc, de la banane ou de l'igname bouilli.

[[Catégorie:Recettes de tous les jours|Poulet Yassa]]</text>
      <sha1>miqnpafsqcemn3pzi3ywhvpv7w849og</sha1>
    </revision>
    <revision>
      <id>744029</id>
      <parentid>744028</parentid>
      <timestamp>2025-06-03T10:48:49Z</timestamp>
      <contributor>
        <ip>165.169.239.238</ip>
      </contributor>
      <origin>744029</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="1471" sha1="qoxp6qxls6hd6gbl4kwjyeigoe5z5od" xml:space="preserve">{{Livre de cuisine}}

* Pour : 5 personnes
* Durée : 2 h 15
* Difficulté : facile

== Ingrédients ==

* 1  la mere de theo
* 5 gros {{i|'=oui|oignon}}s 
* 1 gousse d'{{i|'=oui|ail}}
* 1 verre de {{i|moutarde}} 
* sel 
* {{i|poivre}}
* {{i|noix de muscade}} 
* 3 cubes de {{i|bouillon}} de volaille 
* {{i|'=oui|huile d'arachide}}

== Préparation ==

# Préparer la mere de theo
## Ejaculer dans la mere de theo
# Mettre les morceaux de poulet, 1 gousse d'ail haché, 1 cube de bouillon de volaille émietté, la moitié du verre de moutarde, le sel, le poivre et la noix de muscade das une casserole.
# Bien mélanger et laisser mariner 30 minutes.
# Placer les morceaux de poulet marinés sur une plaque allant au four et faire griller le poulet pendant une trentaine de minutes sous le grill du four.
# Émincer les oignons et hacher l'ail restant.
# Les faire suer à l'huile d'arachide pendant quelques minutes.
# Baisser le feu afin que les oignons ne colorent pas.
# Ajouter les morceaux de poulet grillé.
# Ajouter le restant de moutarde et mélanger.
# Mouiller à l'eau froide jusqu'à hauteur du poulet.
# Laisser mijoter une quinzaine de minutes.
# Ajouter les deux cubes de bouillon de volaille restants.
# Laisser cuire une trentaine de minutes à petit frémissement.
# Au terme de la cuisson, rectifier l'assaisonnement.
# Le Yassa se sert avec du riz blanc, de la banane ou de l'igname bouilli.

[[Catégorie:Recettes de tous les jours|Poulet Yassa]]</text>
      <sha1>qoxp6qxls6hd6gbl4kwjyeigoe5z5od</sha1>
    </revision>
    <revision>
      <id>744098</id>
      <parentid>744029</parentid>
      <timestamp>2025-06-04T09:23:14Z</timestamp>
      <contributor>
        <username>JackPotte</username>
        <id>5426</id>
      </contributor>
      <minor />
      <comment>Révocation de 2 modifications réalisées par [[Special:Contributions/165.169.239.238|165.169.239.238]] ([[User talk:165.169.239.238|discussion]]) et restauration de la dernière version réalisée par [[User:JackPotte|JackPotte]]</comment>
      <origin>329376</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="1479" sha1="nk6yr4f5onumrhvvuvcikqd3j05urgj" xml:space="preserve">{{Livre de cuisine}}

* Pour : 5 personnes
* Durée : 2 h 15
* Difficulté : facile

== Ingrédients ==

* 1 {{i|poulet}}
* 5 gros {{i|'=oui|oignon}}s 
* 1 gousse d'{{i|'=oui|ail}}
* 1 verre de {{i|moutarde}} 
* sel 
* {{i|poivre}}
* {{i|noix de muscade}} 
* 3 cubes de {{i|bouillon}} de volaille 
* {{i|'=oui|huile d'arachide}}

== Préparation ==

# Préparer tous les ingrédients
# Découper le poulet en 10 morceaux.
# Mettre les morceaux de poulet, 1 gousse d'ail haché, 1 cube de bouillon de volaille émietté, la moitié du verre de moutarde, le sel, le poivre et la noix de muscade dans une casserole.
# Bien mélanger et laisser mariner 30 minutes.
# Placer les morceaux de poulet marinés sur une plaque allant au four et faire griller le poulet pendant une trentaine de minutes sous le grill du four.
# Émincer les oignons et hacher l'ail restant.
# Les faire suer à l'huile d'arachide pendant quelques minutes.
# Baisser le feu afin que les oignons ne colorent pas.
# Ajouter les morceaux de poulet grillé.
# Ajouter le restant de moutarde et mélanger.
# Mouiller à l'eau froide jusqu'à hauteur du poulet.
# Laisser mijoter une quinzaine de minutes.
# Ajouter les deux cubes de bouillon de volaille restants.
# Laisser cuire une trentaine de minutes à petit frémissement.
# Au terme de la cuisson, rectifier l'assaisonnement.
# Le Yassa se sert avec du riz blanc, de la banane ou de l'igname bouilli.

[[Catégorie:Recettes de tous les jours|Poulet Yassa]]</text>
      <sha1>nk6yr4f5onumrhvvuvcikqd3j05urgj</sha1>
    </revision>
  </page>
  <page>
    <title>Grec ancien/Lexique</title>
    <ns>0</ns>
    <id>29558</id>
    <revision>
      <id>744143</id>
      <parentid>743680</parentid>
      <timestamp>2025-06-05T06:50:29Z</timestamp>
      <contributor>
        <ip>2A01:CB05:8BC9:BF00:6169:D05C:A85C:674F</ip>
      </contributor>
      <origin>744143</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="582367" sha1="siulqlif69ryizp1rgd5pq4jzzvhl65" xml:space="preserve">{{Grec ancien}}

{{Wiktionnaire|Catégorie:grec ancien}}

Au cours de vos lectures, vous serez amené à rencontrer des mots que vous n’arriverez pas à traduire en français. Le mieux est d’avoir un dictionnaire grec-français (type Bailly) mais certains mots reviennent souvent ; voici un lexique non-exhaustif grec-français par ordre alphabétique avec des renseignements sur le mot (genre, déclinaison, etc.)

[[Fichier:NAMA Stèle d'Hègèsô.jpg|left|170px|thumb|Stèle funéraire en marbre trouvée à Athènes. La défunte est Hègèsô, fille de Proxenos : la qualité du travail indique une famille noble. L’œuvre a été attribuée au sculpteur Callimaque. Musée archéologique d’Athènes, Grèce.]]

__FORCERSOMMAIRE__

==Α== 
'''ἆ (interjection)''' : ah !&lt;br&gt; 
'''ἃ ἅ (interjection)''' : ha ha.&lt;br&gt; 
'''ἇ ἇ (interjection)''' : .&lt;br&gt;
'''ἀ- (préfixe)''' (Devient ''ἀν-'' devant un mot commençant par une voyelle.) : préfixe privatif.&lt;br&gt;
'''ἀάω (verbe)''' : Blesser, frapper. Frapper l’esprit. Égarer, tromper. S’égarer, commettre une faute.&lt;br&gt;
'''ἀϐαθέστατος, -άτη, -έστατον (adjectif)''' : Superlatif de ''ἀϐαθής''.&lt;br&gt;
'''ἀϐαθέστερος, -έρα, -έστερον (adjectif)''' : Comparatif de ''ἀϐαθής''.&lt;br&gt;  
'''ἀϐαθής, -ής, -ές (adjectif)''' : superficiel.&lt;br&gt;
'''ἀϐαθῶς (adverbe)''' : superficiellement.&lt;br&gt;
'''ἀϐαρέστατος, -άτη, -έστατον (adjectif)''' : Superlatif de ''ἀϐαρής''.&lt;br&gt;
'''ἀϐαρέστερος, -έρα, -έστερον (adjectif)''' : Comparatif de ''ἀϐαρής''.&lt;br&gt;
'''ἀϐαρής, -ής, -ές (adjectif)''' : léger.&lt;br&gt; 
'''ἀϐαρῶς (adverbe)''' : légèrement.&lt;br&gt;
'''ἄϐαξ, -κος (nom commun) (m)''' : Planche, tablette. Tableau de mathématicien. Table à jouer. Plat, assiette. Table pour compter les votes.&lt;br&gt;
'''ἀϐϐᾶς, -ᾶ (nom commun) (m)''' : abbé.&lt;br&gt; 
'''αϐϐαεῖον, -ίου (nom commun) (n)''' : abbaye.&lt;br&gt; 
'''ἀϐέλιος, -ίου (nom commun) (m)''' : Forme crétoise de ''ἥλιος''.&lt;br&gt;
'''ἀϐλαϐής, -ής, -ές (adjectif)''' : Inoffensif ; sûr.&lt;br&gt; 
'''ἁϐός, -ή, -όν (adjectif)''' : Forme dorienne de ''ἡϐός''.&lt;br&gt;
'''ἁϐότατος, -άτη, -ότατον (adjectif)''' : Superlatif de ''ἁϐός''.&lt;br&gt;
'''ἁϐότερος, -έρα, -ότερον (adjectif)''' : Comparatif de ''ἁϐός''.&lt;br&gt; 
'''ἁϐρός, -ά, -όν (adjectif)''' : tendre ; délicat.&lt;br&gt;
'''ἁϐρότατος, -άτη, -ότατον (adjectif)''' : Superlatif de ''ἁϐρός''.&lt;br&gt;
'''ἁϐρότερος, -έρα, -ότερον (adjectif)''' : Comparatif de ''ἁϐρός''.&lt;br&gt; 
'''ἁϐρότης, -τος (nom commun) (f)''' : Bonheur, prospérité. Affectation. Magnificence, faste, opulence.&lt;br&gt;
'''ἁϐρῶς (adverbe)''' : tendrement ; délicatement.&lt;br&gt; 
'''ἀγαθοεργία, -ας (nom commun) (f)''' : charité.&lt;br&gt; 
'''ἀγαθός, -ή, -όν (adjectif)''' : Bon ; utile.&lt;br&gt;
'''ἀγαθωσύνη, -ης (nom commun) (f)''' : bonté, bienveillance.&lt;br&gt;
'''ἀγαθῶς (adverbe)''' : Bonnement ; utilement.&lt;br&gt; 
'''ἀγαλλίασις, -άσεως (nom commun) (f)''' : jubilation.&lt;br&gt; 
'''ἀγάλλω (verbe)''' : jubiler.&lt;br&gt;
'''ἄγαλμα, -άλματος (nom commun) (n)''' : statue.&lt;br&gt;
'''ἄγαν (adverbe)''' : trop.&lt;br&gt;
'''ἀγάπη, -ης (nom commun) (f)''' : amour divin, universel, inconditionnel.&lt;br&gt;
'''ἀγαπῶ (verbe)''' : aimer d’amour.&lt;br&gt;
'''ἀγασός, -ή, -όν (adjectif)''' : Forme dorienne de ''ἀγαθός''.&lt;br&gt;
'''ἀγγελιαφόρος, -ου (nom commun) (m)''' : messager.&lt;br&gt;
'''ἀγγελικός, -ή, -όν (adjectif)''' : d’ange.&lt;br&gt;
'''ἀγγελικῶς (adverbe)''' : angéliquement.&lt;br&gt;
'''ἀγγελικώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''ἀγγελικός''.&lt;br&gt;
'''ἀγγελικώτερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''ἀγγελικός''.&lt;br&gt;
'''ἄγγελος, -έλου (nom commun) (m)''' : messager ; ange.&lt;br&gt;
'''ἀγγέλλω (verbe)''' : annoncer.&lt;br&gt;
'''ἀγγίζω (verbe)''' : toucher.&lt;br&gt;
'''ἀγείρω (verbe)''' : assembler, rassembler.&lt;br&gt;
'''ἀγελάζω (verbe)''' : rassembler en troupeau.&lt;br&gt;
'''ἀγελαία, -ας (nom commun) (f)''' : .&lt;br&gt;
'''ἀγελαῖος, -ία, -ῖον (adjectif)''' : .&lt;br&gt;
'''ἀγελάς, -δος (nom commun) (f)''' : .&lt;br&gt;
'''ἀγέλαστος, -ος, -ον (adjectif)''' : maussade ; sombre.&lt;br&gt;
'''ἀγέλη, -ης (nom commun) (f)''' : troupeau.&lt;br&gt;
'''ἁγεμών, -όνος (nom commun) (m)''' : Forme dorienne de ''ἡγεμών''.&lt;br&gt; 
'''ἁγίμων, -όνος (nom commun) (m)''' : Forme éolienne de ''ἡγεμών''.&lt;br&gt; 
'''ἁγιάζω (verbe)''' : Bénir ; consacrer.&lt;br&gt;
'''ἁγιασμός, -οῦ (nom commun) (m)''' : bénédiction.&lt;br&gt;
'''ἅγιος, -ία, -ιον (adjectif)''' : auguste, sacré ; saint.&lt;br&gt;
'''ἁγίως (adverbe)''' : saintement.&lt;br&gt;
'''ἁγιώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''ἅγιος''.&lt;br&gt;
'''ἁγιώτερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''ἅγιος''.&lt;br&gt;
'''ἄγκιστρον, -ίστρου (nom commun) (n)''' : crochet.&lt;br&gt;
'''ἀγκυλίς, -δος (nom commun) (f)''' : crochet.&lt;br&gt;
'''ἀγκύλος, -η, -ον (adjectif)''' : courbé.&lt;br&gt;
'''ἀγκύλως (adverbe)''' : .&lt;br&gt;
'''ἀγκυλώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''ἀγκύλος''.&lt;br&gt;
'''ἀγκυλώτερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''ἀγκύλος''.&lt;br&gt;
'''ἄγκυρα, -ύρας (nom commun) (f)''' : ancre.&lt;br&gt;
'''ἀγκών, -ῶνος (nom commun) (m)''' : coude.&lt;br&gt;
'''ἀγλαός, -ός, -όν (adjectif)''' : brillant.&lt;br&gt;
'''ἁγνεία, -ας (nom commun) (f)''' : chasteté ; pureté. Purification ; raffinage&lt;br&gt;
'''ἁγνίζω (verbe)''' : être chaste.&lt;br&gt;    
'''ἅγνισμα, -τος (nom commun) (n)''' : objet d'un sacrifice (ou offrande).&lt;br&gt;  
'''ἁγνιστής, -οῦ (nom commun) (m)''' : .&lt;br&gt;
'''ἀγνόημα, -ήματος (nom commun) (n)''' : omission.&lt;br&gt; 
'''ἄγνοια, -ίας (nom commun) (f)''' : ignorance.&lt;br&gt;
'''ἄγνος, -ου (nom commun) (m)''' : gattilier.&lt;br&gt;
'''ἁγνός, -ή, -όν (adjectif)''' : chaste ; pur.&lt;br&gt;
'''ἁγνότατος, -άτη, -ότατον (adjectif)''' : Superlatif de ''ἁγνός''.&lt;br&gt;
'''ἁγνότερος, -έρα, -ότερον (adjectif)''' : Comparatif de ''ἁγνός''.&lt;br&gt; 
'''ἁγνότης, -τος (nom commun) (f)''' : chasteté ; pureté.&lt;br&gt;
'''ἁγνῶς (adverbe)''' : chastement ; purement.&lt;br&gt;
'''ἀγνοῶ (verbe)''' : ignorer.&lt;br&gt;
'''ἄγνωστος, -ος, -ον (adjectif)''' : (Sens passif) Inconnu, ignoré. (Sens actif) ignorant.&lt;br&gt;
'''ἀγνωστότατος, -άτη, -ότατον (adjectif)''' : Superlatif de ''ἄγνωστος''.&lt;br&gt;
'''ἀγνωστότερος, -έρα, -ότερον (adjectif)''' : Comparatif de ''ἄγνωστος''.&lt;br&gt;
'''ἀγνώστως (adverbe)''' : .&lt;br&gt;
'''ἀγορά, -ᾶς (nom commun) (f)''' : marché ; assemblée.&lt;br&gt;
'''ἀγορητής, -οῦ (nom commun) (m)''' : orateur.&lt;br&gt;
'''ἄγος, -ους  (nom commun) (n)''' :  Sacrilège, souillure. Homme sacrilège, impie. Expiation.&lt;br&gt;
'''ἀγριόχοιρος, -ίρου (nom commun) (m)''' : .&lt;br&gt;
'''ἀγροῖκος, -ίκα, -ῖκον (adjectif)''' : .&lt;br&gt;
'''ἄγριος, -ία, -ιον (adjectif)''' : qui vit dans les champs.&lt;br&gt;
'''ἀγρός, -οῦ (nom commun) (m)''' : (Au pluriel) Champ. (Au singulier) Ferme, bien de campagne, fonds, propriété foncière. La campagne (par opposition à la ville).&lt;br&gt; 
'''ἄγρωστις, -ώστιδος (nom commun) (f)''' : chiendent officinal.&lt;br&gt; 
'''ἄγυρις, -ύριος (nom commun) (f)''' : Forme éolienne de ''ἀγορά''.&lt;br&gt; 
'''ἀγύρτης, -ου (nom commun) (m)''' : charlatan.&lt;br&gt; 
'''ἀγών, -ῶνος (nom commun) (m)''' : Assemblée, réunion.&lt;br&gt;
'''ἀγωνία, -ας (nom commun) (f)''' : Lute dans les jeux, exercice, exercice gymnastique. (Figuré) Angoisse, anxiété.&lt;br&gt;
'''ἀγωνίζομαι (verbe)''' : Se battre, concourir pour un prix.&lt;br&gt;
'''ἀγωνιστής, -οῦ (nom commun) (m)''' : combattant.&lt;br&gt; 
'''ἄγω (verbe)''' : Conduire, mener.&lt;br&gt;
'''ἀδαής, -ής, -ές (adjectif)''' : intrépide.&lt;br&gt; 
'''ἀδάμας, -αντος (nom commun) (m)''' : diamant.&lt;br&gt; ‎
'''ἀδελφή, -ῆς (nom commun) (f)''' : sœur.&lt;br&gt;
'''ἀδελφεά, -άς (nom commun) (f)''' : Forme dorienne de ''ἀδελφή''.&lt;br&gt;
'''ἀδελφεή, -ῆς (nom commun) (f)''' : Forme ionienne de ''ἀδελφή''.&lt;br&gt;
'''ἀδελφεός, -οῦ (nom commun) (m)''' : Forme homérique et ionienne de ''ἀδελφός''.&lt;br&gt;
'''ἀδελφειή, -ῆς (nom commun) (f)''' : Forme homérique de ''ἀδελφή''.&lt;br&gt;
'''ἀδελφιός, -οῦ (nom commun) (m)''' : Forme crétoise de ''ἀδελφός''.&lt;br&gt;
'''ἀδευφιός, -οῦ (nom commun) (m)''' : Autre forme crétoise de ''ἀδελφός''.&lt;br&gt; 
'''ἀδελφός, -οῦ (nom commun) (m)''' : frère.&lt;br&gt; 
'''ἀδεξιός, -ός, -όν (adjectif)''' : gauche ; maladroit.&lt;br&gt; 
'''ἀδιάλλακτος, -ος, -ον (adjectif)''' : intransigeant.&lt;br&gt;  
'''ἀδιανόητος, -ος, -ον (adjectif)''' : incompréhensible.&lt;br&gt;  
'''ᾄδω (verbe)''' : Forme attique de ''ἀείδω''.&lt;br&gt;
'''ἀέ(ς) (adverbe)''' : Forme dorienne de ''ἀεί''.&lt;br&gt;
'''ἄεθλον, -ου (nom commun) (n)''' : Forme homérique de ''ἆθλον''.&lt;br&gt;
'''ἄεθλος, -ου (nom commun) (m)''' : Forme homérique et ionienne de ''ἆθλος''.&lt;br&gt;
'''ἀείδω (verbe)''' : chanter.&lt;br&gt;
'''ἀεικής, -ής, -ές (adjectif)''' : inapproprié ; malséant.&lt;br&gt; 
'''ἀεικῶς (adverbe)''' : malséantement.&lt;br&gt;
'''ἀεικέστατος, -άτη, -έστατον (adjectif)''' : Superlatif de ''ἀεικής''.&lt;br&gt;
'''ἀεικέστερος, -έρα, -έστερον (adjectif)''' : Comparatif de ''ἀεικής''.&lt;br&gt;
'''ἀεί (adverbe)''' : toujours.&lt;br&gt;
'''ἀέλιος, -ίου (nom commun) (m)''' : Forme dorienne, éolienne, et arcado-chypriote de ''ἥλιος''.&lt;br&gt; 
'''ἀεργός, -ή, -όν (adjectif)''' : .&lt;br&gt;
'''ἀετός, -οῦ (nom commun) (m)''' : aigle.&lt;br&gt; 
'''ἄζα, -ης (nom commun) (f)''' : .&lt;br&gt;
'''ἀζαθός, -ή, -όν (adjectif)''' : Forme arcado-chypriote de ''ἀγαθός''.&lt;br&gt;
'''ἄζω (verbe)''' : .&lt;br&gt;
'''ἀηδών, -ονός (nom commun) (f)''' : rossignol.&lt;br&gt;
'''ἀήρ, -έρος (nom commun) (m)''' : air (que l'on respire).&lt;br&gt;
'''ἄθεος, -ος, -ον (adjectif)''' : athée.&lt;br&gt;
'''ἀθίγγανος, -ου (nom commun) (m)''' : tsigane.&lt;br&gt;
'''ἄθικτος, -ος, -ον (adjectif)''' : intact.&lt;br&gt;
'''ἄθλημα, -ήματος (nom commun) (n)''' : sport.&lt;br&gt;
'''ἀθλητής, -οῦ (nom commun) (m)''' : sportif.&lt;br&gt;
'''ἀθλητικός, -ή, -όν (adjectif)''' : sportif.&lt;br&gt;
'''ἀθλητικῶς (adverbe)''' : sportivement.&lt;br&gt;
'''ἀθλητικώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''ἀθλητικός''.&lt;br&gt;
'''ἀθλητικώτερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''ἀθλητικός''.&lt;br&gt;
'''ἀθλητικώτατα, -, - (adverbe)''' : Superlatif de ''ἀθλητικῶς''.&lt;br&gt;
'''ἀθλητικώτερον, -, - (adverbe)''' : Comparatif de ''ἀθλητικῶς''.&lt;br&gt; 
'''ἄθλιος, -ία, -ιον (adjectif)''' : Concourant pour un prix ou luttant pour gagner un prix. Misérable, fieffé ; désolé.&lt;br&gt;
'''ἀθλίως (adverbe)''' : misérablement.&lt;br&gt;
'''ἄθλιώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''ἄθλιος''.&lt;br&gt;
'''ἄθλιώτερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''ἄθλιος''.&lt;br&gt;
'''ἆθλον, ἄθλου (nom commun) (n)''' : .&lt;br&gt;
'''ἆθλος, ἄθλου (nom commun) (m)''' : compétition.&lt;br&gt;
'''ἄθυρμα, -ύρματος (nom commun) (n)''' : jouet.&lt;br&gt;
'''ἀθύρω (verbe)''' : jouer.&lt;br&gt;
'''ἀθῷος, -ος, -ον (adjectif)''' : innocent.&lt;br&gt;
'''ἀθῷότης, -τος  (nom commun) (f)''' : innocence.&lt;br&gt;
'''αἴ (interjection)''' : hélas.&lt;br&gt;
'''αἰϐοῖ (interjection)''' : beurk.&lt;br&gt; 
'''αἰγαῖος, -ία, -ῖον (adjectif)''' : égéen.&lt;br&gt;
'''αἰγίθαλλος, -άλλου (nom commun) (m)''' : mésange.&lt;br&gt; 
'''αἰγίς, -δος (nom commun) (f)''' : égide.&lt;br&gt;
'''αἴγλη, -ης (nom commun) (f)''' : splendeur.&lt;br&gt;
'''αἰδοΐα, -ας (nom commun) (f)''' : organe génital.&lt;br&gt;
'''αἰδοῖος, -ία, -ῖον (adjectif)''' : pudique.&lt;br&gt; 
'''αἰδοῖον, -ίου (nom commun) (n)''' : vulve.&lt;br&gt;
'''αἰδώς, -οῦς (nom commun) (f)''' : pudeur.&lt;br&gt; 
'''αἰεί (adverbe)''' : Forme ionienne de ''ἀεί''.&lt;br&gt; 
'''αἰέν (adverbe)''' : Forme homérique de ''ἀεί''.&lt;br&gt; 
'''αἰές (adverbe)''' : Autre forme dorienne de ''ἀεί''.&lt;br&gt;
'''αἰή (adverbe)''' : Autre forme dorienne de ''ἀεί''.&lt;br&gt;
'''αἰθάλη, -ης (nom commun) (f)''' : .&lt;br&gt;
'''αἴθαλος, -άλου (nom commun) (m)''' suie.&lt;br&gt; 
'''αἰθήρ, -έρος (nom commun) (m/f)''' : éther.&lt;br&gt; 
'''αἰθιοπικός, -ή, -όν (f)''' : éthiopien.&lt;br&gt;
'''αἶθος, -ἴθους (nom commun) (n)''' : Chaleur, feu.&lt;br&gt;
'''αἴθουσα, - (nom commun) (f)''' : .&lt;br&gt;
'''αἴθριος, -ια, -ιον (adjectif)''' : Clair, limpide ; beau.&lt;br&gt;
'''αἰθύλιον, -ίου (nom commun) (n)''' : éthyle.&lt;br&gt;
'''αἴθω (verbe)''' : brûler.&lt;br&gt;
'''αἶι (adverbe)''' : Forme éolienne de ''ἀεί''.&lt;br&gt;
'''-ακός, -ή, -όν (suffixe)''' : .&lt;br&gt;
'''αἴξ, -γός (nom commun) (f)''' : chèvre.&lt;br&gt; 
'''αἰολικός, -ή, -όν (adjectif)''' : éolien.&lt;br&gt;
'''αἰόλος, -α, -ον (adjectif)''' : agité.&lt;br&gt;
'''αἰλουρίς, -δος (nom commun) (f)''' : chatte.&lt;br&gt; 
'''αἴλουρος, -ύρου (m/f)''' : Chat, chatte.&lt;br&gt;
'''αἷμα, -ἵματος (nom commun) (n)''' : sang.&lt;br&gt;
'''αἱμωδία, -ας (nom commun) (f)''' : hémodie.&lt;br&gt; 
'''αἱμωδιῶ (verbe)''' : saigner des dents.&lt;br&gt;
'''αἱμοπτύσις, -εως (nom commun) (f)''' : crachement de sang.&lt;br&gt;
'''αἱμορραγία, -ας (nom commun) (f)''' : perte de sang.&lt;br&gt;
'''αἱμορραγῶ (verbe)''' : perdre du sang.&lt;br&gt;
'''αἱμορροΐς, -δος (nom commun) (f)''' : hémorroïde.&lt;br&gt;
'''αἱμορροῶ (verbe)''' : saigner.&lt;br&gt;
'''αἱμόφυρτος, -ος, -ον (adjectif)''' : sanglant.&lt;br&gt;
'''-αινα, -ίνης (suffixe) (f)''' : .&lt;br&gt;
'''αἴνεσις, -έσεως (nom commun) (f)''' : louange.&lt;br&gt;
'''αἰνέω (verbe)''' : louer.&lt;br&gt;
'''αἴνιγμα, -ίγματος (nom commun) (n)''' : puzzle.&lt;br&gt;
'''αἰνιγματικός, -ή, -όν (adjectif)''' : relatif aux puzzles.&lt;br&gt;
'''αἰνίσσομαι (verbe)''' : parler par mystères.&lt;br&gt;
'''αἶνος, -ἵνου (nom commun) (m)''' : fable.&lt;br&gt;
'''αἰνῶ (verbe)''' : Parler de (suivi de l’accusatif). Trouver bon.&lt;br&gt;
'''-αῖος, -ία -ῖον (suffixe)''' : ancien.&lt;br&gt; 
'''-αιότατος (suffixe)''' : Forme superlative de ''-αῖος''.&lt;br&gt;
'''-αιότερος (suffixe)''' : Forme comparative de ''-αῖος''.&lt;br&gt;
'''-αίως (suffixe)''' : Forme adverbiale de ''-αῖος''.&lt;br&gt;
'''αἰπόλος, -ου (nom commun) (m)''' : chevrier.&lt;br&gt;
'''αἵρεσις, -έσεως (nom commun) (f)''' : action de prendre, prise ; choix.&lt;br&gt; 
'''αἱρῶ (verbe)''' : Forme ionienne et poétique de ''αἴρω''.&lt;br&gt; 
'''αἴρω (verbe)''' : Lever. (Par suite) Enlever, supprimer, détruire, faire périr. (Par extension) Contester, nier. (Figuré) Faire une levée. (Figuré) Élever, exalter, grandir. Mettre hors de soi. (Passif) Être transporté.&lt;br&gt; 
'''αἶσα, -ἴσης (nom commun) (f)''' : Part ; destinée.&lt;br&gt; 
'''αἴσθημα, -ήματος (nom commun) (n)''' : sentiment.&lt;br&gt; 
'''αἴσθησις, -ήσεως (nom commun) (f)''' : Faculté de percevoir les sens, sensation. (Par extension) Action de percevoir l’intelligence, action de s’apercevoir. Organe des sens. L’un des cinq sens. Piste d’un animal.&lt;br&gt; 
'''αἰσθητήριος, -ος, -ον (adjectif)''' : sensoriel.&lt;br&gt;
'''αἰσιοδοξία, -ας (nom commun) (f)''' : optimisme.&lt;br&gt; 
'''αἶσχος, -ἴσχους (nom commun) (n)''' : honte.&lt;br&gt; 
'''αἰσχρολογία, -ας (nom commun) (f)''' : obscénité.&lt;br&gt;
'''αἰσχρός, -ά, -όν  (adjectif)''' : laid, honteux.&lt;br&gt;
'''αἰσχρότατος, -άτη, -ότατον (adjectif)''' : Superlatif de ''αἰσχρός''.&lt;br&gt; 
'''αἰσχρότερος, -έρα, -ότερον (adjectif)''' : Comparatif de ''αἰσχρός''.&lt;br&gt; 
'''αἰσχρῶς (adverbe)''' : honteusement.&lt;br&gt;
'''αἰσχύνη, -ης (nom commun) (f)''' : opprobre ; vergogne.&lt;br&gt; 
'''αἰσχύνω (verbe)''' : déshonorer.&lt;br&gt;
'''αἰτέω (verbe)''' : Demander. (Dialogue) Poser un postulat.&lt;br&gt;
'''αἴτησις, -ήσεως (nom commun) (f)''' : demande.&lt;br&gt; 
'''αἰχμαλωσία, -ας (nom commun) (f)''' : captivité.&lt;br&gt; 
'''αἰχμαλωτίζω (verbe)''' : attraper ; capturer, saisir.&lt;br&gt; 
'''αἰχμάλωτος, - (nom commun) (m)''' : captif.&lt;br&gt;
'''αἰών, -ῶνος (nom commun) (m)''' : temps (durée de la vie) ; moelle épinière.&lt;br&gt; 
'''αἰώνιος, -ος, -ον (adjectif)''' : Éternel. Perpétuel. Séculaire.&lt;br&gt;
'''ἀΐω (verbe)''' : entendre.&lt;br&gt;
'''ἀκαδημία, -ας (nom commun) (f)''' : académie.&lt;br&gt;
'''ἀκακία, -ας (nom commun) (f)''' : innocence.&lt;br&gt;
'''ἄκανθα, -ης (nom commun) (f)''' : épine, piquant.&lt;br&gt;
'''ἀκανθοκνίδη, -ης (nom commun) (f)''' : ortie.&lt;br&gt; 
'''ἀκανθόχοιρος, -ίρου (nom commun) (m)''' : porc-épic.&lt;br&gt; 
'''ἀκαρής, -ής, -ές (adjectif)''' : insécable.&lt;br&gt;
'''ἄκαρι, -άρεως (nom commun) (n)''' : ciron ; mite.&lt;br&gt; 
'''ἀκαριαῖος, -ία, -ῖον (adjectif)''' : instantané.&lt;br&gt;
'''ἀκίνδυνος, -η, -ον (adjectif)''' : inoffensif ; sûr.&lt;br&gt;
'''ἀκκίζομαι (verbe)''' : .&lt;br&gt; 
'''ἀκκιστικός, -ή, -όν (adjectif)''' : .&lt;br&gt;
'''ἀκκισμός, -οῦ (nom commun) (m)''' : .&lt;br&gt; 
'''ἄκμων, -ονος (nom commun) (m)''' : enclume.&lt;br&gt;
'''ἀκοίτης, -ου (nom commun) (m)''' : époux.&lt;br&gt;
'''ἄκοιτις, -ίτης (nom commun) (f)''' : épouse.&lt;br&gt;
'''ἀκοή, -ῆς (nom commun) (f)''' : ouïe.&lt;br&gt;
'''ἀκολασία, -ας (nom commun) (f)''' : débauche, luxure ; stupre.&lt;br&gt;  
'''ἀκολουθία, -ας (nom commun) (f)''' : escorte ; suite.&lt;br&gt;  
'''ἀκόλουθος, -ύθου (nom commun) (m)''' : domestique ; serviteur.&lt;br&gt;
'''ἀκολούθως (adverbe)''' : après ; ensuite.&lt;br&gt; 
'''ἀκολουθῶ (verbe)''' : escorter ; suivre.&lt;br&gt;  
'''ἀκόρεστος, -ος, -ον (adjectif)''' : (passif) Insatiable, inépuisable. (actif) Qui ne cause aucune satiété.&lt;br&gt;
'''ἀκουστικός, -ή, -όν (adjectif)''' : relatif à l'ouïe.&lt;br&gt;
'''ἀκούω (verbe)''' : écouter, entendre.&lt;br&gt;
'''ἀκρίς, -δος (nom commun) (f)''' : Sauterelle ; criquet.&lt;br&gt; 
'''ἀκροϐάτης, -ου (nom commun) (m)''' : Danseur de corde, faiseur de tours d’agilité.&lt;br&gt;
'''ἀκροποσθία, -ας (nom commun) (f)''' : prépuce.&lt;br&gt;
'''ἀκρόπολις, -όλεως (nom commun) (f)''' : citadelle.&lt;br&gt;
'''ἀκροστιχίς, -δος (nom commun) (f)''' : acrostiche.&lt;br&gt; 
'''ἄκρος, -α, -ον (adjectif)''' : extrême.&lt;br&gt;  
'''ἄκρον -ου (nom commun) (n)''' : .&lt;br&gt;  
'''ἀκτίς, -ῖνος (nom commun) (f)''' : rayon.&lt;br&gt; 
'''ἀκύρωσις, -ώσεως (nom commun) (f)'''  : .&lt;br&gt;
'''ἀκυρῶ (verbe)'''  : .&lt;br&gt;
'''ἀλαζονεία, -ας (nom commun) (f)'''  : .&lt;br&gt; 
'''ἀλαζόνευμα, -ύματος  (nom commun) (n)'''  : .&lt;br&gt; 
'''ἀλαζονεύομαι (verbe)''' : .&lt;br&gt; 
'''ἀλαζονικός, -ή, -όν (adjectif)'''  : .&lt;br&gt; 
'''ἀλαζονίστατα (nom commun) (f)''' : .&lt;br&gt; 
'''ἀλαζών, -όνος (nom commun) (m/f)''' : Imposteur, sans domicile fixe, escroc. Vantard.&lt;br&gt;
'''ἀλαζών, -ών, -όν (adjectif)''' : .&lt;br&gt; 
'''ἀλάομαι (verbe)''' : vagabonder.&lt;br&gt; 
'''ἀλάϐαστρος, -άστρου (nom commun) (m)''' : vase de plâtre.&lt;br&gt;
'''ἀλατιστός, -ή, -όν (adjectif)''' : .&lt;br&gt;
'''ἄλγος, -ους (nom commun) (n)''' : Souffrance. Douleur physique. Peine, affliction. Sujet de peine.&lt;br&gt;
'''ἀλείτης, -ου (nom commun) (m)''' : .&lt;br&gt;
'''ἄλειμμα, -ίμματος (nom commun) (n)''' : .&lt;br&gt; 
'''ἀλειπτήριον, -ίου (nom commun) (m)''' : .&lt;br&gt;
'''ἀλειπτήρ, -ῆρος (nom commun) (m)''' : .&lt;br&gt;
'''ἀλείπτης ''' : .&lt;br&gt;
'''ἀλειπτός ''' : .&lt;br&gt;
'''ἄλειψις, -ῆρος (nom commun) (m)''' : .&lt;br&gt;
'''ἄλειφαρ, -ίφατος (nom commun) (n)''' : pommade.&lt;br&gt; 
'''ἀλείφω (m)''' : pommader.&lt;br&gt;
'''ἀλεκτρυών, -όνος (nom commun) (m/f)''' : Coq ; poule.&lt;br&gt;
'''ἀλέκτωρ, -ορος (nom commun) (m)''' : coq.&lt;br&gt;
'''ἀλεξανδρῖνος, -ίνη, -ῖνον (adjectif)''' : alexandrin.&lt;br&gt; 
'''ἀλέξω (verbe)''' : défendre. (prendre la défense)&lt;br&gt; 
'''ἄλευρον, -ύρου (nom commun) (n)''' : farine de froment.&lt;br&gt;
'''ἀλευρώδης, -ώδης, -ῶδες  (n)''' : semblable à de la farine de froment.&lt;br&gt;
'''ἀλέω (verbe)''' : moudre.&lt;br&gt;
'''ἄλη, -ης (nom commun)''' : errance.&lt;br&gt;
'''ἀλήθεια, -ίας (nom commun) (f)''' : vérité.&lt;br&gt; 
'''ἀληθέστατος, -άτη, -έστατον (adjectif)  (adjectif)''' : Superlatif de ''ἀληθής''.&lt;br&gt;
'''ἀληθέστερος, -έρα, -έτερον (adjectif)''' : Comparatif de ''ἀληθής''.&lt;br&gt;
'''ἀληθής, -ής, -ές (adjectif)''' : vrai.&lt;br&gt;
'''ἀληθινός, -ή, -όν (adjectif)''' : vrai.&lt;br&gt;
'''ἀληθινώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''ἀληθινός''.&lt;br&gt;
'''ἀληθινώτερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''ἀληθινός''.&lt;br&gt;
'''ἀληθινώτατα, -, - (adverbe)''' : Superlatif de ''ἀληθινῶς''.&lt;br&gt;
'''ἀληθινώτερον, -, - (adverbe)''' : Comparatif de ''ἀληθινῶς''.&lt;br&gt; 
'''ἀληθινῶς (adverbe)''' : vraiment.&lt;br&gt;
'''ἀληθῶς (adverbe)''' : vraiment.&lt;br&gt;
'''ἀλήτης, -ου (nom commun) (m)''' : .&lt;br&gt; 
'''ἁλιεύς, -έως (nom commun) (m)''' : pêcheur.&lt;br&gt;
'''ἁλιευτικός, -ή, -όν (adjectif)''' : qui concerne la pêche.&lt;br&gt;
'''ἁλιεύω (verbe)''' : pêcher.&lt;br&gt;
'''ἅλιος, -ίου (nom commun) (m)''' : Forme  de ''ἥλιος''.&lt;br&gt;
'''ἀλιτρός, -ός, -όν (adjectif)''' : vilain.&lt;br&gt; 
'''ἀλιτρότατος, -άτη, -ότατον (adjectif)''' : Superlatif de ''ἀλιτρός''.&lt;br&gt;
'''ἀλιτρότερος, -έρα, -ότερον (adjectif)''' : Comparatif de ''ἀλιτρός''.&lt;br&gt;
'''ἀλιτρῶς (adverbe)''' : vilainement.&lt;br&gt;
'''ἀλκή, -ῆς (nom commun) (f)''' : force.&lt;br&gt; 
'''ἀλκμαῖος, -ία, -ῖον (adjectif)''' : jeune.&lt;br&gt; 
'''ἀλλά (conjonction)''' : (Devient ''ἀλλ’'' devant un mot commençant par une voyelle.) Mais. D’un autre côté, autrement.&lt;br&gt;
'''ἀλλαγή, -ῆς (nom commun) (f)''' : Changement ; échange.&lt;br&gt; 
'''ἀλλάσσω (verbe)''' : Changer, altérer. Échanger.&lt;br&gt;
'''ἄλλαξις, -άξεως (nom commun) (f)''' : troc.&lt;br&gt; 
'''ἄλληλος (adjectif)''' : .&lt;br&gt; 
'''ἀλληλούϊα (interjection)''' : alléluia.&lt;br&gt;
'''ἁλμάω (verbe)''' : saumurer.&lt;br&gt;
'''ἅλμη, -ης (nom commun) (f)''' : saumure.&lt;br&gt;
'''ἀλόη, -ης (nom commun) (f)''' : aloès.&lt;br&gt;
'''ἀλοιφή, -ῆς (nom commun) (f)''' : pommade.&lt;br&gt;
'''ἇλος, ἅλου (nom commun) (m)''' : Forme dorienne de ''ἧλος''.&lt;br&gt;
'''ἄλσος, -ους (nom commun) (n)''' : bois (lieu).&lt;br&gt;
'''ἅλς, -ός (nom commun) (m/f)''' : sel ; mer.&lt;br&gt;
'''ἅλυσις, -ύσεως (nom commun) (f)''' : chaîne (succession d’anneaux enserrés).&lt;br&gt;
'''ἄλυσις, -ύσεως (nom commun) (f)''' : détresse ; angoisse.&lt;br&gt;	
'''ἄλυσσον, -ύσσου (nom commun) (n)''' : alysse.&lt;br&gt;
'''ἀλύω (verbe)''' : Être tout excité ; divaguer.&lt;br&gt;
'''ἄλφα (nom commun) (n)''' : alpha.&lt;br&gt; 
'''ἀλφάϐητος, -ήτου (nom commun) (m)''' : Ensemble des lettres servant à écrire.&lt;br&gt;
'''ἄλφιτα, -ίτας (nom commun) (f)''' : farine d’orge.&lt;br&gt;
'''ἀλφός, -οῦ (nom commun) (m)''' : lèpre blanche.&lt;br&gt;
'''ἀλωπεκῆ, -ῆς (nom commun) (f)''' : peau de renard ; ruse.&lt;br&gt;
'''ἀλωπεκία, -ας (nom commun) (f)''' : chute des cheveux.&lt;br&gt;
'''ἀλωπεκίασις, -άσεως (nom commun) (f)''' : chute des cheveux.&lt;br&gt;
'''ἀλωπεκίς, -δος (nom commun) (f)''' : casquette en peau de renard.&lt;br&gt;
'''ἀλώπηξ, -εκος (nom commun) (f)''' : renard.&lt;br&gt;
'''ἅμμα, -τος (nom commun) (n)''' : nœud.&lt;br&gt;
'''ἅμαξα, -ης (nom commun) (f)''' : chariot.&lt;br&gt;
'''ἁμαξαία, -ας (nom commun) (f)''' : .&lt;br&gt;	
'''ἁμαξαῖος, -ία, -ῖον (adjectif)''' : .&lt;br&gt;	
'''ἁμαξακάρινον, -ίνου (nom commun) (n)''' : .&lt;br&gt;	
'''ἁμαξάρχης, -ου (nom commun) (m)''' : .&lt;br&gt;
'''ἀμαυρός, -ά, -όν  (adjectif)''' : sombre ; obscur.&lt;br&gt;
'''ἀμαύρωσις, -ώσεως (nom commun) (f)''' :  obscurcissement.&lt;br&gt;
'''ἀμαυρῶ (verbe)''' : s’obscurcir.&lt;br&gt;
'''ἁμαρτάς, -δος (nom commun) (f)''' : Faute ; erreur, méprise.&lt;br&gt;
'''ἁμαρτάνω (verbe)''' : Manquer le but. Se tromper, se méprendre. Commettre une faute, faillir, pécher.&lt;br&gt;
'''ἁμάρτημα, -ήματος (nom commun) (n)''' : Échec ; faute. Péché.&lt;br&gt;
'''ἁμαρτία, -ας (nom commun) (f)''' : Erreur ; faute. Péché&lt;br&gt;
'''ἀμάτωρ, -ωρ, -ορ (adjectif)''' : Forme dorienne de ''ἀμήτωρ''.&lt;br&gt;
'''ἀμϐλύς, -εῖα, -ύ (adjectif)''' : émoussé.&lt;br&gt; 
'''ἀμϐρόσιος, -ία, -όσιον (adjectif)''' : divin ; immortel.&lt;br&gt; 
'''ἀμϐροσίως (adverbe)''' : divinement ; immortellement.&lt;br&gt;
'''ἀμϐροσιώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''ἀ μϐρόσιος''.&lt;br&gt;
'''ἀμϐροσιώτερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''ἀμϐρόσιος''.&lt;br&gt;
'''ἄμϐων, -ος (nom commun) (m)''' : Bord arrondi d’un vase.&lt;br&gt; 
'''ἀμέθυστος, -ος, -ον (adjectif)''' : sobre.&lt;br&gt; 
'''ἀμεθύω (verbe)''' : être sobre.&lt;br&gt;
'''ἀμέλγω (verbe)''' : Traire. Sucer, boire.&lt;br&gt; 
'''ἀμελής, -ής, -ής (adjectif)''' : négligeant.&lt;br&gt; 
'''ἀμελῶ (verbe)''' : négliger.&lt;br&gt;  
'''ἀμέρα, -ας (nom commun) (f)''' : Forme dorienne de ''ἡμέρα''.&lt;br&gt; 
'''ἀμήν (adverbe)''' : amen.&lt;br&gt;
'''ἀμήτωρ, -ωρ, -ορ (adjectif)''' : sans mère.&lt;br&gt;  
'''ἀμίς, -δος (nom commun) (f)''' : pot de chambre.&lt;br&gt; 
'''ἀμνάς, -δος (nom commun) (f)''' : agnelle.&lt;br&gt; 
'''ἀμνός, -οῦ (nom commun) (m)''' : agneau.&lt;br&gt; 
'''ἄμεσος (adverbe)''' : .&lt;br&gt;
'''ἀμπέλιον, -ίoυ (nom commun) (n)''' : petite vigne.&lt;br&gt;
'''ἄμπελος, -έλου (nom commun) (m)''' : vigne (plante).&lt;br&gt;
'''ἀμπελών, -ος (nom commun) (m)''' : vigne (endroit où elle est plantée).&lt;br&gt; 
'''ἀμπρακικός, -η, -όν (adjectif)''' : ambracien.&lt;br&gt;
'''ἀμυγδάλη, -ης (nom commun) (f)''' : amygdale.&lt;br&gt;
'''ἀμύγδαλον, -άλoυ (nom commun) (n)''' : amande. (fruit)&lt;br&gt;
'''ἄμυλος, -ύλoυ (nom commun) (m)''' : amidon.&lt;br&gt;  
'''ἀμύνω (verbe)''' : défendre.&lt;br&gt;
'''ἀμφί (adverbe ; préposition)''' : Autour. Séparément ; pour soi. Autour. À partir de ; loin de. (Avec le génitif) 
Autour de ; au milieu de. (Avec le datif) Autour de (quelque chose). (Figuré) Au sujet de ; par suite de. (Avec l’accusatif) Autour de. (Par extension) En faisant le tour de : en circulant à travers ; à travers ; par. Au sujet de. Aux environs de. (Joint à ''περί'') Tout autour de.&lt;br&gt;
'''ἀμφί- (préfixe)''' : De deux côtés ; en double. Tout autour de. Au sujet de.&lt;br&gt;
'''ἀμφιθέατρον, -ου (nom commun) (n)''' : amphithéâtre.&lt;br&gt; 
'''ἀμφιθέητρον, -ου (nom commun) (n)''' : Forme ionienne de ''ἀμφιθέατρον''.&lt;br&gt;
'''ἀμφισϐητήσιμος, -η, -ον (adjectif)''' : contestable.&lt;br&gt;
'''ἀμφισϐητῶ (n)''' : contester.&lt;br&gt;
'''ἀμφί (adverbe ; préposition)''' : Des deux côtés ; aux deux extrémités. Autour. À partir de ; loin de.&lt;br&gt;
'''ἀμφίς (adverbe ; préposition)''' : Des deux côtés ; aux deux extrémités. Autour. À partir de ; loin de.&lt;br&gt;
'''ἀμφορεύς, -έως (nom commun) (m)''' : amphore.&lt;br&gt;  
'''ἀμφότερος, -έρα, -ότερον (adjectif)''' : l’un l’autre, les deux.&lt;br&gt;
'''ἄμφω (déterminant)''' : les deux.&lt;br&gt;  
'''ἀνά (adverbe, préposition)''' : En haut. En avant. En haut de, sur, à travers.&lt;br&gt;
'''ἄνα- (préfixe)''' : De bas en haut. En arrière. (Par suite) faire le contraire. (Par extension) Faire de nouveau.&lt;br&gt;
'''ἀναϐάλλω (verbe)''' : .&lt;br&gt;  
'''ἀναϐολεύς, -έως (nom commun) (m)''' : étrier.&lt;br&gt;
'''ἀναϐολή, -ῆς (nom commun) (f)''' : ajournement, sursis.&lt;br&gt;
'''ἀναγκάζω (verbe)''' :  forcer, contraindre.&lt;br&gt;  
'''ἀναγκαῖος, -ία, -ῖον (adjectif)''' : (actif) Qui contraint. Nécessaire. Parent pour le sang. (passif) Contraint, forcé.&lt;br&gt;
'''ἀνάγκη, -ης (nom propre) (f)''' : Nécessité, contrainte.&lt;br&gt;
'''ἀναγράφω (verbe)''' : .&lt;br&gt; 
'''ἀνάδημα, -τος (nom commun) (n)''' : anadème.&lt;br&gt;
'''ἀνάδοχος, -όχου (nom commun) (m/f)''' : parrain, marraine.&lt;br&gt;
'''ἀναδρομή, -ῆς (nom commun) (f)''' : rétrospective.&lt;br&gt;
'''ἀναδρομικός, -ή, -όν (adjectif)''' : rétrospectif.&lt;br&gt;
'''ἀναδρομικῶς (adverbe)''' : rétrospectivement.&lt;br&gt;
'''ἀνάδυσις, -ύσεως (nom commun) (f)''' : émergence.&lt;br&gt; 	
'''ἀναδύομαι (verbe)''' : émerger.&lt;br&gt; 
'''ἀναζήτησις, -ήσεως (nom commun) (f)''' : recherche.&lt;br&gt;
'''ἀναζητῶ (verbe)''' : rechercher.&lt;br&gt;
'''ἀναθεωρῶ (verbe)''' : réviser.&lt;br&gt;
'''ἀναθυμίασις, -άσεως (nom commun) (f)''' : effluve.&lt;br&gt;
'''ἀναίδεια, -ας (nom commun) (f)''' : impudence.&lt;br&gt;
'''ἀναιδέστατος, -άτη, -έστατον (adjectif)''' : Superlatif de ''ἀναιδής''.&lt;br&gt;
'''ἀναιδέστερος, -έρα, -έστερον (adjectif)''' : Comparatif de ''ἀναιδής''.&lt;br&gt;  	
'''ἀναιδής, -ής, -ές (adjectif)''' : impudent.&lt;br&gt; 
'''ἀναιδῶς (adverbe)''' : impudemment.&lt;br&gt; 
'''ἀναιμία, -ας (nom commun) (f)''' : manque de sang.&lt;br&gt; 
'''ἀναισχυντία, -ας (nom commun) (f)''' : effronterie.&lt;br&gt; 
'''ἀναίσχυντος, -ή, -όν (adjectif)''' : effronté.&lt;br&gt; 
'''ἀναίσχυντότατος, -άτη, -ότατον (adjectif)''' : Superlatif de ''ἀναίσχυντός''.&lt;br&gt;
'''ἀναίσχυντότερος, -έρα, -ότερον (adjectif)''' : Comparatif de ''ἀναίσχυντός''.&lt;br&gt;
'''ἀναίσχυντότατα, -, - (adverbe)''' : Superlatif de ''ἀναίσχυντῶς''.&lt;br&gt;
'''ἀναίσχυντότερον, -, - (adverbe)''' : Comparatif de ''ἀναίσχυντῶς''.&lt;br&gt;
'''ἀναίσχυντῶς (adverbe)''' : effrontément.&lt;br&gt; 
'''ἀνακινῶ (verbe)''' : .&lt;br&gt;
'''ἀνακοίνωσις, -ώσεως (nom commun) (f)''' : communication.&lt;br&gt; 
'''ἀνακοινῶ (verbe)''' : communiquer.&lt;br&gt;
'''ἀνακουφίζω (verbe)''' : soulager.&lt;br&gt;
'''ἀνακούφισις, -ίσεως (nom commun) (f)''' : soulagement.&lt;br&gt; 
'''ἀνακτορία, -ας (nom commun) (f)''' : .&lt;br&gt;
'''ἀνακτόριος, -ος, -ον (adjectif)''' : .&lt;br&gt;
'''ἀνάκτορον, -όρου (nom commun) (n)''' : .&lt;br&gt;
'''ἀναλαμϐάνω (verbe)''' : reprendre.&lt;br&gt;
'''ἀνάλαψις, -άψεως (nom commun) (f)''' : Forme dorienne de ''ἀνάληψις''.&lt;br&gt;
'''ἀνάληψις, -ήψεως (nom commun) (f)''' : Reprise, reprise de forces, rétablissement. Reconnaissance d'un enfant, action de le faire sien. (Religion chrétienne) Ascension, action d’être repris par le Ciel. Réception.&lt;br&gt; 
'''ἀναλογία, -ας (nom commun) (f)''' : proportion.&lt;br&gt; 
'''ἀναλογικός, -ή, -όν (adjectif)''' : proportionnel.&lt;br&gt; 
'''ἀναλογικότατος, -άτη, -ότατον (adjectif)''' : Superlatif de ''ἀναλογικός''.&lt;br&gt;
'''ἀναλογικότερος, -έρα, -ότερον (adjectif)''' : Comparatif de ''ἀναλογικός''.&lt;br&gt;
'''ἀναλογικότατα, -, - (adverbe)''' : Superlatif de ''ἀναλογικῶς''.&lt;br&gt;
'''ἀναλογικότερον, -, - (adverbe)''' : Comparatif de ''ἀναλογικῶς''.&lt;br&gt;
'''ἀναλογικῶς (adverbe)''' : proportionnellement.&lt;br&gt;
'''ἀνάλογος, -η, -ον (adjectif)''' : commensurable.&lt;br&gt; 
'''ἀναμένω (verbe)''' : surveiller.&lt;br&gt;
'''ἀνάμνησις, -ήσεως (nom commun) (f)''' : commémoration.&lt;br&gt;
'''ἀναμνηστικός, -ή, -όν (adjectif)''' : commémoratif.&lt;br&gt;
'''ἀναμνηστικῶς (adverbe)''' : commémorativement.&lt;br&gt;
'''ἀναμνηστικώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''ἀναμνηστικός''.&lt;br&gt;
'''ἀναμνηστικώτερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''ἀναμνηστικός''.&lt;br&gt;
'''ἀναμνηστικώτατα, -, - (adverbe)''' : Superlatif de ''ἀναμνηστικῶς''.&lt;br&gt;
'''ἀναμνηστικώτερον, -, - (adverbe)''' : Comparatif de ''ἀναμνηστικῶς''.&lt;br&gt; 
'''ἄναξις, -εως (nom commun) (f)''' : .&lt;br&gt;
'''ἄναξ, -κτος (nom commun) (m)''' : maître, chef, roi.&lt;br&gt; 
'''ἀνάπαιστος, -ίστου (nom commun) (m)''' : anapeste.&lt;br&gt; 
'''ἀνάπαυσις, -ύσεως (nom commun) (f)''' : repos.&lt;br&gt;
'''ἀναπαύω (verbe)''' : reposer.&lt;br&gt;
'''ἄνασσα, -ας (nom commun) (f)''' : maîtresse, reine.&lt;br&gt;
'''ἀνάστασις, -άσεως (nom commun) (f)''' : résurrection.&lt;br&gt;
'''ἀναστεναγμός, -οῦ (nom commun) (m)''' : soupir.&lt;br&gt;
'''ἀναστενάζω (verbe)''' : soupirer.&lt;br&gt;
'''ἀνατέλλω (verbe)''' : .&lt;br&gt;
'''ἀνατολή, -ῆς (nom commun) (f)''' : est.&lt;br&gt; 
'''ἀνατολικός, -ή, -όν (adjectif)''' : oriental.&lt;br&gt;
'''ἀνατολικότατος, -άτη, -ότατον (adjectif)''' : Superlatif de ''ἀνατολικός''.&lt;br&gt;
'''ἀνατολικότερος, -έρα, -ότερον (adjectif)''' : Comparatif de ''ἀνατολικός''.&lt;br&gt;
'''ἀνατολικότατα, -, - (adverbe)''' : Superlatif de ''ἀνατολικῶς''.&lt;br&gt;
'''ἀνατολικότερον, -, - (adverbe)''' : Comparatif de ''ἀνατολικῶς''.&lt;br&gt;
'''ἀνατολικῶς (adverbe)''' : orientalement.&lt;br&gt;
'''ἀναφέρω (verbe)''' : alléguer ; mentionner.&lt;br&gt;
'''ἀναφλέγω (verbe)''' : enflammer.&lt;br&gt;
'''ἀνάφλεξις, -έξεως (nom commun) (f)''' : combustion.&lt;br&gt;
'''ἀναφορά, -ᾶς (nom commun) (f)''' : allégation, mention.&lt;br&gt; 
'''ἀναφορικός, -ή, -όν (adjectif)''' : allégatoire.&lt;br&gt;
'''ἀναχώρησις, -ήσεως (nom commun) (f)''' : départ.&lt;br&gt;
'''ἀνδραποδίζω (verbe)''' : vendre des hommes libres en esclavage.&lt;br&gt;
'''ἀνδράποδον, -όδου (nom commun) (n)''' : captif.&lt;br&gt;
'''ἀνδρείκελον, -έλου (nom commun) (n)''' : marionnette.&lt;br&gt;
'''ἀνδρεῖος, -ία, -ῖον (adjectif)''' : masculin.&lt;br&gt;
'''ἀνδρειότατος, -άτη, -ότατον (adjectif)''' : Superlatif de ''ἀνδρεῖος''.&lt;br&gt;
'''ἀνδρειότερος, -έρα, -ότερον (adjectif)''' : Comparatif de ''ἀνδρεῖος''.&lt;br&gt;
'''ἀνδρείως (adverbe)''' : masculinement.&lt;br&gt;
'''ἀνδρομανία, -ας (nom commun) (f)''' : andromanie.&lt;br&gt;
'''ἀνδροπρέπεια, -ίας (nom commun) (f)''' : virilité.&lt;br&gt;
'''ἀνδροπρεπής -ής -ές (adjectif)''' : viril.&lt;br&gt;
'''ἀνδροπρεπῶς (adverbe)''' : virilement.&lt;br&gt;
'''ἀνδρότης, -τος (nom commun) (f)''' : virilité.&lt;br&gt;
'''ἀνδρών, -ῶνος (nom commun) (m)''' : Appartement réservé aux hommes.&lt;br&gt;
'''ἀνεκδιήγητος, -ος, -ον (adjectif)''' : inénarrable.&lt;br&gt;
'''ἀνέκδοτος, -ος, -ον (adjectif)''' : Non donnée en mariage, en parlant d’une jeune fille. Inédit, non publié.&lt;br&gt;
'''ἀνέμη, -ης (nom commun) (f)''' : rouet.&lt;br&gt;
'''ἄνεμος, -έμου (nom commun) (m)''' : vent.&lt;br&gt;
'''ἀνερρίπτω (verbe)''' : .&lt;br&gt;
'''ἀνερωτῶ (verbe)''' : .&lt;br&gt;
'''ἀνευθυνότης, -ητος (nom commun) (f)''' : irresponsabilité.&lt;br&gt;
'''ἀνευθύνω (verbe)''' : être irresponsable.&lt;br&gt;
'''ἀνεύρυσμα, -ύσματος (nom commun) (n)''' : élargissement, dilatation.&lt;br&gt;
'''ἀνευρύνω (verbe)''' : élargir, dilater.&lt;br&gt;
'''ἀνεψιά, -ᾶς (nom commun) (f)''' : nièce.&lt;br&gt;
'''ἀνεψιός, -οῦ (nom commun) (m)''' : neveu.&lt;br&gt; 
'''ἄνηθον, -ήθου (nom commun) (n)''' : aneth.&lt;br&gt;
'''ἀνήρ, -δρός (nom commun) (n)''' : Homme, époux ; mâle des animaux.&lt;br&gt;
'''ἄνθεμον, -έμου (nom commun) (n)''' : Diminutif d’''ἄνθος''.&lt;br&gt;
'''ἀνθολογέω (verbe)''' : cueillir des fleurs.&lt;br&gt;
'''ἁνθολογία, -ας (nom commun) (f)''' : florilège.&lt;br&gt;
'''ἀνθολόγιον, -ου (nom commun) (n)''' : recueil.&lt;br&gt;
'''ἀνθόλωψ, -πος (nom commun) (m)''' : antilope.&lt;br&gt;
'''ἄνθος, -ους (nom commun) (n)''' : fleur.&lt;br&gt;
'''ἄνθραξ, κος (nom commun) (m)''' : charbon.&lt;br&gt; 
'''ἀνθρακιά, -ᾶς (nom commun) (f)''' : pile de charbon.&lt;br&gt;
'''ἀνθρωπάριον, -ίου (nom commun) (n)''' : homuncule.&lt;br&gt;
'''ἀνθρώπινος, -η, -ον (adjectif)''' : humain.&lt;br&gt;
'''ἀνθρωπίσκος, -ου (nom commun) (m)''' : mannequin.&lt;br&gt;
'''ἄνθρωπος, -ώπου (nom commun) (m)''' : homme, genre humain.&lt;br&gt;
'''ἀνθρωποκεντρικός, -ή, -όν (adjectif)''' : anthropocentrique.&lt;br&gt;
'''ἀνθρωποειδής, -ής, -ες, (adjectif)''' : anthropoïde.&lt;br&gt;
'''ἀνθρωπολογία, -ας''' : anthropologie.&lt;br&gt;
'''ἀνθρωπομορφισμός, -οῦ (nom commun) (m)''' : anthropomorphisme.&lt;br&gt;
'''ἀνθρωποφαγία, -ας (nom commun) (f)''' : cannibalisme.&lt;br&gt;
'''ἀνθρωποφάγος, -ου (nom commun) (n)''' : cannibale.&lt;br&gt; 
'''ἀνία, -ας (nom commun) (f)''' : ennui.&lt;br&gt;
'''ἁνία, -ας (nom commun) (f)''' : Forme dorienne de ''ἡνία''.&lt;br&gt; 
'''ἄνισος, -η, -ον (adjectif)''' : inégal.&lt;br&gt;
'''ἀνίστημι (verbe)''' : ressusciter.&lt;br&gt;
'''ἄν (adverbe, particule)''' : .&lt;br&gt;
'''ἄννησον, -ήσου (nom commun) (n)''' : anis.&lt;br&gt; 
'''ἀνόδων, -οντος (nom commun) (m/f)''' : édenté.&lt;br&gt;
'''ἀνόητος, -ος, -ον (adjectif)''' : .&lt;br&gt;
'''ἄνοια, -ας (nom commun) (f)''' : démence.&lt;br&gt;
'''ἄνοιγμα, -ίγματος (nom commun) (n)''' : orifice, ouverture.&lt;br&gt;
'''ἀνοίγω (verbe)''' : ouvrir.&lt;br&gt;
'''ἄνοιξις, -ίξεως (nom commun) (f)''' : ouverture.&lt;br&gt;
'''ἀνωμαλία, -ας (nom commun) (f)''' : inégalité, irrégularité.&lt;br&gt;
'''ἀνώμαλος, -ος, -ον (adjectif)''' : inégal, irrégulier.&lt;br&gt;
'''ἄνοικτος, -ος, -ον (adjectif)''' : impitoyable.&lt;br&gt;
'''ἀνοικτότατος, -άτη, -ότατον (adjectif)''' : Superlatif de ''ἄνοικτος''.&lt;br&gt;
'''ἀνοικτότερος, -έρα, -ότερον (adjectif)''' : Comparatif de ''ἄνοικτος''.&lt;br&gt;
'''ἀνοικτότατα, -, - (adverbe)''' : Superlatif de ''ἀνοίκτως''.&lt;br&gt;
'''ἀνοικτότερον, -, - (adverbe)''' : Comparatif de ''ἀνοίκτως''.&lt;br&gt;
'''ἀνοίκτως (adverbe)''' : impitoyablement.&lt;br&gt;
'''ἀνορεξία, -ας (nom commun) (f)''' : manque d’appétit.&lt;br&gt;
'''ἄνους, -ους, -ουν (adjectif)''' : dément.&lt;br&gt;
'''ἀνταγωνίζεσθαι (verbe)''' : contrarier.&lt;br&gt;
'''ἀνταγωνιστής, -οῦ (nom commun) (m)''' : adversaire.&lt;br&gt;  
'''ἀνταίρω (verbe)''' : se rebeller.&lt;br&gt;
'''ἀνταπαίτησις, -ήσεως (nom commun) (f)''' : .&lt;br&gt; 
'''ἀνταπαιτητής, -οῦ (nom commun) (m)''' : .&lt;br&gt;
'''ἀνταπαιτῶ (verbe)''' : .&lt;br&gt;
'''ἀνταρσία, -ας (nom commun) (m)''' : rébellion.&lt;br&gt;
'''ἀντάρτης, -ου (nom commun) (m)''' : rebelle.&lt;br&gt;
'''ἀντάρτικος, -η, -ον (adjectif)''' : rebelle.&lt;br&gt;
'''ἀντάρτικῶς (adverbe)''' : Forme adverbiale de ''ἀντάρτικός''.&lt;br&gt;
'''ἀντάρτικώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''ἀντάρτικός''.&lt;br&gt;
'''ἀντάρτικώτερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''ἀντάρτικός''.&lt;br&gt;
'''ἀντάρτικώτατα, -, - (adverbe)''' : Superlatif de ''ἀντάρτικῶς''.&lt;br&gt;
'''ἀντάρτικώτερον, -, - (adverbe)''' : Comparatif de ''ἀντάρτικῶς''.&lt;br&gt; 
'''ἀντέχω (verbe)''' : endurer.&lt;br&gt;
'''ἀντιάς, -δος (nom commun) (f)''' : (anatomie) amygdale.&lt;br&gt;
'''ἀντιγραφέυς, -έως (nom commun) (m)''' : copiste.&lt;br&gt;
'''ἀντιγραφή, -ῆς (nom commun) (f)''' : recopiage.&lt;br&gt;
'''ἀντιγράφω (verbe)''' : copier. (un texte écrit)&lt;br&gt;
'''ἀντί (préposition)''' : En face de. À l’encontre de, contre. Au lieu de, à la place de. À l’égal de. En échange de.
Par succession, par addition. En comparaison de. (En mot composé) En face, à l'encontre. En opposition avec. En échange de, en retour. Au lieu de, à l'égal de. Par correspondance. (En composition) En face, à l'encontre.&lt;br&gt;
'''ἀντίληψις, -ήψεως (nom commun) (f)''' : perception.&lt;br&gt;
'''ἀντιπαράθεσις, -έσεως (nom commun) (f)''' : confrontation.&lt;br&gt;  
'''ἀντιπαρατίθημι (verbe)''' : confronter.&lt;br&gt; 
'''ἀντίπους, -δός (nom commun) (m)''' : antipode.&lt;br&gt;
'''ἀντίρρησις, -ήσεως (nom commun) (f)''' : objection.&lt;br&gt;
'''ἀντίστοιχος, -ος, -ον (adjectif)''' : correspondant.&lt;br&gt;
'''ἀντιστοίχοτατα, -, - (adverbe)''' : Superlatif de ''ἀντιστοίχως''.&lt;br&gt;
'''ἀντιστοίχοτερον, -, - (adverbe)''' : Comparatif de ''ἀντιστοίχως''.&lt;br&gt;
'''ἀντιστοίχως (adverbe)''' : conformément.&lt;br&gt;
'''ἀντιστοιχῶ (verbe)''' : correspondre.&lt;br&gt;
'''ἀντισυνταγματικός, -ή, -όν (adjectif)''' : inconstitutionnel.&lt;br&gt;
'''ἀντισυνταγματικώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''ἀντισυνταγματικός''.&lt;br&gt;
'''ἀντισυνταγματικώτερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''ἀντισυνταγματικός''.&lt;br&gt;
'''ἀντισυνταγματικώτατα, -, - (adverbe)''' : Superlatif de ''ἀντισυνταγματικῶς''.&lt;br&gt;
'''ἀντισυνταγματικώτερον, -, - (adverbe)''' : Comparatif de ''ἀντισυνταγματικῶς''.&lt;br&gt;
'''ἀντισυνταγματικότης, -τος (nom commun) (f)''' : inconstitutionnalité.&lt;br&gt;
'''ἀντισυνταγματικῶς (adverbe)''' : inconstitutionnellement.&lt;br&gt; 
'''ἀντίφασις, -άσεως (nom commun) (f)''' : contradiction.&lt;br&gt;
'''ἀντιφάσκω (verbe)''' : contredire.&lt;br&gt;
'''ἀντιφατικός -ή -όν (adjectif)''' : contradictoire.&lt;br&gt;
'''ἀντιφατικῶς (adverbe)''' : contradictoirement.&lt;br&gt; 
'''ἀντιφατικώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''ἀντισυνταγματικός''.&lt;br&gt;
'''ἀντιφατικώτερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''ἀντισυνταγματικός''.&lt;br&gt;
'''ἀντιφατικώτατα, -, - (adverbe)''' : Superlatif de ''ἀντιφατικῶς''.&lt;br&gt;
'''ἀντιφατικώτερον, -, - (adverbe)''' : Comparatif de ''ἀντιφατικῶς''.&lt;br&gt;
'''ἀντιφατικότης, -τος (nom commun) (f)''' : contradiction.&lt;br&gt;
'''ἀντίχειρ, -ος (nom commun) (m)''' : pouce.&lt;br&gt;
'''ἀντοχή, -ῆς (nom commun) (f)''' : endurance.&lt;br&gt;
'''ἀνυπακοή, -ῆς (nom commun) (f)''' : désobéissance.&lt;br&gt;
'''ἀνυπάκουος, -η, -ον (adjectif)''' : désobéissant.&lt;br&gt;
'''ἀνύψωσις, -ώσεως (nom commun) (f)''' : élévation.&lt;br&gt;
'''ἀνυπακούω (verbe)''' : désobéir.&lt;br&gt;  
'''ἀνώδυνος, -ος, -ον (adjectif) ''' : qui n’est pas douloureux. Qui n’est pas causé par la douleur.&lt;br&gt;
'''ἀνώγειον, -ίου (nom commun) (n)''' : grenier.&lt;br&gt;
'''ἀνώτατος, -άτη, -ώτατον (adjectif)''' : suprême.&lt;br&gt; 
'''ἀνώτερος, -έρα, -ώτερον (adjectif)''' : supérieur.&lt;br&gt;
'''ἀνωτερότης, -τος (nom commun) (f)''' : supériorité.&lt;br&gt;
'''ἄνω (adverbe)''' : Sur, vers le haut ; au dessus.&lt;br&gt; 
'''ἀξιάκουστος, -ος, -ον (adjectif)''' : digne d’être écouté.&lt;br&gt;
'''ἀξίνη, -ης (nom commun) (f)''' : pioche (outil). Hache&lt;br&gt; 
'''ἀξιο- (préfixe)''' : qui est digne de.&lt;br&gt;
'''ἀξιοθέατος, -ος, -ον (adjectif)''' : digne d’être contemplé.&lt;br&gt;
'''ἀξιόπιστος, -ος, -ον (adjectif)''' : digne de foi.&lt;br&gt;
'''ἄξιος, -α, -ον (adjectif)''' : de valeur, digne de, méritant.&lt;br&gt;
'''ἀξίωμα, -τος (nom commun) (n)''' : Prix, valeur. Ce dont on a été jugé digne. Considération, estime. Marque de considération, honneur. Haut rang, dignité. Ce que l’on juge convenable, ce qui paraît juste.&lt;br&gt; 
'''ἀξιῶ (verbe)''' : mériter (quelque chose).&lt;br&gt;
'''ἄξων, -ονος (nom commun) (m)''' : Axe. Essieu de roue. Axe du ciel, du monde. Axe d’un chemin d’où chemin, route. Crochet du mors d’un cheval. Tablette de bois construite sur un pivot. Arbre ou axe de rotation, pivot, battant balistique.&lt;br&gt; 
'''ἀοιδός, -οῦ (nom commun) (m)''' : Chanteur ; chantre.&lt;br&gt;  
'''ἀόρατος, -ος, ον (adjectif)''' : invisible.&lt;br&gt;
'''ἄορ, -ος (nom commun) (n)''' : épée pendue à la ceinture.&lt;br&gt; 
'''ἀορτήρ, -ῆρος (nom commun) (m)''' : bandoulière.&lt;br&gt;
'''ἀπαγορευτικός, -ή -όν (adjectif)''' : prohibitif.&lt;br&gt;
'''ἀπαγόρευσις, -ύσεως (nom commun) (f)''' : prohibition.&lt;br&gt; 
'''ἀπαγορεύω (verbe)''' : prohiber.&lt;br&gt;  
'''ἀπαγωγεύς, -έως (nom commun) (m)''' : ravisseur.&lt;br&gt;  
'''ἀπαγωγή, -ῆς (nom commun) (f)''' : (Droit) En termes de droit athénien, action d’emmener à un procès un malfaiteur pris en flagrant délit. Action de faire dévier du droit chemin. Paiement (d’une contribution ou d’une amende).&lt;br&gt;
'''ἀπάγω (verbe)''' : conduire ; emmener.&lt;br&gt;
'''ἀπαισιοδοξία, -ας (nom commun) (f)''' : pessimisme.&lt;br&gt; 
'''ἀπαίτησις, -ήσεως (nom commun) (f)''' : exigence (ce que l’on exige).&lt;br&gt; 	 
'''ἀπαιτῶ (verbe)''' : exiger.&lt;br&gt; 
'''ἀπαλλαγή, -ῆς (nom commun) (f)''' : exonération.&lt;br&gt;
'''ἀπαλλακτικός, -ή -όν (adjectif)''' : exonérant.&lt;br&gt;
'''ἀπαλλάσσω (verbe)''' : exonérer.&lt;br&gt;
'''ἀπαπαῖ (interjection)''' : ouille.&lt;br&gt;
'''ἀπαρνοῦμαι (verbe)''' : .&lt;br&gt;
'''ἀπάτωρ, -ωρ, -ορ (adjectif)''' : sans père.&lt;br&gt;  
'''ἄπειμι (verbe)''' : Être absent, s’absenter. Partir, s’en aller.&lt;br&gt;
'''ἀπειρέσιος, -ία, -έσιον (adjectif)''' : Illimité, immense ; innombrable.&lt;br&gt;
'''ἀπειρεσιώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''ἀπειρέσιος''.&lt;br&gt;
'''ἀπειρεσιώτερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''ἀπειρέσιος''.&lt;br&gt;
'''ἀπειρεσίως (adverbe)''' : immensément.&lt;br&gt;
'''ἄπειρος, -ος, -ον (adjectif)''' : infini.&lt;br&gt;
'''ἀπειρότατος, -άτη, -ότατον (adjectif)''' : Superlatif de ''ἄπειρος''.&lt;br&gt;
'''ἀπειρότερος, -έρα, -ότερον (adjectif)''' : Comparatif de ''ἄπειρος''.&lt;br&gt;
'''ἀπείρως (adverbe)''' : infiniment.&lt;br&gt;
'''ἀπελευθέρωσις, -ώσεως (nom commun) (f)''' : libération.&lt;br&gt;
'''ἀπεργάζομαι (verbe)''' : .&lt;br&gt;
'''ἀπέχθεια, -ας (nom commun) (f)''' : répugnance.&lt;br&gt; 
'''ἀπεχθής, -ής, -ές (adjectif)''' : répugnant.&lt;br&gt;
'''ἀπήνη, -ης (nom commun) (f)''' : .&lt;br&gt; 
'''ἀπίθανος, -ος, -ον (adjectif)''' : improbable ; incroyable.&lt;br&gt;
'''ἄπιον, -ίου (nom commun) (n)''' : poire.&lt;br&gt;
'''ἀπιστία, -ας (nom commun) (f)''' : infidélité ; déloyauté.&lt;br&gt; 
'''ἀπιστίη, -ης (nom commun) (f)''' : Forme ionienne de ''ἀπιστία''.&lt;br&gt; 
'''ἄπιστος, -ος, -ον (adjectif)''' : infidèle ; déloyal.&lt;br&gt;
'''ἀπλάνεια, -ίας (nom commun) (f)''' : constance.&lt;br&gt;
'''ἄπληστος, -η, -ον (adjectif)''' : .&lt;br&gt; 
'''ἁπλότης, -τος (nom commun) (f)''' : simplicité.&lt;br&gt;
'''ἁπλοῦς, -ῆ, -οῦν (adjectif)''' : simple.&lt;br&gt;
'''ἀπό (adverbe ; préposition)''' (Devient ''ἀπ’'' devant un mot commençant par une voyelle à esprit doux, et ''ἀφ’'' devant un mot commençant par une voyelle à esprit rude.) : Au loin, en venant de.&lt;br&gt;
'''ἀπό- (préfixe)''' : séparation, éloignement, changement, achèvement, cessation, retour, privation, négation.&lt;br&gt;
'''ἀπόγειον, -ίου (nom commun) (n)''' : apogée.&lt;br&gt;
'''ἀπόγειος, -ος, -ον (adjectif)''' : Qui part de terre, ou vient de son souffle. Éloigné de la terre.&lt;br&gt;
'''ἀπόγονος, -όνου (nom commun) (m)''' : descendant.&lt;br&gt;
'''ἀπογραφή, -ῆς (nom commun) (f)''' : Registre, liste. Copie.&lt;br&gt;
'''ἀπογράφω (m)''' : copier.&lt;br&gt;
'''ἀπόδειξις, -ίξεως (nom commun) (f)''' : évidence, preuve.&lt;br&gt;	
'''ἀποδεικτικός, -ή, -όν (adjectif)''' : évident.&lt;br&gt;
'''ἀποδεικτικῶς (adverbe)''' : évidemment.&lt;br&gt;
'''ἀποδεικτικώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''ἀποδεικτικός''.&lt;br&gt;
'''ἀποδεικτικώτερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''ἀποδεικτικός''.&lt;br&gt;
'''ἀποδεικτικώτατα, -, - (adverbe)''' : Superlatif de ''ἀποδεικτικῶς''.&lt;br&gt;
'''ἀποδεικτικώτερον, -, - (adverbe)''' : Comparatif de ''ἀποδεικτικῶς''.&lt;br&gt; 
'''ἀπολογητικός, -ή, -όν (adjectif)''' : défensif.&lt;br&gt;
'''ἀπολογητικῶς (adverbe)''' : défensivement.&lt;br&gt;
'''ἀπολογητικώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''ἀπολογητικός''.&lt;br&gt;
'''ἀπολογητικώτερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''ἀπολογητικός''.&lt;br&gt;
'''ἀπολογητικώτατα, -, - (adverbe)''' : Superlatif de ''ἀπολογητικῶς''.&lt;br&gt;
'''ἀπολογητικώτερον, -, - (adverbe)''' : Comparatif de ''ἀπολογητικῶς''.&lt;br&gt; 
'''ἀπολογία, -ας (nom commun) (f)''' : Défense, justification.&lt;br&gt;
'''ἀπόλυτος, -η, -ον (adjectif)''' : absolu.&lt;br&gt;
'''ἀπολύτως (adverbe)''' : absolument.&lt;br&gt;
'''ἀπολύω (verbe)''' : congédier, licencier ; renvoyer.&lt;br&gt;
'''ἀποπομπαῖος, -ία, -ῖον (adjectif)''' : expiatoire.&lt;br&gt;
'''ἀποπέμπω (verbe)''' : emporter le mal.&lt;br&gt;
'''ἀποθνῄσκω (verbe)''' : mourir.&lt;br&gt;
'''ἀποκάλυψις, -ύψεως (nom commun) (f)''' : dévoilement.&lt;br&gt;
'''ἀποκαλύπτω (verbe)''' : dévoiler.&lt;br&gt;
'''ἀποκεφαλισμός, -οῦ (nom commun) (f)''' : décapitation.&lt;br&gt;
'''ἀποκεφαλίζω (verbe)''' : décapiter.&lt;br&gt;
'''ἀποκρουστικός, -ή, -όν (adjectif)''' : . &lt;br&gt;
'''ἀποκρούω (verbe)''' : . &lt;br&gt;
'''ἀπόκρυφος, -ος, -ον (adjectif)''' : . &lt;br&gt;
'''ἀπολαμϐάνω (verbe)''' : jouir. (Avoir l’usage, la possession actuelle de quelque chose.)&lt;br&gt; 
'''ἀπόλαυσις, -ύσεως (nom commun) (f)''' : jouissance (Satisfaction voluptueuse ; plaisir né de la relation sexuelle épanouie.)&lt;br&gt;
'''ἀπολαύω (verbe)''' : jouir. (Éprouver un vif plaisir, un orgasme, etc.)&lt;br&gt;
'''ἀπολέγω (verbe)''' : Décliner, refuser.&lt;br&gt;
'''ἀπολογία, -ας (nom commun) (f)''' : Défense, justification.&lt;br&gt;
'''ἀπόλογος, -όγου (nom commun) (m)''' : Défense. Narration, récit détaillé.&lt;br&gt;
'''ἀποπατῶ (verbe)''' : déféquer.&lt;br&gt;
'''ἀποπνίγω (verbe)''' : suffoquer.&lt;br&gt;
'''ἀπορρίπτω (verbe)''' : .&lt;br&gt;
'''ἀπόσπασμα, -άσματος (nom commun) (n)''' : fragment.&lt;br&gt;
'''ἀποστρέφω (verbe)''' : .&lt;br&gt;
'''ἀποστροφή, -ῆς (nom commun) (f)''' : répulsion.&lt;br&gt;
'''ἀπόστροφος, -ος, -ον (adjectif)''' : répulsif.&lt;br&gt;
'''ἀποτέλεσμα, -έσματος (nom commun) (n)''' : résultat ; effet.&lt;br&gt;
'''ἀποτελῶ (verbe)''' : échouer.&lt;br&gt;
'''ἀποστέρησις, -ήσεως (nom commun) (f)''' : frustration.&lt;br&gt;
'''ἀποστερῶ (verbe)''' : frustrer.&lt;br&gt;
'''ἀποτέφρωσις, -ώσεως (nom commun) (f)''' : incinération.&lt;br&gt;	
'''ἀποτεφρῶ (verbe)''' : incinérer.&lt;br&gt;
'''ἀποτυγχάνω (verbe)''' : échouer.&lt;br&gt;
'''ἀποτυχία, -ας (nom commun) (f)''' : échec.&lt;br&gt;
'''ἀπουσία, -ας (nom commun) (f)''' : absence.&lt;br&gt;
'''ἄπους, -ους, -ουν  (adjectif)''' : apode.&lt;br&gt; 
'''ἀποφαίνω (verbe)''' : décider.&lt;br&gt;
'''ἀπόφασις, -άσεως (nom commun) (f)''' : décision.&lt;br&gt;
'''ἀποφεύγω (verbe)''' : s’échapper.&lt;br&gt;
'''ἀπόφημι (verbe)''' : .&lt;br&gt;
'''ἀποφθέγγομαι (verbe)''' : .&lt;br&gt;
'''ἀπόφθεγμα, -έγματος (nom commun) (n)''' : précepte, sentence.&lt;br&gt;
'''ἀποφθορά, -ᾶς (nom commun) (f)''' : avortement.&lt;br&gt;
'''ἀποφόρητον, -ου (nom commun) (n)''' : étrenne.&lt;br&gt;
'''ἀποφυγή, -ῆς (nom commun) (f)''' : échappée.&lt;br&gt; 
'''ἄποψις, -όψεως (nom commun) (f)''' : opinion, point de vue.&lt;br&gt;
'''ἀποψύχω (verbe)''' : s’évanouir.&lt;br&gt;
'''ἁπτικός, -ή, -όν (adjectif)''' : tactile.&lt;br&gt;
'''ἀπύ (adverbe ; préposition)''' : Forme arcado-chypriote et éolienne de ''ἀπό''.&lt;br&gt;
'''ἀπών, -οῦσα, -όν (adjectif)''' : absent.&lt;br&gt;
'''ἅπτω (verbe)''' : toucher.&lt;br&gt;
'''ἅπτω (verbe)''' : ajuster, attacher ; nouer.&lt;br&gt;
'''ἄρα (conjonction)''' : (Devient ''ἄρ’'' devant un mot commençant par une voyelle, et ''ῥά'' après un mot monosyllabique ou un mot finissant par une voyelle.) puis, et, alors. Par suite, ainsi donc, donc. Puisque, à savoir, c’est-à-dire, en effet. Ayant donc, ainsi parlé.&lt;br&gt;
'''ἆρα (particule)''' : (Devient ''ἆρ’'' devant un mot commençant par une voyelle.) est-ce que.&lt;br&gt;
'''ἀρά, -ᾶς (nom commun) (f)''' : Prière. Imprécation.&lt;br&gt;
'''ἄρακος, -άκου  (nom commun) (m)''' : pois.&lt;br&gt;
'''ἀράχνη, -ης (nom commun) (f)''' : araignée.&lt;br&gt;
'''ἀρϐύλη, -ης (nom commun) (f)''' : botte (chaussure épaisse au long col).&lt;br&gt;
'''ἄρδις, -ος (nom commun) (f)''' : pointe de flèche.&lt;br&gt; 
'''ἀργά (adverbe)''' : tard.&lt;br&gt;
'''ἄργιλλος, -ίλλου (nom commun) (m)''' : argile.&lt;br&gt; 
'''ἀργιλλοφόρητος''' : mot fantôme selon Rosane Rocher (1961), comme καλποφόρος, ὀφιοφόρος, ὠποφόρος et σμνρμοφόρος.&lt;br&gt; 
'''ἀργιλλώδης (adjectif)''' : argileux.&lt;br&gt;
'''ἀργός, -ή, -όν (adjectif)''' : blanc ; étincelant.&lt;br&gt;
'''ἄργυρος, -ύρου (nom commun) (m)''' : argent. (métal)&lt;br&gt;
'''ἀργῶ (verbe)''' : .&lt;br&gt;
'''ἀρετά, -ᾶς (nom commun) (f)''' : Forme dorienne de ''ἀρετή''.&lt;br&gt; 
'''ἀρετή, -ῆς (nom commun) (f)''' : vertu.&lt;br&gt; 
'''ἀρή, -ῆς (nom commun) (f)''' : Forme ionienne de ''ἀρά''.&lt;br&gt;
'''ἄρθρον, -ου (nom commun) (n)''' : Jointure, articulation. Article. (outil grammatical)&lt;br&gt;
'''ἀριστερός, -ά, -όν (adjectif)''' : Qui est à gauche.&lt;br&gt;
'''ἀριστόϐουλος, -ος, -ον (adjectif)''' : .&lt;br&gt;
'''ἄριστος, -η, -ον (adjectif)''' : excellent.&lt;br&gt;
'''ἀρκαδικός, -ή, -όν (adjectif)''' : arcadien.&lt;br&gt;
'''ἄρκευθος, -ύθου (nom commun) (f)''' : genévrier.&lt;br&gt; 
'''ἄρκτος, -ου (nom commun) (m/f)''' : ours(e).&lt;br&gt;
'''ἄρκυς, -ος (nom commun) (m)''' : filet.&lt;br&gt;
'''ἄρμα, -τος (nom commun) (t)''' : char.&lt;br&gt;
'''ἁρμονία, -ας  (nom commun) (f)''' : harmonie.&lt;br&gt;
'''ἁρμονικός, -ή, -όν (adjectif)''' : harmonieux.&lt;br&gt;  
'''ἁρμονικῶς (adverbe)''' : harmonieusement.&lt;br&gt;
'''ἁρμονικώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''ἁρμονικός''.&lt;br&gt;
'''ἁρμονικώτερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''ἁρμονικός''.&lt;br&gt;
'''ἁρμονικώτατα, -, - (adverbe)''' : Superlatif de ''ἁρμονικῶς''.&lt;br&gt;
'''ἁρμονικώτερον, -, - (adverbe)''' : Comparatif de ''ἁρμονικῶς''.&lt;br&gt;
'''ἀρνοῦμαι (verbe)''' : refuser.&lt;br&gt;
'''ἄρουρα, -ας (nom commun) (f)''' : aroure.&lt;br&gt;
'''ἀρουραῖος, -ίου (nom commun) (m)''' : rat.&lt;br&gt;
'''ἁρπακτικός, -οῦ (nom commun) (m)''' : prédateur.&lt;br&gt;
'''ἅρπαξ, -γος (nom commun) (m)''' : rapace, pillard.&lt;br&gt;
'''ἁρπίς, -ῖδος (nom commun) (f)''' : pantoufle.&lt;br&gt;
'''ἀρραϐών, -ῶνος (nom commun) (n)''' : arrhes.&lt;br&gt; 
'''ἄρρητος, -ος, -ον (adjectif)''' : Indicible ; ineffable, (Mathématiques) irrationnel.&lt;br&gt; 
'''ἄρσην, -ην, -εν (adjectif)''' : Mâle ; dur, fort.&lt;br&gt; 
'''ἄρρην, -ενος (nom commun) (m)''' : Forme attique de ''ἄρσην''.&lt;br&gt; 
'''ἄρσην, -ενος (nom commun) (m)''' : Homme adulte ; mâle.&lt;br&gt;
'''ἄρσης, -ενος (nom commun) (m)''' : Forme laconienne de ''ἄρσην''.&lt;br&gt; 
'''ἄρριχος, -ίχου (nom commun) (m)''' : panier.&lt;br&gt;
'''ἄρρωστος, -ος, -ον (adjectif)''' : .&lt;br&gt; 
'''ἀρρωστότατος, -άτη, -ότατον (adjectif)''' : Superlatif de ''ἄρρωστος''.&lt;br&gt;
'''ἀρρωστότερος, -έρα, -ότερον (adjectif)'''' : Comparatif de ''ἄρρωστος''.&lt;br&gt;
'''ἀρρωστότατα, -, - (adverbe)''' : Superlatif de ''ἀρρώστως''.&lt;br&gt;
'''ἀρρωστότερον, -, - (adverbe)''' : Comparatif de ''ἀρρώστως''.&lt;br&gt;
'''ἀρρώστως (adverbe)''' : .&lt;br&gt;
'''ἄρτι (adverbe)''' : justement ; exactement. Maintenant.&lt;br&gt;
'''ἄρτιος, -ία, -ον (adjectif)''' : Parfait, complet ; achevé. (Mathématiques) Pair, en parlant des nombres.&lt;br&gt;
'''ἀρτίως (adverbe)''' : parfaitement ; complètement.&lt;br&gt;
'''ἀρτιώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''ἄρτιος''.&lt;br&gt;
'''ἀρτιώτερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''ἄρτιος''.&lt;br&gt;
'''ἀρτοποιός, -οῦ (nom commun) (m)''' : boulanger .&lt;br&gt;
'''ἄρτος, -ου (nom commun) (m)''' : pain. (aliment)&lt;br&gt;
'''ἀρτῶ (verbe)''' : Attacher. (Au passif) Dépendre, pendre, être attaché à.&lt;br&gt; 
'''ἀρύϐαλλος, ου (nom commun) (m)''' : flacon à huile.&lt;br&gt;
'''ἀρχάγγελος, -έλου (nom commun) (m)''' : messager en chef ; archange.&lt;br&gt;
'''ἀρχαῖος, -ία, -ῖον (adjectif)''' : ancien.&lt;br&gt; 
'''ἀρχαιότατος, -άτη, -ότατον (adjectif)''' : Superlatif de ''ἀρχαῖος''.&lt;br&gt;
'''ἀρχαιότερος, -έρα, -ότερον (adjectif)''' : Comparatif de ''ἀρχαῖος''.&lt;br&gt;
'''ἀρχαίως (adverbe)''' : anciennement.&lt;br&gt;  
''', -, - (adverbe)''' : Superlatif de ''ἀρχαίως''.&lt;br&gt;
''', -, - (adverbe)''' : Comparatif de ''ἀρχαίως''.&lt;br&gt;
'''ἀρχαϊκός, -ή, -όν (adjectif)''' : vieilli.&lt;br&gt;
'''ἀρχαϊκότατος, -άτη, -ότατον (adjectif)''' : Superlatif de ''ἀρχαϊκός''.&lt;br&gt;
'''ἀρχαϊκότερος, -έρα, -ότερον (adjectif)''' : Comparatif de ''ἀρχαϊκός''.&lt;br&gt;
'''ἀρχαϊκῶς (adverbe)''' : vieillement.&lt;br&gt;  
'''ἀρχαϊκώτατα, -, - (adverbe)''' : Superlatif de ''ἀρχαϊκῶς''.&lt;br&gt;
'''ἀρχαϊκώτερον, -, - (adverbe)''' : Comparatif de ''ἀρχαϊκῶς''.&lt;br&gt;
'''ἀρχέτυπον, -ύπου (nom commun) (n)''' : modèle.&lt;br&gt; 
'''ἀρχή, -ῆς (nom commun) (f)''' : commencement, commandement.&lt;br&gt;
'''ἀρχηγός, -οῦ (nom commun) (m)''' : chef.&lt;br&gt;
'''-άρχης, -ου (suffixe)''' : qui est chef de.&lt;br&gt;
'''ἀρχι- (préfixe)''' : relatif au commencement, au commandement.&lt;br&gt;
'''ἀρχιδιάκονος, -όνου (nom commun) (m/f)''' : archidiacre.&lt;br&gt;
'''ἀρχιδιήκονος, -όνου (nom commun) (m/f)''' : Forme ionienne de ''ἀρχιδιάκονος''.&lt;br&gt;
'''ἀρχίκλωψ, -πός (nom commun) (m)''' : maître voleur.&lt;br&gt;
'''ἀρχίμιμος, -ίμου (nom commun) (m)''' : archimime.&lt;br&gt;
'''ἀρχιτέκτων, -ονος (nom commun) (m)''' : maître d’œuvre.&lt;br&gt;
'''ἄρχων, -οντος (nom commun) (m)''' : archonte.&lt;br&gt;
'''ἄρωμα, -ώματος (nom commun) (n)''' : parfum.&lt;br&gt; 
'''ἄρω (verbe)''' : nouer.&lt;br&gt;
'''ἄσϐολος, -όλου (nom commun) (f)''' : suie.&lt;br&gt;
'''ἀσέϐεια, -ας (nom commun) (f)''' : impiété.&lt;br&gt;
'''ἀσεϐής, -ής, -ές (adjectif)''' : impie.&lt;br&gt;
'''ἀσεϐῶ (verbe)''' : être impie.&lt;br&gt;
'''ἀσέλγεια, -ας (nom commun) (f)''' : lubricité.&lt;br&gt;
'''ἀσελγέστατος, -άτη, -έστατον (adjectif)''' : Superlatif de ''ἀσελγής''.&lt;br&gt;
'''ἀσελγέστερος, -έρα, -έστερον (adjectif)''' : Comparatif de ''ἀσελγής''.&lt;br&gt;
'''ἀσελγής, -ής, -ές (adjectif)''' : lubrique.&lt;br&gt;
'''ἀσελγότατα, -, - (adverbe)''' : Superlatif de ''ἀσελγῶς''.&lt;br&gt;
'''ἀσελγότερον, -, - (adverbe)''' : Comparatif de ''ἀσελγῶς''.&lt;br&gt;
'''ἀσελγῶς (adverbe)''' : lubriquement.&lt;br&gt;
'''ἀσελγῶ (verbe)''' : être lubrique.&lt;br&gt;
'''ἀσθενής, -ής, -ές (adjectif)''' : malade.&lt;br&gt;
'''ἄσθμα, -τος (nom commun) (n)''' : asthme.&lt;br&gt;
'''ἄσις, - (nom commun) (f)''' : Boue, argile.&lt;br&gt;
'''ἀσκάλαϐος, -άϐου (nom commun) (m)''' : gecko.&lt;br&gt;
'''ἄσκαυλος, -ύλου (nom commun) (m)''' : cornemuse.&lt;br&gt;
'''ἀσκέω (verbe)''' : entraîner.&lt;br&gt;
'''ἄσκημα, -ήματος (nom commun) (n)''' : entraînement.&lt;br&gt;
'''ἄσκησις, -ήσεως (nom commun) (f)''' : exercice.&lt;br&gt;
'''ἀσκητεία, -ας (nom commun) (f)''' : ascétie.&lt;br&gt;
'''ἀσκητήριον, -ίου (nom commun) (n)''' : .&lt;br&gt;
'''ἀσκητής, -οῦ (nom commun) (m)''' : ascète.&lt;br&gt;
'''ἀσκητικός, -ή, -όν (adjectif)''' : ascétique.&lt;br&gt;
'''ἀσκός, -οῦ (nom commun) (m)''' : outre.&lt;br&gt;
'''ἀσκῶ (verbe)''' : exercer.&lt;br&gt;
'''ᾆσμα, -τος (nom commun) (n)''' : chant.&lt;br&gt;
'''ἀσπάλαξ, -κος (nom commun) (m)''' : taupe.&lt;br&gt;
'''ἄσπαλος, -άλου (nom commun) (m)''' : squale.&lt;br&gt;
'''ἀσπίς, -δος (nom commun) (f)''' : bouclier.&lt;br&gt;
'''ἀστακός, -οῦ (nom commun) (m)''' : homard.&lt;br&gt;
'''ἀστεῖος, -ία, -ῖον (adjectif)''' : urbain.&lt;br&gt;
'''ἀστήρ, -έρος (nom commun) (m)''' : étoile.&lt;br&gt;
'''ἀστικός, -ή, -όν (adjectif)''' : urbain.&lt;br&gt;
'''ἀστραπή, -ῆς  (nom commun) (f)''' : éclair.&lt;br&gt; 
'''ἄστρον, -ου (nom commun) (n)''' : Astre, constellation, système d’étoiles.&lt;br&gt;
'''ἀστυνομία, -ας (nom commun) (f)''' : police urbaine.&lt;br&gt;
'''ἀστυνόμος, -ου (nom commun) (m)''' : astynome.&lt;br&gt;	
'''ἀστύνομος, -ος, -ον (adjectif)''' : public.&lt;br&gt;	
'''ἄστυ, -εως (nom commun) (n)''' : Cité ; ville.&lt;br&gt;
'''ἀστυφύλαξ, -κος (nom commun) (m)''' : policier.&lt;br&gt;
'''ἄσυλον, -ύλου (nom commun) (n)''' : asile.&lt;br&gt;
'''ἄσυλος, -ος, -ον (adjectif)''' : inviolable.&lt;br&gt;
'''ἀσυμμετρία, -ας (nom commun) (f)''' : mauvaise proportion.&lt;br&gt;
'''ἄσυχος, -ος, -ον (adjectif)''' : Forme dorienne de ''ἥσυχος''.&lt;br&gt;
'''ἀσφάλεια, -ίας (nom commun) (f)''' : sécurité.&lt;br&gt;
'''ἀσφαλής, -ής, -ές (adjectif)''' : sûr.&lt;br&gt;	
'''ἄσφαλτος, -άλτου (nom commun) (f)''' : asphalte.&lt;br&gt;
'''ἀσφαλῶς (adverbe)''' : sûrement.&lt;br&gt;
'''-άς, -δος (suffixe) (f)''' : Forme des noms d’agent.&lt;br&gt;
'''ἄτα, -ας (nom commun)''' : Forme dorienne de ''ἄτη''.&lt;br&gt;
'''ἄτακτος, -η, -ον (adjectif)''' : vilain.&lt;br&gt; 
'''ἀταξία, -ας (nom commun) (f)''' : vilénie.&lt;br&gt;
'''ἀταραξία, -ας (nom commun) (f)''' : Calme ; imperturbabilité.&lt;br&gt;
'''ἅτερος, -έρα, -ερον (adjectif)''' : Forme dorienne de ''ἕτερος''.&lt;br&gt;
'''ἄτερος, -έρα, -ερον (adjectif)''' : Forme éolienne de ''ἕτερος''.&lt;br&gt;
'''ἄτη, -ης (nom commun)''' : Outrage. (Religion) Péché, faute. Ruine.&lt;br&gt;
'''ἀτιμάζω (verbe)''' : déshonorer.&lt;br&gt;
'''ἄτρακτος, -άκτου (nom commun) (n)''' : fuseau.&lt;br&gt;
'''ἀτραπός, -οῦ (nom commun) (f)''' : sentier.&lt;br&gt;
'''ἄττα, -ου (nom commun) (m)''' : Forme homérique de ''πάππας'' et ''τατᾶ''.&lt;br&gt;
'''ἀτύχημα, -ήματος (nom commun) (n)''' : accident.&lt;br&gt; 
'''ἀτυχῶ (verbe)''' : avoir un accident.&lt;br&gt;
'''αὐθάδεια, -ας (nom commun) (f)''' : insolence.&lt;br&gt;
'''αὐθάδης, -ής, -ές  (adjectif)''' : insolent.&lt;br&gt;
'''αὖθις (adverbe)''' : à nouveau.&lt;br&gt;
'''αὖλαξ, -ὔλακος (nom commun) (m)''' : irrigation.&lt;br&gt;
'''αὐλή, -ῆς (nom commun) (f)''' : cour.&lt;br&gt;
'''αὐλητής, -οῦ (nom commun) (m)''' : joueur d’aulos.&lt;br&gt;
'''αὐλητρίς, -δος (nom commun) (f)''' : joueuse d’aulos.&lt;br&gt;
'''αὐλίζομαι (verbe)''' : passer la nuit.&lt;br&gt;
'''αὖλις, - (nom commun) (f)''' : résidence, camp.&lt;br&gt;
'''αὐλός, -οῦ (nom commun) (m)''' : aulos.&lt;br&gt;
'''αὐλῶ (verbe)''' : jouer de l’aulos.&lt;br&gt;
'''αὐξάνω (verbe)''' : augmenter.&lt;br&gt;
'''αὔξη, -ης (nom commun) (f)''' : croissance.&lt;br&gt;
'''αὔξημα, -ήματος (nom commun) (n)''' : .&lt;br&gt;
'''αὔξησις, -ήσεως (nom commun) (f)''' : Accroissement, hausse.&lt;br&gt;
'''αὔξιμος, -ος, -ον (adjectif)''' : .&lt;br&gt;
'''αὐξητικός, -ή, -όν (adjectif)''' : .&lt;br&gt;
'''αὔξω (verbe)''' : croître.&lt;br&gt;
'''ἀϋπνία, -ας (nom commun) (f)''' : insomnie.&lt;br&gt; 
'''αὔρα, -ας (nom commun) (f)''' : aura.&lt;br&gt;
'''αὔρη, -ης (nom commun) (f)''' : Forme ionienne de ''αὔρα''.&lt;br&gt;
'''αὔριον (adverbe)''' : demain, bientôt.&lt;br&gt;
'''αὐστηρός, -ή, -όν (adjectif)''' : sévère.&lt;br&gt; 
'''αὐστηρότης, -τος (nom commun) (f)''' : sévérité.&lt;br&gt;
'''αὐστηρότατος, -άτη, -ότατον (adjectif)''' : Superlatif de ''αὐστηρότατος''.&lt;br&gt;
'''αὐστηρότερος, -έρα, -ότερον (adjectif)''' : Comparatif de ''αὐστηρότατος''.&lt;br&gt;
'''αὐστηρῶς (adverbe)''' : sévèrement.&lt;br&gt;
'''αὐτανάφλεξις, -έξεως (nom commun) (f)''' : combustion spontanée.&lt;br&gt;
'''αὐτάναξ, -κτος (nom commun) (m)''' : empereur.&lt;br&gt;
'''αὐτάρ (adverbe)''' : mais, cependant.&lt;br&gt;
'''αὐτίκα (adverbe)''' : aussitôt, sur-le-champ.&lt;br&gt;
'''αὐτοκίνητος, -ος, -ον (adjectif)''' : .&lt;br&gt;
'''αὐτοκινῶ (verbe)''' : .&lt;br&gt;
'''αὐτοκράτειρα, -ας (nom commun) (f)''' : impératrice.&lt;br&gt;
'''αὐτοκρατορία, -ας (nom commun) (f)''' : empire.&lt;br&gt;
'''αὐτοκράτωρ, -ορος (nom commun) (m)''' : empereur.&lt;br&gt;
'''αὐτολεξεί (adverbe)''' : mot pour mot.&lt;br&gt;
'''αὐτός -ή, -ό (pronom personnel)''' : il.&lt;br&gt;
'''αὐτοσχεδιάζω (verbe)''' : improviser.&lt;br&gt;
'''αὐτοσχεδιασμός, -οῦ (nom commun) (m)''' : improvisation.&lt;br&gt;
'''αὐτοσχέδιος, -ος, -ον (adjectif)''' : improvisé.&lt;br&gt;
'''αὐτοσχεδίως (verbe)''' : de façon improvisée.&lt;br&gt;
'''αὐτόχθων, -ων, -ον  (adjectif)''' : indigène.&lt;br&gt;
'''αὐτοψία, -ας (nom commun) (f)''' : autopsie.&lt;br&gt; 
'''αὐχήν, -ένος (nom commun) (m)''' : nuque.&lt;br&gt;
'''αὕω (verbe)''' : soustraire.&lt;br&gt;
'''ἀφαίρεσις, -έσεως (nom commun) (f)''' : soustraction.&lt;br&gt; 
'''ἀφαιρῶ (verbe)''' : soustraire.&lt;br&gt;
'''ἀφεδρών, -ῶνος (nom commun) (m)''' : latrine.&lt;br&gt;
'''αφέλεια,  -ίας (nom commun) (f)''' : ingénuité, naïveté.&lt;br&gt;
'''ἀφελής, -ής, -ές  (adjectif)''' : ingénu, naïf.&lt;br&gt; 
'''ἁφή, -ῆς (nom commun) (f)''' : toucher.&lt;br&gt;
'''ἀφήγημα, -ήματος (nom commun) (n)''' : récit.&lt;br&gt;
'''ἀφηγηματικός, -ή -όν (adjectif)''' : narratif.&lt;br&gt;
'''ἀφηγηματικώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''ἀφηγηματικός''.&lt;br&gt;
'''ἀφηγηματικώτερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''ἀφηγηματικός''.&lt;br&gt;
'''ἀφηγηματικώτατα, -, - (adverbe)''' : Superlatif de ''ἀντιφατικῶς''.&lt;br&gt;
'''ἀφηγηματικώτερον, -, - (adverbe)''' : Comparatif de ''ἀντιφατικῶς''.&lt;br&gt;
'''ἀφήγησις, -ήσεως (nom commun) (f)''' : narration.&lt;br&gt;
'''ἀφηγητής, -οῦ (nom commun) (m)''' : narrateur.&lt;br&gt;
'''ἀφηγοῦμαι (verbe)''' : narrer.&lt;br&gt;
'''ἄφθα, -ης (nom commun) (f)''' : aphte.&lt;br&gt;
'''ἀφίημι (verbe)''' : Envoyer, renvoyer. Laisser aller, lâcher, relâcher. Libérer.&lt;br&gt;
'''ἄφιξις, -ίξεως (nom commun) (f)''' : arrivée.&lt;br&gt;
'''ἀφόδευσις, -ύσεως (nom commun) (f)''' : défécation.&lt;br&gt; 
'''ἀφοδεύω (verbe)''' : déféquer.&lt;br&gt;
'''ἀφοπλίζω (verbe)''' : désarmer.&lt;br&gt;
'''ἀφοπλισμός, -οῦ (nom commun) (m)''' : désarmement.&lt;br&gt;
'''ἀφροδισιακός -ή -όν (adjectif)''' : aphrodisiaque.&lt;br&gt;
'''ἀφροδισιασμός, -οῦ (nom commun) (m)''' : aphrodisiasme.&lt;br&gt;
'''ἀφροδισιαστικός, -ή -όν (adjectif)''' : aphrodisiastique.&lt;br&gt;
'''ἀφορισμός, -οῦ (nom commun) (m)''' : abolition, excommunication.&lt;br&gt; 
'''ἀφροδίσιος, -α, -ον (adjectif)''' : vénérien.&lt;br&gt;
'''ἀφορίζω (verbe)''' : abolir, excommunier.&lt;br&gt; 
'''ἀφοσίωσις, -ώσεως (nom commun) (f)''' : dévotion.&lt;br&gt;
'''ἀφρός, -οῦ (nom commun) (m)''' : écume.&lt;br&gt;
'''ἀφύη, -ῆς (nom commun) (f)''' : anchois.&lt;br&gt; 
'''ἀναχαίνω (verbe)''' : retenir son souffle.&lt;br&gt;
'''ἀναχάσκω (verbe)''' : ouvrir la bouche.&lt;br&gt;
'''ἀχαριστῶ (verbe)''' : .&lt;br&gt;
'''ἁχατης, -ου (nom commun) (m)''' : agate.&lt;br&gt;
'''ἀχλυόεις, -εσσα, -εν (adjectif)''' : brumeux.&lt;br&gt; 
'''ἀχλυοέντως (adverbe)''' : .&lt;br&gt;
'''ἀχλυοέστατος, -άτη, -έστατον (adjectif)''' : Superlatif de ''ἀχλυόεις''.&lt;br&gt;
'''ἀχλυοέστερος, -έρα, -ερον (adjectif)''' : Comparatif de ''ἀχλυόεις''.&lt;br&gt;
'''ἄχλυσις, -εως (nom commun) (f)''' : .&lt;br&gt; 
'''ἀχλύς, -ος (nom commun) (f)''' : brume, ténèbres.&lt;br&gt; 
'''ἀχλυώδης, -ης, -ες (adjectif)''' : .&lt;br&gt; 
'''ἀχλυῶ (verbe)''' : .&lt;br&gt; 
'''ἀχράς, -δος (nom commun) (f)''' : poire.&lt;br&gt; 
'''ἄχερδος, -έρδου (nom commun) (f)''' : poire.&lt;br&gt;
'''ἀχυρών, -ῶνος (nom commun) (m)''' : grange.&lt;br&gt; 
'''ἀψίνθιον, -ίου (nom commun) (n)''' : absinthe.&lt;br&gt;
'''ἄψογος, -ος, -ον (n)''' : impeccable.&lt;br&gt;
'''ἄψ (adverbe)''' : En arrière (sans mouvement), en retour. Encore.&lt;br&gt;
'''ἄωτον, -ου (nom commun) (n)''' : summum.&lt;br&gt;
'''ἄω (verbe)''' : souffler, dormir.&lt;br&gt;
'''Ἀαρών (nom propre) (m)''' : Aaron.&lt;br&gt; 
'''Ἀϐαδδών (nom propre) (m)''' : Abaddon.&lt;br&gt; 
'''Ἀϐδίας, -ου (nom propre) (m)''' : Abdias.&lt;br&gt;
'''Ἅϐελ (nom propre) (m)''' : Abel.&lt;br&gt;  
'''Ἀϐέλλα, -ας (nom propre) (f)''' : Avella.&lt;br&gt; 
'''Ἀϐενέζερ (nom propre) (m)''' : Ebenezer.&lt;br&gt; 
'''Ἀϐησσυνία, -ας (nom propre) (f)''' : Abyssinie.&lt;br&gt; 
'''Ἀϐιά (nom propre) (m)''' : Abija.&lt;br&gt; 
'''Ἀϐιάθαρ (nom propre) (m)''' : Abiathar.&lt;br&gt; 
'''Ἀϐιγαία, -ας (nom propre) (m)''' : Abigaëlle.&lt;br&gt;
'''Ἀϐραάμ (nom propre) (m)''' : Abraham.&lt;br&gt; 
'''Ἀϐράμης, -ου (nom propre) (m)''' : Forme alternative de ''Ἀϐραάμ''.&lt;br&gt;
'''Ἀϐραμίας, -ου (nom propre) (m)''' : Forme alternative de ''Ἀϐραάμ''.&lt;br&gt;
'''Ἄϐραμος, - (nom propre) (m)''' : Forme alternative de ''Ἀϐραάμ''.&lt;br&gt;
'''Ἀγαμέμνων, -ονος (nom propre) (m)''' : Agamemnon.&lt;br&gt; 
'''Ἀγαθή, -ῆς (nom propre) (f)''' : Agathe.&lt;br&gt; 
'''Ἀγαθοκλῆς, -έους (nom propre) (m)''' : Agathoclès.&lt;br&gt;
'''Ἀγήνωρ, -ορος (nom propre) (m)''' : Agénor.&lt;br&gt; 
'''Ἀγησίλαος, -άου (nom propre) (m)''' : Agésilas.&lt;br&gt; 
'''Αἰγεύς, -έως  (nom propre) (m)''' : Égée.&lt;br&gt;
'''Αἰγιδιός, -οῦ (prénom) (m)''' : Gilles.&lt;br&gt;
'''Αἴγλη, -ης (nom propre) (f)''' : Églé.&lt;br&gt;
'''Αἰγόκερως, -έρωτος (nom commun) (f)''' : Capricorne.&lt;br&gt;
'''Ἄγκυρα, -ύρας (nom propre) (f)''' : Ankara.&lt;br&gt;
'''Ἀγλαΐα, -ας (nom propre) (f)''' : Aglaé.&lt;br&gt;
'''Ἀγλαός, -οῦ (nom propre) (m)''' : Aglaos.&lt;br&gt;
''', - (nom propre) (m)''' : Agrios.&lt;br&gt;
'''Ἁγνοδίκη, -ης (nom propre) (f)''' : Agnodice.&lt;br&gt;
'''Ἁγνωνίδης, -ου (nom propre) (m)''' : .&lt;br&gt;
'''Ἀγρίππας, -α (nom propre) (m)''' : Agrippa.&lt;br&gt; 
'''Ἀγριππίνη, -ης (nom propre) (f)''' : Agrippine.&lt;br&gt;
'''Ἀδάμ (nom propre) (m)''' : Adam.&lt;br&gt; 
'''ᾍδης, -ου (nom propre) (m)''' : [[wikt:Hadès|Hadès]].&lt;br&gt;
'''Ἀδικία, -ας (nom propre) (f)''' : Adicie.&lt;br&gt; 
'''Ἁδριανούπολις, -όλεως  (nom propre) (f)''' : Edirne.&lt;br&gt;
'''Ἁδριανός, -οῦ (nom propre) (m)''' : Hadrien.&lt;br&gt;
'''Ἄδωνις, -ώνιδος (nom propre) (m)''' : Adonis.&lt;br&gt; 
'''Ἀζαζέλ (nom propre) (m)''' : Azazel.&lt;br&gt; 
'''Ἀθανάσιος, -ίου (nom propre) (m)''' : Athanase.&lt;br&gt;
'''Ἀθάνα, -ας (nom propre) (f)''' : Forme dorienne de ''Ἀθηνᾶ''.&lt;br&gt;
'''Ἀθηνᾶ, -ᾶς (nom propre) (f)''' : [[wikt:Athéna|Athéna]].&lt;br&gt;
'''Ἀθῆναι, -ῶν (nom propre) (f)''' : Athènes.&lt;br&gt;
'''Ἀθηναία, -ας (nom propre) (f)''' : Forme de ''Ἀθηνᾶ''.&lt;br&gt;
'''Ἀθηναῖα, -ίας (nom commun) (f)''' : Athénienne.&lt;br&gt;
'''Ἀθηναῖος, -ίου (nom commun) (m)''' : Athénien.&lt;br&gt;
'''Ἀθήναιος, -ίου (nom propre) (m)''' : Athénée.&lt;br&gt;
'''Ἀθήνη, -ης (nom propre) (f)''' : Forme ionienne de ''Ἀθηνᾶ''.&lt;br&gt;
'''Ἀθηνόδωρος, -ώρου (nom propre) (m)''' : Athénodore.&lt;br&gt;
'''Ἀθύρ (nom propre) (m)''' : Athyr.&lt;br&gt;
'''Ἅθωρ (nom propre) (f)''' : Hathor.&lt;br&gt;
'''Ἄθως, -ω (nom propre) (m)''' : Athos (géant) ; mont Athos.&lt;br&gt;
'''Αἰακός, -οῦ (nom propre) (m)''' : Éaque.&lt;br&gt;
'''Αἴας, -ντος (nom propre) (m)''' : Ajax.&lt;br&gt; 
'''Αἰαία, -ας (nom propre) (f)''' : Ééa.&lt;br&gt;
'''Ἀΐδας, -ου (nom propre) (m)''' : Forme dorienne de ''ᾍδης''.&lt;br&gt;
'''Ἀΐδης, -ου (nom propre) (m)''' : Forme homérique de ''ᾍδης''.&lt;br&gt; 
'''Ἀϊδωνεύς, -έως (nom propre) (m)''' : Forme  de ''ᾍδης''.&lt;br&gt; 
'''Αἰγεύς, -έως (nom propre) (m)''' : Égée.&lt;br&gt;
'''Αἰγιδιός, -οῦ (prénom) (m)''' : Gilles.&lt;br&gt;
'''Αἴγισθος, -ίσθου (nom propre) (m)''' : Égisthte.&lt;br&gt;
'''Αἴγυπτος, -ύπτου (nom propre) (m)''' : Égypte.&lt;br&gt;
'''Αἰήτης, -ου (nom propre) (m)''' : Éétès.&lt;br&gt; 
'''Αἰκατερίνη, -ης (prénom) (f)''' : Catherine.&lt;br&gt;
'''Αἰθαλία, -ας (nom propre) (f)''' : Italie.&lt;br&gt;
'''Αἰθήρ, -έρος (nom propre) (m)''' : [[wikt:Éther|Éther]].&lt;br&gt; 
'''Αἰθιοπία, -ας (nom propre) (f)''' : Éthiopie.&lt;br&gt;
'''Αἰθιοπίς, -δος (nom commun) (f)''' : Éthiopienne.&lt;br&gt;
'''Αἰθίοψ, -πος (nom commun) (m)''' :  Éthiopien.&lt;br&gt;
'''Αἰμιλία, -ας (nom propre) (f)''' : Émilie.&lt;br&gt;
'''Αἰμίλιος, -ίου (nom propre) (m)''' : Émile.&lt;br&gt;
'''Αἰνέας, -ου (nom propre) (m)''' : Forme poétique de ''Αἰνείας''.&lt;br&gt;
'''Αἰνείας, -ου (nom propre) (m)''' : Énée.&lt;br&gt;
'''Αἰνειάς, -δος (nom propre) (f)''' : Énéide.&lt;br&gt;
'''Αἰολίς, -δος (nom propre) (f)''' : Éolide.&lt;br&gt;
'''Αἰολεύς, -έως (nom commun) (m)''' : Éolien.&lt;br&gt;  
'''Αἴολος, -όλου (nom propre) (m)''' : [[wikt:Éole|Éole]].&lt;br&gt;
'''Αἴολος, -όλου (nom propre) (m)''' : Éole (fils d'Hellen).&lt;br&gt;
'''Αἶσα, -ἴσης (nom commun) (f)''' : [[wikt:Ésa|Ésa]].&lt;br&gt; 
'''Αἰσχύλος, -ου (nom propre) (m)''' : Eschyle.&lt;br&gt;
'''Αἴσωπος, -ώπου (nom propre) (m)''' : Ésope.&lt;br&gt;
'''Αἴτνη, -ης (nom propre) (f)''' : Etna.&lt;br&gt;
'''Αἰών, -ῶνου (nom propre) (m)''' : Éon.&lt;br&gt;
'''Ἀκαδημία, -ας (nom propre) (f)''' : jardin d’Académos, près d’Athènes, où Platon enseignait.&lt;br&gt;
'''Ἀκάδημος, -ήμου (nom propre) (m)''' : Académos.&lt;br&gt;
'''Ἄκις, -εως (nom propre) (m)''' : Acis.&lt;br&gt;
'''Ἀκταίων, -ος (nom propre) (m)''' : Actéon.&lt;br&gt;
'''Ἀκτέων, -ος (nom propre) (m)''' : Forme poétique d’''Ἀκταίων''.&lt;br&gt;
'''Ἄκτωρ, -ορος (nom propre) (m)''' : Actor (frère cadet d’Augias).&lt;br&gt;
'''Ἀκκώ, -οῦς (nom propre) (f)''' : Aléria.&lt;br&gt;
'''Ἀλαλίη, -ης (nom propre) (f)''' : Aléria.&lt;br&gt;
'''Ἀλϐίων, -ος (nom propre) (m)''' : Albion.&lt;br&gt;
'''Ἀλεξάνδρεια, -ίας (nom propre) (f)''' : Alexandrie.&lt;br&gt; 
'''Ἀλεξανδρέττα, -ας (nom commun) (f)''' : Alexandrine.&lt;br&gt; 
'''Ἀλεξανδρεύς, -έως (nom commun) (m)''' : Alexandrin.&lt;br&gt;  
'''Ἀλέξανδρος, -άνδρου (nom propre) (m)''' : Alexandre.&lt;br&gt;
'''Ἀλέξανδρος ὁ Μέγας (nom propre) (m)''' : Alexandre le Grand.&lt;br&gt;
'''Ἄλεξις, - (nom propre) (m)''' : Alexis.&lt;br&gt; 
'''Ἀληκτώ, -οῦς (nom propre) (f)''' : Alecto (une des Érynies).&lt;br&gt;
'''Ἀλήτης, -ου (nom propre) (m)''' : Alétès.&lt;br&gt; 
'''Ἀλθαία, -ας (nom propre) (f)''' : Althée.&lt;br&gt;
'''Ἀλιλάτ (nom propre) (f)''' : Al-Lat.&lt;br&gt;
'''Ἀλκάθοος, -ου (prénom) (m)''' : Alcathoos.&lt;br&gt;
'''Ἀλκείδης, ου (nom propre) (m)''' : Alcide (Premier nom d’Héraclès.).&lt;br&gt;
'''Ἄλκης, -ους (nom propre) (m)''' : Alceste.&lt;br&gt;
'''Ἄλκηστις, -ήστιδος (nom propre) (f)''' : Alceste.&lt;br&gt;
'''Ἀλκιϐιάδης, ου (nom propre) (m)''' : Alcibiade.&lt;br&gt;
'''Ἀλκίνοος, -ου (nom propre) (m)''' : Alcinoos.&lt;br&gt;
'''Ἀλκμαίων, -ος (nom propre) (m)''' : Alcméon.&lt;br&gt;
'''Ἀλκμήνη, -ης (nom propre) (f)''' : Alcmène.&lt;br&gt;
'''Ἀλφιτώ, -οῦς  (nom propre) (f)''' : Alphito.&lt;br&gt;
'''Ἀλώπηξ, -εκος (nom propre) (f)''' : Vulpecula.&lt;br&gt;
'''Ἀμϐρόσιος, -ίου  (nom propre) (m)''': Ambroise.&lt;br&gt;
'''Ἀμαζών, -όνος (nom propre) (f)''' : Amazone.&lt;br&gt;
'''Ἀμένωφις, - (nom propre) (m)''': Aménophis.&lt;br&gt;
'''Ἄμηστρις, -δος (nom propre) (f)''' : Amestris.&lt;br&gt;
'''Ἀμαύνι (nom propre) (f)''' : Amemet.&lt;br&gt;
'''Ἀμπρακία, -ας (nom propre) (f)''' : Ambracie.&lt;br&gt;
'''Ἀμπρακιώτης, -ου (nom commun) (m)''' : Ambracien.&lt;br&gt;
'''Ἀμπρακιῶτις, -ώτιδος (nom commun) (f)''' : Ambracienne.&lt;br&gt;
'''Ἀμύντας, -ου (nom propre) (m)''' : Amyntas.&lt;br&gt;
'''Ἀμφιμέδων, -οντος (nom propre) (m)''' : Amphimédon.&lt;br&gt;
'''Ἀμφιστρεύς, -έως (nom propre) (m)''' : Amphitrée.&lt;br&gt;
'''Ἀμφιτρίτη, -ης (nom propre) (f)''' : Amphitrite.&lt;br&gt;
'''Ἀμφιτροπή, -ῆς (nom propre) (f)''' : Amphitropée.&lt;br&gt;
'''Ἀμφιτρύων, -ωνος (nom propre) (m)''' : Amphitryon.&lt;br&gt;
'''Ἀναξίϐια, -ας (nom propre) (f)''' : Anaxibie.&lt;br&gt;
'''Ἀναξίϐιος, -ίου (nom propre) (m)''' : Anaxibios.&lt;br&gt;
'''Ἀννίϐας, -ου (nom propre) (m)''' : Hannibal.&lt;br&gt; 
'''Ἀνδρέας, -ου (prénom) (m)''' : André.&lt;br&gt;
'''Ἄννα, -ας (prénom) (f)''' : Anne.&lt;br&gt;
'''Ἀνάγκη, -ης (nom propre) (f)''' : Ananké.&lt;br&gt;
'''Ἀναῗτις, -ΐτεως (nom propre) (f)''' : Anaïs.&lt;br&gt;
'''Ἀναξαγόρας, -ου (nom propre) (m)''' : Anaxagore.&lt;br&gt;
'''Ἀναξίμανδρος, -ου (nom propre) (m)''' : Anaximandre.&lt;br&gt;
'''Ἀναξιμήνης, -ου (nom propre) (m)''' : Anaximène.&lt;br&gt;
'''Ἀναστασία, -ας (nom propre) (f)''' : Anastasie.&lt;br&gt;
'''Ἀναστάσιος, -ίου (nom propre) (m)''' : Anastase.&lt;br&gt;
'''Ἀνατόλιος, -ίου (nom propre) (m)''' : Anatole.&lt;br&gt; 
'''Ἄνουϐις, -ύϐιδος (nom propre) (m)''' : [[wikt:Anubis|Anubis]].&lt;br&gt;
'''Ἄνουκις, -δος (nom propre) (f)''' : Anoukis.&lt;br&gt;
'''Ἀντέρως, -τος (nom propre) (m)''' : [[wikt:Antéros|Antéros]].&lt;br&gt;
'''Ἀντιγόνη, -ης (nom propre) (f)''' : Antigone.&lt;br&gt;
'''Ἀντίκλεια, -ας (nom propre) (f)''' : Anticlée (mère d'Ulysse).&lt;br&gt;
'''Ἀντικύθηρα, -ήρων (nom propre) (n)''' : Anticythère.&lt;br&gt;
'''Ἀντίνοoς, -όου (nom propre) (m)''' : Antinoüs.&lt;br&gt;
'''Ἀντίπολις, -όλεως (nom propre) (f)''' : Antipolis.&lt;br&gt;
'''Ἀντισθένης, -ους (nom propre) (m)''' : Antisthène. (Philosophe né vers 444 av. J.-C. et décédé vers 365 av. J.-C.)&lt;br&gt;
'''Ἄντων, -ου (nom propre) (m)''' : Anton.&lt;br&gt;
'''Ἀξιός, -οῦ (nom propre) (m)''' : Axius.&lt;br&gt;
'''Ἀπάτη, -ης (nom propre) (f)''' : Apaté.&lt;br&gt;
'''Ἀπιδανός, -οῦ (nom propre) (m)''' : Apidanus.&lt;br&gt;
'''Ἆπις, Ἄπιδος (nom propre)''' : Apis.&lt;br&gt;
'''Ἀπολλόδωρος, -ώρου (nom propre) (m)''' : Apollodore.&lt;br&gt;
'''Ἀπόλλων, -ωνος (nom propre) (m)''' : [[wikt:Apollon|Apollon]].&lt;br&gt;
'''Ἀρά, -ᾶς (nom propre) (f)''' : [[wikt:Ara|Ara]].&lt;br&gt;
'''Ἀραϐία, -ας (nom propre) (f)''' : Arabie.&lt;br&gt;
'''Ἀράχνη, -ης (nom propre) (f)''' : Arachné.&lt;br&gt;
'''Ἄραψ, -ϐος (nom commun) (m/f)''' : Arabe.&lt;br&gt;
'''Ἀραράτ (nom propre) (m)''' :  Ararat.&lt;br&gt;
'''Ἀργαῖος, -ίου (nom propre) (m)''' : Argaïos.&lt;br&gt;
'''Ἀργοναῦτης, -ύτου (nom commun) (m)''' : Argonaute.&lt;br&gt;
'''Ἀργῷος, -ῴος, -ῷον (adjectif)''' : .&lt;br&gt;
'''Ἀργώ, -οῦς (nom propre) (f)''' : Argo.&lt;br&gt;
'''Ἀρετή, -ῆς (nom propre) (f)''' : Arété (déesse).&lt;br&gt;
'''Ἄρευς, -εως (nom propre) (m)''' : Forme éolienne de ''Ἄρης''.&lt;br&gt;
'''Ἄρης, -εως (nom propre) (m)''' : [[wikt:Arès|Arès]].&lt;br&gt;
'''Ἀρήτη, -ης (nom propre) (f)''' : Arété (philosophe grecque de l'école des Cyrénaiques).&lt;br&gt;
'''Ἀρίσταρχος, -άρχου (nom commun) (m)''' : Aristarque.&lt;br&gt;
'''Ἀριστόϐουλος, -ύλου (nom propre) (m)''' : Aristobule.&lt;br&gt;
'''Ἀριστογείτων, -ονος (nom propre) (m)''' : Aristogiton.&lt;br&gt; 
'''Ἀριστοτέλης, -ους (nom propre) (m)''' : Aristote.&lt;br&gt;
'''Ἀριστώνυμος, -ύμου (nom propre) (m)''' : Aristonyme.&lt;br&gt;
'''Ἀρίων, -ονος (nom propre) (m)''' : Arion.&lt;br&gt;
'''Ἀρκαδία, -ας (nom propre) (f)''' : Arcadie.&lt;br&gt;
'''Ἀρκάς, -δος (nom commun) (m/f)''' : Arcadien ; Arcadienne.&lt;br&gt;
'''Ἀρκτοῦρος, -ύρου (nom propre) (m)''' : Arcturus.&lt;br&gt;
'''Ἁρμαγεδών (nom propre) (m)''' : Armageddon.&lt;br&gt;
'''Ἁρμόδιος, -ίου (nom propre) (m)''' : Harmodios.&lt;br&gt;
'''Ἀρσένιος, -ίου (nom propre) (m)''' : Arsène.&lt;br&gt;
'''Ἀρσινόη, -ης (nom propre) (f)''' : Arsinoé.&lt;br&gt;
'''Ἀρταξέρξης, -ου (nom propre) (m)''' : Artaxerxès.&lt;br&gt;
'''Ἄρτεμις, -έμιδος (nom propre) (f)''' : [[wikt:Artémis|Artémis]].&lt;br&gt;
'''Ἀρχίας, -ου (nom propre) (m)''' : Archias.&lt;br&gt;
'''Ἀρχιμήδης, -ους (nom propre) (m)''' : Archimède.&lt;br&gt;
'''Ἀσάνα, -ας (nom propre) (f)''' :  Forme dorienne de ''Ἀθηνᾶ''.&lt;br&gt;
'''Ἀσδρούϐας, -ου (nom propre) (m)''' : Hasdrubal (véritable nom de Clitomaque de Carthage).&lt;br&gt;
'''Ἀσήρ (nom propre) (m)''' : Aser.&lt;br&gt;
'''Ἀσκαλωνίτης, -ου (nom commun) (m)''' : Ascalonite.&lt;br&gt;
'''Ἀσκαλωνῖτις, -ίτιδος (nom commun) (f)''' : Ascalonite.&lt;br&gt;
'''Ἀσκάλων, -ος (nom propre) (m)''' : Ascalon.&lt;br&gt;
'''Ἀσκληπιός, -οῦ (nom propre) (m)''' : [[wikt:Asclépios|Asclépios]].&lt;br&gt;
'''Ἀσμοδαῖος, -ίου (nom propre) (m)''' : Asmodée.&lt;br&gt;
'''Ἀσεννέθ (nom propre) (m)''' : Asnath.&lt;br&gt;
'''Ἀσπαθίνης, -ου (nom propre) (m)''' : Aspathinès.&lt;br&gt;
'''Ἀσσυρία, -ας (nom propre) (f)''' : Assyrie.&lt;br&gt;
'''Ἀσσύριος, -ίου (nom commun) (m)''' : Assyrien.&lt;br&gt;
'''Ἀστάρτη, -ης (nom propre) (f)''' : Astarté.&lt;br&gt;
'''Ἀστυάναξ, -κτος (nom propre) (m)''' : Astyanax.&lt;br&gt;
'''Ἀστυάνασσα, -ας (nom propre) (f)''' : Astyanassa.&lt;br&gt;
'''Ἄστυ, -εως (nom propre) (n)''' : Athènes.&lt;br&gt;
'''Ἄτη, -ης (nom propre) (f)''' : [[wikt:Até|Até]]. (Déesse de l’égarement.)&lt;br&gt;
'''Ἀττική, -ῆς (nom propre) (f)''' : Attique.&lt;br&gt;
'''Ἀτλαντίς, -δος (nom propre) (f)''' : (Toponymie) océan Atlantique. (Mythologie) Atlantide.&lt;br&gt;
'''Ἄτλας, -αντος (nom propre) (m)''' : Atlas.&lt;br&gt;
'''Ἄτροπος, -όπου (nom propre) (f)''' : Atropos (troisième Moire).&lt;br&gt;
'''Αὐγείας, -ου (nom propre) (m)''' : Augias.&lt;br&gt;
'''Αὐλίς, -δος (nom propre) (f)''' : Aulis.&lt;br&gt;
'''Αὐνάν (nom propre) (m)''' : Onan.&lt;br&gt;
'''Αὐξώ, -οῦς (nom propre) (f)''' : Auxo.&lt;br&gt;
'''Αὐσονία, -ας (nom propre) (f)''' : Italie.&lt;br&gt;
'''Αὐσονίη, -ης (nom propre) (f)''' : Forme alternative de ''Αὐσονία''.&lt;br&gt;
'''Αὔσων, -ονος (nom propre) (m)''' : Auson (fils d’Ulysse.)&lt;br&gt; 
'''Αὐτόλυκος, -ύκου (nom propre) (m)''' : Autolycos (Aïeul maternel d’Ulysse.)&lt;br&gt; 
'''Αὐτομέδων, -οντος (nom propre) (m)''' : Automédon (Conducteur du char d’Achille.)&lt;br&gt; 
'''Αὔως, -ω (nom propre) (f)''' : Forme alternative de ''Ἕως''.&lt;br&gt;
'''Ἀφρική, -ῆς (nom propre) (f)''' : Afrique.&lt;br&gt;
'''Ἀφροδίτη, -ης (nom propre) (f)''' : Aphrodite.&lt;br&gt;
'''Ἀφρόδιτος, -ίτου (nom propre) (m)''' : Aphroditos.&lt;br&gt;
'''Ἀφρώ, -οῦς (nom propre) (f)''' : Aphrô.&lt;br&gt; 
'''Ἀχαΐα, -ας (nom propre) (f)''' : Achaïe.&lt;br&gt;
'''Ἀχαιμένης, -ους (nom propre) (m)''' : Achéménès.&lt;br&gt;
'''Ἀχαιμενίδης, -ου (nom propre) (m)''' : Achéménide.&lt;br&gt;
'''Ἀχαιός, -οῦ (nom propre) (m)''' : Achaïos (fils de Xouthos).&lt;br&gt;
'''Ἀχατης, -ου (nom propre) (m)''' : Achatès (fleuve de Sicile).&lt;br&gt;
'''Ἀχελῷος, -ῴου (nom propre) (m)''' : Achéloos.&lt;br&gt;
'''Ἀχέρων, -οντος (nom propre) (m)''' : Achéron.&lt;br&gt;
'''Ἀχιλλεύς, -έως (nom propre) (m)''' : Achille.&lt;br&gt;
'''Ἀωσφόρος, -ου (nom propre) (m)''' : Forme dorienne de ''Ἑωσφόρος''.&lt;br&gt;

==Β==
'''βαθμίς, -δος  (nom commun) (f)''' : échelon.&lt;br&gt;
'''βάθρον, -ου (nom commun) (n)''' : podium.&lt;br&gt;
'''βαθέως (adverbe)''' : profondément.&lt;br&gt;
'''βάθος, -ους (nom commun) (n)''' : Profondeur, hauteur.&lt;br&gt;
'''βαθύς, -εῖα, -ύ (adjectif)''' : profond.&lt;br&gt; 
'''βαθύτατος, -άτη, -ύτατον (adjectif)''' : Superlatif de ''βαθύς''.&lt;br&gt;
'''βαθύτερος, -έρα, -ύτερον (adjectif)''' : Comparatif de ''βαθύς''.&lt;br&gt;
'''βαΐον, -ου (nom commun) (n)''' : rameau.&lt;br&gt;
'''βακτηρία, -ας (nom commun) (f)''' : Bâton de marche ; bâton employé comme insigne de juge.&lt;br&gt;
'''βαλανεῖον, -ίου (nom commun) (n)''' : bain (lieu public).&lt;br&gt;
'''βαλανεύς, -έως (nom commun) (n)''' : plongeur.&lt;br&gt;
'''βάλανος, -άνου (nom commun) (f)''' : Gland de chêne. (Botanique) Datte. Fermoir d’un collier. Pêne d’un verrou. Moule de mer (poisson). Noix, châtaigne. Suppositoire.&lt;br&gt;
'''βαλάντιον, -ίου (nom commun) (n)''' : bourse (sac d'argent).&lt;br&gt;
'''βαλλίζω (verbe)''' : danser.&lt;br&gt;
'''βάμϐαξ, -κος (nom commun) (m)''' : coton.&lt;br&gt; 
'''βαμϐακερός, -ή, -όν (adjectif)''' : .&lt;br&gt;
'''βαμϐακηρός, -ά, -όν (adjectif)''' : .&lt;br&gt;
'''βαμϐάκινος, -ίνου (nom commun) (n)''' : .&lt;br&gt;
'''βαμϐάκιον, -ίου (nom commun) (n)''' : .&lt;br&gt;
'''βαμϐακοειδής, -ής, -ές (adjectif)''' : .&lt;br&gt;
'''βανά, -ᾶς (nom commun) (f)''' : Forme béotienne de ''γυνή''.&lt;br&gt;
'''βάπτω (verbe)''' : plonger, teindre ; baptiser.&lt;br&gt;
'''βάρϐαρα, -ας (nom commun) (f)''' : barbare.&lt;br&gt;
'''βάρϐαρικός, -ή, -όν (adjectif)''' : barbare.&lt;br&gt;
'''βάρϐαρικῶς (adverbe)''' : barbarement.&lt;br&gt;
'''βάρϐαρικώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''βάρϐαρικός''.&lt;br&gt;
'''βάρϐαρικώτερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''βάρϐαρικός''.&lt;br&gt;
'''βάρϐαρικώτατα, -, - (adverbe)''' : Superlatif de ''βάρϐαρικῶς''.&lt;br&gt;
'''βάρϐαρικώτερον, -, - (adverbe)''' : Comparatif de ''βάρϐαρικῶς''.&lt;br&gt; 
'''βάρϐαρος, -άρου (nom commun) (m)''' : barbare.&lt;br&gt;
'''βαρέως (adverbe)''' : lourdement.&lt;br&gt;
'''βᾶρις, -άριδος (nom commun) (f)''' : barque.&lt;br&gt;
'''βᾶρκις, -άρκιδος (nom commun) (f)''' : barque.&lt;br&gt;
'''βαρύς, -εῖα, -ύ (adjectif)''' : lourd.&lt;br&gt;
'''βαρύτατος, -άτη, -ύτατον (adjectif)''' : Superlatif de ''βαρύς''.&lt;br&gt;
'''βαρύτερος, -έρα, -ύτερον (adjectif)''' : Comparatif de ''βαρύς''.&lt;br&gt;
'''βασιλεία, -ας (nom commun) (f)''' : pouvoir royal ; royauté. Royaume.&lt;br&gt;
'''βασίλεια, -ίας (nom commun) (f)''' : princesse. (héritière du souverain régnant)&lt;br&gt;
'''βασιλείδης, -ου (nom commun) (m)''' : prince. (héritier du souverain régnant)&lt;br&gt;
'''βασίλειος, -ία, -ιον (adjectif)''' : royal.&lt;br&gt;
'''βασιλεύς, -έως (nom commun) (m)''' : roi.&lt;br&gt;
'''βασιλήϊος, -, - (adjectif)''' : Forme ionienne de ''βασίλειος''.&lt;br&gt;
'''βασιλῇος, -, - (adjectif)''' : Forme éolienne de ''βασίλειος''.&lt;br&gt;
'''βασιλικός, -ή, -όν (adjectif)''' : royal.&lt;br&gt; 
'''βασίλισσα, -ας (nom commun) (f)''' : reine.&lt;br&gt;
'''βάσις, -εως (nom commun) (f)''' : Action de marcher, marche. Organe pour la marche. Ce sur quoi l’on marche ou l’on se tient.&lt;br&gt;
'''βάσκανος, -ος, -ον (adjectif)''' : Maléfique ; médisant.&lt;br&gt;
'''βασκάνως (adverbe)''' : maléfiquement.&lt;br&gt;
'''βασκανώτατος, -, - (adverbe)''' : Superlatif de ''βάσκανος''.&lt;br&gt;
'''βασκανώτερος, -, - (adverbe)''' : Comparatif de ''βάσκανος''.&lt;br&gt;
'''βασσάρα, -ας (nom commun) (f)''' : renard.&lt;br&gt;
'''βαστάζω (verbe)''' : lever, soulever. Relever. Tenir dans ses bras ou ses mains.&lt;br&gt;
'''βάτος, -ου (nom commun) (f)''' : Ronce, buisson. Épine.&lt;br&gt;
'''βατός, -ή, -όν (adjectif)''' : accessible.&lt;br&gt;
'''βάτραχος, -άχου (nom commun) (m/f)''' : Crapaud ; grenouille.&lt;br&gt;
'''βατῶ (verbe)''' : Forme phocienne de ''πατῶ''.&lt;br&gt;
'''βαυϐάω (verbe)''' : s’endormir.&lt;br&gt;
'''βαυϐών, -ῶνος (nom commun) (m)''' : godemichet.&lt;br&gt;
'''βαυϐώ, -οῦς (nom commun) (f)''' : nourrice.&lt;br&gt;
'''βαυκάλημα, -ήματος (nom commun) (n)''' : berceuse.&lt;br&gt;
'''βαυκίζομαι (verbe)''' : être prude.&lt;br&gt;
'''βαυκός, -ή, -όν (adjectif)''' : prude.&lt;br&gt;
'''βαυκότατος, -άτη, -ότατον (adjectif)''' : Superlatif de ''βαυκός''.&lt;br&gt;
'''βαυκότερος, -έρα, -ότερον (adjectif)''' : Comparatif de ''βαυκός''.&lt;br&gt;
'''βαυκῶς (adverbe)''' : prudemment.&lt;br&gt;
'''βαυκώτατα, -, - (adverbe)''' : Superlatif de ''βαυκῶς''.&lt;br&gt;
'''βαυκώτερον, -, - (adverbe)''' : Comparatif de ''βαυκῶς''.&lt;br&gt;
'''βαφεύς, -έως (nom commun) (m)''' : peintre.&lt;br&gt;
'''βδαλεύς, -έως (nom commun) (m)''' : suceur.&lt;br&gt;
'''βδάλσις, - (nom commun) (f)''' : succion.&lt;br&gt;
'''βδάλλω (verbe)''' : Sucer, téter. Traire le lait.&lt;br&gt;
'''βδέλλα, -ης (nom commun) (f)''' : sangsue.&lt;br&gt;
'''βδέω ‎(verbe)''' : péter (flatuler)&lt;br&gt;
'''βεϐαιῶ (verbe)''' : garantir (se rendre garant de la valeur, de la qualité d’une chose).&lt;br&gt;
'''βέϐηλος, -ος, -ον (adjectif)''' : Franchissable, profane. Impur, interdit.&lt;br&gt;
'''βεϐηλότατος, -άτη, -ότατον (adjectif)''' : Superlatif de ''βέϐηλος''.&lt;br&gt;
'''βεϐηλότερος, -έρα, -ότερον (adjectif)''' : Comparatif de ''βέϐηλος''.&lt;br&gt;
'''βέϐηλως (adverbe)''' : profanement.&lt;br&gt;
'''βεϐηλώτατα, -, - (adverbe)''' : Superlatif de ''βεϐρῶς''.&lt;br&gt;
'''βεϐηλώτερον, -, - (adverbe)''' : Comparatif de ''βεϐρῶς''.&lt;br&gt; 
'''βεϐρός, -ά, -όν (adjectif)''' : stupide.&lt;br&gt;
'''βεϐρότατος, -άτη, -ότατον (adjectif)''' : Superlatif de ''βεϐρός''.&lt;br&gt;
'''βεϐρότερος, -έρα, -ότερον (adjectif)''' : Comparatif de ''βεϐρός''.&lt;br&gt;
'''βεϐρῶς (adverbe)''' : stupidement.&lt;br&gt;
'''βεϐρώτατα, -, - (adverbe)''' : Superlatif de ''βεϐρῶς''.&lt;br&gt;
'''βεϐρώτερον, -, - (adverbe)''' : Comparatif de ''βεϐρῶς''.&lt;br&gt; 
'''βελόνη, -ης (nom commun) (f)''' : aiguille.&lt;br&gt;
'''βέλος, -ους (nom commun) (n)''' : flèche.&lt;br&gt;
'''βέλτιστος, -ίστη, -έλτιστον (adjectif)''' : Superlatif de ''ἀγαθός''.&lt;br&gt;
'''βελτίων, -ων, -έλτιον (adjectif)''' : Comparatif de ''ἀγαθός''.&lt;br&gt;
'''βένθος, -ους (nom commun) (n)''' : benthos.&lt;br&gt;
'''βερϐέριον, -ίου (nom commun) (n)''' : .&lt;br&gt;
'''βεῦδος, -ύδους (nom commun) (n)''' : .&lt;br&gt;
'''βέφυρα, -ύρας (nom commun) (f)''' : Forme béotienne de ''γέφυρα ''.&lt;br&gt;
'''βῆ βῆ (onomatopée)''' : bêlement.&lt;br&gt; 
'''βῆμα, -ήματος (nom commun) (n)''' : .&lt;br&gt; 
'''βήξ, -χός (nom commun) (m)''' : toux.&lt;br&gt;
'''βήσσω (verbe)''' : tousser.&lt;br&gt; 
'''βῆτα (nom commun) (n)''' : bêta.&lt;br&gt;
'''βήττω (verbe)''' : Forme attique ''βήσσω''.&lt;br&gt; 
'''βία, -ας (nom commun) (f)''' : Force, violence.&lt;br&gt;
'''βιάζω (verbe)''' : Contraindre, forcer. (Au passif) Être contraint, forcé soumis.&lt;br&gt;
'''βιϐάζω (verbe)''' : Faire aller ; exalter.&lt;br&gt;
'''βιϐλαρίδιον, -ίου (nom commun) (n)''' : livret.&lt;br&gt;
'''βιϐλιοθήκη, -ης (nom commun) (f)''' : bibliothèque.&lt;br&gt;
'''βιϐλίον, -ου (nom commun) (n)''' : livre.&lt;br&gt;
'''βιϐλιοπωλεῖον, -ίου (nom commun) (n)''' : librairie.&lt;br&gt;
'''βιϐλιοπώλης, -ου (nom commun) (m)''' : libraire.&lt;br&gt;
'''βίϐλος, -ου (nom commun) (f)''' : Papier fait à partir de l'écorce de papyrus.&lt;br&gt;
'''βιϐρώσκω (verbe)''' : Dévorer, manger avec avidité. (Figuré) Dévorer ou engloutir (une fortune).&lt;br&gt;
'''βίος, -ου (nom commun) (m)''' : vie.&lt;br&gt;
'''βίωσις, -ώσεως (nom commun) (f)''' : manière de vie.&lt;br&gt;
'''βινῶ (verbe)''' : foutre, baiser (avoir un rapport sexuel).&lt;br&gt;
'''βιῶ (verbe)''' : être, vivre.&lt;br&gt;
'''βλαδαρός, -ά, -όν (adjectif)''' : flasque.&lt;br&gt;
'''βλαδύς, -εῖα, -ύ (adjectif)''' : faible.&lt;br&gt;
'''βλαδυτής, -ῆτος (nom commun) (f)''' : faiblesse.&lt;br&gt;
'''βλακότατα, -, - (adverbe)''' : Superlatif de ''βλακωδῶς''.&lt;br&gt;
'''βλακότερον, -, - (adverbe)''' : Comparatif de ''βλακωδῶς''.&lt;br&gt;
'''βλακωδῶς (adverbe)''' : stupidement.&lt;br&gt;
'''βλακώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''βλάξ''.&lt;br&gt;
'''βλακώτερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''βλάξ''.&lt;br&gt;
'''βλαπτικός, -ή, -όν (adjectif)''' : .&lt;br&gt;
'''βλαπτικῶς (adverbe)''' : -ment.&lt;br&gt;
'''βλαπτικώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''βλαπτικός''.&lt;br&gt;
'''βλαπτικώτερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''βλαπτικός''.&lt;br&gt;
'''βλαπτικώτατα, -, - (adverbe)''' : Superlatif de ''βλαπτικῶς''.&lt;br&gt;
'''βλαπτικώτερον, -, - (adverbe)''' : Comparatif de ''βλαπτικῶς''.&lt;br&gt; 
'''βλάπτω (verbe)''' : Léser, endommager. (Au passif) Éprouver un accident. Gêner, embarrasser. (En parlant de l’esprit) Troubler sa raison. (Postérieur) Faire du tort, nuire.&lt;br&gt;
'''βλάξ, -κός (nom commun) (m/f)''' : stupide.&lt;br&gt;
'''βλαισός, -ή, -όν (adjectif)''' : balbutiant.&lt;br&gt;
'''βλέμμα, -τος (nom commun) (n)''' : Regard. (Au pluriel) Yeux.&lt;br&gt;
'''βλεννογόνος, -ου (nom commun) (m)''' : muqueuse.&lt;br&gt;	
'''βλεννός, -οῦ (nom commun) (m)''' : mucus.&lt;br&gt;
'''βλέπω (verbe)''' : voir.&lt;br&gt;
'''βλεφαρίς, -δος (nom commun) (f)''' : cil.&lt;br&gt; 
'''βλεφαρῖτις, -ίτης (nom commun) (f)''' : blépharite.&lt;br&gt;
'''βλέφαρον, -άρου (nom commun) (n)''' : paupière.&lt;br&gt;	
'''βλῆμα, -ήματος (nom commun) (n)''' : projectile.&lt;br&gt;
'''βοή, -ῆς (nom commun) (f)''' : clameur.&lt;br&gt;
'''βοήθεια, -ας (nom commun) (f)''' : aide.&lt;br&gt;
'''βοηθός, -ός, -όν (adjectif)''' : aidant.&lt;br&gt;
'''βοηθῶ (verbe)''' : aider.&lt;br&gt;
'''βοιώτιος, -, - (adjectif)''' : béotien.&lt;br&gt;
'''βόλλα, -ας (nom commun) (f)''' : Forme éolienne de ''βουλή''.&lt;br&gt; 
'''βορά, -ᾶς (nom commun) (f)''' : proie.&lt;br&gt; 
'''βόρειος, -ία, -ιον  (adjectif)''' : septentrional.&lt;br&gt;
'''βορειώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''βόρειος''.&lt;br&gt;
'''βορειώτερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''βόρειος''.&lt;br&gt;
'''βορειώτατα, -, - (adverbe)''' : Superlatif de ''βόρειως''.&lt;br&gt;
'''βορειώτερον, -, - (adverbe)''' : Comparatif de ''βόρειως''.&lt;br&gt;
'''βόρειως (adverbe)''' : septentrionalement.&lt;br&gt;
'''βόμϐος, -ου (nom commun) (m)''' : bourdonnement.&lt;br&gt;
'''βομϐυλιός, -οῦ (nom commun) (m)''' : .&lt;br&gt;
'''βόμϐυξ, -κος (nom commun) (m)''' : ver à soie ; sorte de flûte.&lt;br&gt;  
'''βόρειος, -α, -ον (adjectif)''' : septentrional.&lt;br&gt;
'''βορρᾶς, -ᾶ (nom commun) (m)''' : nord.&lt;br&gt;  
'''βόσκω (verbe)''' : Nourrir. Paître, se nourrir (en parlant des animaux)&lt;br&gt;
'''βόστρυχος, -ύχου (nom commun) (m)''' : boucle de cheveux.&lt;br&gt;  
'''βοτάνη, -ης (nom commun) (f)''' : herbe.&lt;br&gt; 
'''βοτανηφάγος, -ος, -ον (adjectif)''' : herbivore.&lt;br&gt;
'''βοτανηφόρος, -ος, -ον (adjectif)''' : enherbé.&lt;br&gt;
'''βοτανίδιον, -ίου (nom commun) (n)''' .&lt;br&gt;
'''βοτανίζω (verbe)''' : désherber.&lt;br&gt; 
'''βοτάνιον, -ίου (nom commun) (n)''' : .&lt;br&gt;
'''βοτανικός, -ή, -όν (adjectif)''' : botanique.&lt;br&gt;
'''βοτανισμός, -οῦ (nom commun) (m)''' : botanisme.&lt;br&gt;
'''βοτανολογία ''' : botanologie.&lt;br&gt;
'''βοτανολόγος ''' : herboriste.&lt;br&gt;
'''βοτανολογῶ (verbe)''' : herboriser.&lt;br&gt;
'''βοτανώδης, -ης, -ης (adjectif)''' : botanique.&lt;br&gt;
'''βοτήρ, -ῆρος (nom commun) (m)''' : berger ; pasteur.&lt;br&gt;
'''βοτόν, -οῦ (nom commun) (n)''' : bétail.&lt;br&gt; 
'''βουϐών, -ῶνος (nom commun) (m)''' : aine.&lt;br&gt;
'''βουίζω (verbe)''' : bourdonner.&lt;br&gt;  
'''βουκολικός, -ή, -όν (adjectif)''' : pastoral.&lt;br&gt;
'''βουκολικῶς (adverbe)''' : pastoralement.&lt;br&gt;
'''βουκολικώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''βουκολικικός''.&lt;br&gt;
'''βουκολικώτερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''βουκολικικός''.&lt;br&gt;
'''βουκολικώτατα, -, - (adverbe)''' : Superlatif de ''βουκολικικῶς''.&lt;br&gt;
'''βουκολικώτερον, -, - (adverbe)''' : Comparatif de ''βουκολικικῶς''.&lt;br&gt; 
'''βουκόλος, -ου (nom commun) (m)''' : bouvier.&lt;br&gt; 
'''βουλευτήριον, -ίου (nom commun) (n)''' : bouleutérion.&lt;br&gt; 
'''βουλή, -ῆς (nom commun) (f)''' : Volonté, vouloir. Décision, conseil. Sénat athénien.&lt;br&gt;
'''βούλησις, -ήσεως (nom commun) (f)''' : volonté.&lt;br&gt;
'''βούπρηστις, -ήστιδος (nom commun) (f)''' : bupreste.&lt;br&gt; 
'''βουνός, -οῦ (nom commun) (m)''' : mont, montagne.&lt;br&gt;  
'''βοῦς, -ός (nom commun) (m/f)''' : bœuf, vache.&lt;br&gt; 
'''βουστροφηδόν (adverbe)''' : En écrivant alternativement de gauche à droite, puis de droite à gauche.&lt;br&gt;
'''βούτημα, -ήματος (nom commun) (n)''' : biscuit.&lt;br&gt;
'''βούτυρον, -ύρου (nom commun) (n)''' : beurre.&lt;br&gt;
'''βραδινός, -ή -όν (adjectif)''' : Forme éolienne de ''ῥαδινός''.&lt;br&gt;
'''βραϐευτής, -οῦ (nom commun) (m)''' : arbitre.&lt;br&gt;  
'''βραδέως (adverbe)''' : lentement.&lt;br&gt;
'''βραδύς, -εῖα, -ύ (adjectif)''' : lent.&lt;br&gt;
'''βραδύτατος, -άτη, -ύτατον (adjectif)''' : Superlatif de ''βραδύς''.&lt;br&gt;
'''βραδύτερος, -έρα, -ύτερον (adjectif)''' : Comparatif de ''βραδύς''.&lt;br&gt;
'''βραδυτής, -ῆτος (nom commun) (f)''' : lenteur.&lt;br&gt;
'''βράγος, -ους (nom commun) (n)''' : bas-fond.&lt;br&gt;
'''βραχέως (adverbe)''' : courtement.&lt;br&gt;
'''βράχος, -ου (nom commun) (m)''' : écueil.&lt;br&gt; 
'''βραχύς, -εῖα, -ύ (adjectif)''' : court.&lt;br&gt;
'''βραχύτατος, -άτη, -ύτατον (adjectif)''' : Superlatif de ''βραχύς''.&lt;br&gt;
'''βραχύτερος, -έρα, -ύτερον (adjectif)''' : Comparatif de ''βραχύς''.&lt;br&gt;
'''βρέμω (verbe)''' : gronder, retentir.&lt;br&gt;
'''βρένθος, -ου (nom commun) (m)''' : fierté.&lt;br&gt;
'''βρέφος, -ους (nom commun) (n)''' : fœtus, nouveau-né.&lt;br&gt;
'''βρεχμός, -οῦ (nom commun) (m)''' : .&lt;br&gt;
'''βρία, -ης (nom commun) (f)''' : ville.&lt;br&gt;
'''βρίμημα, -ήματος (nom commun) (n)''' : .&lt;br&gt;
'''βρεττανικός, -ή, -όν (adjectif)''' : breton insulaire.&lt;br&gt;
'''βρεττανικῶς (adverbe)''' : en breton insulaire.&lt;br&gt;
'''βρεττανικώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''βρεττανικός''.&lt;br&gt;
'''βρεττανικώτερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''βρεττανικός''.&lt;br&gt;
'''βρεττανικώτατα, -, - (adverbe)''' : Superlatif de ''βρεττανικῶς''.&lt;br&gt;
'''βρεττανικώτερον, -, - (adverbe)''' : Comparatif de ''βρεττανικῶς''.&lt;br&gt; 
'''βρόμος, -ου (nom commun) (m)''' : Frémissement, grondement. Pétillement du feu. Grondement du tonnerre.&lt;br&gt;
'''βροντή, -ῆς (nom commun) (f)''' : Tonnerre. Stupeur.&lt;br&gt;
'''βροχίς, -δος (nom commun) (f)''' : .&lt;br&gt;
'''βρόχος, -ου (nom commun) (m)''' : nœud coulant.&lt;br&gt;
'''βρυγμός, -οῦ (nom commun) (m)''' : bruxisme.&lt;br&gt;
'''βρύον, -ου (nom commun) (n)''' : mousse (plante).&lt;br&gt;
'''βρυχηθμός, -οῦ (nom commun) (m)''' : rugissement.&lt;br&gt;
'''βρυχός, -οῦ (nom commun) (m)''' : brycose.&lt;br&gt; 
'''βρυχῶμαι (verbe)''' : rugir.&lt;br&gt;
'''βύας, -ου (nom commun) (m)''' : hibou.&lt;br&gt;
'''βύρσα, -ας (nom commun) (f)''' : outre, cuir.&lt;br&gt;
'''βρώσιμος, -ος, -ον (adjectif)''' : mangeable.&lt;br&gt;
'''βρῶσις, -ώσεως  (nom commun) (f)''' outre, cuir.&lt;br&gt;
'''βωϐός, -ή -όν (adjectif)''' : muet.&lt;br&gt;
'''βωλά, -ᾶς (nom commun) (f)''' : Forme dorienne de ''βουλή''.&lt;br&gt;
'''Βάαλ (nom propre) (m)''' : Baal.&lt;br&gt;
'''Βαϐυλωνεύς, -έως (nom commun) (m)''' : Babylonien.&lt;br&gt;
'''Βαϐυλωνία, -ας (nom commun) (f)''' : Babylonie.&lt;br&gt;
'''Βαϐυλωνιακός, -ός, -όν (adjectif)''' : babylonien.&lt;br&gt;
'''Βαϐυλώνιος, -ος, -ον (adjectif)''' : babylonien.&lt;br&gt;
'''Βαϐυλωνίς, -δος (nom commun) (f)''' : Babylonienne.&lt;br&gt;
'''Βαϐυλών, -ῶνος (nom propre) (f)''' : Babylone.&lt;br&gt;
'''Βάκχος, -ου (nom propre) (m)''' : Bacchus. (Épithète de Dionysos, parfois de Zeus.)&lt;br&gt;
'''Βαλλά, -ᾶς (nom propre) (f)''' : Bilha.&lt;br&gt;
'''Βαρϐάρα, -ας (nom propre) (f)''' : Barbara.&lt;br&gt; 
'''Βαρϐαρικόν, -οῦ (nom propre) (m)''' : Barbaricum.&lt;br&gt;
'''Βαρθολομαῖος, -ίου (nom propre) (m)''' : Barthélémy.&lt;br&gt;
'''Βασίλειος, -ίου (nom propre) (m)''' : Basile.&lt;br&gt;
'''Βαταυΐα, -ας (nom propre) (f)''' : Batavie.&lt;br&gt; 
'''Βατραχομυομαχία, -ας  (nom propre) (f)''' : Bataille des grenouilles et des rats. (Parodie de l’''Iliade'' attribuée à un dénommé Pigrès d’Halicarnasse par Plutarque.)&lt;br&gt;
'''Βάττος, -ου (nom propre) (m)''' : Battos.&lt;br&gt; 
'''Βαυϐώ, -οῦς (nom propre) (f)''' : Baubo.&lt;br&gt;
'''Βαῦκος, -ύκου (nom propre) (m)''' : Baukos.&lt;br&gt; 
'''Βεελφεγώρ (nom propre) (m)''' : Belphégor.&lt;br&gt;
'''Βενδῖς, -ίδος (nom propre) (f)''' : Bendis.&lt;br&gt;
'''Βερενίκη, -ης (nom propre) (f)''' : Bérénice.&lt;br&gt;
'''Βηθανία, -ας (nom propre) (f)''' : Béthanie.&lt;br&gt;
'''Βηθλεέμ (nom propre) (f)''' : Bethléem.&lt;br&gt; 
'''Bηλησαμα, -ας (nom propre) (f)''' : Belisama.&lt;br&gt;
'''Βῆλος, -ήλου (nom propre) (m)''' : Bel.&lt;br&gt;
'''Βηρυτός, -οῦ (nom propre) (f)''' : Beyrouth.&lt;br&gt;
'''Βία, -ας (nom propre) (m)''' : Bia.&lt;br&gt;
'''Βλάσιος, -ίου (nom propre) (m)''' : Blaise.&lt;br&gt;
'''Βλάχος, -ου (nom commun) (m)''' : Valaque.&lt;br&gt;
'''Βοανεργές (nom propre) (m)''' : Boanergès.&lt;br&gt;
'''Βοιωτία, -ας (nom propre) (f)''' : Béotie. (Région de Grèce centrale.)&lt;br&gt;
'''Βοιωτός, -οῦ (nom commun) (m)''' : Béotien.&lt;br&gt;
'''Βοιωτίς, -δος (nom commun) (f)''' : Béotienne.&lt;br&gt;
'''Βορέας, -ου (nom propre) (m)''' : Borée. (dieu du vent du Nord)&lt;br&gt;
'''Βορέης, -ου (nom propre) (m)''' : Forme ionienne de ''Βορέας''.&lt;br&gt;
'''Βορρᾶς, -ᾶ (nom propre) (m)''' : Forme attique de ''Βορέας''.&lt;br&gt;
'''Βοσπορίτης, -ου (nom commun) (m)''' : Bosphorite.&lt;br&gt;
'''Βόσπορος, -όρου (nom propre) (m)''' : Bosphore.&lt;br&gt;
'''Βούϐαστις, -άστιος (nom propre) (f)''' : Bastet.&lt;br&gt;
'''Βουκέφαλος, -άλου (nom propre) (m)''' : Bucéphale (Cheval préféré d’Alexandre le Grand.)&lt;br&gt;
'''Βουτώ, -οῦς (nom propre) (f)''' : Ouadjet.&lt;br&gt;
'''Βρέννος, -ου (nom commun) (m)''' : Brennos.&lt;br&gt;
'''Βρεττανία, -ας (nom propre) (f)''' : Bretagne (province romaine).&lt;br&gt;
'''Βρεττανίς, -δος (nom commun) (f)''' : Bretonne insulaire.&lt;br&gt;
'''Βρεττανός, -οῦ (nom commun) (m)''' : Breton insulaire.&lt;br&gt;
'''Βύϐλος, -ου (nom commun) (f)''' : Byblos.&lt;br&gt;
'''Βυζάντιον, -ίου (nom propre) (n)''' : Byzance.&lt;br&gt;
'''Βύζας, -αντος (nom propre) (m)''' : Byzas.&lt;br&gt;
'''Βιθυνία, -ας (nom propre) (f)''' : Bithynie.&lt;br&gt; 
'''Βιθυνίς, -δος (nom commun) (f)''' : Bithynienne.&lt;br&gt; 
'''Βιθυνός, -οῦ (nom commun) (o)''' : Bithynien.&lt;br&gt; 

==Γ==
'''γα (particule)''' : Forme dorienne et béotienne de ''γε''.&lt;br&gt;
'''γαίω (verbe)''' : exulter, se réjouir.&lt;br&gt;
'''γάλα, -κτος (nom commun) (n)''' : lait.&lt;br&gt;
'''γαλανός, -ός, -όν (adjectif)''' : Forme dorienne de ''γαληνός''.&lt;br&gt;
'''γαλήνη, -ης, -ης (nom commun) (f)''' : Calme de la mer. (Par extension) Calme, sérénité. Galène. Antidote contre les morsures de vipères.&lt;br&gt;
'''γαληνός, -ός, -όν (adjectif)''' : calme (spécialement à propos de la mer).&lt;br&gt;
'''γαλέη, -ης (nom commun) (f)''' : belette.&lt;br&gt;
'''γαλῆ, -ς (nom commun) (f)''' : Forme alternative de ''γαλέη''.&lt;br&gt;
'''γαλιῶ (verbe)''' : Être lascif comme une belette.&lt;br&gt;
'''γάμμα (nom commun) (n)''' : gamma.&lt;br&gt;
'''γαμέτης, -ου (nom commun) (m)''' : époux, mari.&lt;br&gt;
'''γαμῶ (verbe)''' : se marier (quand on parle d’un homme)&lt;br&gt; 
'''γάργαλος, -άλου (nom commun) (m)''' : .&lt;br&gt; 
'''γαργαλίζω (verbe)''' : chatouiller.&lt;br&gt; 
'''γαργαλισμός, -οῦ (nom commun) (m)''' : chatouille.&lt;br&gt;
'''γαργαρεών, -ῶνος (nom commun) (m)''' : luette.&lt;br&gt;
'''γάρ (conjonction)''' : car ; en effet.&lt;br&gt;
'''γαστήρ, -τρός (nom commun) (f)''' : ventre.&lt;br&gt;
'''γαῦρος, -ύρη, -ῦρον (adjectif)''' : Exultant, joyeux. Hautain, dédaigneux.&lt;br&gt;
'''γαυρότατος, -άτη, -έστατον (adjectif)''' : Superlatif de ''γαῦρος''.&lt;br&gt;
'''γαυρότερος, -έρα, -ερον (adjectif)''' : Comparatif de ''γαῦρος''.&lt;br&gt;
'''γαῦρως (adverbe)''' : joyeusement ; hautainement, dédaigneusement.&lt;br&gt;
'''γαυρότης, -τος (nom commun) (f)''' : Exultation. Emportement, férocité.&lt;br&gt;
'''γε (particule)''' : (Devient ''γ’'' devant un mot commençant par une voyelle.) Marque une restriction, une affirmation, ou une conclusion.&lt;br&gt;
'''γείτων, -ονος (nom commun) (m/f)''' : voisin(e).&lt;br&gt;
'''γέλαιμι (verbe)''' : Forme éolienne de ''γελάω''.&lt;br&gt;
'''γελάω (verbe)''' : Rire ; briller.&lt;br&gt;
'''γελοῖος, -ία, -ῖον (adjectif)''' : ridicule ; risible.&lt;br&gt;
'''γελοιότατος, -άτη, -ότατον (adjectif)''' : Superlatif de ''γελοῖος''.&lt;br&gt;
'''γελοιότερος, -έρα, -ότερον (adjectif)''' : Comparatif de ''γελοῖος''.&lt;br&gt;
'''γελοίως (adverbe)''' : ridiculement ; risiblement.&lt;br&gt;
'''γελόω (verbe)''' : Forme homérique de ''γελάω''.&lt;br&gt;
'''γέλως, -τος (nom commun) (m)''' : rire.&lt;br&gt;
'''γελωτοποιός, -ός, -όν (adjectif)''' : comique.&lt;br&gt;
'''γελωτοποιός, -οῦ (nom commun) (m)''' : Bouffon ; pitre.&lt;br&gt;
'''γεμίζω (verbe)''' : emplir.&lt;br&gt;
'''γέμισμα, -ίσματος (nom commun) (n)''' : emplissage.&lt;br&gt;
'''γενεά, -ᾶς (nom commun) (f)''' : naissance, genre ; espèce.&lt;br&gt;
'''γένεσις, -έσεως (nom commun) (f)''' : origine, source. Naissance. Création.&lt;br&gt;
'''γενετήσιος, -α, -ον (adjectif)''' : sexuel.&lt;br&gt;
'''γενετησιότατος, -άτη, -έστατον (adjectif)''' : Superlatif de ''γενετήσιος''.&lt;br&gt;
'''γενετησιότερος, -έρα, -ερον (adjectif)''' : Comparatif de ''γενετήσιος''.&lt;br&gt;
'''γενετησίως (adverbe)''' : sexuellement.&lt;br&gt;
'''γενναῖος, -ία, -ῖον (adjectif)''' : vaillant.&lt;br&gt;
'''γενναιότατος, -άτη, -έστατον (adjectif)''' : Superlatif de ''γενναῖος''.&lt;br&gt;
'''γενναιότερος, -έρα, -ερον (adjectif)''' : Comparatif de ''γενναῖος''.&lt;br&gt;
'''γενναίως (adverbe)''' : vaillamment.&lt;br&gt;
'''γενναιότης, -ητος (nom commun) (f)''' : vaillance.&lt;br&gt; 
'''γεννητικός, -η, -ον (adjectif)''' : génital.&lt;br&gt;
'''γένος, -ους (nom commun) (n)''' : naissance, origine, descendance ; race, genre, espèce ; classe, corporation; nation, peuple, tribu.&lt;br&gt;
'''γεννῶ  (verbe)''' : accoucher.&lt;br&gt; 
'''γερόντειος, -α, -ον (adjectif)''' : .&lt;br&gt;
'''γεροντεύω (verbe)''' : .&lt;br&gt;'''γέρανος, -άνου (nom commun) (m/f)''' : grue (oiseau).&lt;br&gt; 
'''γερουσία, -ας (nom commun) (f)''' : sénat.&lt;br&gt; 
'''γερουσιάρχης, -ου (nom commun) (m)''' : président du sénat.&lt;br&gt; 
'''γερουσιαστής, -οῦ (nom commun) (m)''' : sénateur.&lt;br&gt;
'''γέρων, -οντος (nom commun) (m)''' : vieillard.&lt;br&gt;
'''γεῦμα, -ύματος (nom commun) (n)''' : déjeuner.&lt;br&gt;
'''γεῦσις, -ύσεως (nom commun) (f)''' : goût.&lt;br&gt; 
'''γεύω (verbe)''' : goûter.&lt;br&gt;
'''γέφυρα, -ύρας (nom commun) (f)''' : Chaussée. Pont.&lt;br&gt; 
'''γεω- (préfixe)''' : relatif à la terre.&lt;br&gt;
'''γῆ, -ς (nom commun) (f)''' : terre.&lt;br&gt;
'''γήινος, -η, -ο (adjectif)''' : terrestre.&lt;br&gt;
'''γήρανσις, -άνσεως (nom commun) (f)''' : .&lt;br&gt;
'''γηράσκω (verbe)''' : .&lt;br&gt;
'''γῆρας, -ήρως (nom commun) (n)''' : vieillesse.&lt;br&gt;
'''γῆρυς, -ήρυος (nom commun) (f)''' : Voix ; discours.&lt;br&gt;
'''γηρύω (verbe)''' : chanter.&lt;br&gt;
'''γιγαντιαῖος, -ία, -ῖον (adjectif)''' : gigantesque.&lt;br&gt;
'''γιγαντιότατος, -άτη, -ότατον (adjectif)''' : Superlatif de ''γιγαντιαῖος''.&lt;br&gt;
'''γιγαντιότερος, -έρα, -ότερον (adjectif)''' : Comparatif de ''γιγαντιαῖος''.&lt;br&gt;
'''γιγαντίως (adverbe)''' : gigantesquement.&lt;br&gt;  
''', -, - (adverbe)''' : Superlatif de ''γιγαντίως''.&lt;br&gt;
''', -, - (adverbe)''' : Comparatif de ''γιγαντίως''.&lt;br&gt;
'''γίγας, -αντος (nom commun) (m)''' : géant.&lt;br&gt; 
'''γίγνομαι (verbe)''' : engendrer.&lt;br&gt;
'''γίνιουμαι (verbe)''' : Forme béotienne de ''γίγνομαι''.&lt;br&gt;
'''γίνομαι (verbe)''' : Forme ionienne de ''γίγνομαι''.&lt;br&gt;
'''γίνυμαι (verbe)''' : Forme thessalienne de ''γίγνομαι''.&lt;br&gt;
'''γιγνώσκω (verbe)''' : Apprendre à connaître.&lt;br&gt;
'''γινώσκω (verbe)''' : Forme ionienne de ''γιγνώσκω''.&lt;br&gt;
'''γλάγος, -ους (nom commun) (n)''' : Forme poétique de ''γάλα''.&lt;br&gt;
'''γλάσσα, -ης (nom commun) (f)''' : Forme ionienne de ''γλῶσσα''.&lt;br&gt;
'''γλαυκός, -ή, -όν (adjectif)''' : Brillant, étincelant, éclatant. D’un vert pâle ou gris.&lt;br&gt;
'''γλαυκότατος, -άτη, -ότατον (adjectif)''' : Superlatif de ''γλαυκός''.&lt;br&gt;
'''γλαυκότερος, -έρα, -ότερον (adjectif)''' : Comparatif de ''γλαυκός''.&lt;br&gt;
'''γλαυκῶς (adverbe)''' : vivement.&lt;br&gt; 
'''γλαυκώτατα, -, - (adverbe)''' : Superlatif de ''γλαυκῶς''.&lt;br&gt;
'''γλαυκώτερον, -, - (adverbe)''' : Comparatif de ''γλαυκῶς''.&lt;br&gt;
'''γλαῦξ, -κός (nom commun) (f)''' : chouette.&lt;br&gt;
'''γλαύσσω (verbe)''' : briller (En parlant des yeux).&lt;br&gt;
'''γλεῦκος, -ύκους (nom commun) (n)''' : moût.&lt;br&gt;
'''γλέφαρον, -άρου (nom commun) (n)''' : Forme dorienne de ''βλέφαρον''.&lt;br&gt;	
'''γλήνη, -ης (nom commun) (f)''' : pupille (partie de l’œil).&lt;br&gt;
'''γλῆνος, -ήνους (nom commun) (n)''' : splendeur.&lt;br&gt;
'''γλουτιαῖος, -ία, -αῖν (adjectif)''' : glutéal.&lt;br&gt;
'''γλουτός, -οῦ (nom commun) (m)''' : derrière ; fesse.&lt;br&gt;
'''γλυκέως (adverbe)''' : doucement.&lt;br&gt;
'''γλυκερός, -ή, -όν (adjectif)''' : doux.&lt;br&gt;
'''γλυκερῶς (adverbe)''' : doucement.&lt;br&gt;
'''γλυκύς, -εῖα, -ύ (adjectif)''' : doux, sucré.&lt;br&gt;
'''γλυκύτατος, -άτη, -ύτατον (adjectif)''' : Superlatif de ''γλυκύς''.&lt;br&gt;
'''γλυκύτερος, -έρα, -ύτερον (adjectif)''' : Comparatif de ''γλυκύς''.&lt;br&gt;
'''γλυκώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''γλυκερός''.&lt;br&gt;
'''γλυκώτερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''γλυκερός''.&lt;br&gt;
'''γλυπτόν, -οῦ (nom commun) (n)''' : .&lt;br&gt;
'''γλώνη, -ης (nom commun) (f)''' : poupée.&lt;br&gt; 
'''γλῶσσα, -ώσσης (nom commun) (f)''' : langue. (Organe buccal ; expression orale)&lt;br&gt;
'''γλωσσίς, -δος (nom commun) (f)''' : glotte.&lt;br&gt;
'''γλῶττα, -ώττης (nom commun) (f)''' : Forme attique de ''γλῶσσα''.&lt;br&gt;
'''γλωττίς, -δος (nom commun) (f)''' : Forme attique de ''γλωσσίς''.&lt;br&gt;
'''γνάθος, -ου (nom commun) (f)''' : mâchoire.&lt;br&gt;
'''γνήσιος, -α, -ον (adjectif)''' : véritable.&lt;br&gt;
'''γνῶσις, -ώσεως (nom commun) (f)''' : Savoir ; connaissance, notion. Reconnaissance ; enquête, instruction judiciaire.&lt;br&gt;
'''γοάω (verbe)''' : se lamenter.&lt;br&gt;
'''γόγγρος, -ου (nom commun) (m)''' : congre.&lt;br&gt;
'''γόησσα, -ας (nom commun) (f)''' : enchanteresse ; magicienne.&lt;br&gt;
'''γόης, -τος (nom commun) (m)''' : enchanteur ; magicien.&lt;br&gt;
'''γονεύς, -έως (nom commun) (m)''' : père (parent).&lt;br&gt;
'''γονή, -ῆς (nom commun) (f)''' : génération ; procréation.&lt;br&gt;
'''γονόρροια, -ας (nom commun) (f)''' : gonorrhée.&lt;br&gt;
'''γόνος, -ου (nom commun) (m)''' : procréation.&lt;br&gt;
'''γόνυ, -ατος (nom commun) (n)''' : genou.&lt;br&gt;
'''γόος, -ου (nom commun) (m)''' : lamentation.&lt;br&gt;
'''γοργός, -ή, -όν (adjectif)''' : terrible.&lt;br&gt;
'''γούνα, -ας (nom commun) (f)''' : .&lt;br&gt;
'''γοῦνος, -ύνου (nom commun) (m)''' : Forme ionienne de ''γόνος''.&lt;br&gt;
'''γοῶ (verbe)''' : enchanter, ensorceler.&lt;br&gt;
'''γράθμα, -τος (nom commun) (n)''' : Forme dorienne de ''γράμμα''.&lt;br&gt;
'''γραῖα, -ίας (nom commun) (f)''' : vieillarde.&lt;br&gt;
'''γραμματεύς, -έως (nom commun) (m)''' : scribe.&lt;br&gt;
'''γράμμα, -τος (nom commun) (n)''' : Caractère gravé. Signes divers. Traits d’un dessin ou d’une peinture.&lt;br&gt; 
'''γραπτός, -ή, -όν (adjectif)''' : écrit.&lt;br&gt;
'''γραπτότατος, -άτη, -ότατον (adjectif)''' : Superlatif de ''γραπτός''.&lt;br&gt;
'''γραπτότερος, -έρα, -ότερον (adjectif)''' : Comparatif de ''γραπτός''.&lt;br&gt;
'''γραπτῶς (adverbe)''' : .&lt;br&gt;
'''γραῦς, -ός (nom commun) (f)''' : vieillarde.&lt;br&gt;
'''γραφεύς, -έως (nom commun) (m)''' : peintre.&lt;br&gt;
'''γραφή, -ῆς (nom commun) (f)''' : peinture.&lt;br&gt;
'''γραφία, -ας (nom commun) (f)''' : écriture.&lt;br&gt; 
'''-γραφία, -ας (suffixe)''' : relatif à l’écriture.&lt;br&gt; 
'''γραφικός, -ή, -όν (adjectif)''' : peint.&lt;br&gt;
'''γραφικῶς (adverbe)''' : graphiquement.&lt;br&gt;
'''γραφικώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''γραφικός''.&lt;br&gt;
'''γραφικώτερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''γραφικός''.&lt;br&gt;
'''γραφίς, -δος (nom commun) (f)''' : .&lt;br&gt;
'''γράφω (verbe)''' : écrire.&lt;br&gt;
'''γρηγοράς, -δος (nom commun) (f)''' : vivacité.&lt;br&gt;
'''γρήγορος, -η, -ον (adjectif)''' : vif.&lt;br&gt;
'''γρηγόρως (adverbe)''' : vivement.&lt;br&gt; 
'''γρηγορώτατα, -, - (adverbe)''' : Superlatif de ''γρηγόρως''.&lt;br&gt;
'''γρηγορώτερον, -, - (adverbe)''' : Comparatif de ''γρηγόρως''.&lt;br&gt;
'''γρηγορώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''γρήγορος''.&lt;br&gt;
'''γρηγορώτερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''γρήγορος''.&lt;br&gt;
'''γρῖφος, -ίφου (nom commun) (m)''' : filet ; énigme.&lt;br&gt;
'''γρόνθος, -ου (nom commun) (m)''' : poing.&lt;br&gt;
'''γρύλλος, -ου (nom commun) (m)''' : grillon.&lt;br&gt;
'''γρύψ, -πός (nom commun) (m)''' : griffon.&lt;br&gt;
'''γυμνάζω (verbe)''' : entraîner (diriger l’exercice sportif).&lt;br&gt;
'''γυμνάσιον, -ίου (nom commun) (n)''' : Lieu public réservé aux exercices corporels.&lt;br&gt;
'''γυμνός, -ή, -όν (adjectif)''' : Nu ; légèrement vêtu.&lt;br&gt;
'''γυμνότατα, -, - (adverbe)''' : Superlatif de ''γυμνῶς''.&lt;br&gt;
'''γυμνότερον, -, - (adverbe)''' : Comparatif de ''γυμνῶς''.&lt;br&gt;
'''γυμνότατος, -άτη, -ότατον (adjectif)''' : Superlatif de ''γυμνός''.&lt;br&gt;
'''γυμνότερος, -έρα, -ότερον (adjectif)''' : Comparatif de ''γυμνός''.&lt;br&gt;
'''γυμνότης, -τος (nom commun) (f)''' : nudité.&lt;br&gt;
'''γύμνωσις, -ώσεως (nom commun) (f)''' : dénudage.&lt;br&gt; 
'''γυμνῶς (adverbe)''' : .&lt;br&gt;
'''γυμνῶ (verbe)''' : dénuder.&lt;br&gt;
'''γυνά, -ᾶς (nom commun) (f)''' : Forme dorienne de ''γυνή''.&lt;br&gt;
'''γυναικᾶς, - (nom commun) (m)''' : homme à femmes.&lt;br&gt;
'''γυναικεῖον, -ίου (nom commun) (n)''' : Appartement réservé aux femmes.&lt;br&gt;
'''γυναικεῖος, -ία, -ῖον (adjectif)''' : féminin.&lt;br&gt;
'''γυναικειότατος, -άτη, -ότατον (adjectif)''' : Superlatif de ''γυναικεῖος''.&lt;br&gt;
'''γυναικειότερος, -έρα, -ότερον (adjectif)''' : Comparatif de ''γυναικεῖος''.&lt;br&gt;
'''γυναικείως (adverbe)''' : fémininement.&lt;br&gt;
'''γυναικομανία, -ας (nom commun) (f)''' : gynécomanie.&lt;br&gt;
'''γυνή, -αικός (nom commun) (f)''' : Femme, épouse ; femelle des animaux.&lt;br&gt;
'''γυρῖνος, -ίνου (nom commun) (m)''' : têtard.&lt;br&gt;
'''γῦρος, -ύρου (nom commun) (m)''' : Anneau ; cercle.&lt;br&gt;
'''γυρός, -οῦ (nom commun) (m)''' : rond.&lt;br&gt;
'''γύψ, -πος (nom commun) (m)''' : vautour.&lt;br&gt;
'''γωνία, -ας (nom commun) (f)''' : Angle ; coin.&lt;br&gt;
'''γωρυτός, -οῦ (nom commun) (m)''' : carquois.&lt;br&gt;
'''Γαϐριήλ (nom propre) (m)''' : Gabriel.&lt;br&gt;
'''Γάζα, -ης (nom commun) (f)''' : Gaza.&lt;br&gt;
'''Γαῖα, -ίας (nom propre) (f)''' : [[wikt:Gaïa|Gaïa]].&lt;br&gt;
'''Γαῖη, -ίης (nom propre) (f)''' : Forme ionienne de ''Γαῖα''.&lt;br&gt;
'''Γαλινθιάς, -δος (nom propre) (f)''' : Galanthis.&lt;br&gt;
'''Γαλάτεια, -ίας (nom propre) (f)''' : Galatée (Néréide).&lt;br&gt;
'''Γαλατεία, -ας (nom propre) (f)''' : Galatée.&lt;br&gt;
'''Γαλάτης, -ου (nom commun) (m)''' : Galate.&lt;br&gt;
'''Γαλατία, -ας (nom propre) (f)''' : Galatie.&lt;br&gt;
'''Γαλλία, -ας (nom propre) (f)''' : Gaule.&lt;br&gt;
'''Γανυμήδης, -ου (nom propre) (m)''' : Ganymède.&lt;br&gt;
'''Γεδεών, -ος (nom propre) (m)''' : Gédéon.&lt;br&gt;
'''Γελλώ, -οῦς (nom propre) (f)''' : Gello.&lt;br&gt;
'''Γέλων, -ος (nom propre) (m)''' : Gélon.&lt;br&gt;
'''Γεννησαρέτ (nom propre) (f)''' : Gennésaret.&lt;br&gt; 
'''Γερμανία, -ας (nom propre) (f)''' : Allemagne.&lt;br&gt;
'''Γερμανίς, -δος  (nom commun) (f)''' : Allemande.&lt;br&gt;
'''Γερμανός, -οῦ (nom commun) (m)''' : Allemand.&lt;br&gt;
'''Γέτης, -ου (nom commun) (m)''' : Gète.&lt;br&gt;
'''Γεώργιος, -ίου (prénom) (m)''' : Georges.&lt;br&gt;
'''Γῆρας, -ήρως (nom propre) (m)''' : Géras.&lt;br&gt;
'''Γηρυόνης, -ου (nom propre) (m)''' : Forme alternative de ''Γηρυών''.&lt;br&gt;
'''Γηρυών, -όνος (nom propre) (m)''' : Géryon.&lt;br&gt;
'''Γῆ, -ς (nom propre) (f)''' : Terre.&lt;br&gt;
'''Γλαῦκος, -ύκου (nom propre) (m)''' : Glaucos.&lt;br&gt;
'''Γοργώ, -όνος (nom propre) (f)''' : Gorgone.&lt;br&gt;
'''Γότθος, -ου (nom commun) (m)''' : Goth.&lt;br&gt;
'''Γοῦτος, -ύτου (nom commun) (m)''' : Geat.&lt;br&gt;
'''Γραῖα, -ίας (nom propre) (f)''' : Grée.&lt;br&gt;
'''Γρηγόριος, -ίου (nom propre) (m)''' : Grégoire.&lt;br&gt; 
'''Γύγης, -ου (nom propre) (m)''' : Gygès.&lt;br&gt;
'''Γύθειον, -ίου (nom propre) (n)''' : Gythio.&lt;br&gt;
'''Γύθιον, -ίου (nom propre) (n)''' : Forme alternative de ''Γύθειον''.&lt;br&gt;

==Δ==
'''δάγυς, -ύδος (nom commun) (f)''' : dagyde.&lt;br&gt;
'''δαήρ, -έρος (nom commun) (m)''' : beau-frère.&lt;br&gt;
'''δαιμόνιος, -ία, -όνιον (adjectif)''' : étrange.&lt;br&gt;
'''δαιμόνιον, -ίου (nom commun) (n)''' : génie (être merveilleux).&lt;br&gt;
'''δαιμονίως (adverbe)''' : étrangement.&lt;br&gt;
'''δαιμονίοτατα, -, - (adverbe)''' : Superlatif de ''δαιμονίως''.&lt;br&gt;
'''δαιμονίοτερον, -, - (adverbe)''' : Comparatif de ''δαιμονίως''.&lt;br&gt;
'''δαιμονιώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''δαιμόνιος''.&lt;br&gt;
'''δαιμονιώτερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''δαιμόνιος''.&lt;br&gt;
'''δαίμων, -ονος (nom commun) (m)''' : divinité.&lt;br&gt;
'''δακκύλιος, -υλίου (nom commun) (m)''' : Forme béotienne de ''δάκτυλος''.&lt;br&gt;
'''δάκνω (verbe)''' : mordre.&lt;br&gt;
'''δάκος, -ους (nom commun) (n)''' : .&lt;br&gt;
'''δάκρυ, -ύου (nom commun) (n)''' : larme.&lt;br&gt;
'''δακτύλιον, -ίου (nom commun) (n)''' : anneau.&lt;br&gt;
'''δάκτυλος, -ύλου (nom commun) (m)''' : doigt.&lt;br&gt;
'''δάλτος, -ου (nom commun) (f)''' : Forme chypriote de ''δέλτος''.&lt;br&gt;
'''δαμάζω (dompter)''' : domestiquer ; dompter.&lt;br&gt;
'''δάμαλις, -άλεως (nom commun) (f)''' : génisse.&lt;br&gt;  
'''δαμοκρατία, -ας (nom commun) (f)''' : Forme dorienne de ''δημοκρατία''.&lt;br&gt;  
'''δᾶμος, -άμου (nom commun) (m)''' : Forme dorienne de ''δῆμος''.&lt;br&gt;
'''δάνειον, -ίου (nom commun) (n)''' : prêt.&lt;br&gt;
'''δάνος, -ου (nom commun) (m)''' : Forme macédonienne de ''θάνατος''.&lt;br&gt;
'''δαρθάνω (verbe)''' : s’endormir.&lt;br&gt;
'''δάσος, -ους (nom commun) (n)''' : bois (lieu), forêt.&lt;br&gt;
'''δασύνω (verbe)''' : .&lt;br&gt;
'''δασύς, -εῖα, -ύ (adjectif)''' : Velu, poilu. feuillu ; boisé.&lt;br&gt;
'''δασύτης, -τος (nom commun) (f)''' : pilosité.&lt;br&gt;
'''δαῦκον, -ύκου (nom commun) (n)''' : carotte ou navet utilisé en médecine.&lt;br&gt;
'''δεῖγμα, -ίγματος (nom commun) (f)''' : échantillon.&lt;br&gt;
'''δείδω (verbe)''' : avoir peur.&lt;br&gt;
'''δείκτης, -ου (nom commun) (m)''' : index.&lt;br&gt;
'''δεινός, -ή, -όν (adjectif)''' : terrible.&lt;br&gt; 
'''δέ (particule)''' : mais, puis, d’autre part, donc.&lt;br&gt;
'''δέκα (adjectif numéral)''' : dix.&lt;br&gt;
'''δεκαετία, -ας (nom commun) (f)''' : décennie.&lt;br&gt;
'''δεκάς, -δος (nom commun) (f)''' : dizaine.&lt;br&gt;
'''δέκομαι (verbe)''' : Forme éolienne et ionienne de ''δέχομαι''.&lt;br&gt;
'''δελεάζω (verbe)''' : appâter.&lt;br&gt;
'''δέλεαρ, -τος (nom commun) (n)''' : appât.&lt;br&gt;
'''δέλτα (nom commun) (n)''' : delta.&lt;br&gt;
'''δέλτος, -ου (nom commun) (f)''' : tablette d’écriture.&lt;br&gt;
'''δέλφαξ, -κος (nom commun) (f)''' : .&lt;br&gt;
'''δελφίς, -ῖνος (nom commun) (m)''' : dauphin.&lt;br&gt;
'''δελφύς, -ος (nom commun) (f)''' : matrice.&lt;br&gt;
'''δέμω (verbe)''' : construire.&lt;br&gt;
'''δενδρολίϐανον, -άνου (nom commun) (n)''' : romarin.&lt;br&gt;
'''δένδρον, -ου (nom commun) (n)''' : arbre.&lt;br&gt;
'''δένδρεον, -ου (nom commun) (n)''' : Forme homérique de ''δένδρον''.&lt;br&gt;
'''δεξιτερός, -ή, -όν (adjectif)''' : Forme de ''δεξιός''.&lt;br&gt; 
'''δεξιός, -ά, -όν (adjectif)''' : qui est à droite, placé à droite. (Par suite) De bon augure, favorable. Qui a de la dextérité, adroit, industrieux, habile.&lt;br&gt; 
'''δέος, -ους (nom commun) (n)''' : effroi, peur.&lt;br&gt; 
'''δέρας, -ατος (nom commun) (n)''' : peau, cuir.&lt;br&gt; 
'''δέρκομαι (verbe)''' : voir clair.&lt;br&gt;
'''δέρμα, -τος (nom commun) (n)''' : peau.&lt;br&gt; 
'''δέρω (verbe)''' : écorcher.&lt;br&gt;
'''δέσμευσις, -ύσεως (nom commun) (f)''' : lien.&lt;br&gt; 
'''δεσμεύω (verbe)''' : lier.&lt;br&gt;
'''δέσμη, -ης (nom commun) (f)''' : bouquet, faisceau, liasse. 
'''δεσμός, -οῦ (nom commun) (m)''' : Lien (corde, câble, amarre, courroie, nœud). (Par extension) Clou. (D’ordinaire au pluriel) Liens, chaînes, fers. (Par suite) Emprisonnement, prison. (En général) Captivité. (Figuré) Liens d’amitié.&lt;br&gt;
'''δέσποινα, -ίνης (nom commun) (f)''' : maîtresse d’une maisonnée.&lt;br&gt;
'''δεσπότης, -ου (nom commun) (m)''' : maître d’une maisonnée ; maître d’un dème.&lt;br&gt;
'''δεῦμα, -ύματος (nom commun) (n)''' : chair cuite.&lt;br&gt;
'''δεῦρο (adverbe)''' : ici (avec mouvement).&lt;br&gt;
'''δευτεραγωνιστής, -οῦ (nom commun) (m)''' : deutéragoniste.&lt;br&gt;
'''δεύτερος, -α, -ον (adjectif)''' : deuxième.&lt;br&gt;
'''δευτήρ, -ῆρος (nom commun) (m)''' : chaudron.&lt;br&gt;
'''δεύω (verbe)''' : mouiller.&lt;br&gt;  
'''δέφυρα, -ύρας (nom commun) (f)''' : Forme crétoise de ''γέφυρα''.&lt;br&gt;
'''δέχομαι (verbe)''' : Accepter, admettre, agréer. Accueillir, recevoir, recueillir, adopter. Prendre, revêtir, comporter.&lt;br&gt;
'''δή (particule)''' : vraiment, assurément.&lt;br&gt;
'''δῆγμα, -ήγματος (nom commun) (m)''' : morsure.&lt;br&gt;
'''δηκτήριος, -ος, -ον (adjectif)''' : mordant.&lt;br&gt;
'''δηλητήρ, -ρός (nom commun) (m)''' : destructeur.&lt;br&gt;
'''δηλοῦμαι (verbe)''' : détruire.&lt;br&gt;
'''δήλωσις, -ώσεως (nom commun) (f)''' : déclaration.&lt;br&gt; 
'''δηλῶ (verbe)''' : déclarer.&lt;br&gt;  
'''δημοκρατία, -ας (nom commun) (f)''' : république.&lt;br&gt; 
'''δημόσιος, -ία, -όσιον (adjectif)''' : public.&lt;br&gt;
'''δημοσίως (adverbe)''' : publiquement.&lt;br&gt;
'''δημοσιώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''δημόσιος''.&lt;br&gt;
'''δημοσιώτερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''δημόσιος''.&lt;br&gt;
'''δῆμος, -ήμου (nom commun) (m)''' : contrée, pays, terre.&lt;br&gt;
'''δημότης, -ου (nom commun) (m)''' : concitoyen.&lt;br&gt;‎
'''δημοτικός, -ή, -όν (adjectif)''' : commun.&lt;br&gt;
'''δημοτικῶς (adverbe)''' : communément.&lt;br&gt;
'''δημοτικώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''δημοτικός''.&lt;br&gt;
'''δημοτικώτερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''δημοτικός''.&lt;br&gt;
'''δημοτικώτατα, -, - (adverbe)''' : Superlatif de ''δημοτικῶς''.&lt;br&gt;
'''δημοτικώτερον, -, - (adverbe)''' : Comparatif de ''δημοτικῶς''.&lt;br&gt;
'''δημωδέστατος, -άτη, -έστατον (adjectif)''' : Superlatif de ''δημώδης''.&lt;br&gt;
'''δημωδέστερος, -έρα, -έστερον (adjectif)''' : Comparatif de ''δημώδης''.&lt;br&gt;
'''δημώδης, -ης, -ες (adjectif)''' : vernaculaire.&lt;br&gt;
'''δημωδῶς (adverbe)''' : vernaculairement.&lt;br&gt;
'''δήν (particule)''' : il y a longtemps.&lt;br&gt;
'''δηρός, -ά, -όν (adjectif)''' : .&lt;br&gt;
'''διά (adverbe ; préposition)''' : .&lt;br&gt;
'''διαϐεϐαιῶ (verbe)''' : garantir (se rendre garant de l’existence de la réalité d’une chose).&lt;br&gt;
'''διαϐιϐάζω (verbe)''' : lire.&lt;br&gt;
'''διαϐιϐρώσκω (verbe)''' : .&lt;br&gt;
'''διάϐολος, -ου (masculin) (m)''' : calomniateur ; diable.&lt;br&gt;  
'''διαϐολικός, -ή, -όν (adjectif)''' : du diable.&lt;br&gt;
'''διαϐολικῶς (adverbe)''' : diaboliquement.&lt;br&gt;
'''διαϐολικώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''διαϐολικός''.&lt;br&gt;
'''διαϐολικώτερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''διαϐολικός''.&lt;br&gt;
'''διάγνωσις, -ώσεως (nom commun) (f)''' : .&lt;br&gt;
'''διάδημα, -ήματος (nom commun) (n)''' : diadème.&lt;br&gt;
'''διαδῶ (verbe)''' : .&lt;br&gt;
'''διάζωμα, -ώματος (nom commun) (n)''' : caleçon.&lt;br&gt;
'''διάθεσις, -έσεως (nom commun) (f)''' : disposition.&lt;br&gt;
'''διαθήκη, -ης (nom commun) (f)''' : testament, volonté (document écrit). Testament (livre religieux)&lt;br&gt;
'''διαίρεσις, -έσεως (nom commun) (f)''' : division.&lt;br&gt;
'''διαίσθησις, -ήσεως (nom commun) (f)''' : intuition.&lt;br&gt;
'''διαισθητικός, -ή, -όν (adjectif)''' : intuitif.&lt;br&gt;
'''διαισθητικῶς (adverbe)''' : intuitivement.&lt;br&gt;
'''διαιτητής, -οῦ (nom commun) (m)''' : arbitre.&lt;br&gt;  
'''διακινῶ (verbe)''' : .&lt;br&gt;
'''διάκονος, -όνου (nom commun) (m/f)''' : Serviteur, servante.&lt;br&gt;
'''διακοπή, -ῆς (nom commun) (f)''' : interruption.&lt;br&gt;
'''διακόπτω (verbe)''' : interrompre.&lt;br&gt;
'''διακορεύω (verbe)''' : déflorer.&lt;br&gt;
'''διακόρησις, -ήσεως (nom commun) (f)''' : défloration.&lt;br&gt;
'''διάκρισις, -ίσεως (nom commun) (f)''' : discrétion ; distinction.&lt;br&gt;
'''διακριτικός, -ή, -όν (adjectif)''' : discret ; distinct.&lt;br&gt;
'''διακριτικότατα, -, - (adverbe)''' : Superlatif de ''διακριτικῶς''.&lt;br&gt;
'''διακριτικότερον, -, - (adverbe)''' : Comparatif de ''διακριτικῶς''.&lt;br&gt;
'''διακριτικότατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''διακριτικός''.&lt;br&gt;
'''διακριτικότερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''διακριτικός''.&lt;br&gt;
'''διακριτικῶς (adverbe)''' : discrètement ; distinctement.&lt;br&gt;
'''διάλεξις, -έξεως (nom commun) (f)''' : exposé.&lt;br&gt;
'''διαλέγομαι (verbe)''' : discuter.&lt;br&gt; 
'''διάλεκτος, -έκτου (nom commun) (f)''' : discussion ; dialecte.&lt;br&gt;
'''διαλλάττω (verbe)''' : transiger.&lt;br&gt;
'''διάλογος, -όγου (nom commun) (m)''' : dialogue.&lt;br&gt;
'''διαμαστίγωσις, -ώσεως (nom commun) (f)''' : .&lt;br&gt;
'''διαμαστιγῶ (verbe)''' : .&lt;br&gt;
'''διανόησις, -ήσεως (nom commun) (f)''' : pensée.&lt;br&gt;
'''διανοῶ  (verbe)''' : penser.&lt;br&gt;
'''διαπραγμάτευσις, -ύσεως (nom commun) (f)''' : négociation.&lt;br&gt;
'''διαπραγματεύομαι (verbe)''' : négocier.&lt;br&gt;
'''διαρρήγνυμι (verbe)''' : cambrioler.&lt;br&gt;
'''διαρρήκτης, -ου (nom commun) (m)''' : cambrioleur.&lt;br&gt;
'''διάρρηξις, -ήξεως (nom commun) (m)''' : cambriolage.&lt;br&gt;
'''διάρροια, -ας (nom commun) (f)''' : diarrhée.&lt;br&gt;
'''διάσεισις, -ίσεως (nom commun) (f)''' : commotion.&lt;br&gt;
'''διασείω (verbe)''' : .&lt;br&gt;
'''διασκέδασις, -άσεως (nom commun) (f)''' : divertissement.&lt;br&gt; 
'''διάστασις, -άσεως (nom commun) (f)''' : dimension.&lt;br&gt;
'''διαστέλλω (verbe)''' : Répandre, séparer. Distinguer, déterminer.&lt;br&gt;
'''διάστημα, -ήματος (nom commun) (n)''' : espace.&lt;br&gt;
'''διαστολή, -ῆς (nom commun) (f)''' : Élargissement, expansion, dilatation. Petite coche ou fente.&lt;br&gt;
(Figuré) Distinction.&lt;br&gt;
'''διάστρεμμα, -έμματος (nom commun) (n)''' : entorse.&lt;br&gt;
'''διαστρέφω (verbe)''' : disposer.&lt;br&gt;
'''διατίθημι (verbe)''' : disposer.&lt;br&gt;
'''διατριϐή, -ῆς (nom commun) (f)''' : conversation (philosophique).&lt;br&gt;
'''διαφθείρω (verbe)''' : corrompre.&lt;br&gt;
'''διαφθορά, -ᾶς (nom commun) (f)''' : corruption.&lt;br&gt;
'''διαφθορεῖον, -ίου (nom commun) (n)''' : .&lt;br&gt;
'''διαφθορεύς, -έως (nom commun) (m)''' : .&lt;br&gt;
'''διαχειριστής, -οῦ (masculin) (m)''' : gestionnaire.&lt;br&gt;  
'''διαχείρισις, -ίσεως (nom commun) (f)''' : gestion.&lt;br&gt;
'''διαχειριστικός, -ή, -όν (adjectif)''' : .&lt;br&gt;
'''διαχειριστικῶς (adverbe)''' : -ment.&lt;br&gt;
'''διαχειριστικώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''διαχειριστικός''.&lt;br&gt;
'''διαχειριστικώτερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''διαχειριστικός''.&lt;br&gt;
'''διαχειριστικώτατα, -, - (adverbe)''' : Superlatif de ''διαχειριστικῶς''.&lt;br&gt;
'''διαχειριστικώτερον, -, - (adverbe)''' : Comparatif de ''διαχειριστικῶς''.&lt;br&gt; 
'''διδάσκαλος, -άλου (nom commun) (m)''' : instituteur.&lt;br&gt;
'''διδάσκω (verbe)''' : enseigner, instruire ; entraîner.&lt;br&gt;
'''διαφέρω (verbe)''' : différer.&lt;br&gt;
'''διαφορά, -ᾶς	(nom commun) (f)''' : différence.&lt;br&gt;
'''διαφορετικός, -ή, -όν (adjectif)''' : différent.&lt;br&gt;
'''διαφορετικώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''διαφορετικός''.&lt;br&gt;
'''διαφορετικώτερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''διαφορετικός''.&lt;br&gt;
'''διαφορετικώτατα, -, - (adverbe)''' : Superlatif de ''διαφορετικῶς''.&lt;br&gt;
'''διαφορετικώτερον, -, - (adverbe)''' : Comparatif de ''διαφορετικῶς''.&lt;br&gt; 
'''δίδυμος, -ος, -ον (adjectif)''' : double ; jumeau.&lt;br&gt;
'''δίδωμι (verbe)''' : donner.&lt;br&gt;
'''διείσδυσις, -ύσεως (nom commun) (f)''' : pénétration.&lt;br&gt;
'''διεισδύω (verbe)''' : pénétrer.&lt;br&gt;
'''διεύθυνσις, -ύνσεως (nom commun) (f)''' : direction.&lt;br&gt;
'''διευθύνων, -ουσα, -ον  (adjectif)''' : directeur.&lt;br&gt;
'''διευθυντής, -οῦ (nom commun) (m)''' : directeur.&lt;br&gt; 
'''διευθύνω (verbe)''' : diriger.&lt;br&gt; 
'''διθύραμϐος, -άμϐου (nom commun) (m)''' : dithyrambe.&lt;br&gt; 
'''διήγημα, -ήματος (nom commun) (n)''' : conte.&lt;br&gt;
'''διήγησις, -ήσεως (nom commun) (f)''' : narration.&lt;br&gt;
'''διηγοῦμαι (verbe)''' : narrer.&lt;br&gt; 
'''διήκονος, -όνου (nom commun) (m/f)''' : Forme ionienne de ''διάκονος''.&lt;br&gt;
'''διίσταμαι (verbe)''' : .&lt;br&gt;
'''διίστημι (verbe)''' : .&lt;br&gt;
'''δικάζω (verbe)''' : juger.&lt;br&gt; 
'''δικαίωμα, -ώματος (nom commun) (n)''' : (Droit) Jugement. Justification. Décret.&lt;br&gt;
'''δικαιῶ (verbe)''' : rendre juste.&lt;br&gt;
'''δικαστήριον, -ίου (nom commun) (n)''' : tribunal.&lt;br&gt;
'''δικαστής, -οῦ (nom commun) (m)''' : juge.&lt;br&gt;
'''δίκη, -ης (nom commun) (f)''' : Coutume, manière, mode. Ordre, loi, droit. Justice. Jugement. Punition, vengeance, pénalité.&lt;br&gt;
'''δίκτυον, -ύου (nom commun) (n)''' : filet.&lt;br&gt;
'''δίνη, -ης (nom commun) (f)''' : tourbillon.&lt;br&gt;
'''δίλημμα, -ήμματος (nom commun) (n)''' : dilemme.&lt;br&gt;
'''διπλοῦς, -ῆ, -οῦν ‎(adjectif)''' : double.&lt;br&gt;
'''διοίκησις, -ήσεως (nom commun) (f)''' : administration.&lt;br&gt;
'''διοικητής, -οῦ (nom commun) (m)''' : administrateur.&lt;br&gt;
'''διοικητικός, -ή, -όν ‎(adjectif)''' : administratif.&lt;br&gt;
'''διοικῶ (verbe)''' : administrer.&lt;br&gt; 
'''διορθώνω (verbe)''' : corriger.&lt;br&gt;
'''δισσός, -ή, -όν ‎(adjectif)''' : double.&lt;br&gt;
'''δισσότατα, -, - (adverbe)''' : Superlatif de ''δισσῶς''.&lt;br&gt;
'''δισσότερον, -, - (adverbe)''' : Comparatif de ''δισσῶς''.&lt;br&gt;
'''δισσότατος, -άτη, -ότατον (adjectif)''' : Superlatif de ''δισσός''.&lt;br&gt;
'''δισσότερος, -έρα, -ότερον (adjectif)''' : Comparatif de ''δισσός''.&lt;br&gt;
'''δίς (adverbe)''' : deux fois.&lt;br&gt;
'''δισσῶς (adverbe)''' : doublement.&lt;br&gt;
'''δίφθογγος, -όγγου (nom commun) (f)''' : diphtongue.&lt;br&gt;
'''δίφουρα, -ύρας (nom commun) (f)''' : Forme laconienne de ''γέφυρα''.&lt;br&gt;
'''δίφρος, -ου (nom commun) (m)''' : tabouret.&lt;br&gt;
'''διχόνοια, -ας (nom commun) (f)''' : discorde.&lt;br&gt;
'''διχορεῖος, -ίου (nom commun) (m)''' : dichorée.&lt;br&gt;
'''δίψα, -ης  (nom commun) (f)''' : soif.&lt;br&gt;
'''διψώ (verbe)''' : avoir soif.&lt;br&gt;
'''διωγμός, -οῦ (nom commun) (m)''' : persécution.&lt;br&gt;
'''διώκω (verbe)''' : persécuter.&lt;br&gt;
'''διῶρυξ, -ώρυγος (nom commun) (f)''' : canal.&lt;br&gt;
'''δμωή, -ῆς (nom commun) (f)''' : domestique, servante.&lt;br&gt;
'''δμῳή, -ῆς (nom commun) (f)''' : esclave.&lt;br&gt;
'''δμῴιος, -ίου (nom commun) (m)''' : esclave.&lt;br&gt;
'''δμώς, -ός (nom commun) (m)''' : domestique, serviteur.&lt;br&gt;
'''δόγμα, -τος (nom commun) (n)''' : Opinion. Décision, décret, arrêt. Doctrine.&lt;br&gt;
'''δογματικός, -ή, -όν (adjectif)''' : doctrinal.&lt;br&gt;
'''δογματικῶς (adverbe)''' : doctrinalement.&lt;br&gt;
'''δογματικώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''δογματικός''.&lt;br&gt;
'''δογματικώτερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''δογματικός''.&lt;br&gt;	
'''δοθιήν, -ένος (nom commun) (m)''' : furoncle.&lt;br&gt;
'''δόκησις, -ήσεως (nom commun) (f)''' : Opinion ; croyance.&lt;br&gt;
'''δοκέω (verbe)''' : Penser, supposer. Sembler.&lt;br&gt;
'''δολερός, -ή, -όν (adjectif)''' : rusé.&lt;br&gt;
'''δολιόω (verbe)''' : abuser.&lt;br&gt;
'''δόλος, -ου (nom commun) (m)''' : ruse.&lt;br&gt;
'''δόξα, -ης (nom commun) (f)''' : Opinion, vue, point de vue, conjecture, supposition. (Dans le Nouveau Testament.) Gloire, honneur ; splendeur.&lt;br&gt;
'''δοξάζω (verbe)''' : Imaginer. Glorifier.&lt;br&gt;
'''δοξολογία, -ας (nom commun) (f)''' : doxologie.&lt;br&gt;
'''δοξόλογος, -όγου (nom commun) (m)''' : doxologue.&lt;br&gt;
'''δοξοσοφία, -ας (nom commun) (f)''' : doxosophie.&lt;br&gt;
'''δοξόσοφος, -όφου (nom commun) (m)''' : doxosophe.&lt;br&gt;
'''δουλεία, -ας (nom commun) (f)''' : servitude.&lt;br&gt;
'''δουλεύω (verbe)''' : être esclave. Travailler à gages, faire un travail mercenaire.&lt;br&gt;
'''δούλη, -ης (nom commun) (f)''' : esclave.&lt;br&gt;
'''δοῦλος, -ύλου (nom commun) (m)''' : esclave.&lt;br&gt; 
'''δουλόω (verbe)''' : asservir.&lt;br&gt;
'''δούξ, -κός (nom commun) (m)''' : chef.&lt;br&gt;
'''δόμος, -ου (nom commun) (m)''' : Maison, palais ; chambre, appartement.&lt;br&gt;
'''δόναξ, -κος (nom commun) (m)''' : Roseau ; objet fait de roseau.&lt;br&gt;
'''δονέω (verbe)''' : agiter.&lt;br&gt;
'''δόνημα, -ήματος (nom commun) (n)''' : agitation.&lt;br&gt;
'''δορκάς, -δος (f)''' : chevreuil.&lt;br&gt;
'''δοράκινον, -ίνου (nom commun) (n)''' : pêche (fruit).&lt;br&gt; 
'''δόρκος, -ου (nom commun) (m)''' : Forme de ''δορκάς''.&lt;br&gt;
'''δόρκων, -ος (nom commun) (m)''' : Forme de ''δορκάς''.&lt;br&gt;
'''δόρξ, -κος (nom commun) (m)''' : Forme de ''δορκάς''.&lt;br&gt;
'''δόσις, -εως (nom commun) (f)''' : don ; cadeau.&lt;br&gt;
'''δοχεῖον, -ίου (nom commun) (n)''' : récipient.&lt;br&gt;
'''δράκαινα, -ίνης (nom commun) (f)''' : dracène.&lt;br&gt;
'''δράκων, -οντος (nom commun) (m)''' : dragon.&lt;br&gt;
'''δρᾶμα, -άματος (nom commun) (n)''' : action théâtrale ; pièce de théâtre.&lt;br&gt;
'''δραπέτης, -ου (nom commun) (m)''' : fugitif.&lt;br&gt;
'''δράσσομαι (verbe)''' : saisir.&lt;br&gt;
'''δραχμή, -ῆς (nom commun) (f)''' : Poignée, contenu de la main. Drachme attique.&lt;br&gt;
'''δράω (verbe)''' : .&lt;br&gt; 
'''δρίλαξ, -κος (nom commun) (m)''' : sangsue.&lt;br&gt;
'''δρομαῖος, -ία, -ῖον (adjectif)''' : .&lt;br&gt;
'''δρομάς, -δος (nom commun) (m)''' : dromadaire.&lt;br&gt;
'''δρόμος, -ου (nom commun) (m)''' : Course (de chevaux), lutte à la course, tour de promenade.&lt;br&gt;
'''δρόσος, -ου (nom commun) (f)''' : rosée.&lt;br&gt;
'''δρυμός, -οῦ (nom commun) (m)''' : bois (lieu), forêt.&lt;br&gt;
'''δύη, -ης (nom commun) (f)''' : misère.&lt;br&gt;
'''δύναμις, -εως (nom commun) (f)''' : force en puissance.&lt;br&gt;
'''δύο (adjectif numéral)''' : deux.&lt;br&gt;
'''δύσις, -εως (nom commun) (f)''' : ouest.&lt;br&gt; 
'''δυσλογία, -ας (nom commun) (f)''' : .&lt;br&gt;
'''δυσμικός, -ή, -όν (adjectif)''' : occidental.&lt;br&gt;
'''δυσ- (préfixe)''' : Difficulté, malheur.&lt;br&gt;
'''δυσσέϐεια, -ίας (nom commun) (f)''' : impiété.&lt;br&gt;
'''δυσσεϐέστατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''δυσσεϐής''.&lt;br&gt;
'''δυσσεϐέστερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''δυσσεϐής''.&lt;br&gt;
'''δυσσεϐής, -ής, -ές (adjectif)''' : impie.&lt;br&gt;
'''δυσσεϐῶς (adverbe) : impieusement.&lt;br&gt;
'''δυστύχημα, -ήματος (nom commun) (n)''' : accident.&lt;br&gt; 
'''δυστυχής, -ής, -ές (adjectif)''' : malheureux.&lt;br&gt;
'''δυστυχία, -ας (nom commun) (f)''' : malheur.&lt;br&gt;
'''δυστυχῶς (adverbe)''' : malheureusement.&lt;br&gt;
'''δυστυχῶ (verbe)''' : causer un malheur.&lt;br&gt;
'''δυτικός, -ή, -όν (adjectif)''' : occidental.&lt;br&gt;
'''δυτικότατος, -άτη, -ότατον (adjectif)''' : Superlatif de ''δυτικός''.&lt;br&gt;
'''δυτικότερος, -έρα, -ότερον (adjectif)''' : Comparatif de ''δυτικός''.&lt;br&gt;
'''δυτικότατα, -, - (adverbe)''' : Superlatif de ''δυτικῶς''.&lt;br&gt;
'''δυτικότερον, -, - (adverbe)''' : Comparatif de ''δυτικῶς''.&lt;br&gt;
'''δυτικῶς (adverbe)''' : occidentalement.&lt;br&gt;
'''δύω (verbe)''' : S’enfoncer, se plonger. (Par extension) Pénétrer dans. (Par analogie) Se revêtir de.&lt;br&gt;
'''δώδεκα (adjectif numéral)''' : douze.&lt;br&gt;
'''δωδεκάς, -δος (nom commun) (f)''' : douzaine.&lt;br&gt;
'''δῶμα, -ώματος (nom commun) (n)''' : Construction. Maison, demeure. Chambre principale. Temple (demeure d’un dieu).&lt;br&gt;
'''δωμάτιον, -ίου  (nom commun) (n)''' : chambre.&lt;br&gt;
'''δωράκινον, -ίνου  (nom commun) (n)''' : pêche (fruit).&lt;br&gt;
'''δῶρον, -ώρου (nom commun) (n)''' : Don ; présent. Paume de la main ; palme.&lt;br&gt;
'''δώτωρ, -ορος (nom commun) (m)''' : donneur.&lt;br&gt;
'''δῶ (verbe)''' : Lier, attacher. (Par extension) Enfermer, emprisonner. (Par analogie) Entraver, empêcher, retenir. (Figuré) Lier, enchaîner. Manquer, avoir besoin de. (Impersonnel) Il est besoin de, il faut. (Forme moyenne) Avoir besoin.
(Par suite) Demander, prier.&lt;br&gt;
'''Δαϐίδ (nom propre) (m)''' : Forme alternative de ''Δαυίδ''.&lt;br&gt;
'''Δαίδαλος, -άλου (nom propre) (m)''' : Dédale.&lt;br&gt;
'''Δάκης, -ου (nom commun) (n)''' : Dace.&lt;br&gt;
'''Δαμασκός, -οῦ (nom propre) (f)''' : Damas.&lt;br&gt;
'''Δαμαστής, -οῦ (nom propre) (m)''' : Damastès (Autre surnom de Polypémon).&lt;br&gt;
'''Δαμάτηρ, -τρός (nom propre) (f)''' : Forme arcado-chypriote, béotienne, et dorienne de ''Δημήτηρ''.&lt;br&gt;
'''Δαμιανός, -οῦ (nom propre) (m)''' : Damien.&lt;br&gt;
'''Δαμία, -ας (nom propre) (f)''' : Damia.&lt;br&gt;
'''Δάμις, - (nom propre) (m)''' : Damis.&lt;br&gt;
'''Δάν, -ός (nom propre) (m)''' : Forme  de ''Ζεύς''.&lt;br&gt;
'''Δανιήλ (nom propre) (m)''' : Daniel.&lt;br&gt;
'''Δάνος, -ου (nom commun) (m)''' : Forme macédonienne de ''Θάνατος''.&lt;br&gt;
'''Δαυείδ (nom propre) (m)''' : Forme alternative de ''Δαυίδ''.&lt;br&gt;
'''Δαυίδ (nom propre) (m)''' : David.&lt;br&gt;
'''Δεῖμος, -ίμου (nom propre) (m)''' : Déimos.&lt;br&gt;
'''Δεινώ, -οῦς (nom propre) (f)''' : Dino. (une des Grées)&lt;br&gt;
'''Δέσποινα, -ίνης (nom propre) (f)''' : [[wikt:Despina|Despina]].&lt;br&gt;
'''Δεύς, -ως (nom propre) (m)''' : Forme laconienne de ''Ζεύς''.&lt;br&gt;
'''Δῃάνειρα, -ίρας (nom propre) (f)''' : Déjanire.&lt;br&gt;
'''Δηϊδάμεια, -ίας (nom propre) (f)''' : Déidamie.&lt;br&gt;
'''Δηιόκης, -ου (nom propre) (m)''' : Déjocès.&lt;br&gt;
'''Δηΐφοϐος, -όϐου (nom propre) (m)''' : Déiphobe.&lt;br&gt;
'''Δημήτηρ, -τρος (nom propre) (f)''' : [[wikt:Déméter|Déméter]].&lt;br&gt;
'''Δημήτριος, -ίου (nom propre) (m)''' : Démétrios.&lt;br&gt;
'''Δημιουργός, -οῦ (nom propre) (m)''' : Créateur.&lt;br&gt;
'''Δημοσθένης, -ους (nom propre) (m)''' : Démosthène.&lt;br&gt;
'''Δημώναξ, -ώνακτος (nom propre) (m)''' : Démonax.&lt;br&gt;
'''Δίδυμοι, -ων (nom propre) (m)''' : Gémeaux.&lt;br&gt;
'''Δίκη, -ης (nom propre) (f)''' : [[wikt:Dicé|Dicé]]. (Déesse de la justice divine.)&lt;br&gt;
'''Δίκτυον, -ύου (nom propre) (n)''' : Réticule.&lt;br&gt;
'''Διόδωρος, -ώρου (nom propre) (m)''' : Diodore.&lt;br&gt; 
'''Διογένης, -ους (nom propre) (m)''' : Diogène.&lt;br&gt; 
'''Διόνυσος, -ύσου (nom propre) (m)''' : [[wikt:Dionysos|Dionysos]].&lt;br&gt;
'''Διομέδων, -οντος (nom propre) (m)''' : Diomède.&lt;br&gt; 
'''Διώνη, -ης (nom propre) (f)''' : [[wikt:Dioné|Dioné]].&lt;br&gt;
'''Δούναϐις, -άϐεως (nom propre) (m)''' : Danube.&lt;br&gt;
'''Δύμη, -ης (nom propre) (f)''' : Dymé.&lt;br&gt;
'''Δυσνομία, -ας (nom propre) (m)''' : Dysnomie.&lt;br&gt;
'''Δωμάτηρ, -τρός (nom propre) (f)''' : Forme éolienne de ''Δημήτηρ''.&lt;br&gt;
'''Δωριεύς, -έως (nom commun) (m)''' : Dorien.&lt;br&gt; 
'''Δωρικός, -ή, -όν (adjectif)''' : dorien.&lt;br&gt; 
'''Δωρίς, -δος (nom propre) (f)''' : Doris. (Océanide) (nom commun) Dorienne.&lt;br&gt;
'''Δωροθέα, -ας (nom propre) (f)''' : Dorothée.&lt;br&gt;
'''Δωρόθεος, -έου (nom propre) (m)''' : Dorothéos.&lt;br&gt;
'''Δῶρος, -ώρου (nom propre) (m)''' : Doros.&lt;br&gt;

==Ε==
'''ἐάν (conjonction)''' : si (éventuel).&lt;br&gt;
'''ἔαρ, -ος (nom commun) (n)''' : printemps.&lt;br&gt;
'''ἑϐδομάς, -δος (nom commun) (f)''' : semaine.&lt;br&gt;
'''ἑϐδομήκοντα (adjectif numéral)''' : soixante-dix.&lt;br&gt;
'''ἕϐδομος, -όμη, -ομον (adjectif numéral)''' : septième.&lt;br&gt;
'''ἑϐραΐζω (verbe)''' : .&lt;br&gt;
'''ἑϐραῖος, -ία, -ῖον (adjectif)''' : israélite.&lt;br&gt;
'''ἑϐραϊκός, -ή, -όν (adjectif)''' : hébraïque.&lt;br&gt;
'''ἑϐραϊστί (adverbe)''' : en hébreu.&lt;br&gt;
'''ἐγγόνη, -ης (nom commun) (f)''' : petite-fille.&lt;br&gt;
'''ἐγγύησις, -ήσεως (nom commun) (f)''' : garantie.&lt;br&gt; 
'''ἐγγύς (adverbe)''' : proche.&lt;br&gt;
'''ἐγγυῶμαι (verbe)''' : garantir (se rendre garant, répondre d’une chose, du maintien, de l’exécution d’une chose).&lt;br&gt;
'''ἐγείρω (verbe)''' : réveiller.&lt;br&gt;
'''ἐγκέφαλος, -άλου (nom commun) (m)''' : cerveau.&lt;br&gt;
'''ἔγκλησις, -ίσεως (nom commun) (f)''' : accusation.&lt;br&gt; 
'''ἔγκλισις, -ίσεως (nom commun) (f)''' : mode (grammaire).&lt;br&gt; 
'''ἐγκόπρησις, -ήσεως (nom commun) (f)''' : incontinence fécale.&lt;br&gt;
'''ἐγκόσμιος, -α, -ο (adjectif)''' : .&lt;br&gt;
'''ἔγκυος, -ος, -ον (adjectif)''' : enceinte.&lt;br&gt;
'''ἐγκυμονῶ (verbe)''' : engrossir.&lt;br&gt;
'''ἐγκύμων, -ων, -ον (adjectif)''' : .&lt;br&gt;
'''ἐγώ (pronom personnel)''' : je.&lt;br&gt;
'''ἔδαφος, -άφους (nom commun) (n)''' : sol.&lt;br&gt;
'''ἐδεμικός, -ή, -όν (adjectif)''' : édénique.&lt;br&gt;
'''ἐδεμικῶς (adverbe)''' : édéniquement.&lt;br&gt;
'''ἐδεμικώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''ἐδεμικός''.&lt;br&gt;
'''ἐδεμικώτερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''ἐδεμικός''.&lt;br&gt;
'''ἐδεμικώτατα, -, - (adverbe)''' : Superlatif de ''ἐδεμικῶς''.&lt;br&gt;
'''ἐδεμικώτερον, -, - (adverbe)''' : Comparatif de ''ἐδεμικῶς''.&lt;br&gt; 
'''ἔδεσμα, -έσματος (nom commun) (n)''' : nourriture.&lt;br&gt;	
'''ἕδρα, -ας (nom commun) (f)''' : Siège. Trône. Résidence, demeure. Partie du corps sur laquelle on s'assied. Action de s'asseoir. Assemblée siégeante.&lt;br&gt;
'''ἑδραῖος, ία, -ῖον (adjectif)''' : .&lt;br&gt;
'''ἐδώδιμος, -η, -ο (adjectif)''' : mangeable.&lt;br&gt;
'''ἐδωδή, -ῆς (nom commun) (f)''' : .&lt;br&gt; 
'''ἔδω (verbe)''' : nourrir.&lt;br&gt;
'''ἕζομαι (verbe)''' : asseoir.&lt;br&gt;
'''ἔζω (verbe)''' : nourrir.&lt;br&gt;
'''ἐθίζω (verbe)''' : accoutumer.&lt;br&gt;
'''ἐθικός, -ή, -όν (adjectif)''' : coutumier.&lt;br&gt;
'''ἐθικῶς (adverbe)''' : coutumièrement.&lt;br&gt;
'''ἐθικώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''ἐθικός''.&lt;br&gt;
'''ἐθικώτερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''ἐθικός''.&lt;br&gt;
'''ἐθνικός, -ή, -όν (adjectif)''' : national.&lt;br&gt;
'''ἐθνικῶς (adverbe)''' : sagement.&lt;br&gt;
'''ἐθνικώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''ἐθνικός''.&lt;br&gt;
'''ἐθνικώτερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''ἐθνικός''.&lt;br&gt;
'''ἔθνος, -ους (nom commun) (n)''' : Famille, ensemble des proches. Nation. Tribu. (Religion) (Au pluriel) Gentils, les non-juifs, usage tardif dans la Bible. Troupeau.&lt;br&gt;
'''ἔθος, -ους (nom commun) (n)''' : coutume.&lt;br&gt;
'''ἔθω (verbe)''' : avoir coutume de ; être habituel.&lt;br&gt;
'''-ειδής, -ής, -ές (suffixe)''' : en forme de.&lt;br&gt;
'''-ειδῶς (suffixe)''' : .&lt;br&gt;
'''-ειδέστατος, -άτη, -έστατον (suffixe)''' : Superlatif de ''-ειδής''.&lt;br&gt;
'''-ειδέστερος, -έρα, -έστερον (suffixe)''' : Comparatif de ''-ειδής''.&lt;br&gt;
'''εἰδοποίησις, -ήσεως (nom commun) (f)''' : information.&lt;br&gt;
'''εἰδοποιῶ (verbe)''' : informer.&lt;br&gt;
'''εἶδος, -ἴδους (nom commun) (f)''' : Forme du corps ; air d'une personne ou d'une chose.&lt;br&gt;
'''εἰδύλλιον, -ίου (nom commun) (n)''' : Petit poème lyrique.&lt;br&gt;
'''εἰδωλολάτρης, -ου (nom commun) (m)''' : païen.&lt;br&gt;
'''εἰδωλολατρία, -ας (nom commun) (f)''' : paganisme.&lt;br&gt;
'''εἴδωλον, -ώλου (nom commun) (n)''' : Simulacre, fantôme ; image, portrait.&lt;br&gt;
'''εἴδω (verbe)''' : voir.&lt;br&gt;
'''εἰ (adverbe, conjonction)''' : si.&lt;br&gt;
'''εἰ μή (conjonction)''' : à moins que ; sauf si.&lt;br&gt;
'''εἰκονικός, -ή, -όν (adjectif)''' : virtuel.&lt;br&gt;
'''εἰκός, -τος (nom commun) (n)''' : raison.&lt;br&gt;
'''εἰκών, -όνος (nom commun) (f)''' : image, portrait.&lt;br&gt;
'''εἴκω (verbe)''' : Être semblable ; ressembler.&lt;br&gt; 
'''εἰσαφίημι (verbe)''' : .&lt;br&gt; 
'''εἰς (adverbe ; préposition)''' : Dans. Jusqu’à ; vers.&lt;br&gt;
'''εἷς, ἑνός (adjectif numéral)''' : un.&lt;br&gt;
'''εἰκοσαριά, -ᾶς (nom commun) (f)''' : vingtaine.&lt;br&gt; 
'''εἴκοσι(ν) (adjectif numéral)''' : vingt.&lt;br&gt;
'''ἐείκοσι(ν) (adjectif numéral)''' : Forme homérique de ''εἴκοσι(ν)''.&lt;br&gt;
'''ϝίκατι(ν) (adjectif numéral)''' : Forme béotienne de ''εἴκοσι(ν)''.&lt;br&gt;
'''ϝείκατι(ν) (adjectif numéral)''' : Forme dorienne de ''εἴκοσι(ν)''.&lt;br&gt;
'''βείκατι(ν) (adjectif numéral)''' : Forme sud-orientale de ''εἴκοσι(ν)''.&lt;br&gt;
'''εἷλιξ, -κος (nom commun) (f)''' : Forme poétique de ''ἕλιξ''.&lt;br&gt;
'''εἰλύω (verbe)''' : .&lt;br&gt;
'''εἴλω (verbe)''' : tourner ; enrouler. Entasser.&lt;br&gt;
'''εἷμα, -ἵματος (nom commun) (n)''' : Couverture ; vêtement.&lt;br&gt;
'''εἶμι (verbe)''' : aller, se déplacer.&lt;br&gt;
'''εἰμί (verbe)''' : être.&lt;br&gt;
'''-εῖον, -ίου (suffixe) (n)''' : lieu caractéristique.&lt;br&gt; 
'''εἶπα (verbe)''' : Forme ionienne de ''εἶπον''.&lt;br&gt;
'''εἴπην (verbe)''' : Forme dorienne de ''εἶπον''.&lt;br&gt;
'''ἔειπον (verbe)''' : Forme homérique de ''εἶπον''.&lt;br&gt;
'''εἶπον (verbe)''' : dire, parler.&lt;br&gt;
'''εἰρωνεία, -ας (nom commun) (f)''' : dissimulation.&lt;br&gt;
'''εἴρων, -ος (nom commun) (m/f)''' : dissimulateur.&lt;br&gt;
'''εἰσϐάλλω (verbe)''' : envahir.&lt;br&gt;
'''εἰσϐδάλλω (verbe)''' : .&lt;br&gt;
'''εἰσϐολέυς, -έως (nom commun) (m)''' : envahisseur.&lt;br&gt;
'''εἰσϐολή, -ῆς (nom commun) (f)''' : invasion.&lt;br&gt; 
'''εἰσχωρῶ (verbe)''' : pénétrer.&lt;br&gt;
'''ἕκαστος, -άστη, -αστον (adjectif)''' : Chaque, chacun.&lt;br&gt;
'''ἑκάτερος, -έρα, -άτερον (adjectif)''' : L’un de deux, chacun des deux.&lt;br&gt; 
'''ἑκατόν (adjectif numéral)''' : cent.&lt;br&gt; 
'''ἑκατομμύριον, -ίου (nom commun) (n)''' : million.&lt;br&gt;
'''ἑκατονταρχία, -ας (nom commun) (f)''' : centurie.&lt;br&gt;
'''ἑκατόνταρχος, -άρχου (nom commun) (m)''' : centurion.&lt;br&gt;
'''ἐκϐιάζω (verbe)''' : faire chanter.&lt;br&gt;
'''ἐκϐιασμός, -οῦ (nom commun) (m)''' : chantage.&lt;br&gt; 
'''ἐκδίδω (verbe)''' : éditer.&lt;br&gt;
'''ἐκδίκησις, -ήσεως (nom commun) (f)''' : vengeance.&lt;br&gt;
'''ἐκδικητής, -οῦ (nom commun) (m)''' : vengeur.&lt;br&gt; 
'''ἐκδικητικός, -ή, -ον (adjectif)''' : vengeur.&lt;br&gt;
'''ἐκδικῶ (verbe)''' : venger.&lt;br&gt;
'''ἔκδοσις, -όσεως (nom commun) (f)''' : édition.&lt;br&gt;
'''ἐκδοχή, -ῆς (nom commun) (f)''' : version.&lt;br&gt;
'''ἐκδύω (verbe)''' : Faire disparaître, ôter.&lt;br&gt;
'''ἐκ (adverbe ; préposition ; préfixe)''' (Devient ''ἐξ'' devant un mot commençant par une voyelle, et ''ἐγ'' devant un mot commençant par ''β'', ''δ'', ''λ'' ou ''μ''.) : Hors, dehors.&lt;br&gt; 
'''ἐκεῖθεν (adverbe démonstratif)''' : de là-bas.&lt;br&gt;
'''ἐκεῖ (adverbe démonstratif)''' : là-bas (sans mouvement).&lt;br&gt;
'''ἐκεῖσε (adverbe démonstratif)''' : là-bas (avec mouvement).&lt;br&gt;
'''ἐκείνῃ (adverbe démonstratif)''' : par là-bas.&lt;br&gt;
'''ἔκζεμα, -έματος (nom commun) (n)''' : eczéma.&lt;br&gt;
'''ἑκηϐόλος, -όλου (nom commun) (m)''' : tireur d’élite.&lt;br&gt;
'''ἔκθεσις, -έσεως (nom commun) (f)''' : exposition.&lt;br&gt;
'''ἐκκαλέω (verbe)''' : sommer.&lt;br&gt;
'''ἐκκένωσις, -ώσεως (nom commun) (f)''' : évacuation.&lt;br&gt; 
'''ἐκκενῶ (verbe)''' : évacuer.&lt;br&gt;
'''ἐκκεντρικός, -ή, -όν (adjectif)''' : excentrique.&lt;br&gt;
'''ἐκκίνησις, -ήσεως (nom commun) (f)''' : départ.&lt;br&gt;
'''ἐκκλεισία, -ας (nom commun) (f)''' : Forme thessalienne de ''ἐκκλησία''.&lt;br&gt;
'''ἐκκλησία, -ας (nom commun) (f)''' : assemblée.&lt;br&gt;
'''ἐκκλησίασμα, -άσματος (nom commun) (n)''' : congrégation.&lt;br&gt;
'''ἐκλέγω (verbe)''' : choisir, sélectionner.&lt;br&gt;
'''ἐκλεκτικός, -ή, -όν  (adjectif)''' : sélectif.&lt;br&gt;
'''ἐκλογή, -ῆς (nom commun) (f)''' : choix, élection.&lt;br&gt;
'''ἐκμιαίνομαι (verbe)''' : éjaculer.&lt;br&gt;
'''ἐκπομπή, -ῆς (nom commun) (f)''' :  émission.&lt;br&gt;
'''ἐκπέμπω (verbe)''' : émettre.&lt;br&gt;
'''ἔκστασις, -άσεως (nom commun) (f)''' : transport spirituel.&lt;br&gt;
'''ἐκτάμνω (verbe)''' : Forme homérique et ionienne de ''ἐκτέμνω''.&lt;br&gt;
'''ἐκτέμνω (verbe)''' : .&lt;br&gt;
'''ἐκθέτης, -ου (nom commun) (m)''' : exposant.&lt;br&gt;
'''ἐκθετικός, -ή, -όν (adjectif)''' : exponentiel.&lt;br&gt;
'''ἔκρηξις, -ήξεως (nom commun) (f)''' : explosion.&lt;br&gt;
'''ἐκτίθημι (verbe)''' : exposer.&lt;br&gt;
'''ἑκτικός, -ή, -όν  (adjectif)''' : habituel.&lt;br&gt;
'''ἑκτικότατος, -άτη, -ότατον (adjectif)''' : Superlatif de ''ἑκτικός''.&lt;br&gt;
'''ἑκτικότερος, -έρα, -ότερον (adjectif)''' : Comparatif de ''ἑκτικός''.&lt;br&gt;
'''ἑκτικῶς (adverbe)''' : habituellement.&lt;br&gt;
'''ἐκτιμῶ (verbe)''' : estimer.&lt;br&gt;
'''-εκτομία, -ας (suffixe)''' : action de couper.&lt;br&gt;
'''ἐκτός (adverbe ; préposition)''' : au-dehors ; hors de.&lt;br&gt;
'''ἑκυρά, -ᾶς (nom commun) (f)''' : belle-mère.&lt;br&gt;
'''ἑκυρός, -οῦ (nom commun) (m)''' : beau-père.&lt;br&gt;
'''ἐκφεύγω (verbe)''' : échapper à.&lt;br&gt;
'''ἔκφρασις, -άσεως (nom commun) (f)''' : expression.&lt;br&gt;
'''ἐκφράζω (verbe)''' : exprimer.&lt;br&gt;
'''ἐκφοϐῶ (verbe)''' : intimider.&lt;br&gt;
'''ἐκχύμωμα, -ώµατος (nom commun) (n)''' : Forme alternative de ''ἐκχύμωσις''.&lt;br&gt;
'''ἐκχύμωσις, -ώσεως (nom commun) (f)''' : bleu.&lt;br&gt; (tache de sang extravasé).&lt;br&gt;
'''ἐκχῶ (verbe)''' : s’écouler.&lt;br&gt;
'''ἐλάσσων, -ων, -ον (adjectif)''' : Comparatif de ''ἐλαχύς''.&lt;br&gt;
'''ἐλάττωμα, -ώµατος (nom commun) (n)''' : vice.&lt;br&gt;
'''ἔλαφος, -άφου (nom commun) (m/f)''' : Cerf ; biche.&lt;br&gt;
'''ἐλαφρός, -ή, -όν (adjectif)''' : léger, leste ; agile.&lt;br&gt;
'''ἐλαφρότατος, -άτη, -ότατον (adjectif)''' : Superlatif de ''ἐλαφρός''.&lt;br&gt;
'''ἐλαφρότερος, -έρα, -ότερον (adjectif)''' : Comparatif de ''ἐλαφρός''.&lt;br&gt;
'''ἐλαφρῶς (adverbe)''' : légèrement, lestement ; agilement.&lt;br&gt;
'''ἐλαχέως (adverbe)''' : petitement, courtement ; moyennement.&lt;br&gt;
'''ἐλάχιστος, -ίστη, -άχιστον (adjectif)''' : Superlatif de ''ἐλαχύς''.&lt;br&gt;
'''ἐλαχύς, -άχεια, -ύ (adjectif)''' : petit, court ; moyen.&lt;br&gt;
'''ἔλεγχος, -έγχους (nom commun) (n)''' : examen ; réfutation.&lt;br&gt;
'''ἐλέγχω (verbe)''' : examiner ; réfuter.&lt;br&gt;
'''ἐλεεινός, -ή, -όν (adjectif)''' : compatissant.&lt;br&gt;
'''ἐλέφας, -αντος (nom commun) (m)''' : Éléphant ; dent d’éléphant ; défense d’éléphant, ivoire. 
Objet garni d’ivoire ou ressemblant à de l’ivoire.&lt;br&gt;
'''ἐλεημοσύνη, -ης (nom commun) (f)''' : aumône.&lt;br&gt;
'''ἐλεημονέστατος, -άτη, -έστατον (adjectif)''' : Superlatif de ''ἐλεήμων''.&lt;br&gt;
'''ἐλεημονέστερος, -έρα, -έστερον (adjectif)''' : Comparatif de ''ἐλεήμων''.&lt;br&gt;
'''ἐλεήμονως (adverbe)''' : charitablement.&lt;br&gt;
'''ἐλεήμων, -ων, -ον (adjectif)''' : charitable.&lt;br&gt;
'''ἔλεος, -έου (nom commun) (f)''' : Pitié ; compassion.&lt;br&gt;
'''ἐλευθερία, -ας (nom commun) (f)''' : liberté.&lt;br&gt;
'''ἐλευθερίη, -ας (nom commun) (f)''' : Forme ionienne de ''ἐλευθερία''.&lt;br&gt; 
'''ἐλεύθερος, -έρα, ύθερον (adjectif)''' : libre. Qui convient à un homme libre, digne d’un homme libre.&lt;br&gt;
'''ἐλευθέρως (adverbe)''' : librement.&lt;br&gt;
'''ἐλευθερώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''ἐλεύθερος''.&lt;br&gt;
'''ἐλευθερώτερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''ἐλεύθερος''.&lt;br&gt;
'''ἐλελεῦ (verbe)''' : pousser un cri de guerre.&lt;br&gt;
'''ἐλελελεῦ (nom commun)''' : cri de guerre.&lt;br&gt;
'''ἐλεῶ (verbe)''' : avoir pitié.&lt;br&gt;
'''ἕλιξ, -κος (nom commun) (f)''' : Spirale, vrille. (Par analogie) Oreille externe.&lt;br&gt;
'''ἑλίσσω (verbe)''' : tourner autour.&lt;br&gt;
'''ἕλκηθρον, -ήτρου (nom commun) (n)''' : traîneau.&lt;br&gt;
'''ἕλκω (verbe)''' : hisser.&lt;br&gt;
'''ἐλλείπω (verbe)''' : Laisser derrière soi. Laisser de côté, négliger ; omettre. Manquer, faire défaut. (Intransitif) Rester en arrière.&lt;br&gt;
'''ἔλλειψις, -ίψεως (nom commun) (f)''' : Manque, défaut ; insuffisance.&lt;br&gt;
'''ἑλληνίζω (verbe)''' : parler grec.&lt;br&gt;
'''ἑλληνικός, -ή, -όν (adjectif)''' : grec.&lt;br&gt;
'''ἑλληνικῶς (adverbe)''' : .&lt;br&gt;
'''ἑλληνικώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''ἑλληνικός''.&lt;br&gt;
'''ἑλληνικώτερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''ἑλληνικός''.&lt;br&gt;
'''ἑλληνιστής, -οῦ (nom commun) (m)''' : homme parlant grec.&lt;br&gt;
'''ἑλληνιστί (adverbe)''' : en grec.&lt;br&gt;
'''ἑλληνίστρια, -ας (nom commun) (f)''' : femme parlant grec.&lt;br&gt;
'''ἐλλός, -οῦ (nom commun) (m)''' : faon.&lt;br&gt;
'''ἐλπίς, -δος (nom commun) (f)''' : espoir.&lt;br&gt;
'''ἔλυτρον, -ύτρου (nom commun) (n)''' : Enveloppe, étui, fourreau. (Par extension) Tout ce qui sert d’enveloppe.&lt;br&gt;
'''ἐλύω (verbe)''' : Entourer, rouler autour.&lt;br&gt;
'''ἔμϐρυον, -ύου (nom commun) (n)''' : embryon.&lt;br&gt;
'''ἔμεσις, -έσεως (nom commun) (f)''' : .&lt;br&gt;
'''ἐμετικός, -ή, -όν (adjectif)''' : vomitif.&lt;br&gt;
'''ἔμετος, -έτου (nom commun) (f)''' : vomissement.&lt;br&gt;
'''ἐµμί (verbe)''' : Forme éolienne de ''εἰμί''.&lt;br&gt;
'''ἐμῶ (verbe)''' : vomir.&lt;br&gt;
'''ἐμμονή, -ῆς (nom commun) (f)''' : obsession.&lt;br&gt;
'''ἐμός, -ή, -όν (adjectif possessif)''' : mon.&lt;br&gt;
'''ἐμπειρία, -ας  (nom commun) (f)''' : expérience.&lt;br&gt;
'''ἐμπειρικός, -ή, -όν (adjectif)''' : expérienciel.&lt;br&gt;
'''ἐμπειρικότατος, -άτη, -ότατον (adjectif)''' : Superlatif de ''ἐμπειρικός''.&lt;br&gt;
'''ἐμπειρικότερος, -έρα, -ότερον (adjectif)''' : Comparatif de ''ἐμπειρικός''.&lt;br&gt;
'''ἐμπειρικότατα, -, - (adverbe)''' : Superlatif de ''ἐμπειρικῶς''.&lt;br&gt;
'''ἐμπειρικότερον, -, - (adverbe)''' : Comparatif de ''ἐμπειρικῶς''.&lt;br&gt;
'''ἐμπειρικῶς (adverbe)''' : expérienciellement.&lt;br&gt;
'''ἐμπλάσσω (verbe)''' : emplâtrer.&lt;br&gt;
'''ἔμπλαστρον, -άστρου (nom commun) (n)''' : emplâtre.&lt;br&gt;
'''ἔμπνευσις, -ύσεως (nom commun) (f)''' : .&lt;br&gt;
'''ἐμπορεῖον, -ίου (nom commun) (n)''' : boutique.&lt;br&gt;
'''ἐμπόρευμα, -ύματος  (nom commun) (n)''' : marchandise.&lt;br&gt;
'''ἐμπορεύομαι (verbe)''' : commercer.&lt;br&gt;
'''ἐμπόριον, -ίου (nom commun) (n)''' : commerce.&lt;br&gt;
'''ἔμπορος, -όρου (nom commun) (m)''' : marchand.&lt;br&gt;
'''ἐμπρός (verbe)''' : devant.&lt;br&gt;
'''ἐμφαίνω (verbe)''' : Montrer ; présenter.&lt;br&gt;
'''ἐμφανής, -ής, -ές (adjectif)''' : apparent.&lt;br&gt;
'''ἐμφανίζω (verbe)''' : apparaître.&lt;br&gt;
'''ἐμφάνισις, -ίσεως (nom commun) (f)''' : apparence.&lt;br&gt;
'''ἔμφασις, -άσεως (nom commun) (f)''' : apparence.&lt;br&gt;
'''ἔμφραγμα, -άγματος (nom commun) (n)''' : infarctus.&lt;br&gt;
'''ἐμφρουρῶ (verbe)''' : .&lt;br&gt;
'''ἐμφύσημα, -ήματος (nom commun) (n)''' : inflation.&lt;br&gt;
'''ἐμφυσηματώδης, -ης, -ες (adjectif)''' : inflationnaire.&lt;br&gt;
'''ἐναλλακτικός, -ή, -όν (adjectif)''' : alternatif.&lt;br&gt;
'''ἐναλλακτικῶς (adverbe)''' : alternativement.&lt;br&gt;
'''ἐναλλακτικώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''ἐναλλακτικός''.&lt;br&gt;
'''ἐναλλακτικώτερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''ἐναλλακτικός''.&lt;br&gt;
'''ἐνάρετος, -ος, -ον (adjectif)''' : vertueux.&lt;br&gt;
'''ἔνδεια, -ας (nom commun) (f)''' : indigence.&lt;br&gt; 
'''ἐνδεής, -ής, -ής (adjectif)''' : indigent.&lt;br&gt;
'''ἐνδόμυχος, -ος, -ον (adjectif)''' : intime.&lt;br&gt;
'''ἔνδον (adverbe ; préposition)''' : en dedans, intérieurement, à l'intérieur ; au-dedans de, à l'intérieur de.&lt;br&gt;
'''ἔνδος (adverbe ; préposition)''' : Forme dorienne de ''ἔνδον''.&lt;br&gt;
'''ἐνδοτάτω (adverbe)''' : Superlatif de ''ἔνδον''.&lt;br&gt;
'''ἐνδοτέρω (adverbe)''' : Comparatif de ''ἔνδον''.&lt;br&gt;
'''ἔνδυμα, -ύματος (nom commun) (n)''' : vêtement.&lt;br&gt;
'''ἐνέργεια, -ίας (nom commun) (f)''' : force en action.&lt;br&gt;
'''ἐνεργής, -ής, -ής (adjectif)''' : productif.&lt;br&gt;
'''ἐνεργός, -ός, -όν (adjectif)''' : actif.&lt;br&gt;
'''ἐνεργούμενος, -ένου (nom commun) (m)''' : énergumène.&lt;br&gt;
'''ἐνεργῶ (verbe)''' : Agir, produire, accomplir, exécuter. Agir sur, influencer (particulièrement en mauvaise part en parlant du mauvais esprit).
(Voie moyenne) Opérer, agir.&lt;br&gt;
'''ἐνενήκοντα (adjectif numéral)'''  : quatre-vingt-dix.&lt;br&gt;
'''ἐνέχομαι (verbe)''' : .&lt;br&gt;
'''ἔνθα (adverbe)''' : ici.&lt;br&gt;
'''ἐνθάδε (adverbe)''' : ici-même.&lt;br&gt;
'''ἐνθένδε (adverbe)''' : d’ici.&lt;br&gt;
'''ἐννέα (adjectif numéral)''' : neuf.&lt;br&gt;
'''ἔνεμα, -έματος (nom commun) (n)''' : lavement. (Remède liquide.)&lt;br&gt;
'''ἔνεσις, -έσεως (nom commun) (f)''' : injection.&lt;br&gt; 
'''ἐνεστώς, -ῶτος (nom commun) (n)''' : présent.&lt;br&gt;
'''ἐννῆ (adjectif numéral)''' : Forme de ''ἐννέα''.&lt;br&gt;
'''ἐνέχομαι (verbe)''' : .&lt;br&gt;
'''ἐνίημι (verbe)''' : injecter.&lt;br&gt;
'''ἐν (adverbe ; préposition)''' : Dans, en, parmi.&lt;br&gt;
'''ἐν- (préfixe)''' (Devient ''ἐγ-'' devant ''γ'', ''κ'', ''ξ'', ''χ'' ; ''ἐλ-'' devant ''λ'' ; ''ἐμ-'' devant ''β'', ''µ'', ''π'', ''φ'', ''ψ'' ; ''ἐρ-'' devant ''ρ'' dans quelques mots comme ''ἔρρινον'' ; ''ἐσ-'' devant ''σ''.) : in-.&lt;br&gt; 
'''ἐνηλικίωσις, -ώσεως (nom commun) (f)''' : majorité.&lt;br&gt;
'''ἐνήλικος -η -ον (adjectif)''' : adulte.&lt;br&gt;
'''ἐνῆλιξ, -ήλικος (nom commun) (m)''' : adulte.&lt;br&gt;
'''ἔνθεσις, -έσεως (nom commun) (f)''' : enthèse.&lt;br&gt;
'''ἐνθουσιασμός, -οῦ (nom commun) (m)''' : enthousiasme.&lt;br&gt;
'''ἐνθουσιαστικός, -ή, -όν (adjectif)''' : enthousiasmant.&lt;br&gt;
'''ἐνθουσιαστικῶς (adverbe)''' : -ment.&lt;br&gt;
'''ἐνθουσιαστικώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''ἐνθουσιαστικός''.&lt;br&gt;
'''ἐνθουσιαστικώτερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''ἐνθουσιαστικός''.&lt;br&gt;
'''ἐνθουσιαστικώτατα, -, - (adverbe)''' : Superlatif de ''ἐνθουσιαστικῶς''.&lt;br&gt;
'''ἐνθουσιαστικώτερον, -, - (adverbe)''' : Comparatif de ''ἐνθουσιαστικῶς''.&lt;br&gt; 
'''ἐνθουσιώδης, -ης, -ες (adjectif)''' : enthousiaste.&lt;br&gt;
''', -άτη, -ώτατον (adjectif)''' : Superlatif de ''ἐνθουσιώδης''.&lt;br&gt;
''', -έρα, -ώτερον (adjectif)''' : Comparatif de ''ἐνθουσιώδης''.&lt;br&gt;
''', -, - (adverbe)''' : Superlatif de ''''.&lt;br&gt;
''', -, - (adverbe)''' : Comparatif de ''''.&lt;br&gt; 
'''ἐνίοτε (adverbe)''' : quelquefois.&lt;br&gt;
'''ἔννοια, -ίας (nom commun) (f)''' : concept.&lt;br&gt;
'''ἐνοριακός, -ή, -όν (adjectif)''' : paroissial.&lt;br&gt;
'''ἐνορία, -ας (nom commun) (f)''' : paroisse.&lt;br&gt;
'''ἐνοχή, -ῆς (nom commun) (f)''' : culpabilité.&lt;br&gt; 
'''ἕννυμι (verbe)''' : enfiler. (mettre un vêtement)&lt;br&gt;  
'''ἑνότης, -τος (nom commun) (f)''' : unité.&lt;br&gt;
'''ἐνούρησις, -ήσεως (nom commun) (f)''' : incontinence urinaire.&lt;br&gt;
'''ἐνουρῶ (verbe)''' : ne pas pouvoir retenir son urine.&lt;br&gt;
'''ἐνοχή, -ῆς (nom commun) (f)''' : culpabilité.&lt;br&gt; 
'''ἐνόχλησις, -ήσεως (nom commun) (f)''' : Dérangement ; embêtement.&lt;br&gt;
'''ἐνοχλητικός, -ή, -όν (adjectif)''' : Dérangeant ; embêtant.&lt;br&gt;
'''ἐνοχλῶ (verbe)''' : Déranger ; embêter.&lt;br&gt; 
'''ἐνσκήπτω (verbe)''' : sévir.&lt;br&gt;
'''ἔνταξις, -άξεως (f)''' : insertion.&lt;br&gt;
'''ἐντάσσω (verbe)''' : insérer.&lt;br&gt;
'''ἐνταῦθα (adverbe)''' : là.&lt;br&gt;
'''ἐντίθημι (verbe)''' : introduire.&lt;br&gt;
'''ἐντρέπω (verbe)''' : .&lt;br&gt;
'''ἐντύπωσις, -ώσεως (nom commun) (f)''' : impression.&lt;br&gt;
'''ἐντυπῶ (verbe)''' : .&lt;br&gt;
'''ἕνωσις, -ώσεως (nom commun) (f)''' : union.&lt;br&gt;
'''ἐνώτιον, -ίου (nom commun) (n)''' : boucle d'oreille.&lt;br&gt;
'''ἔορ, -ος (nom commun) (f)''' : Fille ; cousine.&lt;br&gt;
'''ἐρείκη, -ης (nom commun) (f)''' : bruyère.&lt;br&gt;
'''ἑορτάζω (verbe)''' : fêter.&lt;br&gt;
'''ἑορτή, -ῆς (nom commun) (f)''' : fête.&lt;br&gt;
'''ἐξαδελφή, -ῆς (nom commun) (f)''' : cousine.&lt;br&gt;
'''ἐξάδελφος, -ου (nom commun) (m)''' : cousin.&lt;br&gt;
'''ἐξαίρεσις, -έσεως (nom commun) (m)''' : extraction.&lt;br&gt;
'''ἐξαίρω (verbe)''' : exalter.&lt;br&gt;
'''ἐξαιρῶ (verbe)''' : retirer.&lt;br&gt;
'''ἐξαίσιος, -ια, -ιον (adjectif)''' : .&lt;br&gt;
'''ἑξαν (adverbe)''' : Forme dorienne de ''ἑξῆς''.&lt;br&gt;
'''ἔξαρσις, -άρσεως (nom commun) (f)''' : exaltation.&lt;br&gt; 
'''ἐξάρτημα, -ήματος (nom commun) (n)''' : accessoire.&lt;br&gt;
'''ἕξ (adjectif numéral) (m/f/n)''' : six.&lt;br&gt;
'''ϝέξ (adjectif numéral) (m/f/n)''' : Forme dorienne de ''ἕξ''.&lt;br&gt; 
'''ἑξακόσιοι (adjectif numéral)''' : six-cents.&lt;br&gt;
'''ἐξάντλησις, -ήσεως (nom commun) (f)''' : épuisement.&lt;br&gt;
'''ἐξαντλῶ (verbe)''' : épuiser.&lt;br&gt;
'''ἐξαπάτησις, -ήσεως (nom commun) (f)''' : supercherie.&lt;br&gt;
'''ἐξαπατῶ (verbe)''' : .&lt;br&gt;
'''ἐξέδρα, -ας (nom commun) (f)''' : plate-forme.&lt;br&gt;
'''ἐξέγερσις, -έρσεως (nom commun) (f)''' : insurrection.&lt;br&gt;
'''ἑξείης (adverbe)''' : Forme poétique de ''ἑξῆς''.&lt;br&gt;
'''ἐξήγησις, -ήσεως (nom commun) (f)''' : Exposé. Explication.&lt;br&gt;
'''ἐξηγητής, -ου (nom commun) (m)''' : .&lt;br&gt;
'''ἐξἡγοῦμαι (verbe)''' : Conduire, exposer.&lt;br&gt;
'''ἑξήκοντα (adjectif numéral)''' : soixante.&lt;br&gt;
'''ἑξῆς (adverbe)''' : .&lt;br&gt;
'''ἐξιλέωσις, -ώσεως (nom commun) (f)''' : expiation.&lt;br&gt;
'''ἐξιλεῶ (verbe)''' : expier.&lt;br&gt;
'''ἐξέλιξις, -ίξεως (nom commun) (f)''' : évolution.&lt;br&gt;
'''ἐξελίσσω (verbe)''' : évoluer.&lt;br&gt;
'''ἐξευτελίζω (verbe)''' : humilier.&lt;br&gt;
'''ἐξέτασις, -άσεως (nom commun) (f)''' : examen, recherche.&lt;br&gt;
'''ἐξίστημι (verbe)''' : déplacer.&lt;br&gt;
'''ἕξις, -εως (nom commun) (f)''' : habitude.&lt;br&gt;
'''ἐξόγκωμα, -ώματος (nom commun) (n)''' : Proéminence ; protubérance.&lt;br&gt;
'''ἔξοδος, -ου (nom commun) (f)''' : Issue ; sortie, départ.&lt;br&gt;
'''ἐξομολόγησις, -ήσεως (nom commun) (f)''' : confession.&lt;br&gt;
'''ἐξομολογητήριον, -ίου (nom commun) (n)''' : confessionnal.&lt;br&gt; 
'''ἐξομολογητής, -οῦ (nom commun) (m)''' : confesseur.&lt;br&gt; 
'''ἐξομολογῶ (verbe)''' : confesser.&lt;br&gt;
'''ἐξορία, -ας (nom commun) (f)''' : exil.&lt;br&gt;
'''ἐξορίζω (verbe)''' : exorciser.&lt;br&gt;
'''ἐξορκισμός, -οῦ (nom commun) (m)''' : exorcisme.&lt;br&gt; 
'''ἐξορκιστής, -οῦ (nom commun) (m)''' : exorciste.&lt;br&gt; 
'''ἐξύπνημα, -ήματος (nom commun) (n)''' : réveil.&lt;br&gt;
'''ἔξυπνος, -ος, -ον (adjectif)''' : .&lt;br&gt; 
'''ἐξυπνῶ (verbe)''' : réveiller.&lt;br&gt;
'''ἐξωθῶ (verbe)''' : .&lt;br&gt;
'''ἐξωκκλήσιον, -ίου (nom commun) (n)''' : chapelle.&lt;br&gt;
'''ἐξωµίς, -δος (nom commun) (f)''' : exomide.&lt;br&gt;
'''ἐξώστης, -ου (nom commun) (m)''' : balcon.&lt;br&gt; 
'''ἐξωτερικός, -ή, -όν (adjectif)''' : extérieur, externe.&lt;br&gt; 
'''ἐξωτικός, -ή, -όν (adjectif)''' : étranger.&lt;br&gt;
'''ἔξω (adverbe)''' : hors de.&lt;br&gt;
'''ἐπαινῶ (verbe)''' : vanter.&lt;br&gt;
'''ἐπαναλαμϐάνω (verbe)''' : répéter ; reprendre.&lt;br&gt;
'''ἐπαλήθευσις, -ύσεως (nom commun) (f)''' : vérification.&lt;br&gt;
'''επαληθευτικός, -ή, -όν (adjectif)''' : vérificatif.&lt;br&gt;
'''ἐπαληθευτικῶς (adverbe)''' : vérificativement.&lt;br&gt;
'''ἐπαληθευτικώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''επαληθευτικός''.&lt;br&gt;
'''ἐπαληθευτικώτερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''επαληθευτικός''.&lt;br&gt;
'''ἐπαληθευτικώτατα, -, - (adverbe)''' : Superlatif de ''επαληθευτικῶς''.&lt;br&gt;
'''ἐπαληθευτικώτερον, -, - (adverbe)''' : Comparatif de ''επαληθευτικῶς''.&lt;br&gt; 
'''ἐπαληθεύω (verbe)''' :  vérifier.&lt;br&gt;
'''ἐπαναληπτικός, -ή, -όν (adjectif)''' : répétitif.&lt;br&gt;
'''ἐπαναληπτικῶς (adverbe)''' : répétitivement.&lt;br&gt;
'''ἐπαναληπτικώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''ἐπαναληπτικός''.&lt;br&gt;
'''ἐπαναληπτικώτερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''ἐπαναληπτικός''.&lt;br&gt;
'''ἐπαναληπτικώτατα, -, - (adverbe)''' : Superlatif de ''ἐπαναληπτικῶς''.&lt;br&gt;
'''ἐπαναληπτικώτερον, -, - (adverbe)''' : Comparatif de ''ἐπαναληπτικῶς''.&lt;br&gt;
'''ἐπανάληψις, -ήψεως (nom commun) (f)''' : répétition.&lt;br&gt;
'''ἐπανάστασις, -άσεως (nom commun) (f)''' : révolution.&lt;br&gt;
'''ἐπανεκκίνησις, -ήσεως (nom commun) (f)''' : redémarrage.&lt;br&gt;
'''ἐπάνω (adverbe)''' : .&lt;br&gt;
'''ἐπαρχία, -ας (nom commun) (f)''' : province.&lt;br&gt;
'''ἔπαρχος, -άρχου (nom commun) (m)''' : .&lt;br&gt; 
'''ἐπάρχω (verbe)''' : .&lt;br&gt;
'''ἐπαφή, -ῆς (nom commun) (f)''' : contact.&lt;br&gt;
'''ἐπαφίημι (verbe)''' : contacter.&lt;br&gt;
'''ἐπεξῆς (adverbe)''' : Forme ionienne de ''ἐφεξῆς''.&lt;br&gt;
'''ἐπένδυσις, -ύσεως (nom commun) (f)''' : .&lt;br&gt;
'''ἐπενδύω (verbe)''' : revêtir par-dessus.&lt;br&gt;
'''ἐπένθεσις, -έσεως (nom commun) (f)''' (Grammaire) Insertion d’une lettre à l’intérieur d’un mot.&lt;br&gt; 
'''ἐπεντίθημι (verbe)''' : Insérer une lettre à l’intérieur d’un mot.&lt;br&gt;
'''ἐπερώτησις, -ήσεως (nom commun) (f)''' : interpellation.&lt;br&gt;	
'''ἑπτά (adjectif numéral)''' : sept.&lt;br&gt;
'''ἐπεισοδιακός, -ή, -όν (adjectif)''' : épisodique.&lt;br&gt; 
'''ἐπεισόδιον, -ου (nom commun) (n)''' : épisode.&lt;br&gt;
'''ἐπιϐαίνω (verbe)''' : Monter. (Marine) Embarquer, monter dans un bateau. (Militaire) Attaquer, avancer sur l’ennemi. Monter à cheval, aller à cheval.&lt;br&gt;
'''ἐπιϐδάλλω (verbe)''' : .&lt;br&gt;
'''ἐπιϐήτωρ, -ορος (nom commun) (m)''' : étalon.&lt;br&gt;
'''ἐπιϐλαϐής, -ής, -ές (adjectif)''' : .&lt;br&gt; 
'''ἐπίϐλημα, -ήματος (nom commun) (m)''' : châle.&lt;br&gt;
'''ἐπίγραθμα, -άθματος (nom commun) (n)''' : Forme dorienne de ''ἐπίγραμμα''.&lt;br&gt;
'''ἐπίγραμμα, -άμματος (nom commun) (n)''' : inscription.&lt;br&gt; 
'''ἐπίδειξις, -ίξεως (nom commun) (f)''' : exhibition.&lt;br&gt;
'''ἐπιδεκτικός, -ή, -όν (adjectif)''' : .&lt;br&gt;
'''ἐπιδέχομαι (verbe)''' : .&lt;br&gt;
'''ἐπιείκεια, -ίας (nom commun) (f)''' : indulgence.&lt;br&gt;	
'''ἐπιεικής, -ής, -ές (adjectif)''' : indulgent.&lt;br&gt;
'''ἐπί (adverbe)'''  (Devient ''ἐπ&lt;nowiki&gt;'&lt;/nowiki&gt;'' devant une voyelle avec esprit doux et ''ἐφ&lt;nowiki&gt;'&lt;/nowiki&gt;'' devant une voyelle avec esprit rude.) : sur.&lt;br&gt; 
'''ἐπιθαλάμιον, -ίου (nom commun) (n)''' : .&lt;br&gt;
'''ἐπιθιγγάνω (verbe)''' : .&lt;br&gt;
'''ἐπιτιθέναι (verbe)''' : .&lt;br&gt;
'''ἐπίθεσις, -έσεως (nom commun) (f)''' : attaque ; assaut.&lt;br&gt;
'''ἐπίθετον, -έτου (nom commun) (n)''' : adjectif.&lt;br&gt;
'''ἐπίθετος, -, - (adjectif)''' : adjectival.&lt;br&gt; 
'''ἐπίθημα, -ήματος (nom commun) (n)''' : .&lt;br&gt;
'''ἐπιθυμέω (verbe)''' : désirer.&lt;br&gt; 
'''ἐπιθυμία, -ας (nom commun) (f)''' : Désir, souhait. Passion.&lt;br&gt;
'''ἐπίθυμος, -, - (adjectif)''' : Désireux ; passionné.&lt;br&gt;
'''ἐπικαλοῦμαι (verbe)''' : invoquer.&lt;br&gt;
'''ἐπικαλύπτω (verbe)''' : recouvrir.&lt;br&gt;
'''ἐπικάλυψις, -ύψεως (nom commun) (f)''' : recouvrement.&lt;br&gt;
'''ἐπικός, -ή, -όν (adjectif)''' : relatif aux vers.&lt;br&gt;
'''ἐπικότατα, -, - (adverbe)''' : Superlatif de ''ἐπικῶς''.&lt;br&gt;
'''ἐπικότερον, -, - (adverbe)''' : Comparatif de ''ἐπικῶς''.&lt;br&gt;
'''ἐπικύρωσις, -ώσεως (nom commun) (f)''' : ratification.&lt;br&gt;
'''ἐπικυρῶ (verbe)''' : ratifier.&lt;br&gt;
'''ἐπικῶς (adverbe)''' : épiquement.&lt;br&gt;
'''ἐπικώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''ἐπικός''.&lt;br&gt;
'''ἐπικώτερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''ἐπικός''.&lt;br&gt;
'''ἐπιλαμϐάνω (verbe)''' : invoquer.&lt;br&gt;
'''ἐπίληπτος, -ος, -ον (adjectif)''' : .&lt;br&gt;
'''ἐπιληψία, -ας (nom commun) (f)''' : .&lt;br&gt;
'''ἐπιλογή, -ῆς (nom commun) (f)''' : sélection.&lt;br&gt;
'''ἐπίλογος, -όγου (nom commun) (m)''' : postface.&lt;br&gt; 
'''ἐπίπληξις, -ήξεως (nom commun) (f)''' : réprimande.&lt;br&gt;
'''ἐπιπλήττω (verbe)''' : réprimander.&lt;br&gt; 
'''ἐπιτίθημι (verbe)''' : attaquer.&lt;br&gt;
'''ἐπιείκεια, -ίας (nom commun) (f)''' : indulgence.&lt;br&gt;  
'''ἐπιεικής, -ής -ές (adjectif)''' : indulgent.&lt;br&gt;
'''ἐπιμέλεια, -ίας (nom commun) (f)''' : sollicitude.&lt;br&gt;
'''ἐπιμελής, -ής -ές (adjectif)''' : soigneux.&lt;br&gt;	
'''ἐπιμέλησις, -ήσεως (nom commun) (f)''' : soin.&lt;br&gt;
'''ἐπιμελότατα, -, - (adverbe)''' : Superlatif de ''ἐπιμελῶς''.&lt;br&gt;
'''ἐπιμελότερον, -, - (adverbe)''' : Comparatif de ''ἐπιμελῶς''.&lt;br&gt;
'''επιμελοῦμαι (verbe)''' : prendre soin de, veiller à ; se préoccuper de.&lt;br&gt;
'''ἐπιμελῶς (adverbe)''' : soigneusement.&lt;br&gt;
'''ἐπιούσιος, -α, -ον (adjectif)''' : supersubstantiel.&lt;br&gt;
'''ἔπιπλον, -ίπλου (nom commun) (n)''' : fourniture.&lt;br&gt;
'''ἐπίρρημα, -ήματος (nom commun) (n)''' : adverbe.&lt;br&gt;
'''ἐπιρρίπτω (verbe)''' : .&lt;br&gt;
'''ἐπιρρωνύω (verbe)''' : corroborer.&lt;br&gt;
'''ἐπίρρωσις, -ώσεως (nom commun) (f)''' : corroboration.&lt;br&gt;
'''ἐπίσημος, -α, -ον''' : Marqué, noté. Notable, remarquable.&lt;br&gt;
'''ἐπισκέπτης, -ου (nom commun) (m)''' : visiteur.&lt;br&gt;
'''ἐπισκέπτομαι (verbe)''' : visiter.&lt;br&gt;
'''ἐπίσκεψις, -έψεως (nom commun) (f)''' : visite (action de visiter).&lt;br&gt;
'''ἐπιστάζω (verbe)''' : saigner du nez.&lt;br&gt;
'''ἐπίσταμαι (verbe)''' : Savoir ; connaitre.&lt;br&gt;
'''ἐπίσταξις, -άξεως (nom commun) (f)''' : saignement nasal.&lt;br&gt;
'''ἐπιστέλλω (verbe)''' : envoyer.&lt;br&gt;
'''ἐπιστήμη, -ης (nom commun) (f)''' : Science ; savoir.&lt;br&gt;
'''ἐπιστημονέστατος, -άτη, -έστατον (adjectif)''' : Superlatif de ''ἐπιστήμων''.&lt;br&gt;
'''ἐπιστημονέστερος, -έρα, -έστερον (adjectif)''' : Comparatif de ''ἐπιστήμων''.&lt;br&gt;
'''ἐπιστήμονως (adverbe)''' : savamment.&lt;br&gt;
'''ἐπιστήμων, -ων, -ον (adjectif)''' : Savant ; instruit.&lt;br&gt;
'''ἐπιστολή, -ῆς (nom commun) (f)''' : Ordre ou avis émis par un message verbal ou écrit. Message écrit, lettre.&lt;br&gt;
'''ἐπιστολικός, -ή, -όν (adjectif)''' : épistolaire.&lt;br&gt;
'''ἐπιστολικῶς (adverbe)''' : épistolairement.&lt;br&gt;
'''ἐπιστολικώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''ἐπιστολικός''.&lt;br&gt;
'''ἐπιστολικώτερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''ἐπιστολικός''.&lt;br&gt;
'''ἐπιστολικώτατα, -, - (adverbe)''' : Superlatif de ''ἐπιστολικῶς''.&lt;br&gt;
'''ἐπιστολικώτερον, -, - (adverbe)''' : Comparatif de ''ἐπιστολικῶς''.&lt;br&gt; 
'''ἐπιστροφή, -ῆς (nom commun) (f)''' : retour.&lt;br&gt;
'''ἐπιτακτικός, -ή, -όν (adjectif)''' : impératif.&lt;br&gt;
'''ἐπιτακτικῶς (adverbe)''' : impérativement.&lt;br&gt;
'''ἐπιτακτικώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''ἐπιτακτικός''.&lt;br&gt;
'''ἐπιτακτικώτερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''ἐπιτακτικός''.&lt;br&gt;
'''ἐπιτακτικώτατα, -, - (adverbe)''' : Superlatif de ''ἐπιτακτικῶς''.&lt;br&gt;
'''ἐπιτακτικώτερον, -, - (adverbe)''' : Comparatif de ''ἐπιτακτικῶς''.&lt;br&gt; 
'''ἐπιτέμνω (verbe)''' : .&lt;br&gt;
'''ἐπιτήδειος, -α, -ον (adjectif)''' : commode ; pratique.&lt;br&gt;
'''ἐπιτηδειότατος, -άτη, -ότατον (adjectif)''' : Superlatif de ''ἐπιτήδειος''.&lt;br&gt;
'''ἐπιτηδειότερος, -έρα, -ότερον (adjectif)''' : Comparatif de ''ἐπιτήδειος''.&lt;br&gt;
'''ἐπιτηδειότατα, -, - (adverbe)''' : Superlatif de ''ἐπιτηδείως''.&lt;br&gt;
'''ἐπιτηδειότερον, -, - (adverbe)''' : Comparatif de ''ἐπιτηδείως''.&lt;br&gt;
'''ἐπιτηδείως (adverbe)''' : commodément.&lt;br&gt;
'''ἐπιτομή, -ῆς (nom commun) (f)''' : compendium.&lt;br&gt;
'''ἐπιτόνιον, -ίου (nom commun) (n)''' : .&lt;br&gt;
'''ἐπιτρέπω (verbe)''' : autoriser, permettre.&lt;br&gt;
'''ἐπιφέρω (verbe)''' : .&lt;br&gt;
'''ἐπιφώνημα, -ήματος (nom commun) (n)''' : interjection.&lt;br&gt;
'''ἐπιφώνησις, -ήσεως (nom commun) (f)''' : .&lt;br&gt;
'''ἐπιφωνῶ (verbe)''' : .&lt;br&gt;
'''ἐπιχαιρεκακία, -ας (nom commun) (f)''' : .&lt;br&gt;
'''ἐπιχαιρέκακος, -ος, -ον (adjectif)''' : .&lt;br&gt;
'''ἐπιχαίρω (verbe)''' : réjouir.&lt;br&gt;
'''ἐπιχείρημα, -ήματος (nom commun) (n)''' : argument.&lt;br&gt; 
'''ἐπιχειρῶ (verbe)''' : cicatriser.&lt;br&gt; 
'''ἕπομαι (verbe)''' : argumenter.&lt;br&gt;
'''ἔπος, -ους (nom commun) (n)''' : Parole ; vers.&lt;br&gt;
'''ἐποποιία, -ας (nom commun) (f)''' : épopée.&lt;br&gt; 
'''ἐπουλῶ (verbe)''' : cicatriser.&lt;br&gt; 
'''ἐπύλλιον, -ίου (nom commun) (n)''' : .&lt;br&gt;	
'''ἐπῳδή, -ῆς (nom commun) (f)''' : incantation.&lt;br&gt;	
'''ἐπώδυνος, -ος, -ον (adjectif)''' : douloureux. Causé par la douleur.&lt;br&gt; 
'''ἑπωµίς, -δος (nom commun) (f)''' : épaulette.&lt;br&gt;
'''ἐπωνύμιον, -ίου (nom commun) (n)''' : nom de famille.&lt;br&gt;	
'''ἐπωφελής, -ής, -ές (adjectif)''' : .&lt;br&gt; 
'''ἔραμαι (verbe)''' : aimer d'amour, désirer.&lt;br&gt;
'''ἔρανος, -άνου (nom commun) (m)''' : quête.&lt;br&gt;
'''ἐραστής, -οῦ (nom commun) (m)''' : amant.&lt;br&gt;
'''ἑραστός, -ή, -όν (adjectif)''' : aimable, amoureux.&lt;br&gt; 
'''ἐράστρια, -ας (nom commun) (f)''' : amante.&lt;br&gt;
'''ἐραστριάω (verbe)''' : être amoureux.&lt;br&gt;
'''ἐρέϐινθος, -ίνθου (nom commun) (m)''' : pois chiche.&lt;br&gt; 
'''ἔρεϐος, -έϐους (nom commun) (n)''' : obscurité.&lt;br&gt;
'''ἐρρωσθαι (verbe)''' : se bien porter.&lt;br&gt;
'''ἐργάζομαι (verbe)''' : travailler.&lt;br&gt; 
'''ἐργαλεῖον, -ίου (nom commun) (n)''' : outil.&lt;br&gt;  
'''ἐργαστήριακός, -ή -όν (adjectif)''' : laborantin.&lt;br&gt; 
'''ἐργαστήριον, -ίου (nom commun) (n)''' : atelier, laboratoire.&lt;br&gt; 
'''ἐργαστήρ, -ῆρος (nom commun) (m)''' : travailleur.&lt;br&gt;
'''ἐργάτης, -ου (nom commun) (m)''' : ouvrier, travailleur.&lt;br&gt; 
'''ἔργον, -ου (nom commun) (n)''' : travail.&lt;br&gt;
'''ἐργώδης, -ης, -ες (adjectif)'''  : laborieux.&lt;br&gt; 
'''ϝέργον, -ου (nom commun) (n)''' : Forme dorienne de ''ἔργον''.&lt;br&gt;
'''ϝάργον, -ου (nom commun) (n)''' : Forme éléenne de ''ἔργον''.&lt;br&gt;
'''ἐρέσσω (verbe)''' : ramer.&lt;br&gt; 
'''ἐρετμόν, -οῦ  (nom commun) (n)''' : rame.&lt;br&gt;
'''ἐρεύγομαι (verbe)''' : roter.&lt;br&gt; 
'''ἔρευνα, -ας (nom commun) (f)''' :  enquête, recherche.&lt;br&gt;
'''ἐρευνητής, -οῦ (nom commun) (m)''' : enquêteur, chercheur.&lt;br&gt;
'''ἐρευνῶ (verbe)''' :  enquêter, rechercher.&lt;br&gt;
'''ἐρέφω (verbe)''' : toiturer, couronner.&lt;br&gt;
'''ἐρημίτης, -ου (nom commun) (m)''' : ermite.&lt;br&gt;
'''ἔρημος, -ήμου (nom commun) (f)''' : désert.&lt;br&gt;
'''ἑρμηνεύς, -έως (nom commun) (m)''' : Interprète, traducteur ; messager des dieux.&lt;br&gt;
'''ἑρμηνευτικός, -ή, -όν (adjectif)''' : .&lt;br&gt;
'''ἑρμηνεύω (verbe)''' : Exprimer sa pensée par la parole. (Par suite) Faire connaître, indiquer, exposer (quelque chose). Interpréter, traduire.&lt;br&gt;
'''ἔρομαι (verbe)''' : Demander, enquêter ; s’enquérir de.&lt;br&gt;
'''ἑρπετόν, -οῦ (nom commun) (n)''' : Reptile ; serpent.&lt;br&gt;
'''ἕρπυλλος, -ύλλου (nom commun) (m)''' : serpolet.&lt;br&gt;
'''ἑρπυσμός, -οῦ (nom commun) (m)''' : fluage.&lt;br&gt;
'''ἐρῥωσθαι (verbe)''' : se bien porter.&lt;br&gt;
'''ἔρσην, -ενος (nom commun) (m)''' : Forme crétoise et éolienne de ''ἄρσην''.&lt;br&gt;
'''ἐρεύθω (verbe)''' : rougir.&lt;br&gt;
'''ἔρχομαι (verbe)''' : Venir, aller. S'en aller.&lt;br&gt;
'''ἐρύθημα, -ήματος (nom commun) (n)''' : érythème.&lt;br&gt;
'''ἐρυθρός, -ά, -όν (adjectif)'''  : rouge.&lt;br&gt; 
'''ἐρυσίπελας, -έλατος (nom commun) (n)''' : inflammation cutanée.&lt;br&gt;
'''ἐρωή, -ῆς (nom commun) (f)''' : précipitation.&lt;br&gt;
'''ἐρωδιός, -οῦ (nom commun) (m)''' : héron.&lt;br&gt;
'''ἐρωμένη, -ης (nom commun) (f)''' : femme aimé.&lt;br&gt;
'''ἐρώμενος, -ένου (nom commun) (m)''' : homme aimé.&lt;br&gt;
'''ἔρως, -τος (nom commun) (n)''' : amour « naturel » ; désir sexuel, plaisir corporel.&lt;br&gt;
'''ἐρώτημα, -ήματος (nom commun) (n)''' : question.&lt;br&gt;	
'''ἐρωτηματικός, -ή, -όν (adjectif)''' : interrogatif.&lt;br&gt;
'''ἐρωτηματικότατα, -, - (adverbe)''' : Superlatif de ''ἐρωτηματικῶς''.&lt;br&gt;
'''ἐρωτηματικότερον, -, - (adverbe)''' : Comparatif de ''ἐρωτηματικῶς''.&lt;br&gt;
'''ἐρωτηματικῶς (adverbe)''' : érotiquement.&lt;br&gt;
'''ἐρωτηματικώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''ἐρωτηματικός''.&lt;br&gt;
'''ἐρωτηματικώτερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''ἐρωτηματικός''.&lt;br&gt;
'''ἐρώτησις, -ήσεως (nom commun) (f)''' : interrogation.&lt;br&gt;
'''ἐρωτικός, -ή, -όν (adjectif)''' : relatif à l'amour « naturel ».&lt;br&gt;  
'''ἐρωτικότατα, -, - (adverbe)''' : Superlatif de ''ἐρωτικῶς''.&lt;br&gt;
'''ἐρωτικότερον, -, - (adverbe)''' : Comparatif de ''ἐρωτικῶς''.&lt;br&gt;
'''ἐρωτικῶς (adverbe)''' : érotiquement.&lt;br&gt;
'''ἐρωτικώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''ἐρωτικός''.&lt;br&gt;
'''ἐρωτικώτερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''ἐρωτικός''.&lt;br&gt;
'''ἐρωτῶ (verbe)''' : interroger.&lt;br&gt;
'''ἐρῶ (verbe)''' : aimer d'amour, désirer. Verser hors de ; vomir.&lt;br&gt;
'''ἐσσαῖος, -ίου (nom commun) (m)''' : essénien.&lt;br&gt;
'''ϝεσή, -ῆς (nom commun) (f)''' : toilettes.&lt;br&gt;
'''ἐσθής, -ήτος (nom commun) (f)''' : vêtement.&lt;br&gt;
'''ἐσθίω (verbe)''' : manger.&lt;br&gt;
'''ἐσθλός, -ή, -όν (adjectif)''' : Excellent ; (poétique) bon.&lt;br&gt;
'''ἐσθλῶς (adverbe)''' : excellemment.&lt;br&gt;
'''ἐσθλώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''ἐσθλός''.&lt;br&gt;
'''ἐσθλώτερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''ἐσθλός''.&lt;br&gt;
'''ἐσλός, -ή, -όν (adjectif)''' : Forme dorienne de ''ἐσθλός''.&lt;br&gt;
'''ἑσπέρα, -ας (nom commun) (f)''' : Soir ; ouest.&lt;br&gt;
'''ϝεσπέρα, -ας (nom commun) (f)''' : Forme ancienne de ''ἑσπέρα''.&lt;br&gt;
'''ἕσπερος, -ος, -ον (adjectif)''' : Relatif au soir ; occidental.&lt;br&gt;
'''ἑστίασις, -άσεως (nom commun) (f)''' : restauration.&lt;br&gt;
'''ἑστιατόριον, -ίου (nom commun) (n)''' : restaurant.&lt;br&gt;
'''ἑστιάτωρ, -ορος (nom commun) (m)''' : restaurateur.&lt;br&gt;
'''ἑστιάω (verbe)'''  recevoir chez soi.&lt;br&gt;
'''ἐσχάρα, -ας (nom commun) (f)''' : Foyer ; autel domestique et sanctuaire pour les suppliants. Autel pour les sacrifices. Brasier. Réchaud.&lt;br&gt;
'''ἐσχάριον, -ίου (nom commun) (n)''' : cale (dispositif maritime).&lt;br&gt;
'''ἔσχατος, -άτη, -ον (adjectif)''' : dernier.&lt;br&gt;
'''ἐσωτερικός, -ή, -όν (adjectif)''' : intérieur, interne.&lt;br&gt; 
'''ἔσω (adverbe)''' : .&lt;br&gt;
'''ἐσωτάτω (adverbe)''' : Superlatif de ''ἔσω''.&lt;br&gt;
'''ἐσωτέρω (adverbe)''' : Comparatif de ''ἔσω''.&lt;br&gt;
'''ἑταῖρα, -ίρας (nom commun) (f)''' : compagne.&lt;br&gt;
'''ἑταιρείη, -ης (nom commun) (f)''' : Forme ionienne de ''ἑταιρεία''.&lt;br&gt;
'''ἑταιρεῖος, -ία, -ῖον (adjectif)''' : compagnon.&lt;br&gt;
'''ἑταῖρη, -ίρης (nom commun) (f)''' : Forme ionienne de ''ἑταῖρα''.&lt;br&gt;
'''ἑταίρησις, -ήσεως (nom commun) (f)''' : compagnie.&lt;br&gt;
'''ἑταῖρος, -ίρου (nom commun) (m)''' : compagnon.&lt;br&gt;
'''ἐτεός, -ά, -όν (adjectif)''' : .&lt;br&gt;
'''ἐτεῶς (adverbe)''' : .&lt;br&gt;
'''ἐτεώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''ἐτεός''.&lt;br&gt;
'''ἐτεώτερος, -έρα, -ώτερον (adjectif)''' : Comparatif de''ἐτεός''.&lt;br&gt;
'''ἔτης, -ου (nom commun) (m)''' : cousin ; voisin.&lt;br&gt;
'''ἔτος, -ους (nom commun) (n)''' : année.&lt;br&gt;
'''ϝέτος, -ους (nom commun) (n)''' : Forme ancienne de ''ἔτος''.&lt;br&gt;
'''ἔτυμος, -η, -ον (adjectif)''' : Vrai ; réel, véritable.&lt;br&gt; 
'''εὐάζω (verbe)''' : .&lt;br&gt;
'''εὐαί (interjection)''' : .&lt;br&gt;
'''εὐαγγελίζω (verbe)''' : annoncer une bonne nouvelle.&lt;br&gt;
'''εὐαγγελισμός, -οῦ (nom commun) (m)''' : annonciation.&lt;br&gt;
'''εὖγμα, -ὔγματος (nom commun) (n)''' : vœu.&lt;br&gt;
'''εὐδαιμονία, -ας (nom commun) (f)''' : bonheur.&lt;br&gt;
'''εὐδαίμων, -ων, -ον (adjectif)''' : heureux.&lt;br&gt;
'''εὐδαιμόνως (adverbe)''' : heureusement.&lt;br&gt;
'''εὐδαιμονέστατος, -άτη, -έστατον (adjectif)''' : Superlatif de ''εὐδαίμων''.&lt;br&gt;
'''εὐδαιμονέστερος, -έρα, -έρερον (adjectif)''' : Comparatif de ''εὐδαίμων''.&lt;br&gt;
'''εὕδω (verbe)''' : dormir.&lt;br&gt;
'''εὐγενής, -ής, -ές (adjectif)''' : noble.&lt;br&gt;
'''εὐεργεσία, -ας (nom commun) (f)''' : bénéfice.&lt;br&gt;
'''εὐεργέτης, -ου (nom commun) (n)''' : bienfaiteur.&lt;br&gt;
'''εὐεργέτις, -δος (nom commun) (f)''' : bienfaitrice.&lt;br&gt;
'''εὐεργετῶ (bénéfice)''' : bénéficier.&lt;br&gt;
'''εὐ- (préfixe)''' : bon, bien.&lt;br&gt;
'''εὐθέως (adverbe)''' : Directement ; immédiatement.&lt;br&gt;
'''εὔθυνα, -ύνης (nom commun) (f)''' : responsabilité.&lt;br&gt;
'''εὐθυνότης, -ητος (nom commun) (f)''' : responsabilité.&lt;br&gt;
'''εὐθύνω (verbe)''' : être responsable.&lt;br&gt;
'''εὐθύς, -εῖα, -ύ (adjectif)''' : Direct ; immédiat.&lt;br&gt;
'''εὐθύτατος, -άτη, -ύτατον (adjectif)''' : Superlatif de ''εὐθύς''.&lt;br&gt;
'''εὐθύτερος, -έρα, -ύτερον (adjectif)''' : Comparatif de ''εὐθύς''.&lt;br&gt;
'''εὐλάϐεια, -ας (nom commun) (f)''' : piété.&lt;br&gt;
'''εὐλαϐής, -ής, -ές (adjectif)''' : pieux.&lt;br&gt;
'''εὐλαϐικός, -ή, -όν (adjectif)''' : .&lt;br&gt;
'''εὐλαϐικῶς  (adverbe)''' : avec piété.&lt;br&gt;
'''εὐλαϐῶς (adverbe)''' : pieusement.&lt;br&gt;
'''εὐλαλος, -ος, -ον (adjectif)''' : qui parle bien.&lt;br&gt;
'''εὐλογιά, -ᾶς (nom commun) (f)''' : variole.&lt;br&gt; 
'''εὐλογία, -ας (nom commun) (f)''' : louange.&lt;br&gt;
'''εὐμετάϐλητος, -η, -ον (adjectif)''' : .&lt;br&gt;
'''εὐμορφία, -ας (nom commun) (f)''' : beauté.&lt;br&gt;
'''εὔμορφος, -ος, -ον (adjectif)''' : beau.&lt;br&gt;
'''εὔνοια, -ίας (nom commun) (f)''' : faveur.&lt;br&gt;
'''εὐνοϊκός, -ή, -όν (adjectif)''' : favorable.&lt;br&gt;
'''εὐνοϊκῶς (adverbe)''' : favorablement.&lt;br&gt;
'''εὐνοϊκώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''εὐνοϊκός''.&lt;br&gt;
'''εὐνοϊκώτερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''εὐνοϊκός''.&lt;br&gt;
'''εὐνοϊκώτατα, -, - (adverbe)''' : Superlatif de ''εὐνοϊκῶς''.&lt;br&gt;
'''εὐνοϊκώτερον, -, - (adverbe)''' : Comparatif de ''εὐνοϊκῶς''.&lt;br&gt; 	
'''εὔνους, -ους, -ουν (adjectif)''' : .&lt;br&gt; 
'''εὐπατρίδης, -ου (nom commun) (m)''' : gentilhomme.&lt;br&gt;
'''εὐοπλέω (verbe)''' : être bien armé.&lt;br&gt;
'''εὐρετήριον, -ήριου (nom commun) (n)''' : index (liste).&lt;br&gt;
'''εὐρέως (adverbe)''' : largement.&lt;br&gt;
'''εὐρύς, -εῖα, -ύ (adjectif)''' : Large. (Par extension) Vaste, spacieux.&lt;br&gt;
'''εὐρύτατος, -άτη, -ύτατον (adjectif)''' : Superlatif de ''εὐρύς''.&lt;br&gt;
'''εὐρύτερος, -έρα, -ύτερον (adjectif)''' : Comparatif de ''εὐρύς''.&lt;br&gt;
'''εὔρωστος, -ος, -ον (adjectif)''' : .&lt;br&gt; 
'''εὐρωστότατος, -άτη, -ότατον (adjectif)''' : Superlatif de ''εὔρωστος''.&lt;br&gt;
'''εὐρωστότερος, -έρα, -ότερον (adjectif)'''' : Comparatif de ''εὔρωστος''.&lt;br&gt;
'''εὐρωστότατα, -, - (adverbe)''' : Superlatif de ''εὐρώστως''.&lt;br&gt;
'''εὐρωστότερον, -, - (adverbe)''' : Comparatif de ''εὐρώστως''.&lt;br&gt;
'''εὐρώστως (adverbe)''' : .&lt;br&gt;
'''εὐσέϐεια, -ίας (nom commun) (f)''' : piété.&lt;br&gt;
'''εὐσεϐέστατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''εὐσεϐής''.&lt;br&gt;
'''εὐσεϐέστερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''εὐσεϐής''.&lt;br&gt;
'''εὐσεϐής, -ής, -ές (adjectif)''' : pieux.&lt;br&gt;
'''εὐσεϐῶς (adverbe)''' : pieusement.&lt;br&gt;
'''εὐσυνείδητος, -ος, -ον (adjectif)''' : consciencieux.&lt;br&gt;
'''ἐύς, -εῖα, -ύ (adjectif)''' : bon, brave.&lt;br&gt;
'''εὐτελέστατος, -άτη, -έστατον (adjectif)''' : Superlatif de ''εὐτελής''.&lt;br&gt;
'''εὐτελέστερος, -έρα, -έστερον (adjectif)''' : Comparatif de ''εὐτελής''.&lt;br&gt;
'''εὐτελής, -ής, -ές (adjectif)''' : Bon marché. De vil prix, de peu de valeur. Avare.&lt;br&gt;
'''εὐτελίζω (verbe)''' : mépriser.&lt;br&gt;
'''εὐτελῶς (adverbe)''' : .&lt;br&gt;
'''εὐτυχία, -ας (nom commun) (f)''' : bonheur.&lt;br&gt;
'''εὖ (adverbe)''' : Bien (idée d’origine) Noblement. Bien, régulièrement ; justement. Bien, avec bienveillance. Heureusement.&lt;br&gt;
'''εὐτυχέστατος, -άτη, -έστατον (adjectif)''' : Superlatif de ''εὐτυχής''.&lt;br&gt;
'''εὐτυχέστερος, -έρα, -έστερον (adjectif)''' : Comparatif de ''εὐτυχής''.&lt;br&gt;
'''εὐτυχής, -ής, -ές (adjectif)''' : heureux.&lt;br&gt;
'''εὐτυχῶς (adverbe)''' : heureusement.&lt;br&gt;
'''εὔφλεκτος, -ος, -ον (adjectif)''' : inflammable.&lt;br&gt;
'''εὐφραδέστατος, -άτη, -έστατον (adjectif)''' : Superlatif de ''εὐφραδής''.&lt;br&gt;
'''εὐφραδέστερος, -έρα, -έστερον (adjectif)''' : Comparatif de ''εὐφραδής''.&lt;br&gt;
'''εὐφραδής, -ής, -ές (adjectif)''' : .&lt;br&gt;
'''εὔφρων, -ων, -ον (adjectif)''' : .&lt;br&gt;
'''εὐφυέστατος, -άτη, -έστατον (adjectif)''' : Superlatif de ''εὐφυής''.&lt;br&gt;
'''εὐφυέστερος, -έρα, -έστερον (adjectif)''' : Comparatif de ''εὐφυής''.&lt;br&gt;
'''εὐφυής, -ής, -ές (adjectif)''' : .&lt;br&gt;
'''εὐφυῶς (adverbe)''' : .&lt;br&gt;
'''εὐφωνία, -ας (nom commun) (f)''' : bonne sonorité.&lt;br&gt;
'''εὐχαριστία, -ας (nom commun) (f)''' : .&lt;br&gt;
'''εὐχάριστος, -ος, -ον (adjectif)''' : .&lt;br&gt;
'''εὐχαριστῶ (verbe)''' : remercier.&lt;br&gt;
'''εὐχή, -ῆς (nom commun) (f)''' : vœu.&lt;br&gt;
'''εὔχομαι (verbe)''' : formuler un vœu.&lt;br&gt;
'''εὖχος, -ὔχους (nom commun) (n)''' : Prière, vœu.&lt;br&gt;
'''εὐχωλή, -ῆς (nom commun) (f)''' : Prière, vœu.&lt;br&gt;
'''-εύς, -έως (suffixe) (m)''' : .&lt;br&gt;
'''-εύω (suffixe)''' : .&lt;br&gt;
'''ἐφαμέριος, -ίου (nom commun) (m)''' : Forme dorienne de ''ἐφημέριος''.&lt;br&gt;
'''ἐφαμερεύω (verbe)''' : Forme dorienne de ''ἐφημερεύω''.&lt;br&gt;
'''ἐφαρμόζω (verbe)''' : appliquer.&lt;br&gt;
'''ἐφεξείης (adverbe)''' : Forme poétique de ''ἐφεξῆς''.&lt;br&gt;
'''ἐφεξῆς (adverbe)''' : dorénavant, désormais.&lt;br&gt; 
'''ἐφήϐαιον, -ίου (nom commun) (m)''' : pubis.&lt;br&gt; 
'''ἐφηϐεία, -ας (nom commun) (f)''' : Service militaire rassemblant les jeunes Athéniens âgés de 18 à 20 ans.&lt;br&gt;
'''ἐφηϐικός,  -ή, -όν (adjectif)''' : adolescent.&lt;br&gt;
'''ἔφηϐος, -ήϐου (nom commun) (m)''' : Jeune garçon ayant quitté l’autorité des femmes.&lt;br&gt;
'''ἐφημέριος, -ίου (nom commun) (m)''' : curé.&lt;br&gt;
'''ἐφημερεύω (verbe)''' : .&lt;br&gt;
'''ἐφιάλτης, -ου (nom commun) (m)''' : cauchemar.&lt;br&gt;
'''ἔχθος, -ους (nom commun) (n)''' : Haine ; hostilité.&lt;br&gt;
'''ἐχθρά, -ᾶς (nom commun) (f)''' : ennemie.&lt;br&gt;
'''ἐχθρός, -ά, -όν (adjectif)''' : Détesté de ; ennemi de.&lt;br&gt;
'''ἐχθρός, -οῦ (nom commun) (m)''' : ennemi.&lt;br&gt;
'''ἐχθρότης, -τος (nom commun) (f)''' : inimitié.&lt;br&gt;
'''ἔχθω (verbe)''' : Haïr ; être hostile.&lt;br&gt;
'''ἔχιδνα, -ης (nom commun) (f)''' : vipère.&lt;br&gt;
'''ἐχῖνος, -ίνου (nom commun) (m)''' : hérisson.&lt;br&gt;
'''ἔχις, -εως (nom commun) (m)''' : vipère.&lt;br&gt;
'''ἔχω (verbe)''' : avoir.&lt;br&gt;
'''ἕψημα, -ήματος (nom commun) (f)''' : cuisson.&lt;br&gt;
'''ἕψησις, -ήσεως (nom commun) (f)''' : ébulition.&lt;br&gt;
'''ἒ ψιλόν (nom commun) (n)''' : epsilon.&lt;br&gt;
'''ἕψω (verbe)''' : Bouillir, cuire. Fondre, en parlant des métaux, raffiner, purifier. (Figuré) Être chaud pour ; chérir.&lt;br&gt;
'''ἕως (conjonction)''' : jusqu'à ce que ; tant que.&lt;br&gt; 
'''Ἑϐραία, -ας (nom commun) (f)''' : Israélite.&lt;br&gt; 
'''Ἑϐραῖος, -ίου (nom commun) (m)''' : Israélite.&lt;br&gt;
'''Ἑϐραΐς, -δος (nom commun) (f)''' : Israélite.&lt;br&gt; 
'''Ἐδέμ (nom propre) (m)''' : Éden.&lt;br&gt; 
'''Εἰλείθυια, -ίας (nom propre) (f)''' : [[wikt:Ilithyie|Ilithyie]] (déesse de l'enfantement).&lt;br&gt;
'''Εἰρηναῖος, -ίου (nom propre) (m)''' : Irénée.&lt;br&gt;
'''Εἰρήνη, -ης (nom propre) (f)''' : [[wikt:Eiréné|Eiréné]].&lt;br&gt;
'''Ἑκάϐη, -ης (nom propre) (f)''' : Hécube.&lt;br&gt;
'''Ἑκάτη, -ης (nom propre) (f)''' : Hécate.&lt;br&gt;
'''Ἑκατόγχειρες, -ων (nom propre) (m)''' : Hécatonchires.&lt;br&gt;
'''Ἕκτωρ, -ορος (nom propre) (m)''' : Hector.&lt;br&gt;
'''Ἐλεάζαρος, -άρου (nom propre) (m)''' : Éléazar.&lt;br&gt; 
'''Ἐλαμείτης, -ου (nom commun) (m)''' : Élamite.&lt;br&gt;
'''Ἐλεύθυια, -ίας (nom propre) (f)''' : Forme ancienne de ''Εἰλείθυια''.&lt;br&gt;
'''Ἑλένη, -ης (nom propre) (f)''' : Hélène.&lt;br&gt;
'''Ἕλενος, -ένου (nom propre) (m)''' : Hélénos.&lt;br&gt;
'''Ἐλισάϐετ (nom propre) (f)''' : Élisabeth.&lt;br&gt;
'''Ἑλλάς, -δος (nom propre) (f)''' : Grèce.&lt;br&gt;
'''Ἕλλη, -ης (nom propre) (f)''' : Hellé.&lt;br&gt;
'''Ἕλλην, -ος (nom propre) (m)''' : Hellen.&lt;br&gt; 
'''Ἕλλην, -ος (nom commun) (m)''' : Grec.&lt;br&gt; 
'''Ἑλληνίς, -δος (nom commun) (f)''' : Grecque.&lt;br&gt; 
'''Ἑλλήσποντος, -όντου (nom commun) (m)''' : Helléspont.&lt;br&gt;
'''Ἐμπεδοκλῆς, -έους (nom propre) (m)''' : Empédocle.&lt;br&gt;
'''Ἐνάρετη, -ης (nom propre) (f)''' :  Énarété.&lt;br&gt;
'''Ἐνδυμίων, -ωνος (nom propre) (m)''' : Endymion.&lt;br&gt;
'''Ἐνετός, -οῦ (nom commun) (m)''' : Vénète.&lt;br&gt;
'''Ἐνυώ, -οῦς (nom propre) (f)''' : [[wikt:Ényo|Ényo]].&lt;br&gt;
'''Ἐπαμεινώνδας, -ου (nom commun) (m)''' : Épaminondas.&lt;br&gt;
'''Ἐπίκτητος, -ήτου (nom propre) (m)''' : Épictète.&lt;br&gt;
'''Ἐπιμηθεύς, -έως (nom propre) (m)''' : Épiméthée.&lt;br&gt;
'''Ἐπιφί (nom propre) (m)''' : Epiphi.&lt;br&gt;
'''Ἐρατοσθένης, -ους (nom propre) (m)''' : Ératosthène. (Savant grec né en -276 et mort en -194.)&lt;br&gt;
'''Ἐρατώ, -οῦς (nom propre) (f)''' : Érato.&lt;br&gt;
'''Ἔρεϐος, -έϐους (nom propre) (n)''' : [[wikt:Érèbe|Érèbe]].&lt;br&gt;
'''Ἐρεχθεύς, -έως (nom propre) (m)''' : Érechtée.&lt;br&gt;
'''Ἐρινύς, -ος (nom propre) (f)''' : Érynie.&lt;br&gt;
'''Ἔρις, -εως (nom propre) (f)''' : [[wikt:Éris|Éris]].&lt;br&gt;
'''Ἐριφύλη, -ης (nom propre) (f)''' : Ériphyle.&lt;br&gt;
'''Ἑρμᾶς, -οῦ (nom propre) (m)''' : Forme dorienne de ''Ἑρμῆς''.&lt;br&gt;
'''Ἑρμαφρόδιτος, -ίτου (nom propre) (m)''' : Hermaphrodite.&lt;br&gt;
'''Ἑρμῆς, -οῦ (nom propre) (m)''' : [[wikt:Hermès|Hermès]].&lt;br&gt;
'''Ἑρμιονεύς, -έως (nom propre) (m)''' : Hermionée.&lt;br&gt;
'''Ἑρμιόνη, -ης (nom propre) (f)''' : Hermione.&lt;br&gt;
'''Ἑρμιονίς, -δος (nom propre) (f)''' : Hermionide.&lt;br&gt;
'''Ἑρμιών, -ῶνος (nom propre) (m)''' : Hermion.&lt;br&gt;
'''Ἑρμογένης, -ους (nom propre) (m)''' : Hermogénès.&lt;br&gt;
'''Ἐρυσίχθων, -ονος (nom propre) (m)''' : Érysichthon.&lt;br&gt;
'''Ἔρως, -τος (nom propre) (m)''' : [[wikt:Éros|Éros]].&lt;br&gt;
'''Ἑσπερία, -ας (nom propre) (f)''' : Hespérie.&lt;br&gt;
'''Ἑσπερίδες, -ων (nom propre) (f)''' : Hespérides.&lt;br&gt;
'''Ἑσπερίς, -δος (nom propre) (f)''' : Hespéris.&lt;br&gt; 
'''Ἕσπερος, -έρου (nom propre) (m)''' : Hespéros.&lt;br&gt;
'''Εὔα, -ας (nom propre) (f)''' : Ève.&lt;br&gt;
'''Εὐάγριος, -ίου (nom propre) (m)''' : Évagre.&lt;br&gt;
'''Εὐγενία, -ας (nom propre) (f)''' : Eugénie.&lt;br&gt;
'''Εὐγένιος, -ίου (nom propre) (m)''' : Eugène.&lt;br&gt;
'''Εὔδημος, -ήµου (nom propre) (m)''' : Eudème.&lt;br&gt;
'''Εὔιος, -ίου (nom propre) (m)''' : Euïos.&lt;br&gt;
'''Εὐλαλία, -ας (nom propre) (f)''' : Eulalie.&lt;br&gt;
'''Εὐλάλιος, -ίου (nom propre) (m)''' : Eulalios.&lt;br&gt;
'''Εὔμαιος, -ίου (nom propre) (m)''' : Eumée. (Porcher de Laërte et d’Ulysse.)&lt;br&gt; 
'''Εὐήμερος, -έρου (nom propre) (m)''' : Évhémère.&lt;br&gt;
'''Εὔμηλος, -ήλου (nom propre) (m)''' : Eumélos.&lt;br&gt;
'''Εὔνηος, -ήου (nom propre) (m)''' : Eunée.&lt;br&gt;
'''Εὐνομία, -ας (nom propre) (f)''' : Eunomie.&lt;br&gt;
'''Εὐήρης, -ου  (nom propre) (m)''' : Évérès.&lt;br&gt;
'''Εὐριπίδης, -ου (nom propre) (m)''' : Euripide.&lt;br&gt;
'''Εὔρος, -ου  (nom propre) (m)''' : Euros. (dieu du vent d'est)&lt;br&gt;
'''Εὐρυάλη, -ης (nom propre) (f)''' : Euryale.&lt;br&gt;
'''Εὐρυδίκη, -ης (nom propre) (f)''' : Eurydice.&lt;br&gt;
'''Εὐρύθεμις, -έμιδας (nom propre) (f)''' : Eurythémis.&lt;br&gt;
'''Εὐρύκλεια, -ίας (nom propre) (f)''' : Euryclée.&lt;br&gt;
'''Εὐρύλοχος, -όχου (nom propre) (m)''' : Euryloque.&lt;br&gt;
'''Εὐρυσθεύς, -έως (nom propre) (m)''' : Eurysthée (fils de Sthénélos et Nicipée).&lt;br&gt;
'''Εὐρωπαῖος, -ίου (nom commun) (m)''' : Européen.&lt;br&gt;
'''Εὐρώπη, -ης (nom propre) (f)''' : Europe.&lt;br&gt;
'''Εὐσέϐεια, -ας (nom propre) (f)''' : Eusébie.&lt;br&gt;
'''Εὐσέϐιος, -ίου (nom propre) (m)''' : Eusèbe.&lt;br&gt;
'''Εὐστάθιος, -ίου (prénom) (m)''' : Eustache.&lt;br&gt;
'''Εὔσταχυς, -άχυος (prénom) (m)''' : Eustache.&lt;br&gt;
'''Εὐτέρπη, -ης (nom propre) (f)''' : Euterpe.&lt;br&gt;
'''Εὐτύχιος, -ίου (nom propre) (m)''' : Eutychius.&lt;br&gt;
'''Εὐφημία, -ας (nom propre) (f)''' : Euphémie.&lt;br&gt;
'''Εὔφημος, -ήμου (nom propre) (m)''' : Euphémos.&lt;br&gt;
'''Εὐφράτης, -ου (nom propre) (m)''' : Euphrate (fleuve de Turquie et d’Irak).&lt;br&gt;
'''Εὐφροσύνη, -ης (nom propre) (f)''' : Euphrosyne.&lt;br&gt;
'''Εὔφρων, -ονος (nom propre) (m)''' : Euphron.&lt;br&gt;
'''Ἔφεσος, -έσου (nom propre) (f)''' : Éphèse.&lt;br&gt;
'''Ἐφιάλτης, -ου (nom propre) (m)''' : Éphialtès.&lt;br&gt;
'''Ἕως, -ω (nom propre) (f)''' : Forme alternative de ''Ἠώς''.&lt;br&gt;
'''Ἑωσφόρος, -ου (nom propre) (m)''' : Lucifer.&lt;br&gt;

==Ζ==
'''ζῆλος, -ήλου  (nom commun) (m)''' : Jalousie ; zèle.&lt;br&gt;
'''ζηλοτυπία, -ας  (nom commun) (m)''' : jalousie.&lt;br&gt;
'''ζηλότυπος, -ος, -ον (adjectif)''' : jaloux.&lt;br&gt;
'''ζηλωτής, -οῦ (nom commun) (m)''' : zélote.&lt;br&gt;
'''ζηλῶ (verbe)''' : aimer ardemment.&lt;br&gt;
'''ζῆτα (nom commun) (n)''' : zêta.&lt;br&gt;
'''ζήτησις, -ήσεως (nom commun) (f)''' : recherche.&lt;br&gt;
'''ζητητικός, -ός, -όν (adjectif)''' : aimant chercher ; rechercher.&lt;br&gt;
'''ζητῶ (verbe)''' : demander ; chercher.&lt;br&gt;
'''ζιγγίϐερις, -έρεως (nom commun) (f)''' : gingembre.&lt;br&gt;
'''ζιζάνιον, -ίου (nom commun) (n)''' : ivraie.&lt;br&gt;
'''ζιζανοσπορεύς, -έως (nom commun) (m)''' : .&lt;br&gt;
'''ζιζανιοσπόρος, -ου (nom commun) (m)''' : .&lt;br&gt;
'''ζιζανώδης, -ης, -ες (adjectif)''' : .&lt;br&gt;
'''ζίζυφον, -ύϕου (nom commun) (n)''' : jujubier.&lt;br&gt;
'''ζόα, -ας (nom commun) (f)''' : Forme dorienne de ''ζωή''.&lt;br&gt;  
'''ζόη, -ης (nom commun) (f)''' : Forme ionienne de ''ζωή''.&lt;br&gt;  
'''ζοΐα, -ας (nom commun) (f)''' : Forme éolienne de ''ζωή''.&lt;br&gt;  
'''ζόρξ, -κος  (nom commun) (m)''' : Forme de ''δορκάς''.&lt;br&gt;
'''ζυγαριά, -ᾶς (nom commun) (f)''' : balance.&lt;br&gt; 
'''ζυγόν, -οῦ (nom commun) (n)''' : joug.&lt;br&gt;
'''ζῦθος, -ύθου  (nom commun) (m)''' : bière.&lt;br&gt;
'''ζωά, -ᾶς (nom commun) (f)''' : Autre forme dorienne de ''ζωή''.&lt;br&gt;  
'''ζωή, -ῆς (nom commun) (f)''' : vie.&lt;br&gt;
'''ζῶμα, -ώματος (nom commun) (n)''' : caleçon.&lt;br&gt;
'''ζώμευμα, -ύματος (nom commun) (n)''' : soupe.&lt;br&gt;
'''ζωμεύω (verbe)''' : bouillir en soupe.&lt;br&gt;
'''ζωμήρυσις, -ύσεως (nom commun) (f)''' : louche à soupe.&lt;br&gt;
'''ζωμίδιον, -ίου (nom commun) (n)''' : sauce.&lt;br&gt;
'''ζωμός, -οῦ (nom commun) (m)''' : bouillon, soupe.&lt;br&gt;
'''ζωός, -ή, -όν (adjectif)''' : vivant.&lt;br&gt;
'''ζῷον, -ῴου (nom commun) (n)''' : animal.&lt;br&gt;
'''ζωοπανήγυρις, -ύρεως (nom commun) (f)''' : .&lt;br&gt;
'''ζῶ (verbe)''' : vivre.&lt;br&gt;
'''Ζαϐουλών (nom propre) (m)''' : Zabulon.&lt;br&gt;
'''Ζαγρεύς, -έως (nom propre) (m)''' : Zagreus.&lt;br&gt;
'''Ζακχαῖος, -ίου (nom propre) (m)''' : Zachée.&lt;br&gt;
'''Ζάν, -ός (nom propre) (m)''' : Forme dorienne de ''Ζεύς''.&lt;br&gt;
'''Ζάς, -νος (nom propre) (m)''' : Autre forme dorienne de ''Ζεύς''.&lt;br&gt;
'''Ζαχαρίας, -ου (nom propre) (m)''' : Zacharie.&lt;br&gt;
'''Ζεϐεδαῖος, -ίου (nom propre) (m)''' : Zébédée.&lt;br&gt;
'''Ζευξίππη, -ης (nom propre) (f)''' : Zeuxippe.&lt;br&gt;
'''Ζεῦξις, -ύξεως (nom propre) (m)''' : Zeuxis.&lt;br&gt;
'''Ζεῦς, -ύσεως (nom propre) (m)''' : Forme lesbienne de ''Ζεύς''.&lt;br&gt; 
'''Ζεύς, Διός (nom propre) (m)''' : [[wikt:Zeus|Zeus]].&lt;br&gt;
'''Ζέφυρος, -ύρου (nom propre) (m)''' : [[wikt:Zéphyr|Zéphyr]]. (dieu du vent d'ouest)&lt;br&gt;
'''Ζῆλος, -ήλου (nom propre) (m)''' : Zélos.&lt;br&gt;
'''Ζήν, -ός (nom propre) (m)''' : Forme poétique de ''Ζεύς''.&lt;br&gt;
'''Ζηνοϐία, -ας (nom propre) (f)''' : Zénobie.&lt;br&gt;
'''Ζηνοϐίος, -ίου (nom propre) (m)''' : Zénobios.&lt;br&gt;
'''Ζυγός, -οῦ (nom propre) (m)''' : Balance.&lt;br&gt;
'''Ζωροάστρης, -ου (nom propre) (m)''' : Zoroastre.&lt;br&gt;

==Η== 
'''ἡ (article défini)''' : la.&lt;br&gt;
'''ἤ (conjonction)''' : ou.&lt;br&gt;
'''ᾗ  (adverbe relatif)''' : par là où (je passe).&lt;br&gt;
'''ἥϐη, -ης (nom commun) (f)''' : jeunesse.&lt;br&gt; 
'''ἡϐητέστατος, -άτη, -έστατον (adjectif)''' : Superlatif de ''ἡϐητής''.&lt;br&gt;
'''ἡϐητέστερος, -έρα, -έστερον (adjectif)''' : Comparatif de ''ἡϐητής''.&lt;br&gt;
'''ἡϐητής, -ής, -ές (adjectif)''' : juvénile.&lt;br&gt;
'''ἡϐητῶς (adverbe)''' : juvénilement.&lt;br&gt;
'''ἡϐός, -ή, -όν (adjectif)''' : jeune.&lt;br&gt;
'''ἡϐότατος, -άτη, -ότατον (adjectif)''' : Superlatif de ''ἡϐός''.&lt;br&gt;
'''ἡϐότερος, -έρα, -ότερον (adjectif)''' : Comparatif de ''ἡϐός''.&lt;br&gt; 
'''ἡγείσθαι (verbe)''' : conduire.&lt;br&gt; 
'''ἡγεμονία, -ας (nom commun) (f)''' : Action de conduire, de diriger. Suprématie, puissance. Règne.&lt;br&gt; 
'''ἡγεμονεύω (verbe)''' : .&lt;br&gt; 
'''ἡγεμών, -όνος (nom commun) (m)''' : souverain.&lt;br&gt;
'''ἡγέομαι (verbe)''' : Marcher devant. (après Homère) Croire, penser.&lt;br&gt;
'''ἡγέτης, -ου (nom commun) (m)''' : leader.&lt;br&gt; 
'''-ηγός, -οῦ (suffixe) (m/f)''' : .&lt;br&gt;
'''ἥδομαι (verbe)''' : avoir plaisir à, se réjouir de.&lt;br&gt;
'''ἡδονή, -ῆς (nom commun) (f)''' : plaisir.&lt;br&gt;
'''ἡδύς, -εῖα, -ύ (adjectif)''' : doux, agréable.&lt;br&gt;
'''ἡδύχρουν, - (nom commun) (n)''' : .&lt;br&gt;
'''ἠθικός, -ή, -όν (adjectif)''' : moral.&lt;br&gt;
'''ἠθικότατα, -, - (adverbe)''' : Superlatif de ''ἠθικῶς''.&lt;br&gt;
'''ἠθικότερον, -, - (adverbe)''' : Comparatif de ''ἠθικῶς''.&lt;br&gt;
'''ἠθικῶς (adverbe)''' : moralement.&lt;br&gt; 
'''ἠθικώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''ἠθικός''.&lt;br&gt;
'''ἠθικώτερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''ἠθικός''.&lt;br&gt;
'''ἦθος, ἤθους (nom commun) (n)''' : us et coutumes.&lt;br&gt;
'''ἠϊθέη, -ης (nom commun) (f)''' : célibataire.&lt;br&gt;
'''ἠΐθεος, -έου (nom commun) (m)''' : célibataire.&lt;br&gt; 
'''ἠι (adverbe)''' : Forme béotienne de ''ἀεί''.&lt;br&gt; 
'''-ήϊον, -ΐου (suffixe)''' : Forme ionienne de ''-εῖον''.&lt;br&gt;
'''ἥκω (verbe)''' : être présent, être là.&lt;br&gt;
'''ἠλακάτη, -ης (nom commun) (f)''' : quenouille.&lt;br&gt; 
'''ἤλεκτρον, -έκτρου (nom commun) (n)''' : ambre jaune.&lt;br&gt;
'''ἠλέκτωρ, -, - (adjectif)''' : brillant.&lt;br&gt;
'''ἡλιακός, -ή, -όν (adjectif)''' : solaire.&lt;br&gt;
'''ἤλιθιος, -η, -ον (adjectif)''' : stupide.&lt;br&gt;
'''ἡλικία, -ας (nom commun) (f)''' : âge.&lt;br&gt; 
'''ἥλιος, -ίου (nom commun) (m)''' : soleil.&lt;br&gt;
'''ἠέλιος, -ίου (nom commun) (m)''' : Forme homérique de ''ἥλιος''.&lt;br&gt; 
'''ἡλιοστάσιον, -ίου (nom commun) (n)''' : solstice.&lt;br&gt;
'''ἧλιξ, ἥλικος (nom commun) (m/f)''' : camarade.&lt;br&gt;
'''ἧλος, ἥλου (nom commun) (m)''' : Clou, tête de clou. Cal, durillon, galle.&lt;br&gt;
'''ἧμαι (verbe)''' : être assis.&lt;br&gt;
'''ἡμεῖς (pronom personnel) (m)''' : nous.&lt;br&gt;
'''ἡμέρα, -ας (nom commun) (f)''' : jour.&lt;br&gt;
'''ἡμέρα Ἡλίου (nom commun) (f)''' : dimanche.&lt;br&gt;
'''ἡμέρα Σελήνης (nom commun) (f)''' : lundi.&lt;br&gt;
'''ἡμέρα Ἄρεως (nom commun) (f)''' : mardi.&lt;br&gt;
'''ἡμέρα Ἕρμου (nom commun) (f)''' : mercredi.&lt;br&gt;
'''ἡμέρα Διός (nom commun) (f)''' : jeudi.&lt;br&gt; 
'''ἡμέρα Ἀφροδίτης (nom commun) (f)''' : vendredi.&lt;br&gt;
'''ἡμέρα Κρόνου (nom commun) (f)''' : samedi.&lt;br&gt;
'''ἡμέρη, -ης''' (nom commun) (f) Forme homérique et ionienne de ''ἡμέρα''.&lt;br&gt;
'''ἡμερήσιος, -ια, -ον (adjectif)''' : journalier ; diurne.&lt;br&gt;
'''ἡμερολόγιον, -ίου (nom commun) (n)''' : calendrier.&lt;br&gt;
'''ἡμέτερος, -έρα, -έτερον (adjectif possessif)''' : notre.&lt;br&gt;
'''ἡμι- (préfixe)''' : à moitié.&lt;br&gt;
'''ἡμίκλαστος, -, - (adjectif)''' : .&lt;br&gt;
'''ἡμικρανία, -ας (nom commun) (f)''' : migraine.&lt;br&gt;
'''ἡμίονος, -όνου (nom commun) (m)''' : hémione.&lt;br&gt;
'''ἡνία, -ας (nom commun) (f)''' : .&lt;br&gt;
'''ἡνίοχος, -όχου (nom commun) (m)''' : cocher.&lt;br&gt;
'''ἧπαρ, ἥπατος (nom commun) (n)''' : foie.&lt;br&gt;
'''ἡπατικός, -ή, -όν (adjectif)''' : hépatique.&lt;br&gt;
'''ἡπατῖτις, -ίτης (nom commun) (f)''' : hépatite.&lt;br&gt;
'''ἤπειρος, -ίρου (nom commun) (f)''' : continent.&lt;br&gt;
'''ἠπειρωτικός, -ή, -όν (adjectif)''' : continental.&lt;br&gt;
'''ἡράκλειος, -α, -ον (adjectif)''' : herculéen.&lt;br&gt;
'''ἡρωίνη, -ης (nom commun) (f)''' : héroïne.&lt;br&gt;
'''ἡρωικός, -ή, -όν (adjectif)''' : héroïque.&lt;br&gt;
'''ἡρωικότατα, -, - (adverbe)''' : Superlatif de ''ἡρωικῶς''.&lt;br&gt;
'''ἡρωικότερον, -, - (adverbe)''' : Comparatif de ''ἡρωικῶς''.&lt;br&gt;
'''ἡρωικῶς (adverbe)''' : héroïquement.&lt;br&gt; 
'''ἡρωικώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''ἡρωικός''.&lt;br&gt;
'''ἡρωικώτερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''ἡρωικός''.&lt;br&gt;
'''ἡρωισμός, -οῦ (nom commun) (m)''' : héroïsme.&lt;br&gt;
'''ἡρωίς, -δος (nom commun) (f)''' : héroïne.&lt;br&gt;
'''ἥρως, -ος (nom commun) (m)''' : héros.&lt;br&gt;
'''ἧσσα, ἥσσης (nom commun) (f)''' : défaite.&lt;br&gt;
'''ἡσσῶμαι (verbe)''' : être défait.&lt;br&gt;
'''ἡσυχάζω (verbe)''' : être en paix, garder le silence.&lt;br&gt;
'''ἡσυχασμός, -οῦ (nom commun) (m)''' : hésychasme.&lt;br&gt;
'''ἡσυχία, -ας (nom commun) (f)''' : Immobilité. Repos, calme ; silence.&lt;br&gt;
'''ἥσυχος, -ος, -ον (adjectif)''' : Calme, tranquille.&lt;br&gt;
'''ἡσύχως (adverbe)''' : Calmement, tranquillement.&lt;br&gt;
'''ἡσυχώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''ἥσυχος''.&lt;br&gt;
'''ἡσυχώτερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''ἥσυχος''.&lt;br&gt;
'''σωματικώτατα, -, - (adverbe)''' : Superlatif de ''ἡσύχως''.&lt;br&gt;
'''σωματικώτερον, -, - (adverbe)''' : Comparatif de ''ἡσύχως''.&lt;br&gt; 
'''ἦτα (nom commun) (n)''' : êta.&lt;br&gt;
'''ἧτρον, ἥτρου (nom commun) (n)''' : abdomen.&lt;br&gt;
'''ἧττα, ἥττης (nom commun) (f)''' : Forme attique de ''ἧσσα''.&lt;br&gt;
'''ἡττῶμαι (verbe)''' : Forme attique de ''ἡσσῶμαι''.&lt;br&gt;
'''ἡφαιστεῖον, -ίου (nom commun) (m)''' : volcan.&lt;br&gt;
'''ἦχος, ἤχου (nom commun) (m)''' : son.&lt;br&gt;
'''ἠχώ, -οῦς (nom commun) (f)''' : son répercuté.&lt;br&gt;
'''ἠώς, -οῦς (nom commun) (f)''' : aurore.&lt;br&gt;
'''Ἥϐη, -ης (nom propre) (f)''' : [[wikt:Hébé|Hébé]].&lt;br&gt;
'''Ἡγήσιππος, -ίππου (nom propre) (m)''' : Hégésippe.&lt;br&gt;
'''Ἡγησώ, -οῦς (nom propre) (f)''' : Hègèsô.&lt;br&gt;
'''Ἠλίας, -α (nom propre) (m)''' : Élie.&lt;br&gt;  
'''Ἥλιος, -ίου (nom propre) (m)''' : [[wikt:Hélios|Hélios]].&lt;br&gt;
'''Ἠλύσιον, -ίου (nom propre) (n)''' :  Élysée. (Séjour des hommes vertueux après leur mort.)&lt;br&gt; 
'''Ἡμέρα, -ας (nom propre) (f)''' : [[wikt:Héméra|Héméra]].&lt;br&gt;
'''Ἤπειρος, -ίρου (nom propre) (f)''' : Épire.&lt;br&gt;
'''Ἠπιδανός, -οῦ (nom propre) (m)''' : Forme ionienne d&lt;nowiki&gt;'&lt;/nowiki&gt;''Ἀπιδανός''.&lt;br&gt;
'''Ἥρα, -ας (nom propre) (f)''' : [[wikt:Héra|Héra]].&lt;br&gt;
'''Ἡρακλέης, -ους (nom propre) (m)''' : Forme poétique de ''Ἡρακλῆς''.&lt;br&gt;
'''Ἡρακλῆς, -έους (nom propre) (m)''' : Héraclès.&lt;br&gt;
'''Ἡρόστρατος, -άτου (nom propre) (m)''' : Hérostrate.&lt;br&gt;
'''Ἠσαΐας, -ου (nom propre) (m)''' : Isaïe.&lt;br&gt;
'''Ἡσαΐας, -ου (nom propre) (m)''' : Forme alternative de ''Ἠσαΐας''.&lt;br&gt;
'''Ἡσαῦ (nom propre) (m)''' : Ésaü.&lt;br&gt; 
'''Ἠσαῦ (nom propre) (m)''' : Forme alternative de ''Ἡσαῦ''.&lt;br&gt;
'''Ἡσύχιος, -ίου (nom propre) (m)''' : Hésychios.&lt;br&gt;
'''Ἥφαιστος, -ίστου (nom propre) (m)''' : [[wikt:Héphaïstos|Héphaïstos]].&lt;br&gt;
'''Ἠχώ, -οῦς (nom propre) (f)''' : [[wikt:Écho|Écho]].&lt;br&gt;
'''Ἠώς, -οῦς (nom propre) (f)''' : [[wikt:Éos|Éos]].&lt;br&gt;

==Θ==
'''θαλάμη, -ης (nom commun) (f)''' : Gîte ; tanière.&lt;br&gt;
'''θάλαμος, -άμου (nom commun) (m)''' : chambre.&lt;br&gt;
'''θάλασσα, -ης (nom commun) (f)''' : mer.&lt;br&gt; 
'''θάλαττα, -ης (nom commun) (f)''' : Forme attique de ''θάλασσα''.&lt;br&gt; 
'''θάμϐος, -ους (nom commun) (n)''' : stupeur.&lt;br&gt;
'''θανατηφόρος, -ος, -ον (adjectif)''' : mortifère.&lt;br&gt; 
'''θάνατος, -άτου (nom commun) (m)''' : mort.&lt;br&gt; 
'''θανάτωσις, -ώσεως (nom commun) (f)''' : .&lt;br&gt;  
'''θανατῶ (verbe)''' : .&lt;br&gt;
'''θανών, -ών, -όν (adjectif)''' : mort.&lt;br&gt;
'''θάπτω (verbe)''' : enterrer.&lt;br&gt;
'''θαυμάζω (verbe)''' : être stupéfait.&lt;br&gt;
'''θαῦμα, -ύατος (nom commun) (n)''' : objet d’admiration ou d’étonnement ; merveille.&lt;br&gt;
'''θαυμαστός, -ή, -όν (adjectif)''' : merveilleux.&lt;br&gt; 
'''θαυματουργία, -ας (nom commun) (f)''' : tour de force ; création de merveilles.&lt;br&gt;
'''θαυματουργός, -ός, -όν (adjectif)''' : Qui crée des merveilles.&lt;br&gt; 
'''θαυματουργός, -οῦ (nom commun) (m)''' : créateur de merveilles.&lt;br&gt;
'''θαυματουργῶ (verbe)''' : créer des merveilles.&lt;br&gt;
'''θεά, -ᾶς (nom commun) (f)''' : déesse.&lt;br&gt;
'''θέα, -ας (nom commun) (f)''' : contemplation.&lt;br&gt; 
'''θέαμα, -άματος (nom commun) (n)''' : spectacle.&lt;br&gt; 
'''θεατής, -οῦ (nom commun) (m)''' : spectateur.&lt;br&gt;
'''θεατρικός, -ή, -όν (adjectif)''' : théâtral.&lt;br&gt;
'''θεατρικῶς (adverbe)''' : théâtralement.&lt;br&gt;
'''θεατρικώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''θεατρικός''.&lt;br&gt;
'''θεατρικώτερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''θεατρικός''.&lt;br&gt;
'''θεατρικώτατα, -, - (adverbe)''' : Superlatif de ''θεατρικῶς''.&lt;br&gt;
'''θεατρικώτερον, -, - (adverbe)''' : Comparatif de ''θεατρικῶς''.&lt;br&gt; 
'''θέατρον, -ου (nom commun) (n)''' : théâtre.&lt;br&gt; 
'''θεατρινισμός, -οῦ (nom commun) (m)''' : .&lt;br&gt;
'''θεατρινίστικος, -η, -ον (adjectif)''' : .&lt;br&gt; 
'''θεατρίνος, -ου (nom commun) (m)''' : acteur.&lt;br&gt;	
'''θέημα, -ήματος (nom commun) (n)''' : Forme ionienne de ''θέαμα''.&lt;br&gt; 
'''θέητρον, -ου (nom commun) (n)''' : Forme ionienne de ''θέατρον''.&lt;br&gt;
'''θεῖα, -ίας (nom commun) (f)''' : tante.&lt;br&gt; 
'''θεῖον, -ίου (nom commun) (m)''' : soufre ; fumée de soufre.&lt;br&gt;
'''θεῖος, -ίου (nom commun) (m)''' : oncle.&lt;br&gt; 
'''θέειος, -ίου (nom commun) (m)''' : Forme homérique de ''θεῖος''.&lt;br&gt; 
'''θεήϊος, -ΐου (nom commun) (m)''' :  Forme  de ''θεῖος''.&lt;br&gt;
'''-θέτης, -ου (suffixe) (m)''' :  .&lt;br&gt;
'''θέλγω (verbe)''' : fasciner.&lt;br&gt;
'''θέμα, -τος (nom commun) (n)''' : Dépôt, ce qui est placé, posé ou déposé. Endroit où l’on pose ou place quelque chose. .&lt;br&gt;
'''θεματίζω (verbe)''' : déposer.&lt;br&gt;
'''θεματίτης, -ου (nom commun) (m)''' : dépositaire.&lt;br&gt;
'''θεματικός, -ή, -όν (adjectif)''' : thématique.&lt;br&gt; 
'''θέμις, -τος (nom commun) (f)''' : loi divine ou morale.&lt;br&gt; 
'''θέογνις, -δος (nom commun) (m)''' : .&lt;br&gt;
'''θεός, -οῦ (nom commun) (m)''' : dieu.&lt;br&gt;
'''θεραπεία, -ας (nom commun) (f)''' : soin.&lt;br&gt; 
'''θεραπευτήριον, -ίου (nom commun) (n)''' : sanatorium.&lt;br&gt; 
'''θεραπευτής, -οῦ (nom commun) (m)''' : soignant.&lt;br&gt; 
'''θεραπευτικός, -ή, -όν  (adjectif)''' : attentif, serviable ; curatif.&lt;br&gt;
'''θεραπεύω (verbe)''' : soigner ; prendre soin de.&lt;br&gt;
'''θεράπων, -οντος (nom commun) (m)''' : serviteur.&lt;br&gt; 
'''θερμόν, -οῦ (nom commun) (n)''' : chaleur.&lt;br&gt; 
'''θερμός, -ή, -όν (adjectif)''' : chaud.&lt;br&gt; 
'''θερμότατος, -άτη, -ότατον (adjectif)''' : Superlatif de ''θερμός''.&lt;br&gt;
'''θερμότερος, -έρη, -ότατον (adjectif)''' : Comparatif de ''θερμός''.&lt;br&gt;
'''θερμῶς (adverbe)''' : chaudement.&lt;br&gt; 
'''θέρος, -ους (nom commun) (n)''' : été.&lt;br&gt; 
'''θέρω (verbe)''' : chauffer.&lt;br&gt;
'''θέσις, -εως (nom commun) (f)''' : .&lt;br&gt;
'''θεσμός, -οῦ (nom commun) (m)''' : (Primitivement) Toute loi ou institution établie par les dieux, institution sacrée, rite, coutume antique. Loi divine ou naturelle, par opposition à la loi écrite. (Par extension) Loi faite par les hommes, loi écrite.&lt;br&gt;
'''θεσμοθέτης, -ου (nom commun) (m)''' : parlementaire.&lt;br&gt; 
'''θεσμοθετεῖον, -ίου (nom commun) (n)''' : parlement.&lt;br&gt;
'''θεύς, -έως (nom commun) (m)''' :  Forme dorienne de ''θεός''.&lt;br&gt;
'''θεῶμαι (verbe)''' : Regarder, contempler (le plus souvent avec étonnement ou admiration), admirer. Contempler en esprit. Voir clairement. Être spectateur. Revoir, passer en revue, examiner.&lt;br&gt;
'''θεώρημα, -ήματος (nom commun) (n)''' : Spectacle, fête ; règle, principe, objet d'étude ou de méditation ; contemplation, recherche.&lt;br&gt;
'''θεωρητικός, -ή, -όν (adjectif)''' : théorique.&lt;br&gt;
'''θεωρητικῶς (adverbe)''' : théoriqument.&lt;br&gt;
'''θεωρητικώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''θεωρητικός''.&lt;br&gt;
'''θεωρητικώτερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''θεωρητικός''.&lt;br&gt;
'''θεωρητικώτατα, -, - (adverbe)''' : Superlatif de ''θεωρητικῶς''.&lt;br&gt;
'''θεωρητικώτερον, -, - (adverbe)''' : Comparatif de ''θεωρητικῶς''.&lt;br&gt; 
'''θεωρία, -ας (nom commun) (f)''' : Observation, vue, action de voir. Spectacle, ce qui est vu. Mission diplomatique. État de spectateur, audience.&lt;br&gt;
'''θεωρός, -οῦ (nom commun) (m)''' : Spectateur, observateur.&lt;br&gt;	
'''θεωρῶ (verbe)''' : Observer, examiner, contempler. Inspecter, passer en revue. Contempler. (Figuré) Contempler par l’intelligence.&lt;br&gt; 
'''θέω (verbe)''' : courir.&lt;br&gt; 
'''θήϊος, -ΐου (nom commun) (m)''' : Forme éolienne de ''θεῖος''.&lt;br&gt;
'''θήκη, -ης (nom commun) (f)''' : Boîte, coffre. Cercueil, tombeau.&lt;br&gt;  
'''θήλεια, - (nom commun) (f)''' : .&lt;br&gt; 
'''θηλυκός, -ή, -όν (adjectif)''' : féminin.&lt;br&gt; 
'''θῆλυ, -ήλεας (nom commun) (f)''' : femelle.&lt;br&gt;  
'''θῆλυς, -ήλεια, -ῆλυ (adjectif)''' : femelle.&lt;br&gt;
'''θηλύτης, -τος (nom commun) (f)''' : féminité.&lt;br&gt;
'''θηλῶ (verbe)''' : .&lt;br&gt;
'''θῆμα, -ήματος (nom commun) (n)''' : tombe.&lt;br&gt;
'''θήρα, -ας (nom commun) (f)''' : chasse.&lt;br&gt;
'''θήραμα, -άματος (nom commun) (n)''' : proie.&lt;br&gt;
'''θηρευτής, -οῦ (nom commun) (m)''' : chasseur.&lt;br&gt;
'''θηρευτικός, -ή, -όν (adjectif)''' : de chasse.&lt;br&gt;
'''θηριότης, -τας (nom commun) (f)''' : monstruosité.&lt;br&gt;
'''θηριώδης, -ης, -ες (adjectif)''' : monstrueux.&lt;br&gt;
'''θηριωδία, -ας (nom commun) (f)''' : monstruosité.&lt;br&gt;
'''θηρίον, -ου (nom commun) (n)''' : animal sauvage.&lt;br&gt;
'''θήρ, -ός (nom commun) (m)''' : bête sauvage.&lt;br&gt;
'''θηρῶ (verbe)''' : chasser.&lt;br&gt;
'''θησαυρός, -οῦ (nom commun) (m)''' : trésor.&lt;br&gt;
'''θῆσσα, -ήσσα (nom commun) (f)''' : serve.&lt;br&gt;
'''θής, -τός (nom commun) (m)''' : serf.&lt;br&gt;
'''θῆτα (nom commun) (n)''' : thêta.&lt;br&gt;
'''θητεία, -ας (nom commun) (f)''' : service.&lt;br&gt; 
'''θητεύω (verbe)''' : asservir.&lt;br&gt;
'''θῆττα, -ήττα (nom commun (f)''' : Forme attique de ''θῆσσα''.&lt;br&gt;
'''θιγγάνω (verbe)''' : toucher.&lt;br&gt;
'''θιός, -οῦ (nom commun) (m)''' : Forme béotienne et arcado-chypriote de ''θεός''.&lt;br&gt;
'''θλάσις, -εως (nom commun) (f)''' : contusion.&lt;br&gt;
'''θλιϐή, -ῆς (nom commun) (f)''' : .&lt;br&gt;
'''θλίϐω (verbe)''' : Presser ; compresser, réduire. Oppresser, attrister.&lt;br&gt; 
'''θλῖψις, -ίψεως (nom commun) (f)''' : Pression, compression ; oppression.&lt;br&gt; 
'''θλίψις, -εως (nom commun) (f)''' : chagrin, tristesse.&lt;br&gt;
'''θλῶ (verbe)''' : étendre.&lt;br&gt; 
'''θναίσκω (verbe)''' : Forme éolienne de ''θνῄσκω''.&lt;br&gt; 
'''θνᾴσκω (verbe)''' : Forme dorienne de ''θνῄσκω''.&lt;br&gt; 
'''θνῄσκω (verbe)''' : mourir.&lt;br&gt;
'''θοάζω (verbe)''' : se hâter.&lt;br&gt;
'''θολερός, -ά, -όν (adjectif)''' : sale.&lt;br&gt;
'''θολερώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''θολερός''.&lt;br&gt;
'''θολερώτερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''θολερός''.&lt;br&gt;
'''θολερῶς (adverbe)''' : salement.&lt;br&gt;
'''θοός, -ή, -όν (adjectif)''' : rapide.&lt;br&gt;
'''θόρυϐος, -ύϐου (nom commun) (m)''' : bruit.&lt;br&gt;
'''θορυϐωδέστατος, -άτη, -έστατον (adjectif)''' : Superlatif de ''θορυϐώδης''.&lt;br&gt;
'''θορυϐωδέστερος, -έρα, -έστερον (adjectif)''' : Comparatif de ''θορυϐώδης''.&lt;br&gt;
'''θορυϐώδης, -ης, -ες (adjectif)''' : bruyant.&lt;br&gt;
'''θορυϐώδως (adverbe)''' : bruyamment.&lt;br&gt;
'''θοῶς (adverbe)''' : rapidement.&lt;br&gt; 
'''θοώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''θοός''.&lt;br&gt;
'''θοώτερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''θοός''.&lt;br&gt;
'''θρᾴκιος, -ος, -ον (adjectif)''' : thrace.&lt;br&gt;
'''θρασέως (adverbe)''' : audacieusement.&lt;br&gt; 
'''θράσος, -ους (nom commun) (n)''' : audace.&lt;br&gt;
'''θρασύς, -εῖα, -ύ (adjectif)''' : audacieux.&lt;br&gt;
'''θρασύτατος, -άτη, -ύτατον (adjectif)''' : Superlatif de ''θρασύς''.&lt;br&gt;
'''θρασύτερος, -έρα, -ύτερον (adjectif)''' : Comparatif de ''θρασύς''.&lt;br&gt;
'''θρασύτης, -τητος (nom commun) (f)''' : audace (qualité).&lt;br&gt;
'''θρῄκιος, -ος, -ον (adjectif)''' : Forme poétique de ''θρᾴκιος''.&lt;br&gt;
'''θρῆνος, -ήνου (nom commun) (m)''' : lamentation.&lt;br&gt;
'''θρηνῶ (verbe)''' : se lamenter.&lt;br&gt; 
'''θρησκεία, -ας (nom commun) (n)''' : religion.&lt;br&gt;
'''θρησκεύω (verbe)''' : observer religieusement.&lt;br&gt;
'''θρῆσκος, -ήσκα, -ῆσκον (adjectif)''' : pieux.&lt;br&gt;
'''θρίαμϐος, -άμϐου (nom commun) (m)''' : triomphe.&lt;br&gt; 
'''θρίξ, τριχός (nom commun) (f)''' : poil.&lt;br&gt; 
'''θρίψ, -πός (nom commun) (m)''' : petite vrillette. (Au figuré) avare.&lt;br&gt; 
'''θροέω (verbe)''' : froisser.&lt;br&gt; 
'''θρόμϐος, -ου (nom commun) (m)''' : Grumeau, caillot.&lt;br&gt;
'''θρόνος, -ου (nom commun) (m)''' : siège élevé.&lt;br&gt;
'''θρόος, -ου (nom commun) (m)''' : froissement.&lt;br&gt;
'''θροῦς, -οῦ (nom commun) (m)''' : rumeur.&lt;br&gt;
'''θροῶ (verbe)''' : froisser.&lt;br&gt;
'''θρυλικός, -ή -όν (adjectif)''' : légendaire.&lt;br&gt; 
'''θρῦλος, -ύλου (nom commun) (f)''' : légende. (Récit populaire, plus ou moins fabuleux.)&lt;br&gt;
'''θρύπτω (verbe)''' : casser ; morceler.&lt;br&gt;
'''θυγάτηρ, -ρός (nom commun) (f)''' : fille. (descendante)&lt;br&gt; 
'''θύλακος, -άκου (nom commun) (m)''' : bourse ; sac.&lt;br&gt;
'''θῦμα, -ύματος (nom commun) (n)''' : victime.&lt;br&gt;
'''θυμίαμα, -άματος (nom commun) (n)''' : encens.&lt;br&gt;
'''θυμιάω (verbe)''' : brûler.&lt;br&gt;
'''θυμίημα, -ήματος (nom commun) (n)''' : Forme ionienne de ''θυμίαμα''.&lt;br&gt;
'''θυμολέων, -ων, -ον (adjectif)''' : Courageux ; cœur-de-lion.&lt;br&gt;
'''θυμός, -οῦ (nom commun) (m)''' : Âme, souffle de vie. Esprit, cœur. Courage.&lt;br&gt;
'''θύμος, -ου (nom commun) (m)''' : thym.&lt;br&gt;
'''θύννος, -ου (nom commun) (m)''' : thon.&lt;br&gt;
'''θύρα, -ας (nom commun) (f)''' :  Porte, battant ; ouverture, entrée.&lt;br&gt;
'''θυραωρός, -οῦ (nom commun) (m)''' : Forme homérique de ''θυρωρός''.&lt;br&gt;
'''θυρωρεῖον, -ίου (nom commun) (n)''' : conciergerie.&lt;br&gt;
'''θυρωρός, -οῦ (nom commun (m) : concierge.&lt;br&gt;
'''θύρσος, -ου (nom commun) (m)''' : thyrse.&lt;br&gt;
'''θύρωμα, -ώματος (nom commun) (n)''' : portail.&lt;br&gt;
'''θυσία, -ας (nom commun) (f)''' : sacrifice.&lt;br&gt;
'''θυσιάζω (verbe)''' : sacrifier.&lt;br&gt;
'''θωή, -ῆς (nom commun) (f)''' : .&lt;br&gt;
'''θῶμα, -ώματος (nom commun) (n)''' : Forme ionienne de ''θαῦμα''.&lt;br&gt;
'''θωμαστός, -ή, -όν (adjectif)''' : Forme ionienne de ''θαυμαστός''.&lt;br&gt; 
'''θῶμιγξ, -ώμιγγος (nom commun) (f)''' : Corde ; ficelle.&lt;br&gt;
'''θωπεία, -ας (nom commun) (f)''' : caresse.&lt;br&gt;
'''θώπευμα, -ύματος (nom commun) (n)''' : caresse.&lt;br&gt;
'''θωπευτικός, -ή, -όν (adjectif)''' : caressant.&lt;br&gt;
'''θωπεύω (verbe)''' : caresser.&lt;br&gt;     
'''θώς, -ός (nom commun) (m/f)''' : chacal.&lt;br&gt;
'''θώϋμα, -τος (nom commun) (n)''' : Autre forme ionienne de ''θαῦμα''.&lt;br&gt;
'''θώψ, -πός (nom commun) (m)''' : adulateur.&lt;br&gt;
'''Θαδδαῖος, -ίου (nom propre) (m)''' : Thadée.&lt;br&gt;
'''Θαΐς, -δος (nom propre) (f)''' : [[wikt:Thaïs|Thaïs]].&lt;br&gt;
'''Θάλεια, -ας (nom propre) (f)''' : Thalie. (muse)&lt;br&gt;
'''Θαλῆς, -άλεω (nom propre) (m)''' : Thalès.&lt;br&gt;
'''Θαλία, -ας (nom propre) (f)''' : Thalie. (Charite)&lt;br&gt;
'''Θάνατος, -άτου  (nom propre) (m)''' : [[wikt:Thanatos|Thanatos]].&lt;br&gt;
'''Θαῦμας, -ύμαντος (nom propre) (m)''' : Thaumas.&lt;br&gt;
'''Θάψος, -ου (nom propre) (f)''' : Thapsus. (ville de Tunisie)&lt;br&gt;
'''Θέμις, -δος (nom propre) (f)''' : [[wikt:Thémis|Thémis]].&lt;br&gt;
'''Θεμιστοκλῆς, -έους (nom propre) (m)''' : Thémistocle.&lt;br&gt;
'''Θέτις, -δος (nom propre) (f)''' : [[wikt:Thétis|Thétis]].&lt;br&gt;
'''Θέογνις, -δος (nom propre) (m)''' : Théognis.&lt;br&gt;
'''Θεοδοσία, -ας (nom propre) (f)''' : Théodosia.&lt;br&gt;
'''Θεοδόσιος, -ίου (nom propre) (m)''' : Théodose.&lt;br&gt;
'''Θεόδουλος, -ύλος (nom propre) (m)''' : Théodule.&lt;br&gt; 
'''Θεόδωρος, -ώρου (nom propre) (m)''' : Théodore.&lt;br&gt;
'''Θεόπομπος, -όμπου (nom propre) (m)''' : Théopompe.&lt;br&gt;
'''Θεός, -οῦ (nom propre) (m)''' : Dieu.&lt;br&gt;
'''Θεοφάνης, -ου (nom propre) (m)''' : Théophane.&lt;br&gt;
'''Θεοφανία, -ας (nom propre) (f)''' : Théophanie.&lt;br&gt;
'''Θεόφιλος, -ίλου (nom propre) (m)''' : Théophile.&lt;br&gt;
'''Θεόφραστος, -άστου (nom propre) (m)''' : Théophraste.&lt;br&gt;
'''Θερμοπύλαι, -ῶν (nom propre) (f)''' : Thermopyles.&lt;br&gt;
'''Θέσπις, -εως (nom propre) (m)''' : Thespsis.&lt;br&gt;
'''Θεσσαλία, -ας (nom propre) (f)''' : Thessalie.&lt;br&gt;  
'''Θεσσαλικός, -ή, -όν (adjectif)''' : thessalien.&lt;br&gt;   
'''Θεσσαλίς, -δος (nom commun) (f)''' : Thessalienne.&lt;br&gt;  
'''Θεσσαλονίκη, -ης (nom propre) (f)''' : Thessalonique.&lt;br&gt;  
'''Θεσσαλός, -οῦ (nom commun) (m)''' : Thessalien.&lt;br&gt; 
'''Θευδᾶς, -ᾶ (nom propre) (m)''' : Theudas.&lt;br&gt;
'''Θευδέριχος, -ίχου (nom propre) (m)''' : Théodoric.&lt;br&gt;
'''Θῆϐαι, -ῶν (nom propre) (f)''' : Thèbes.&lt;br&gt;
'''Θησεύς, -έως (nom propre) (m)''' : Thésée.&lt;br&gt;
'''Θίνη, -ης (nom propre) (f)''' : Synonyme de ''Σίνη''.&lt;br&gt;
'''Θιός, -οῦ (nom propre) (m)''' : Forme béotienne de ''Ζεύς''.&lt;br&gt;
'''Θίσϐη, -ης (nom propre) (f)''' : Thisbé.&lt;br&gt; 
'''Θόας, -αντος (nom propre) (m)''' : Thoas.&lt;br&gt;
'''Θούθμωσις, -ώσιδος (nom propre) (m)''' : Thoutmôsis.&lt;br&gt;
'''Θουκυδίδης, -ου (nom propre) (m)''' : Thucydide.&lt;br&gt;
'''Θόωσα, -ης (nom propre) (f)''' : Thoosa.&lt;br&gt;
'''Θρᾴκη, -ης  (nom propre) (f)''' : Thrace.&lt;br&gt;
'''Θρᾷξ, -ᾳκός (nom propre) (m)''' : Thrax.&lt;br&gt;
'''Θρᾷξ, -ᾳκός (nom commun) (m)''' : Thrace.&lt;br&gt;
'''Θρᾷσσα, -ᾴσσης (nom commun) (f)''' : Thrace.&lt;br&gt;
'''Θρᾷττα, -ᾴττης (nom commun) (f)''' : Forme attique de ''Θρᾷσσα''.&lt;br&gt;
'''Θρῄκη, -ης  (nom propre) (f)''' : Forme poétique de ''Θρᾴκη''.&lt;br&gt;
'''Θρῇξ, -ῃκός (nom commun) (m)''' : Forme poétique de ''Θρᾷξ''.&lt;br&gt;
'''Θρῇσσα, -ῄσσης (nom commun) (f)''' : Forme poétique de ''Θρᾷσσα''.&lt;br&gt; 
'''Θωθ (nom propre) (m)''' : Thot.&lt;br&gt;
'''Θωμᾶς, -ᾶ (prénom) (m)''' : Thomas.&lt;br&gt;

==Ι== 
'''ἴαμϐος, -άµϐου (nom commun) (m)''' : ïambe.&lt;br&gt; 
'''ἰάομαι (verbe)''' : soigner.&lt;br&gt;
'''ἱαρός, -ά, -όν (adjectif)''' : Forme dorienne de ''ἱερός''.&lt;br&gt; 
'''ἴασις, -άσεως (nom commun) (f)''' : cure ; remède.&lt;br&gt;
'''ἴασπις, -δος (nom commun) (f)''' :  jaspe.&lt;br&gt;
'''ἰατήρ, -ῆρος (nom commun) (m)''' :  guérisseur.&lt;br&gt;
'''ἰατός, -ός, -όν (adjectif)''' : curable ; soignable.&lt;br&gt;
'''ἰατρεία, -ας (nom commun) (f)''' : médecine.&lt;br&gt;
'''ἰατρικός, -ή, -όν  (adjectif)''' : médical.&lt;br&gt;
'''ἰατρικῶς (adverbe)''' : médicalement.&lt;br&gt;
'''ἰατρικώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''ἰατρικός''.&lt;br&gt;
'''ἰατρικώτερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''ἰατρικός''.&lt;br&gt;
'''ἰατρικώτατα, -, - (adverbe)''' : Superlatif de ''ἰατρικῶς''.&lt;br&gt;
'''ἰατρικώτερον, -, - (adverbe)''' : Comparatif de ''ἰατρικῶς''.&lt;br&gt; 
'''ἰατρός, -οῦ (nom commun) (m)''' : médecin.&lt;br&gt; 
'''ἱϐίσκος, -ου (nom commun) (m)''' : guimauve.&lt;br&gt; 
'''ἴγνης, -τος (nom commun) (m)''' : indigène.&lt;br&gt; 
'''ἰγνύα, -ας (nom commun) (f)''' : jarret.&lt;br&gt;
'''ἰγνύη, -ης (suffixe) (f)''' : Forme hommérique et ionienne de ''ἰγνύα''.&lt;br&gt;
'''ἰγνύς, -ος (nom commun) (f)''' : Forme de ''''.&lt;br&gt;
'''ἴκτις, -δος (nom commun) (f)''' : martre.&lt;br&gt;
'''ἱρός, -ά, -όν (adjectif)''' : Forme ionienne de ''ἱερός''.&lt;br&gt;
'''ἷρος, -α, -ον (adjectif)''' : Forme éolienne de ''ἱερός''.&lt;br&gt;
'''-ία, -ας (suffixe) (f)''' : marque nominale.&lt;br&gt;
'''-ικός, -ή, -όν (suffixe)''' : marque adjectivale.&lt;br&gt;
'''-ικῶς (adverbe)''' : Forme adverbiale de ''-ικός''.&lt;br&gt;
'''-ικώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''-ικός''.&lt;br&gt;
'''-ικώτερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''-ικός''.&lt;br&gt;
'''-ικώτατα, -, - (adverbe)''' : Superlatif de ''-ικῶς''.&lt;br&gt;
'''-ικώτερον, -, - (adverbe)''' : Comparatif de ''-ικῶς''.&lt;br&gt; 
'''-ίσκος, -ου (suffixe)''' : diminutif.&lt;br&gt;
'''-ιμος, -ος, -ον (suffixe)''' : .&lt;br&gt;
'''ἱαρεύς, -έως (nom commun) (m)''' : Forme dorienne de ''ἱερεύς''.&lt;br&gt;
'''ἰαῦ (interjection)''' : hé, ho.&lt;br&gt;
'''ἰαύω (verbe)''' : Dormir, se reposer.&lt;br&gt;
'''ἶϐις, ἴϐιδος  (nom commun) (f)''' : ibis.&lt;br&gt;
'''ἰδίᾳ (adverbe)''' : en particulier, séparément, à part.&lt;br&gt;
'''ἰδιοσυγκρασία, -ας (nom commun) (f)''' : tempérament particulier.&lt;br&gt;
'''ἴδιος, -ία, -ιον (adjectif)''' : propre, particulier.&lt;br&gt;
'''ἰδιοφυής, -ής, -ές (adjectif)''' : génial.&lt;br&gt;
'''ἰδιοφυΐα, -ας (nom commun) (f)''' : génie (talent d’une personne).&lt;br&gt; 
'''ἰδιώτης, -ου (nom commun) (m)''' : individu, plébéien ; ignorant.&lt;br&gt; 
'''ἰδίω (verbe)''' : suer.&lt;br&gt; 
'''ἵδρυμα, -ύματος (nom commun) (n)''' : institution.&lt;br&gt;
'''ἵδρυσις, -ύσεως (nom commun) (n)''' : fondation.&lt;br&gt;
'''ἱδρύω (verbe)''' : .&lt;br&gt; 
'''ἱδρώς, -ῶτος (nom commun) (m)''' : sueur ; sudation. Sève ; jus, moisissure.&lt;br&gt; 
'''ἱέραξ, -κου (nom commun) (m)''' : faucon.&lt;br&gt;
'''ἱερατεία, -ας (nom commun) (f)''' : tempérament particulier.&lt;br&gt; 
'''ἱεράτευμα, -ύματος (nom commun) (n)''' : .&lt;br&gt;
'''ἱερατεύω (verbe)''' : .&lt;br&gt;
'''ἱερατικός, -ή, -όν (adjectif)''' : sacerdotal.&lt;br&gt;
'''ἱερατικῶς (adverbe)''' : sacerdotalement.&lt;br&gt;
'''ἱερατικώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''ἱερατικός''.&lt;br&gt;
'''ἱερατικώτερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''ἱερατικός''.&lt;br&gt;
'''ἱέρεια, -ίας (nom commun) (f)''' : prêtresse.&lt;br&gt; 
'''ἱερεύς, -έως (nom commun) (m)''' : prêtre.&lt;br&gt; 
'''ἱεροκῆρυξ, -ήρυκος (nom commun) (m)''' : prêcheur.&lt;br&gt;
'''ἱερόν, -οῦ (nom commun) (n)''' : sanctuaire.&lt;br&gt;
'''ἱεροσυλία, -ας (nom commun) (m)''' : sacrilège (action).&lt;br&gt;
'''ἱερόσυλος, -ύλου (nom commun) (m)''' : sacrilège (personne).&lt;br&gt;
'''ἱερός, -ά, -όν (adjectif)''' : sacré.&lt;br&gt;
'''ἱερῶς (adverbe)''' : sacrément.&lt;br&gt;
'''ἱερώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''ἱερός''.&lt;br&gt;
'''ἱερώτερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''ἱερός''.&lt;br&gt;
'''ἱεροσύνη, -ης (nom commun) (f)''' : sacerdoce.&lt;br&gt; 
'''ἱερῶ (verbe)''' : .&lt;br&gt;
'''ἰή (interjection)''' : Youpi, hourra. Aïe.&lt;br&gt;
'''ἷημι (verbe)''' : envoyer, lancer.&lt;br&gt;
'''ἰητρός, -οῦ (nom commun) (m)''' : Forme homérique et ionienne de ''ἰατρός''.&lt;br&gt;
'''ἰθαγενής, -ής, -ές (adjectif)''' : indigène.&lt;br&gt;
'''ἰθακήσιος, -ος, -ον (adjectif)''' : ithacien.&lt;br&gt;
'''ἰθέως (adverbe)''' : Forme homérique et ionienne de ''εὐθέως''.&lt;br&gt;
'''ἰθύς, -εῖα, -ύ (adjectif)''' : Forme homérique et ionienne de ''εὐθύς''.&lt;br&gt;
'''ἰθύτατος, -άτη, -ύτατον (adjectif)''' : Superlatif de ''ἰθύς''.&lt;br&gt;
'''ἰθύτερος, -έρα, -ύτερον (adjectif)''' : Comparatif de ''ἰθύς''.&lt;br&gt;
'''ἰθύφαλλος, -άλλου (nom commun) (m)''' : ithyphalle.&lt;br&gt;
'''ἱκεσία, -ας (nom commun) (f)''' : supplique.&lt;br&gt;  
'''ἱκετεύω (verbe)''' : supplier.&lt;br&gt;
'''ἱκέτις, -δος (nom commun) (f)''' : pèlerine.&lt;br&gt;
'''ἱκέτης, -ου (nom commun) (m)''' : pèlerin.&lt;br&gt;
'''ἴκκος, -ου (nom commun) (m/f)''' : Forme éolienne de ''ἵππος''.&lt;br&gt;
'''ἱκνέομαι (verbe)''' : aller à ; atteindre. Venir.&lt;br&gt;
'''ἴκρια, -ας (nom commun) (f)''' : .&lt;br&gt;  
'''ἴκριον, -ου (nom commun) (n)''' : échafaudage.&lt;br&gt;  
'''ἰκρίωμα, -ώματος (nom commun) (n)''' : échafaudage.&lt;br&gt; 
'''ἰκριῶ (verbe)''' : .&lt;br&gt; 
'''ἴκτις, -δος (nom commun) (f)''' : fouine.&lt;br&gt;
'''-ικός, -ή, -όν (adjectif)''' : -ique.&lt;br&gt;
'''-ικῶς (adverbe)''' : -ment.&lt;br&gt;
'''-ικώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''-ικός''.&lt;br&gt;
'''-ικώτερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''-ικός''.&lt;br&gt;
'''-ικώτατα, -, - (adverbe)''' : Superlatif de ''-ικῶς''.&lt;br&gt;
'''-ικώτερον, -, - (adverbe)''' : Comparatif de ''-ικῶς''.&lt;br&gt; 
'''ἵκω (verbe)''' : venir.&lt;br&gt;
'''ἵλαος, -ος, -ον (adjectif)''' : propice (en parlant des dieux). Gentil, aimable (en parlant des hommes).&lt;br&gt;
'''ἱλαρός, -ά, -όν (adjectif)''' : joyeux, riant.&lt;br&gt;
'''ἱλαρότης, -τος (nom commun) (f)''' : hilarité.&lt;br&gt; 
'''ἱλάσκομαι (verbe)''' : apaiser, calmer.&lt;br&gt; 
'''ἴλεξ, -κος (nom commun) (f)''' : houx.&lt;br&gt; 
'''ἰλιγγιωδέστατος, -άτη, -έστατον (adjectif)''' : Superlatif de ''ἰλιγγιώδης''.&lt;br&gt;
'''ἰλιγγιωδέστερος, -έρα, -έστερον (adjectif)''' : Comparatif de ''ἰλιγγιώδης''.&lt;br&gt;
'''ἰλιγγιώδης, -ης, -ες (adjectif)''' : vertigineux.&lt;br&gt;
'''ἰλιγγιωδῶς (adverbe)''' : vertigineusement.&lt;br&gt;
'''ἰλιγγιωδώτατα, -, - (adverbe)''' : Superlatif de ''ἰλιγγιωδῶς''.&lt;br&gt;
'''ἰλιγγιωδώτερον, -, - (adverbe)''' : Comparatif de ''ἰλιγγιωδῶς''.&lt;br&gt;
'''ἴλιγγος, -ίγγου (nom commun) (m)''' : vertige.&lt;br&gt;
'''ἰλλυρικός, -ή, -όν (adjectif)''' : illyrien.&lt;br&gt;
'''ἰλλυρικῶς (adverbe)''' : illyriennement.&lt;br&gt;
'''ἰλλυρικώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''ἰλλυρικός''.&lt;br&gt;
'''ἰλλυρικώτερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''ἰλλυρικός''.&lt;br&gt;
'''ἰλλυρικώτατα, -, - (adverbe)''' : Superlatif de ''ἰλλυρικῶς''.&lt;br&gt;
'''ἰλλυρικώτερον, -, - (adverbe)''' : Comparatif de ''ἰλλυρικῶς''.&lt;br&gt; 
'''ἴλλω (verbe)''' : avoir le vertige.&lt;br&gt;
'''ἰλύς, -ος (nom commun) (f)''' : Boue, sédiment. Impureté.&lt;br&gt;
'''ἱμάς, -άντος	(nom commun) (m)''' : courroie.&lt;br&gt;
'''ἱμάσσω (verbe)''' : fouetter, flageller ; frapper.&lt;br&gt;
'''ἱμάτιον, -ίου (nom commun) (n)''' : himation.&lt;br&gt;
'''ἵμερος, -έρου (nom commun) (n)''' : désir amoureux.&lt;br&gt;
'''ἱμῶ (verbe)''' : .&lt;br&gt;
'''ἰξευτής, -οῦ (nom commun) (m)''' : oiseleur.&lt;br&gt;
'''ἰξεύω (verbe)''' : oiseler.&lt;br&gt;
'''ἰξός, -οῦ (nom commun) (m)''' : Glu ; gui.&lt;br&gt;
'''ἰός, -οῦ (nom commun) (m)''' : Venin ; flèche.&lt;br&gt; 
'''ἰουδαῖος, -ία, -ῖον (adjectif)''' : juif.&lt;br&gt;
'''ἴου (interjection)''' : beurk.&lt;br&gt;
'''ἰπνός, -οῦ (nom commun) (m)''' : four.&lt;br&gt;
'''ἱππάζομαι (verbe)''' : chevaucher.&lt;br&gt;
'''ἱππαλεκτρυών, -όνος (nom commun) (m/f)''' : hippalectryon.&lt;br&gt;
'''ἱππασία, -ας (nom commun) (f)''' : chevauchée.&lt;br&gt;
'''ἱππαστί (adverbe)''' : à cheval.&lt;br&gt;
'''ἱππεύς, -έως (nom commun) (m)''' : cavalier.&lt;br&gt;
'''ἱππευτής, -οῦ (nom commun) (m)''' : cavalier.&lt;br&gt;
'''ἱππεύω (verbe)''' : monter à cheval.&lt;br&gt;
'''ἱππικός, -ή, -όν (adjectif)''' : équin.&lt;br&gt;
'''ἱππικῶς (adverbe)''' : équinement.&lt;br&gt;
'''ἱππικώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''ἱππικός''.&lt;br&gt;
'''ἱππικώτερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''ἱππικός''.&lt;br&gt;
'''ἱππικώτατα, -, - (adverbe)''' : Superlatif de ''ἱππικῶς''.&lt;br&gt;
'''ἱππικώτερον, -, - (adverbe)''' : Comparatif de ''ἱππικῶς''.&lt;br&gt; 
'''ἵππος, -ου (nom commun) (m/f)''' : cheval, jument.&lt;br&gt;
'''ἱππόκαμπος, -άμπου (nom commun) (m)''' : hippocampe.&lt;br&gt; 
'''ἱπποσύνη, -ης (nom commun) (f)''' : Équitation. (Militaire) Cavalerie.&lt;br&gt;
'''ἱπποπόταμος, -άμου (nom commun) (m)''' : hippopotame.&lt;br&gt;
'''ἱππο- (préfixe)''' : relatif au cheval.&lt;br&gt;
'''ἱππότης, -ου (nom commun) (m)''' : cavalier.&lt;br&gt;
'''ἴορκος, -όρκος (nom commun) (m)''' : Forme de ''δορκάς''.&lt;br&gt;
'''ἰός, -οῦ (nom commun) (m)''' : Flèche ; venin.&lt;br&gt;
'''ἰοῦ (interjection)''' : hourra.&lt;br&gt; 
'''ἱρεύς, -έως (nom commun) (m)''' : Forme ionienne de ''ἱερεύς''.&lt;br&gt; 
'''ἵρηξ, -κος (nom commun) (m)''' : Forme ionienne de ''ἱέραξ''.&lt;br&gt;
'''ἶρις, ἴριδος (nom commun) (f)''' : (anatomie) iris (météorologie) arc-en-ciel.&lt;br&gt;
'''ἰσαίτατα, -, - (adverbe)''' : Superlatif de ''ἴσως''.&lt;br&gt;
'''ἰσαίτερον, -, - (adverbe)''' : Comparatif de ''ἴσως''.&lt;br&gt;
'''ἴσατις, -δος (nom commun) (f)''' : guède.&lt;br&gt;
'''ἰσημερία, -ας (nom commun) (f)''' : équinoxe.&lt;br&gt;
'''ἰσορροπία, -ας (nom commun) (f)''' : équilibre.&lt;br&gt;
'''ϝίσϝος, -η, -ον (adjectif)''' : Forme arcado-chypriote et crétoise de ''ἴσος''.&lt;br&gt;
'''ἰσθμός, -οῦ (nom commun) (m)''' : isthme.&lt;br&gt; 
'''ἴσοξ, -κου (nom commun) (m)''' : brochet.&lt;br&gt; 
'''ἶσος, -η, -ον (adjectif)''' : Forme homérique de ''ἴσος''.&lt;br&gt;
'''ἴσος, -η, -ον (adjectif)''' : égal.&lt;br&gt;
'''ἴς, -νός (nom commun) (f)''' : force, puissance ; muscle.&lt;br&gt;
'''ἵστημι (verbe)''' : Placer ; mettre debout.&lt;br&gt; 
'''ἱστίον,  -ου (nom commun) (n)''' : os de la hanche.&lt;br&gt; 
'''ἱστόρημα, -ήματος (nom commun) (n)''' : narration.&lt;br&gt; 
'''ἱστορία, -ας (nom commun) (f)''' : Enquête, examination ; observation, étude.&lt;br&gt;
'''ἱστορικός, -ή, -όν (adjectif)''' : D’enquête, bien informé.&lt;br&gt;
'''ἱστορῶ (verbe)''' : enquêter.&lt;br&gt;
'''ἱστός, -οῦ (nom commun) (m)''' : mât.&lt;br&gt; 
'''ἵστωρ, -ορος (nom commun) (m/f)''' : Individu sachant. Personne connaissant la loi. Juge.&lt;br&gt; 
'''ἰσχίον, -ου (nom commun) (n)''' : os de la hanche.&lt;br&gt; 
'''ἰσχνός, -ή, -όν (adjectif)''' : Desséché, sec. Maigre, grêle ; frêle.&lt;br&gt; 
'''ἰσχνότατα, -, - (adverbe)''' : Superlatif de ''ἰσχνῶς''.&lt;br&gt;
'''ἰσχνότερον, -, - (adverbe)''' : Comparatif de ''ἰσχνῶς''.&lt;br&gt;
'''ἰσχνότατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''ἰσχνός''.&lt;br&gt;
'''ἰσχνότερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''ἰσχνός''.&lt;br&gt;
'''ἰσχνῶς (adverbe)''' : maigrement.&lt;br&gt;
'''ἴσχω (verbe)''' : tenir.&lt;br&gt; 
'''ἴσως (adverbe)''' : également.&lt;br&gt;
'''ἰσαίτατος, -άτη, -ίτατον (adjectif)''' : Superlatif de ''ἴσος''.&lt;br&gt;
'''ἰσαίτερος, -έρα, -ίτερον (adjectif)''' : Comparatif de ''ἴσος''.&lt;br&gt;
'''ἰταλός, -οῦ (nom commun) (m)''' : Bouvillon, taurillon.&lt;br&gt; 
'''ἰταμός, -ή, -όν (adjectif)''' : effronté.&lt;br&gt; 
'''ἰταμότατα, -, - (adverbe)''' : Superlatif de ''ἰταμῶς''.&lt;br&gt;
'''ἰταμότερον, -, - (adverbe)''' : Comparatif de ''ἰταμῶς''.&lt;br&gt;
'''ἰταμότατος, -άτη, -ότατον (adjectif)''' : Superlatif de ''ἰταμός''.&lt;br&gt;
'''ἰταμότερος, -έρα, -ότερον (adjectif)''' : Comparatif de ''ἰταμός''.&lt;br&gt;
'''ἰταμότης, -ητος (nom commun) (f)''' : effronterie.&lt;br&gt;
'''ἰταμῶς (adverbe)''' : effrontément.&lt;br&gt;
'''-ίτης, -ου (suffixe) (m)''' : Suffixe nominal masculin.&lt;br&gt;
'''-ῖτις, -ίτιδος (suffixe) (f)''' : Suffixe nominal féminin.&lt;br&gt;
'''ἴυγξ, -γγος (nom commun) (f)''' : torcol.&lt;br&gt;
'''ἰύζω (verbe)''' : crier de peine ou de joie.&lt;br&gt;
'''ἴφυον, -ου (nom commun) (n)''' : .&lt;br&gt; 
'''ἰχθυοέστατος, -άτη, -έστατον (adjectif)''' : Superlatif de ''ἰχθυόεις''.&lt;br&gt;
'''ἰχθυοέστερος, -έρα, -ερον (adjectif)''' : Comparatif de ''ἰχθυόεις''.&lt;br&gt;
'''ἰχθυόεις, -εσσα, -εν (adjectif)''' : poissonneux.&lt;br&gt;
'''ἰχθύς, -ος (nom commun) (m)''' : poisson.&lt;br&gt; 
'''ἴχνος, -ους (nom commun) (n)''' : trace de pas.&lt;br&gt;   
'''ἰώϐηλος, -ήλου (nom commun) (m)''' : jubilé.&lt;br&gt;
'''ἰῶτα (nom commun) (n)''' : iota.&lt;br&gt;
'''ἰωτακισμός, -οῦ (nom commun) (m)''' : iotacisme.&lt;br&gt;
'''Ἰάκωϐος, -ώϐου (nom propre) (m)''' : Jacob, Jacques.&lt;br&gt;
'''Ἰαπετός, -οῦ (nom propre) (m)''' : Japet.&lt;br&gt;
'''Ἴασος, -άσου (nom propre) (f)''' : Iasos (ville).&lt;br&gt;
'''Ἰάσων, -ονος (nom propre) (m)''' : Jason. (chef des Argonautes)&lt;br&gt; 
'''Ἴδας, -α (nom propre) (m)''' : Idas.&lt;br&gt; 
'''Ἰδομενεύς, -έως (nom propre) (m)''' : Idoménée.&lt;br&gt;
'''Ἰάμϐλιχος, -ίχου (nom propre) (m)''' : Jamblique.&lt;br&gt;
'''Ἰαω (nom propre) (m)''' : Yahweh.&lt;br&gt;
'''Ἰϐηρία, -ας (nom propre) (m)''' : Ibérie.&lt;br&gt; 
'''Ἴϐηρ, -ος (nom commun) (m)''' : Ibère.&lt;br&gt;
'''Ἰγνάτιος, -ίου (nom propre) (m)''' : Ignace.&lt;br&gt;
'''Ἰεριχώ (nom propre) (f)''' : Jéricho.&lt;br&gt; 
'''Ἰερειχώ (nom propre) (f)''' : Forme alternative de ''Ἰεριχώ''.&lt;br&gt; 
'''Ἱερειχώ (nom propre) (f)''' : Forme alternative de ''Ἰεριχώ''.&lt;br&gt; 
'''Ἱεριχοῦς (nom propre) (f)''' : Forme alternative de ''Ἰεριχώ''.&lt;br&gt; 
'''Ἱεριχώ, -οῦς (nom propre) (f)''' : Forme alternative de ''Ἰεριχώ''.&lt;br&gt; 
'''Ἰέρνη, -ης (nom propre) (f)''' : Irlande.&lt;br&gt;
'''Ἱεροκλῆς, -έους (nom propre) (m)''' : Hiéroclès.&lt;br&gt;
'''Ἱεροσάλημα (nom propre) (f)''' : Forme alternative de ''Ἱερουσαλήμ''.&lt;br&gt;
'''Ἱεροσόλυμα (nom propre) (f/n)''' : Forme alternative de ''Ἱερουσαλήμ''.&lt;br&gt;
'''Ἱερουσαλήμ (nom propre) (f)''' : Jérusalem (ville).&lt;br&gt;
'''Ἰερουσαλήμ (nom propre) (f)''' : Forme alternative de ''Ἱερουσαλήμ''.&lt;br&gt;
'''Ἱερώνυμος, -ύμου (prénom) (m)''' : Jérôme.&lt;br&gt;
'''Ἰεσσαί (nom propre) (m)''' : Jessé.&lt;br&gt;
'''Ἰεσσαῖος, -ίου (nom propre) (m)''' : Forme alternative de ''Ἰεσσαί''.&lt;br&gt;
'''Ἰησαΐας, -ου (nom propre) (m)''' : Forme alternative de ''Ἠσαΐας''.&lt;br&gt;
'''Ἰησοῦς, -οῦ (nom propre) (m)''' : Jésus, Josué.&lt;br&gt; 
'''Ἰησαΐας, -ου (nom propre) (m)''' : Forme alternative de ''Ἠσαΐας''.&lt;br&gt;
'''Ἰησοῦς, -οῦ (nom propre) (m)''' : Jésus, Josué.&lt;br&gt; 
'''Ἰθάκα, -ης (nom propre) (f)''' : Forme dorienne de ''Ἰθάκη''.&lt;br&gt;
'''Ἰθάκη, -ης (nom propre) (f)''' : Ithaque.&lt;br&gt;
'''Ἴθακος, -άκου (nom commun) (m)''' : Ithacien.&lt;br&gt;
'''Ἰκάριος, -ίου (nom propre) (m)''' : Icarios.&lt;br&gt;
'''Ἴκαρος, -άρου (nom propre) (m)''' : Icare.&lt;br&gt;
'''Ἴκελος, -έλου (nom propre) (m)''' : Icélos.&lt;br&gt;
'''Ἰλιάς, -δος (nom propre) (f)''' : Iliade.&lt;br&gt;
'''Ἴλιον, -ίου (nom propre) (n)''' : Ilion.&lt;br&gt;
'''Ἰλιάς, -δος (nom propre) (f)''' : Iliade.&lt;br&gt; 
'''Ἴλιον, -ίου (nom propre) (n)''' : Ilion, Troie.&lt;br&gt;
'''Ἰλλυρία, -ας (nom propre) (f)''' : Illyrie.&lt;br&gt;
'''‎Ἰλλυρίς, -δος (nom commun) (f)''' : Illyrienne.&lt;br&gt;
‎'''Ἰλλυριός, -οῦ (nom commun) (m)''' : Illyrien.&lt;br&gt;
'''Ἶλος, Ἴλου (nom propre) (m)''' : Ilos (fils de Tros et de Callirrhoé).&lt;br&gt;
'''Ἵμερος, -έρου (nom propre) (m)''' : Himéros.&lt;br&gt;
'''Ἰμούθης, -ου (nom propre) (m)''' : Imhotep.&lt;br&gt;
'''Ἰξίων, -ονος (nom propre) (m)''' : Ixion.&lt;br&gt;
'''Ἰόλαος, -άου (nom propre) (m)''' : Iolaos.&lt;br&gt;
'''Ἰόλεως, -ώ (nom propre) (m)''' : Forme de ''Ἰόλαος''.&lt;br&gt;
'''Ἰουδαῖα, -ίας (nom propre) (f)''' : Judée.&lt;br&gt;
'''Ἰουδαῖα, -ίας (nom commun) (f)''' : Juive.&lt;br&gt;
'''Ἰουδαῖος, -ίου (nom commun) (m)''' : Juif.&lt;br&gt;
'''Ἰούδας, -α (nom propre) (m)''' : Judas.&lt;br&gt; 
'''Ἰουδίθ (nom propre) (f)''' : Judith.&lt;br&gt; 
'''Ἵππαρχος, -άρχου (nom commun) (m)''' : Hipparque (Fils cadet de Pisistrate, il fut assassiné par Harmodios et Aristogiton en −514 av. J.-C.).&lt;br&gt;
'''Ἶρις, Ἴριδος (nom propre) (f)''' : [[wikt:Iris|Iris]].&lt;br&gt;
'''Ἰσαάκ (nom propre) (m)''' : Issac.&lt;br&gt;
'''Ἴσακος, - (nom propre) (m)''' : Forme alternative de ''Ἰσαάκ''.&lt;br&gt; 
'''Ἴσαυρα, -ας (nom propre) (f)''' : Isaura.&lt;br&gt;
'''Ἰσαυρία, -ας (nom propre) (f)''' : Isaurie.&lt;br&gt;
'''Ἴσαχος, - (nom propre) (m)''' :  Forme alternative de ''Ἰσαάκ''.&lt;br&gt; 
'''Ἰσίδωρος, -ώρου (nom propre) (m)''' : Isidore.&lt;br&gt; 
'''Ἶσις, Ἴσιδος (nom propre) (f)''' : [[wikt:Isis|Isis]].&lt;br&gt;
'''Ἰσθμός, -οῦ (nom propre) (m)''' : Isthmos.&lt;br&gt; 
'''Ἱσπανία, -ας (nom propre) (f)''' : Espagne.&lt;br&gt;
'''Ἱσπανίς, -δος  (nom commun) (f)''' : Espagnole.&lt;br&gt;
'''Ἱσπανός, -οῦ (nom commun) (m)''' : Espagnol.&lt;br&gt;
'''Ἰσμαήλ (nom propre) (m)''' : Ismaël.&lt;br&gt;
'''Ἰσραήλ (nom propre) (m)''' : Israël.&lt;br&gt;
'''Ἴστρος, -ου (nom propre) (f)''' : Danube inférieur.&lt;br&gt;
'''Ἰταλία -ας (nom propre) (f)''' : Italie.&lt;br&gt;
'''Ἰταλίς, -δος (nom commun) (f)''' : Italienne.&lt;br&gt;
'''Ἰταλιώτης, -ου (nom commun) (m)''' : Italiote.&lt;br&gt;
'''Ἱταλιῶτις, -ώτιδος (nom commun) (f)''' : Italiote.&lt;br&gt;
'''Ἰταλός, -οῦ (nom commun) (m)''' : Italien.&lt;br&gt;
'''Ἴτυς, -ος (nom propre) (m)''' : Itys.&lt;br&gt;
'''Ἴϋγξ, -γγος (nom propre) (f)''' : [[wikt:Jynx|Jynx]].&lt;br&gt;
'''Ἰφθίμη, -ης (nom propre) (f)''' : Iphtimé (sœur de Pénélope).&lt;br&gt;
'''Ἰφιάνασσα, -ας (nom propre) (f)''' : Forme homérique de ''Ἰφιγένεια''.&lt;br&gt;
'''Ἰφιγένεια, -ίας (nom propre) (f)''' : Iphigénie.&lt;br&gt;
'''Ἰφικλῆς, -έους (nom propre) (m)''' : Iphiclès (demi-frère jumeau d'Héraclès).&lt;br&gt;
'''Ἰχθύες, -ων (nom propre) (m)''' : Poissons.&lt;br&gt;
'''Ἰωάννα, -ας (prénom) (f)''' : Jeanne.&lt;br&gt;
'''Ἰωάννης ὁ Χρυσόστομος (nom propre) (m)''' : Jean Chrysostome.&lt;br&gt;
'''Ἰωήλ (nom propre) (m)''' : Joël.&lt;br&gt;
'''Ἰωνάθαν (nom propre) (m)''' : Jonathan.&lt;br&gt;
'''Ἰωνᾶς, -ᾶ (nom propre) (m)''' : Jonas.&lt;br&gt;
'''Ἰωνία, -ας (nom propre) (f)''' : Ionie.&lt;br&gt;
'''Ἴων, -ος (nom propre) (m)''' : Ion (fils de Xouthos).&lt;br&gt;
'''Ἴων, -ος (nom commun) (m)''' : Ionien.&lt;br&gt;
'''Ἰωσήφ (nom propre) (m)''' : Joseph.&lt;br&gt;
'''Ἰωσίας, -ου (nom propre) (m)''' : Josias.&lt;br&gt;
'''Ἰώ, -οῦς (nom propre) (f)''' : [[wikt:Io|Io]].&lt;br&gt;

==Κ==
'''ϗ (symbole)''' : Et. (Abréviation graphique valant ''καί'' en grec comme ''&amp;'' valant ''et'' en français.)&lt;br&gt;
'''καδεμών, -όνος (nom commun) (m)''' : Forme dorienne de ''κηδεμών''.&lt;br&gt;
'''καδιμών, -όνος (nom commun) (m)''' : Forme éolienne de ''κηδεμών''.&lt;br&gt;
'''κάδος, -ου (nom commun) (m)''' : seau.&lt;br&gt;
'''καθαίρω (verbe)''' : Purger, nettoyer ; laver. Étriller.&lt;br&gt;
'''καθαρεύω (verbe)''' : purifier.&lt;br&gt;
'''καθαρίζω (verbe)''' : Nettoyer, purifier. (Médecine) Guérir d’une infection.&lt;br&gt;
'''καθαρός, -ά, -όν (adjectif)''' : pur.&lt;br&gt;
'''καθαρῶς (adverbe)''' : purement.&lt;br&gt;
'''καθαρώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''καθαρός''.&lt;br&gt;
'''καθαρώτερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''καθαρός''.&lt;br&gt;
'''καθέδρα, ας (nom commun) (f)''' : Ce qui sert à s'asseoir. Action d'être ou de demeurer assis.&lt;br&gt;
'''καθετήρ, -ῆρος (nom commun) (m)''' : Ligne pour pêcher. Collier, pendant ; ornement de femme.&lt;br&gt;
'''καθεύδω (verbe)''' : dormir.&lt;br&gt;
'''καθηγέομαι (verbe)''' : professer.&lt;br&gt;
'''καθηγήτειρα, -ίρας (nom commun) (f)''' : professeure.&lt;br&gt;
'''καθηγητής, -οῦ (nom commun) (m)''' : professeur.&lt;br&gt;
'''καθηγητικός, -ή , -όν (adjectif)''' : professoral.&lt;br&gt;
'''καθηγητικῶς (adverbe)''' : professoralement.&lt;br&gt;
'''καθηγητικώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''καθηγητικός''.&lt;br&gt; 
'''καθηγητικώτερος, -έρη, -ώτερον (adjectif)''' : Comparatif de ''καθηγητικός''.&lt;br&gt; 
'''καθηγητικώτατα, -, - (adverbe)''' : Superlatif de ''καθηγητικῶς''.&lt;br&gt;
'''καθηγητικώτερον, -, - (adverbe)''' : Comparatif de ''καθηγητικῶς''.&lt;br&gt; 
'''καθήλωσις, -ώσεως (nom commun) (f)''' : détention.&lt;br&gt; 
'''καθηλῶ (verbe)''' : détenir.&lt;br&gt;
'''καθίημι (verbe)''' : descendre.&lt;br&gt;
'''κάθημαι (verbe)''' : siéger.&lt;br&gt;
'''καθολικός, -ή, -όν (adjectif)''' : Général ; universel.&lt;br&gt;
'''καθολικῶς (adverbe)''' : Généralement ; universellement.&lt;br&gt;
'''καθολικώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''καθολικός''.&lt;br&gt; 
'''καθολικώτερος, -έρη, -ώτερον (adjectif)''' : Comparatif de ''καθολικός''.&lt;br&gt; 
'''καθολικώτατα, -, - (adverbe)''' : Superlatif de ''καθολικῶς''.&lt;br&gt;
'''καθολικώτερον, -, - (adverbe)''' : Comparatif de ''καθολικῶς''.&lt;br&gt; 
'''καθοράω (verbe)''' : regarder.&lt;br&gt;
'''καί (conjonction)''' : Et ; Et même, même. Et en outre. Et ensuite, puis. Ou.&lt;br&gt;
'''καινός, -ή, -όν (adjectif)''' : nouveau.&lt;br&gt; 
'''καινότατος, -άτη, -ότατον (adjectif)''' : Superlatif de ''καινός''.&lt;br&gt; 
'''καινότερος, -έρη, -ότερον (adjectif)''' : Comparatif de ''καινός''.&lt;br&gt; 
'''καινότατα, -, - (adverbe)''' : Superlatif de ''καινῶς''.&lt;br&gt;
'''καινότερον, -, - (adverbe)''' : Comparatif de ''καινῶς''.&lt;br&gt;
'''καίνωσις, -ώσεως (nom commun) (f)''' : renouvellement.&lt;br&gt;
'''καινῶς (adverbe)''' : nouvellement.&lt;br&gt;
'''καῖρος, -ίρου (nom commun) (m)''' : embrouille.&lt;br&gt; 
'''καιρός, -οῦ (nom commun) (m)''' : temps (durée, époque).&lt;br&gt; 
'''καιρόω (verbe)''' : embrouiller.&lt;br&gt;
'''καίρωσις, -ώσεως (nom commun) (f)''' : embrouillage.&lt;br&gt;  
'''καίω (verbe)''' : brûler.&lt;br&gt;
'''κάκιον, -, - (adverbe)''' : Comparatif de ''κακῶς''.&lt;br&gt;
'''κάκιστα, -, - (adverbe)''' Superlatif de ''κακῶς''.&lt;br&gt;
'''κακοδαίμων, -ων, -ον (adjectif)''' : malheureux.&lt;br&gt;
'''κακοδαιμόνως (adverbe)''' : malheureusement.&lt;br&gt;
'''κακοδαιμονέστατος, -άτη, -έστατον (adjectif)''' : Superlatif de ''κακοδαίμων''.&lt;br&gt;
'''κακοδαιμονέστερος, -έρα, -έρερον (adjectif)''' : Comparatif de ''κακοδαίμων''.&lt;br&gt;
'''κακοήθης, -ης, -ες (adjectif)''' : malin.&lt;br&gt;
'''κακοῦργος, -ύργα, -ῦργον (adjectif)''' : Dérangé ; malfaisant.&lt;br&gt;
'''κακός, -ή, όν (adjectif)''' : Mauvais ; laid.&lt;br&gt;
'''κακο- (préfixe)''' : mauvais.&lt;br&gt;
'''κακοφωνία, -ας (nom commun) (f)''' : mauvaise sonorité.&lt;br&gt;
'''κακκῶ (verbe)''' : déféquer ; chier.&lt;br&gt;
'''κακῶς (adverbe)''' : mal.&lt;br&gt;
'''κάλαθος, -άθου (nom commun) (m)''' : corbeille, panier.&lt;br&gt;
'''κάλαϊς, -, - (adjectif)''' : bleu ciel.&lt;br&gt;
'''κάλιον, -, - (adverbe)''' : Comparatif de ''καλῶς''.&lt;br&gt;
'''κάλιστα, -, - (adverbe)''' Superlatif de ''καλῶς''.&lt;br&gt;
'''καλλι- (préfixe)''' : beau.&lt;br&gt;
'''καλλίπυγοσις, -όσεως (nom commun) (f)''' : .&lt;br&gt;
'''καλλίπυγος, -ος, -ον (adjectif)''' : Qui a de belles fesses.&lt;br&gt;
'''κάλλιστος, -, - (adjectif)''' : Superlatif de ''καλός''.&lt;br&gt;
'''καλλίων, -, - (adjectif)''' : Comparatif de ''καλός''.&lt;br&gt; 
'''κάλλος, -ους (nom commun) (n)''' : beauté.&lt;br&gt; 
'''καλοήθης, -ης, -ες  (adjectif)''' : bénin.&lt;br&gt; 
'''καλός, -ή, -όν (adjectif)''' : Beau ; bon.&lt;br&gt; 
'''κάλος, -η, -ον (adjectif)''' : Forme éolienne de ''καλός''.&lt;br&gt; 
'''καλϝός, -ή, -όν (adjectif)''' : Forme béotienne de ''καλός''.&lt;br&gt;
'''κάλυμμα, -ύμματος (nom commun) (n)''' : couverture.&lt;br&gt;
'''κάλυξ, -κος (nom commun) (m/f)''' : (Botanique) Calice des fleurs ; écale ou peau des fruits.&lt;br&gt;
'''καλύπτω (verbe)''' : Couvrir ; envelopper, cacher.&lt;br&gt;
'''καλῶς (adverbe)''' : Bien ; d’une belle manière.&lt;br&gt;
'''καλῶ (verbe)''' : appeler.&lt;br&gt;
'''καμάρα, -ας (nom commun) (f)''' : Voûte ; chambre voûtée.&lt;br&gt;
'''καμάρη, -ης (nom commun) (f)''' : Forme ionienne de ''καμάρα''.&lt;br&gt; 
'''κάμαξ, -κος (nom commun) (m/f)''' : Perche. Hampe de la lance. (Marine) Gouvernail, manche de la rame.&lt;br&gt;
'''κάμηλος, -ήλου (nom commun) (m/f)''' : chameau.&lt;br&gt;
'''καμηλοπάρδαλις, -άλεως (nom commun) (f)''' : girafe.&lt;br&gt;
'''κάμινος, -ίνου (nom commun) (m)''' : cheminée.&lt;br&gt;
'''κάμπη, -ης (nom commun) (f)''' : chenille.&lt;br&gt;
'''καμπή, -ῆς (nom commun) (f)''' : articulation.&lt;br&gt;
'''κάμπος, -ους (nom commun) (n)''' : poisson marin.&lt;br&gt;
'''κάπρος, -ου (nom commun) (n)''' : sanglier.&lt;br&gt;
'''κάμπτω (verbe)''' : courber.&lt;br&gt;
'''καμπύλη, -ης (nom commun) (f)''' : courbure.&lt;br&gt;
'''καμπύλος, -η, -ον (adjectif)''' : Courbé, tordu. Voilé (en parlant d’une roue.)&lt;br&gt;
'''καμπυλότης, -τος (nom commun) (f)''' : courbure.&lt;br&gt;
'''κανδάκη, -ης (nom commun) (f)''' : candace.&lt;br&gt; 
'''κανάσσω (verbe)''' : cliquer.&lt;br&gt;
'''καναχή, -ῆς (nom commun) (f)''' : clic.&lt;br&gt;
'''καναχίζω (verbe)''' :  claquer.&lt;br&gt;
'''καναχηδά (adverbe)''' : .&lt;br&gt;
'''καναχής, -ής, -ές (adjectif)''' : .&lt;br&gt;
'''καναχῶ (verbe)''' : cliquer.&lt;br&gt;
'''κἄν (conjonction)''' : .&lt;br&gt;
'''κάνθαρος, -άρου (nom commun) (m)''' : cafard.&lt;br&gt;
'''κανονικός, -ή, -όν (adjectif)''' : régulier.&lt;br&gt;
'''κανονικῶς (adverbe)''' : régulièrement.&lt;br&gt;
'''κανονικώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''κανονικός''.&lt;br&gt;
'''κανονικώτερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''κανονικός''.&lt;br&gt;
'''κανονικώτατα, -, - (adverbe)''' : Superlatif de ''κανονικῶς''.&lt;br&gt;
'''κανονικώτερον, -, - (adverbe)''' : Comparatif de ''κανονικῶς''.&lt;br&gt; 
'''κανών, -όνος (nom commun) (m)''' : Tige de roseau, règle de maçon ou de charpentier. (Figuré) Règle, modèle ; principe.&lt;br&gt;
'''κάνωπον, -ώπου (nom commun) (n)''' : chou-fleur.&lt;br&gt;
'''καπηλεῖον, -ίου (nom commun) (n)''' : taverne.&lt;br&gt;
'''καπηλεύω (verbe)''' : tenir une taverne.&lt;br&gt;
'''καπηλικός, -ή, -όν (adjectif)''' : tavernier.&lt;br&gt;
'''καπηλίς, -δος (nom commun) (f)''' : tavernière.&lt;br&gt;
'''κάπηλος, -ήλου (nom commun) (m)''' : tavernier.&lt;br&gt;
'''κάππα (nom commun) (n)''' : kappa.&lt;br&gt;
'''κάπτω (verbe)''' : Avaler, prendre (une bouffée d’air).&lt;br&gt;
'''κάρα, -τος (nom commun) (n)''' : Tête ; visage.&lt;br&gt;
'''κάραϐος, -άϐου (nom commun) (m)''' : Crabe ; langouste. Scarabée ; escarbot.&lt;br&gt;
'''κάρδαμον, -ου (nom commun) (n)''' : cresson.&lt;br&gt;
'''καρδία, -ας (nom commun) (f)''' : cœur.&lt;br&gt;
'''καρδιακός, -ή, -ός (adjectif)''' : cardiaque.&lt;br&gt;
'''καρδιακῶς (adverbe)''' : cardiaquement.&lt;br&gt;
'''καρδιακώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''καρδιακός''.&lt;br&gt;
'''καρδιακώτερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''καρδιακός''.&lt;br&gt;
'''καρδούχιος, -ος, -ον  (adjectif)''' : kurde.&lt;br&gt;
'''καρηϐάρεια, -ίας (nom commun) (f)''' : mal de tête.&lt;br&gt;
'''κάρη, -τος (nom commun) (n)''' : Forme homérique et ionienne de ''κάρα''.&lt;br&gt;
'''καρίς, -δος (nom commun) (f)''' : crevette.&lt;br&gt;
'''καρκίνος, -ίνου (nom commun) (m)''' : (Zoologie) Crabe. (Astronomie) Constellation du Cancer. (Médecine) Chancre, tumeur, cancer. 
Pince pour saisir ou tenir les objets dans le feu. Compas. Sorte de bandage. (Habillement) Sorte de chaussure.&lt;br&gt;
'''καρπάλιμος, -ος, -ον (adjectif)''' : rapide.&lt;br&gt;  
'''καρπός, -οῦ (nom commun) (m)''' : (Sens propre) Fruit, graine ; produit, récolte. (Sens figuré) Produit de quelque chose : enfant (produit du corps), poésie (produit de l'esprit), profit. (Anatomie) Poignet.&lt;br&gt;
'''καρύκιον, -ίου (nom commun) (m)''' : Forme dorienne de ''κηρύκειον''.&lt;br&gt; 
'''κᾶρυξ, -άρυκος (nom commun) (m)''' : Forme dorienne de ''κῆρυξ''.&lt;br&gt; 
'''καρυόφυλλον, -ύλλου (nom commun) (n)''' : œillet.&lt;br&gt;
'''καρύσσω (verbe)''' : Forme dorienne de ''κηρύσσω''.&lt;br&gt; 
'''κάρφος, -ους (nom commun) (n)''' : brindille.&lt;br&gt;
'''κάρχαρος, -α, -ον (adjectif)''' : aiguisé.&lt;br&gt;
'''καρχηδονιακός, -ή, -όν (adjectif)''' : carthaginois.&lt;br&gt;
'''καρῶτον, -ώτου (nom commun) (n)''' : carotte.&lt;br&gt;
'''κατά (adverbe ; préposition)''' (Devient ''κατ᾽'' devant un mot commençant par une voyelle à esprit doux, et ''καθ᾽'' devant un mot commençant par une voyelle à esprit rude.) : De haut en bas. En bas. En dessous, au fond. (Par extension) À fond, complètement. 
(Avec le génitif) marque l’origine, le point de départ ou le point d’arrivée. Contre, idée d’hostilité. (Avec l’accusatif) suivant, selon.
Par, avec l'idée de succession (un par un). Pendant, avec l’idée de temps. Après, avec l’idée de succession temporelle (jour après jour). À travers, idée de transpercement, de part en part, d’un bout à l’autre.&lt;br&gt;
'''καταϐιϐρώσκω (verbe)''' : .&lt;br&gt;
'''καταγέλαστος, -ος, -ον (adjectif)''' : ridicule.&lt;br&gt;
'''καταγλώττισμα, -ίσματος (nom commun) (n)''' : baiser intrabuccal.&lt;br&gt;
'''καταγράφω (verbe)''' : condamner.&lt;br&gt;
'''καταδικάζω (verbe)''' : condamner.&lt;br&gt;
'''καταδίκη, -ης (nom commun) (f)''' : condamnation.&lt;br&gt;
'''καταδικαστικός, -ή, -όν (adjectif)''' : condamnable.&lt;br&gt;
'''κατάδικος, -ίκου (nom commun) (m/f)''' : condamné.&lt;br&gt;
'''κατάδυσις, -ύσεως (nom commun) (f)''' : émergence.&lt;br&gt; 	
'''καταδύομαι (verbe)''' : plonger.&lt;br&gt; 
'''κατακλύζω (verbe)''' : inonder.&lt;br&gt; 
'''κατάκλυσις, -ύσεως (nom commun) (f)''' : inondation.&lt;br&gt;
'''κατακλυσμιαίος, -α, -ον (adjectif)''' : diluvien.&lt;br&gt;
'''κατακλυσμικός, -ή, -όν (adjectif)''' : diluvien.&lt;br&gt;
'''κατακλυσμικότατα, -, - (adverbe)''' : Superlatif de ''κατακλυσμικῶς''.&lt;br&gt;
'''κατακλυσμικότερον, -, - (adverbe)''' : Comparatif de ''κατακλυσμικῶς''.&lt;br&gt;
'''κατακλυσμικῶς (adverbe)''' : désastreusement.&lt;br&gt;
'''κατακλυσμικώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''κατακλυσμικός''.&lt;br&gt;
'''κατακλυσμικώτερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''κατακλυσμικός''.&lt;br&gt;
'''κατακλυσμός, -οῦ (nom commun) (m)''' : déluge.&lt;br&gt;
'''κατακτητής, -οῦ (nom commun) (m)''' : conquérant.&lt;br&gt;
'''κατακτῶμαι (verbe)''' : conquérir.&lt;br&gt;
'''καταλαμϐάνω (verbe)''' : saisir.&lt;br&gt;
'''κατάλαψις, -άψεως (nom commun) (f)''' : Forme dorienne de ''κατάληψις''.&lt;br&gt;
'''κατάληψις, -ήψεως (nom commun) (f)''' : Saisissement. Prise de possession, occupation.&lt;br&gt; 
'''κατάλογος, -όγου (nom commun) (m)''' : liste.&lt;br&gt;	
'''καταλογογράφησις, -ήσεως (nom commun) (f)''' : listage.&lt;br&gt;
'''καταλογογραφῶ (verbe)''' : lister.&lt;br&gt;
'''κατάπλασμα, -άσματος	(nom commun) (n)''' : cataplasme.&lt;br&gt;
'''κατάπτωσις, -ώσεως (nom commun) (f)''' : décadence.&lt;br&gt;
'''κατάπυγον, -ύγου (nom commun) (n)''' : doigt d'honneur.&lt;br&gt;
'''κατάρα, -ας (nom commun) (f)''' : malédiction.&lt;br&gt;
'''καταριέμαι (verbe)''' : maudire.&lt;br&gt;
'''καταστροφικός, -ή, -όν (adjectif)''' : désastreux.&lt;br&gt;
'''καταστροφικότατα, -, - (adverbe)''' : Superlatif de ''καταστροφικῶς''.&lt;br&gt;
'''καταστροφικότερον, -, - (adverbe)''' : Comparatif de ''καταστροφικῶς''.&lt;br&gt;
'''καταστροφικῶς (adverbe)''' : désastreusement.&lt;br&gt;
'''καταστροφικώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''καταστροφικός''.&lt;br&gt;
'''καταστροφικώτερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''καταστροφικός''.&lt;br&gt;
'''καταστροφή, -ῆς (nom commun) (f)''' : Désastre, destruction ; renversement.&lt;br&gt;
'''κατάσχεσις, -έσεως (nom commun) (f)''' : confiscation.&lt;br&gt;
'''κατάταξις, -άξεως (nom commun) (f)''' : mise en ordre.&lt;br&gt;
'''κατατάσσω (verbe)''' : mettre en ordre.&lt;br&gt;
'''καταφυγή, -ῆς (nom commun) (f)''' : .&lt;br&gt;
'''καταφύγιον, -ίου (nom commun) (n)''' : abri.&lt;br&gt; 
'''κάτεργον, -έργου (nom commun) (n)''' : bagne.&lt;br&gt;
'''κατηγορῶ (verbe)''' : accuser.&lt;br&gt;
'''κατηγορία, -ας (nom commun) (f)''' : Charge ; accusation.&lt;br&gt;
'''κατηγορίη, -ης (nom commun) (f)''' : Forme ionienne de ''κατηγορία''.&lt;br&gt;
'''κατήχησις, -ήσεως (nom commun) (f)''' : .&lt;br&gt;
'''κατηχίζω (verbe)''' : .&lt;br&gt;
'''κατηχισμός, -οῦ (nom commun) (m)''' : .&lt;br&gt;
'''κατηχιστής, -οῦ (nom commun) (m)''' : .&lt;br&gt;
'''κατηχούμενος, -ένου (nom commun) (m)''' : .&lt;br&gt;
'''κατηχῶ (verbe)''' : .&lt;br&gt;
'''κάτοπτρον, -όπτρου (nom commun) (m)''' : miroir.&lt;br&gt; 
'''κατώτατος, -άτη, -ώτατον (adjectif)''' : .&lt;br&gt; 
'''κατώτερος, -έρα, -ώτερον (adjectif)''' : inférieur.&lt;br&gt;
'''κατωτερότης, -τος (nom commun) (f)''' : infériorité.&lt;br&gt;
'''κάτω (adverbe)''' : sous.&lt;br&gt;
'''καῦκος, -ύκου (nom commun) (m)''' : .&lt;br&gt;
'''καῦµα, -ύματος (nom commun) (n)''' : chaleur de l’été.&lt;br&gt;
'''καύσις, -εως (nom commun) (f)''' : combustion.&lt;br&gt;
'''καυστός, -ή, -όν (adjectif)''' : torride.&lt;br&gt;
'''καυστῶς (adverbe)''' : torridement.&lt;br&gt;
'''καυστώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''καυστός''.&lt;br&gt;
'''καυστώτερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''καυστός''.&lt;br&gt;
'''καυστώτατα, -, - (adverbe)''' : Superlatif de ''καυστῶς''.&lt;br&gt;
'''καυστώτερον, -, - (adverbe)''' : Comparatif de ''καυστῶς''.&lt;br&gt;
'''καύχημα, -ήματος (nom commun) (n)''' : vantardise.&lt;br&gt; 
'''καυχός, -οῦ (nom commun) (m)''' : Forme crétoise de ''χαλκός''.&lt;br&gt;
'''καυχῶμαι (verbe)''' : .&lt;br&gt;
'''κεγχριαῖος, -ία, -ῖον (adjectif)''' : granuleux.&lt;br&gt;
'''κέγχρος, -ου (nom commun) (m)''' : (Botanique) Millet. Grain.&lt;br&gt;
'''κεῖμαι (verbe)''' : être couché, se reposer ; être situé.&lt;br&gt;
'''κείμενον, -ένου (nom commun) (n)''' : texte.&lt;br&gt; 
'''κεινός, -ή, -όν (adjectif)''' : Forme ionienne de ''κενός''.&lt;br&gt;
'''κείρω (verbe)''' : .&lt;br&gt;
'''κελαινός, -ή, -όν (adjectif)''' : obscur.&lt;br&gt;
'''κελτικός, -ή, -όν (adjectif)''' : celte.&lt;br&gt;
'''κελτικῶς (adverbe)''' : .&lt;br&gt;
'''κελτικώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''κελτικός''.&lt;br&gt;
'''κελτικώτερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''κελτικός''.&lt;br&gt;
'''κελτιστί (adverbe)''' : en grec.&lt;br&gt;
'''κενός, -ή, -όν (adjectif)''' : Vide. Vain, frivole.&lt;br&gt;
'''κενϝός, -ή, -όν (adjectif)''' : Forme ancienne de ''κενός''.&lt;br&gt;
'''κενεός, -ή, -όν (adjectif)''' : Forme poétique de ''κενός''.&lt;br&gt;
'''κεντρικός, -ή, -όν (adjectif)''' : central.&lt;br&gt;
'''κέντρον, -ου (nom commun) (n)''' : Aiguillon, dard. Pointe du compas, d’où centre du cercle.&lt;br&gt;
'''κεντῶ (verbe)''' : piquer.&lt;br&gt;
'''κενῶς (adverbe)''' : Habilement, sagement. Ingénieusement, finement.&lt;br&gt;
'''κενώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''κενός''.&lt;br&gt;
'''κενώτερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''κενός''.&lt;br&gt;
'''κεραμεύς, -έως (nom commun) (m)''' : potier.&lt;br&gt;
'''κεραμικός, -ή, -όν (adjectif)''' : d’argile.&lt;br&gt;
'''κέραμος, -άμου (nom commun) (m)''' : argile.&lt;br&gt; 
'''κεράννυμι (verbe)''' : mélanger.&lt;br&gt;
'''κέρας, -τος (nom commun) (n)''' : Corne. (Par analogie) Bras d’un fleuve ; aile d’une armée ou d’une flotte ; antenne ou vergue d’un navire ; pic d’une montagne. (Sophisme) argument cornu.&lt;br&gt;
'''κεραός, -ά, -όν (adjectif)''' : Cornu ; fait de corne.&lt;br&gt; 
'''κεραϝός, -ά, -όν (adjectif)''' : Forme ancienne de ''κεραός''.&lt;br&gt; 
'''κερασός, -οῦ (nom commun) (m)''' : cerise.&lt;br&gt; 
'''κεραυνός, -οῦ (nom commun) (m)''' : foudre.&lt;br&gt;
'''κέρκηρις, -ήρεως (nom commun) (m)''' : sarcelle.&lt;br&gt;
'''κερκοπίθακος, -άκου (nom commun) (m)''' : Forme dorienne de ''κερκοπίθηκος''.&lt;br&gt;
'''κερκοπίθηκος, -ήκου (nom commun) (m)''' : cercopithèque.&lt;br&gt;
'''κέρκος, -ου (nom commun) (f)''' : queue.&lt;br&gt;
'''κέρκωψ, -πος (nom commun) (m)''' : singe à longue queue.&lt;br&gt;
'''κεστός, -ή, -όν (adjectif)''' : brodé.&lt;br&gt; 
'''κεστότατος, -άτη, -ότατον (adjectif)''' : Superlatif de ''κεστός''.&lt;br&gt;
'''κεστότερος, -έρα, -ότερον (adjectif)''' : Comparatif de ''κεστός''.&lt;br&gt;
'''κεστῶς (adverbe)''' : .&lt;br&gt;
'''κεφαλαία, -ας (nom commun) (f)''' : mal de tête.&lt;br&gt;
'''κεφαλή, -ῆς (nom commun) (f)''' : tête.&lt;br&gt;
'''κεφάλιον, -ίου (nom commun) (n)''' : petite tête.&lt;br&gt;
'''κεφαλίς, -δος (nom commun) (f)''' : bonnet, chapeau.&lt;br&gt;
'''κηδεμών, -όνος (nom commun) (m)''' : .&lt;br&gt;
'''κηκίς, -ῖδος (nom commun) (f)''' : Jet. Teinture tiré de la galle.&lt;br&gt;
'''κηλίς, -ῖδος (nom commun) (f)''' : .&lt;br&gt;
'''κνημίς, -ῖδος (nom commun) (f)''' : .&lt;br&gt;
'''κρηπίς, -ῖδος (nom commun) (f)''' : .&lt;br&gt;
'''κῆπος, -ήπου (nom commun) (m)''' : jardin ; sorte de singe.&lt;br&gt;
'''κηρός, -οῦ (nom commun) (m)''' : cire.&lt;br&gt;
'''κῆρ, -ος (nom commun) (n)''' : cœur.&lt;br&gt; 
'''κῆρυγμα, -ύγματος (nom commun) (n)''' : proclamation à voix haute.&lt;br&gt; 
'''κηρύκειον, -ίου (nom commun) (m)''' : caducée.&lt;br&gt;
'''κῆρυξ, -ήρυκος (nom commun) (m)''' : héraut.&lt;br&gt; 
'''κηρύσσω (verbe)''' : annoncer.&lt;br&gt;
'''κηρύττω (verbe)''' : Forme attique de ''κηρύσσω''.&lt;br&gt;
'''κηφήν, -ῆνος (nom commun) (m)''' : bourdon.&lt;br&gt;
'''κηφηνώδης, -ης, -ες (adjectif)''' : .&lt;br&gt; 
'''κιϐδηλεύω (verbe)''' : falsifier.&lt;br&gt;
'''κιϐδηλία, -ας (nom commun) (f)''' : falsification.&lt;br&gt;  
'''κίϐδηλος, -ος, -ου (adjectif)''' : falsifié ; frauduleux.&lt;br&gt;
'''κιϐδηλότατος, -άτη, -ότατον (adjectif)''' : Superlatif de ''κίϐδηλος''.&lt;br&gt;
'''κιϐδηλότερος, -έρα, -ότερον (adjectif)''' : Comparatif de ''κίϐδηλος''.&lt;br&gt;
'''κιϐδήλως (adverbe)''' : frauduleusement.&lt;br&gt;
'''κιϐωτός, -οῦ (nom commun) (f)''' : arche.&lt;br&gt; 
'''κιγκλίς, -δος (nom commun) (f)''' : bergeronnette.&lt;br&gt;
'''κιδαφεύω (verbe)''' : ruser.&lt;br&gt;
''' κίδαφος, -άφη, -ίδαφον (adjectif)''' : rusé.&lt;br&gt;
'''κίδαφότατος, -άτη, -ότατον (adjectif)''' : Superlatif de ''κίδαφος''.&lt;br&gt;
'''κίδαφότερος, -έρα, -ότερον (adjectif)''' : Comparatif de ''κίδαφος''.&lt;br&gt;
'''κιδάφως (adverbe)''' : frauduleusement.&lt;br&gt;
'''κικκάϐη, -ης (nom commun) (f)''' : .&lt;br&gt; 
'''κῖκυς, -ίκυος (nom commun) (f)''' : force ; vigueur.&lt;br&gt; 
'''κιθάρα, -ας (nom commun) (f)''' : cithare.&lt;br&gt; 
'''κιθάρη, -ης (nom commun) (f)''' : Forme ionienne de ''κιθάρα''.&lt;br&gt; 
'''κιθών, -ῶνος (nom commun) (m)''' : Forme ionienne de ''χιτών''.&lt;br&gt;
'''κίνδυνος, -ύνου (nom commun) (m)''' : Danger, risque ; entreprise hasardeuse.&lt;br&gt;  
'''κινηθμός, -οῦ (nom commun) (m)''' : .&lt;br&gt;
'''κίνημα, -ήματος (nom commun) (n)''' : mouvement.&lt;br&gt; 
'''κίνησις, -ήσεως (nom commun) (f)''' : mouvement.&lt;br&gt; 
'''κινητέον, -ου (nom commun) (n)''' : .&lt;br&gt; 
'''κινητήρ, -ῆρος (nom commun) (m)''' : .&lt;br&gt; 
'''κινητής, -οῦ (nom commun) (m)''' : .&lt;br&gt; 
'''κινητήριος, -α, -ον (adjectif)''' : .&lt;br&gt; 
'''κινητικός, -ή, -όν (adjectif)''' : .&lt;br&gt; 
'''κινητός, -ή, -όν (adjectif)''' : .&lt;br&gt; 
'''κίνητρον, -ήτρου (nom commun) (n)''' : .&lt;br&gt; 
'''κίνναμον, -άμου (nom commun) (n)''' : cannelle.&lt;br&gt;
'''κινῶ (verbe)''' : bouger.&lt;br&gt;
'''κιξάλλης, -ου (nom commun) (m)''' : voleur de grand chemin.&lt;br&gt;
'''κίρκος, -ου (nom commun) (m)''' : (ornithologie) Faucon. Anneau.&lt;br&gt;
'''κιρρός, -ά, -όν (adjectif)''' : brun-roux.&lt;br&gt;
'''κισσαϐίζω (verbe)''' : .&lt;br&gt;
'''κῖσσα, -ης (nom commun) (f)''' : geai des chênes.&lt;br&gt;
'''κίσσα, -ης (nom commun) (f)''' : pie.&lt;br&gt;
'''κισσός, -οῦ (nom commun) (m)''' : lierre.&lt;br&gt; 
'''κισσοστεφής, -ής, -ές (adjectif)''' : couronné de lierre.&lt;br&gt;
'''κισσῶ (verbe)''' : .&lt;br&gt;
'''κίττα, -ης (nom commun) (f)''' : Forme attique de ''κίσσα''.&lt;br&gt;
'''κιτών, -ῶνος (nom commun) (m)''' : Forme dorienne de ''χιτών''.&lt;br&gt;
'''κιχόρη, -ης (nom commun) (f)''' : chicorée.&lt;br&gt;
'''κλάδος, -ου (nom commun) (m)''' : Branche (d'arbre), rameau.&lt;br&gt;
'''κλαΐς, -δός (nom commun) (f)''' : Forme dorienne de ''κλείς''.&lt;br&gt; 
'''κλᾶϊς, -άϊδος (nom commun) (f)''' : Forme éolienne de ''κλείς''.&lt;br&gt; 
'''κλαίω (verbe)''' : Pleurer sur, déplorer. Appeler en criant. Se mettre en pleurs.&lt;br&gt;
'''κλᾶμμα, -άμματος (nom commun) (f)''' : Forme éolienne de ''κλῆμα''.&lt;br&gt;
'''κλαστός, -ή, -όν (adjectif)''' : brisé, cassé.&lt;br&gt;
'''κλαυθμυρίζω (verbe)''' : faire pleurer.&lt;br&gt;
'''κλαῦμα, -ύματος (nom commun) (n)''' : pleur.&lt;br&gt;
'''κλαυσίγελως, -τος (nom commun) (m)''' : .&lt;br&gt; 
'''κλαυστός, -ή, -όν (adjectif)''' : Pleuré. Funèbre, triste.&lt;br&gt;
'''κλάω (verbe)''' : Briser, casser.&lt;br&gt;
'''κλεῖθρον, -ίθρου (nom commun) (n)''' : serrure.&lt;br&gt;
'''κλειθροποιός, -οῦ (nom commun) (m)''' : serrurier.&lt;br&gt; 
'''κλείς, -δός (nom commun) (f)''' : clé.&lt;br&gt;
'''κλειτορίς, -δος (nom commun) (f)''' : clitoris.&lt;br&gt;  
'''κλείω (verbe)''' : fermer.&lt;br&gt;
'''κλέπτης, -ου (nom commun) (m)''' : voleur.&lt;br&gt;  
'''κλέπτω (verbe)''' : voler. (dérober)&lt;br&gt;
'''κληΐς, -δός (nom commun) (f)''' : Forme ionienne de ''κλείς''.&lt;br&gt;  
'''κλῄς, -δός (nom commun) (f)''' : Forme attique de ''κλείς''.&lt;br&gt; 
'''κλέος, -ους (nom commun) (n)''' : gloire.&lt;br&gt;
'''κλεψύδρα, -ας (nom commun) (m)''' : clepsydre.&lt;br&gt;   
'''κλέω (verbe)''' : être célèbre.&lt;br&gt; 
'''κλῆμα, -ήματος (nom commun) (n)''' : pampre.&lt;br&gt;
'''κληματίζω (verbe)''' : .&lt;br&gt; 
'''κληματικός, -ή, -όν (adjectif)''' : .&lt;br&gt;
'''κλημάτινος, -η, ον (adjectif)''' : .&lt;br&gt;
'''κληματίς, -δος (nom commun) (f)''' : Diminutif de ''κλῆμα''.&lt;br&gt;
'''κληματῖτις, -ίτιδος (nom commun) (f)''' : .&lt;br&gt;
'''κληματόδεσις, -εως (nom commun) (f)''' : .&lt;br&gt;
'''κληματοειδής, -ής, -ές (adjectif)''' : .&lt;br&gt;
'''κληματόεις, -εσσα, εν (adjectif)''' : .&lt;br&gt;
'''κληματόομαι (verbe)''' : .&lt;br&gt;
'''κληματώδης, -ης, -ες (adjectif)''' : .&lt;br&gt;
'''κλήρωσις, -ώσεως (nom commun) (f)''' : .&lt;br&gt; 
'''κληρονομία, -ας (nom commun) (f)''' : héritage.&lt;br&gt; 	
'''κληρονομικότης, -τος (nom commun) (f)''' : hérédité.&lt;br&gt; 	
'''κληρονομικός, -ή, -όν (adjectif)''' : héréditaire.&lt;br&gt; 
'''κληρονόμος, -ου (nom commun) (m)''' : héritier.&lt;br&gt;
'''κληρονομῶ (verbe)''' : hériter.&lt;br&gt; 
'''κλῆρος, -ήρου (nom commun) (m)''' : .&lt;br&gt; 
'''κληρόω (verbe)''' : .&lt;br&gt; 
'''κλητήρ, -ῆρος (nom commun) (m)''' : Témoin ; héraut.&lt;br&gt; 
'''κλίμα, -τος (nom commun) (n)''' : Inclinaison, pente. Inclinaison de la Terre, latitude, climat.&lt;br&gt;
'''κλῖμαξ, -ίμακος (nom commun) (f)''' : Escalier ; échelle.&lt;br&gt;  
'''κλίνη, -ης (nom commun) (f)''' : lit.&lt;br&gt;
'''κλίνω (verbe)''' : Pencher. Pencher sur, s’appuyer sur. Coucher, allonger, étendre.&lt;br&gt; 
'''κλίννω (verbe)''' : Forme éolienne de ''κλίνω''.&lt;br&gt; 
'''κλίσις, -εως (nom commun) (f)''' : déclinaison.&lt;br&gt; 
'''κλίτος, -ους (nom commun) (n)''' : allée.&lt;br&gt; 
'''κλῖτος, -ίτους (nom commun) (n)''' : .&lt;br&gt; 
'''κλιτύς, -ος (nom commun) (n)''' : Forme béotienne de ''κλῖτος''.&lt;br&gt;
'''κλόνις, -ος (nom commun) (f)''' : sacrum.&lt;br&gt;  
'''κλόνος, -ου (nom commun) (m)''' : Confusion ;  excitation.&lt;br&gt;  
'''κλύδων, -ος (nom commun) (m)''' : Vague. Trouble, agitation, mouvement tumultueux.&lt;br&gt; 
'''κλύζω ‎(verbe)''' : Laver, nettoyer. Battre de ses flots, baigner de ses flots.&lt;br&gt;
'''κλυστήρ, -έρος (nom commun) (m)''' : seringue.&lt;br&gt; 
'''κλύω (verbe)''' : entendre.&lt;br&gt;
'''κλωβός, -ϐοῦ (nom commun) (m)''' : cage à oiseau.&lt;br&gt;
'''κλών, -ός (nom commun) (m)''' : .&lt;br&gt;
'''κλώψ, -πός (nom commun) (m)''' : voleur.&lt;br&gt;
'''κλῶ (verbe)''' : S’entendre nommer ; entendre parler de soi.&lt;br&gt;
'''κνέφας, -ους (nom commun) (n)''' : Aube ; crépuscule, obscurité.&lt;br&gt;
'''κνῆκος, -ήκου (nom commun) (f)''' : carthame des teinturiers.&lt;br&gt;
'''κνήμη, -ης (nom commun) (f)''' : jambe.&lt;br&gt;
'''κνίδη, -ης (nom commun) (f)''' : ortie.&lt;br&gt;
'''κνίδωσις, -ώσεως (nom commun) (f)''' : urticaire.&lt;br&gt;
'''κνίζω (verbe)''' : Gratter. ; taillader.&lt;br&gt;
'''κοϐαλεία, -ας (nom commun) (f)''' : .&lt;br&gt;
'''κοϐαλεύω (verbe)''' : .&lt;br&gt;
'''κοϐαλίκευμα, -ύματος (nom commun) (n)''' : .&lt;br&gt;
'''κοϐαλισμός, -οῦ (nom commun) (m)''' : .&lt;br&gt;
'''κόϐαλος, -άλου (nom commun) (m)''' : Chenapan ; garnement. Gobelin.&lt;br&gt;
'''κοθαρός, -ά, -όν (adjectif)''' : Forme dorienne de ''καθαρός''.&lt;br&gt;  
'''κόθαρος, -ά, -όν (adjectif)''' : Forme éolienne de ''καθαρός''.&lt;br&gt; 
'''κοιλάς, -δος (nom commun) (f)''' : vallée.&lt;br&gt;
'''κοῖλος, -ίλη, -ῖλον (adjectif)''' : creux.&lt;br&gt;
'''κοῖλος, -ίλου (nom commun) (m)''' : creux.&lt;br&gt;
'''κοιμάω (verbe)''' : (Actif) Mettre sur une couche, mettre au lit. (Passif) Faire reposer, faire dormir. (Passif, par euphémisme) Faire mourir. (Figuré) Assoupir, apaiser, calmer.&lt;br&gt;
'''κοιμέω (verbe)''' : Forme ionienne de ''κοιμάω''.&lt;br&gt;
'''κοιμητήριον, -ου (nom commun) (n)''' : Dortoir ; cimetière.&lt;br&gt; 
'''κοιμίζω (verbe)''' : endormir.&lt;br&gt;
'''κοινοϐουλευτικός, -ή, -όν (adjectif)''' : parlementaire.&lt;br&gt;
'''κοινοϐούλιον, -ίου (nom commun) (n)''' : parlement.&lt;br&gt;
'''κοινός, -ή, -όν (adjectif)''' : commun.&lt;br&gt;
'''κοινότατος, -άτη, -ότατον (adjectif)''' : Superlatif de ''κοινός''.&lt;br&gt;
'''κοινότερος, -έρα, -ότερον (adjectif)''' : Comparatif de ''κοινός''.&lt;br&gt;
'''κοινωνία, -ας (nom commun) (f)''' : société.&lt;br&gt;
'''κοίνωσις, -ώσεως (nom commun) (f)''' : .&lt;br&gt;
'''κοινῶς (adverbe)''' : communément.&lt;br&gt;
'''κοινῶ (verbe)''' : Communiquer. Rendre commun à, faire savoir. Mettre en communication, unir. Rendre commun à tous, prostituer, profaner, souiller.
Unir, assembler, ajuster (une pièce d'une construction). (Moyen) Communiquer, mettre en commun. &lt;br&gt;
'''κοῖος, -ίη, -ῖον (adjectif)''' : Forme ionienne de ''ποῖος''.&lt;br&gt;
'''κοῖτος, -ίτου (nom commun) (m)''' : Lit, couche.&lt;br&gt;
'''κόκκος,  -ου (nom commun) (m)''' : Graine, grain, pépin. (Entomologie) Cochenille, kermès, galle du chêne kermès. (par analogie) Pilule. (par analogie) Testicules.&lt;br&gt;
'''κόλλαθον, -άθου (nom commun) (n)''' : .&lt;br&gt; 
'''κολοιός, -οῦ (nom commun) (m)''' : choucas.&lt;br&gt; 
'''κόκκυξ, -υγος (nom commun) (m)''' : coucou, coccyx.&lt;br&gt;  
'''κόκκυ (onomatopée)''' : cri du coucou.&lt;br&gt; 
'''κωκύω (verbe)''' : crier, se lamenter.&lt;br&gt;
'''κολακεία, -ας (nom commun) (f)''' : flatterie.&lt;br&gt; 
'''κολακευτικός, -ή, -όν (adjectif)''' : flatteur.&lt;br&gt;
'''κολακευτικώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''κολακευτικός''.&lt;br&gt;
'''κολακευτικώτερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''κολακευτικός''.&lt;br&gt;
'''κολακευτικῶς (adverbe)''' : flatteusement.&lt;br&gt; 
'''κολακεύω (verbe)''' : flatter.&lt;br&gt;
'''κόλαξ, -κος (nom commun) (m)''' : flatteur.&lt;br&gt;
'''κολάπτω (verbe)''' : frapper.&lt;br&gt;  
'''κόλασις, -άσεως (nom commun) (f)''' : punition.&lt;br&gt; 
'''κολαφίζω (verbe)''' : gifler.&lt;br&gt;
'''κόλαφος, -άφου (nom commun) (m)''' : gifle.&lt;br&gt;
'''κολεός, -οῦ (nom commun) (m)''' : Fourreau ; vagin.&lt;br&gt;
'''κόλλα, -ης (nom commun) (f)''' : colle.&lt;br&gt;
'''κόλλαϐος, -άϐου (nom commun) (m)''' : Gâteau, petit pain. Cheville qui attache les cordes de la lyre.&lt;br&gt;
'''κολλάω (verbe)''' : coller.&lt;br&gt; 
'''κόλλιξ, -κος (nom commun) (m)''' : petit pain.&lt;br&gt;
'''κολλύρα, -ας (nom commun) (f)''' : petit pain.&lt;br&gt;
'''κολλῶ (verbe)''' : .&lt;br&gt;  
'''κολοϐός, -ή, -όν (adjectif)''' : écorné, tronqué ; mutilé.&lt;br&gt;
'''κολοιός, -οῦ  (nom commun) (m)''' : geai.&lt;br&gt; 
'''κόλον, -ου (nom commun) (n)''' : membre, extrémité ; côlon.&lt;br&gt;
'''κολοκύνθη, - (nom commun) (f)''' : .&lt;br&gt;
'''κολοκυνθίς, - (nom commun) (f)''' : .&lt;br&gt;
'''κολοσσός, -οῦ (nom commun) (m)''' : colosse.&lt;br&gt;
'''κολοττός, -οῦ (nom commun) (m)''' : Forme attique de ''κολοσσός''.&lt;br&gt;
'''κολοφών, -ῶνος (nom commun) (m)''' : Sommet. (Figuré) Achèvement, couronnement. Balle de jeu.&lt;br&gt;
'''κόλπος, -ου (nom commun) (m)''' : (Anatomie) Sein (de la mère ou de la nourrice). Utérus. Pli, creux d’un vêtement. Repli, renfoncement de la mer entre deux vagues. Sein de la terre, d’où Enfers. Golfe. Gouffre, cavité ; vallée profonde.&lt;br&gt;
'''κολχικός, -ή, -όν (adjectif)''' : colchien.&lt;br&gt;
'''κολώνη, -ης (nom commun) (f)''' : monticule, tertre ; tumulus.&lt;br&gt;
'''κόμϐος, ου (nom commun) (m)''' : bande.&lt;br&gt;
'''κοµικός, -ή, -όν (adjectif)''' : comique.&lt;br&gt;
'''κοµικότατα, -, - (adverbe)''' : Superlatif de ''κοµικῶς''.&lt;br&gt;
'''κοµικότερον, -, - (adverbe)''' : Comparatif de ''κοµικῶς''.&lt;br&gt;
'''κοµικῶς (adverbe)''' : comiquement.&lt;br&gt;
'''κοµικώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''κοµικός''.&lt;br&gt;
'''κοµικώτερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''κοµικός''.&lt;br&gt;
'''κομπάζω (verbe)''' : hâbler.&lt;br&gt;
'''κομπαστής, -οῦ (nom commun) (m)''' : hâbleur.&lt;br&gt;
'''κομψός, -ή, -όν (adjectif)''' : élégant.&lt;br&gt;
'''κομψότατα, -, - (adverbe)''' : Superlatif de ''κομψῶς''.&lt;br&gt;
'''κομψότερον, -, - (adverbe)''' : Comparatif de ''κομψῶς''.&lt;br&gt;
'''κομψότης, -τος (nom commun) (f)''' : élégance.&lt;br&gt;  
'''κομψῶς (adverbe)''' : élégamment.&lt;br&gt;
'''κομψώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''κομψός''.&lt;br&gt;
'''κομψώτερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''κομψός''.&lt;br&gt;
'''κονδυλισμίς, -δος (nom commun) (f)''' : chiquenaude ; pichenette.&lt;br&gt;
'''κόνδυ, -ος (nom commun) (n)''' : somm e.&lt;br&gt;
'''κονία, -ας (nom commun) (f)''' : poussière.&lt;br&gt;
'''κονίη, -ης (nom commun) (f)''' : Forme homérique et ionienne de ''κονία''.&lt;br&gt; 
'''κόνικλος, -ίκλου (nom commun) (m)''' : lapin.&lt;br&gt; 
'''κόνις, -εως (nom commun) (f)''' : cendre ; poussière.&lt;br&gt;
'''κονίς, -δος (nom commun) (f)''' : lente.&lt;br&gt;
'''κοντά (adverbe)''' : près ; à proximité.&lt;br&gt; 
'''κοντινός, -ή, -όν (adjectif)''' : proche.&lt;br&gt;
'''κοντινῶς (adverbe)''' : .&lt;br&gt;
'''κοντινώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''κοντινός''.&lt;br&gt;
'''κοντινώτερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''κοντινός''.&lt;br&gt;
'''κογχύλιον, -ίου (nom commun) (n)''' : coquillage.&lt;br&gt;
'''κοπριά, -ᾶς (nom commun) (f)''' : fumier.&lt;br&gt;
'''κόπρος, -ου (nom commun) (m)''' : excrément.&lt;br&gt;
'''κόρα, -ας (nom commun) (f)''' : Forme éolienne de ''κόρη''.&lt;br&gt;
'''κόραξ, -κος (nom commun) (m)''' : corbeau.&lt;br&gt;
'''κορέννυμι (verbe)''' : rassasier ; (Au passif et au moyen) Être rassasié. Avoir le dégoût de.&lt;br&gt;
'''κόρευμα, -ύματος (nom commun) (n)''' : virginité.&lt;br&gt;
'''κορεύομαι (verbe)''' : être vierge.&lt;br&gt;
'''κόρη, -ης (nom commun) (f)''' : jeune fille.&lt;br&gt;
'''κορίαννον, -άννου (nom commun) (n)''' : coriandre.&lt;br&gt;
'''κορίζομαι (verbe)''' : caresser.&lt;br&gt;      
'''κορμός, -οῦ (nom commun) (m)''' : .&lt;br&gt;
'''κόρος, -ου (nom commun) (m)''' : Jeune garçon ; satiété, dédain.&lt;br&gt;
'''κόρυζα, -ης (nom commun) (f)''' : coryza.&lt;br&gt;
'''κόρυς, -θος (nom commun) (f)''' : Tête ; casque.&lt;br&gt;
'''κορώνη, -ης (nom commun) (f)''' : corneille.&lt;br&gt;
'''κορωνός, -ή, -όν (adjectif)''' : courbe ; recourbé.&lt;br&gt;
'''κόσμημα, -ήματος (nom commun) (n)''' : bijou.&lt;br&gt;
'''κοσμητικός, -ή, -όν (adjectif)''' : Décoratif ; ordonné.&lt;br&gt;
'''κοσμητής, -οῦ (nom commun) (m)''' : Ordonnateur ; arrangeur.&lt;br&gt;
'''κόσμος, -ου (nom commun) (m)''' : Ordre. Monde ; univers.&lt;br&gt;
'''κόσσυκος, -ύκου (nom commun) (m)''' : Forme de ''κόσσυϕος''.&lt;br&gt;
'''κόσσυϕος, -ύϕου (nom commun) (m)''' : merle.&lt;br&gt;
'''κόσος, -η, -ον (adjectif)''' : Forme ionienne de ''πόσος''.&lt;br&gt;
'''κόττος, -ου (m)''' : coq.&lt;br&gt;
'''κόττυϕος, -ύϕου (nom commun) (m)''' : Forme attique de ''κόσσυϕος''.&lt;br&gt;
'''κοτύλη, -ης (nom commun) (f)''' : écuelle.&lt;br&gt;
'''κουρεύς, -έως (nom commun) (m)''' : barbier.&lt;br&gt;
'''κουρεῖον, -ίου (nom commun) (n)''' : boutique du barbier.&lt;br&gt;
'''κούρη, -ης (nom commun) (f)''' : Forme ionienne de ''κόρη''.&lt;br&gt;
'''κοῦρος, -ύρου (nom commun) (m)''' : Forme ionienne de ''κόρος''.&lt;br&gt;
'''κοῦ (adverbe interrogatif)''' : Forme ionienne de ''ποῦ''.&lt;br&gt;
'''κοῦφος, -ύφη, -ῦφον (adjectif)''' : léger.&lt;br&gt;
'''κουφότατος, -άτη, -ότατον (adjectif)''' : Superlatif de ''κοῦφος''.&lt;br&gt;
'''κουφότερος, -έρα, -ότερον (adjectif)''' : Comparatif de ''κοῦφος''.&lt;br&gt;
'''κούφως (adverbe)''' : légèrement.&lt;br&gt;
'''κόφινος, -ίνου (nom commun) (m)''' : corbeille.&lt;br&gt;
'''κοχλιάριον, -ίου (nom commun) (n)''' : cuillère.&lt;br&gt;
'''κοχλίας, -ου (nom commun) (m)''' : escargot.&lt;br&gt;  
'''κρα (onomatopée)''' : croa.&lt;br&gt; 
'''κράϐατος, -άτου (nom commun) (m)''' : Forme macédonienne de ''κράϐϐατος''.&lt;br&gt;
'''κράϐϐατος, -άτου (nom commun) (m)''' : grabat.&lt;br&gt;
'''κραιπάλη, -ης (nom commun) (f)''' : ivresse.&lt;br&gt;
'''κραίνω (verbe)''' : Commander, gouverner.&lt;br&gt;
'''κράμϐη, -ης (nom commun) (f)''' : chou.&lt;br&gt;
'''κράμϐος, -η, -ον (f)''' : fort (en parlant de la voix ou du son).&lt;br&gt;
'''κρανίον, -ου (nom commun) (n)''' : crâne.&lt;br&gt;
'''κρανοκοπέω (verbe)''' : décapiter.&lt;br&gt;
'''κράνος, -ους (nom commun) (n)''' : casque.&lt;br&gt;
'''κρᾶσις, -άσεως (nom commun) (n)''' : mélange de deux ou plusieurs choses.&lt;br&gt;
'''κράτειρα, -ίρας (nom commun) (f)''' : dirigeante.&lt;br&gt;
'''κράτος, -ους (nom commun) (n)''' : Force du corps, vigueur, solidité. Domination, puissance.&lt;br&gt;
'''κράτωρ, -ορος (nom commun) (m)''' : dirigeant.&lt;br&gt;
'''κραυγάζω (verbe)''' : crier.&lt;br&gt;
'''κραυγή, -ῆς (nom commun) (f)''' : cri.&lt;br&gt;
'''κρέας, -ατος (nom commun) (n)''' : viande.&lt;br&gt;
'''κρεῖας, -ίατος (nom commun) (n)''' : Forme homérique de ''κρέας''.&lt;br&gt;
'''κρείουσα, -ας (nom commun) (f)''' : cri.&lt;br&gt;
'''κρείσσων, -ων, -ον (adjectif)''' : maîtresse ; souveraine.&lt;br&gt;
'''κρείων, -οντος (nom commun) (m)''' : seigneur, maître ; souverain.&lt;br&gt;
'''κρέξ, -κου (nom commun) (m)''' : râle (oiseau).&lt;br&gt;
'''κρέων, -οντος (nom commun) (m)''' : Forme homérique de ''κρείων''.&lt;br&gt;
'''κρημνός, -οῦ (nom commun) (m)''' : falaise, précipice.&lt;br&gt;
'''κρηναῖος, -ία, -ῖον (adjectif)''' : .&lt;br&gt; 
'''κρήνη, -ης (nom commun) (m)''' : Source, puits ; fontaine. (Poétique) (Au pluriel) Eau.&lt;br&gt; 
'''κρηπίς, -ῖδος (nom commun) (f)''' : pantoufle.&lt;br&gt;
'''κρῆσις, -ήσεως (nom commun) (n)''' : Forme ionienne de ''κρᾶσις''.&lt;br&gt;
'''κρῆς, -ήτος (nom commun) (n)''' : Forme dorienne de ''κρέας''.&lt;br&gt;
'''κρίϐανος, -άνου (nom commun) (m)''' : braséro ; four à pain.&lt;br&gt;
'''κρίκος, -ου (nom commun) (m)''' : anneau.&lt;br&gt;
'''κρῖμα, -ίματος (nom commun) (n)''' : Objet de contestation, contestation, querelle. (Par suite) Jugement, décision judiciaire. Condamnation, peine. (Par extension) Jugement, Décision. Action de juger.&lt;br&gt;
'''κριός, -οῦ  (nom commun) (m)''' : bélier.&lt;br&gt;
'''κρίνω (verbe)''' : décider.&lt;br&gt; 
'''κρίσις, -ίσεως (nom commun) (f)''' : décision.&lt;br&gt; 
'''κριτήριον, -ίου (nom commun) (n)''' : test.&lt;br&gt; 
'''κριτήρ, -ῆρος (nom commun) (m)''' : interprète.&lt;br&gt;
'''κριτής, -οῦ  (nom commun) (m)''' : juge.&lt;br&gt;
'''κριτικός, -ή, -όν (adjectif)''' : décisif.&lt;br&gt;
'''κριτικῶς (adverbe)''' : décisivement.&lt;br&gt;
'''κριτικώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''κριτικός''.&lt;br&gt;
'''κριτικώτερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''κριτικός''.&lt;br&gt;
'''κροκόδειλος, -ίλου (nom commun) (m)''' : crocodile.&lt;br&gt;
'''κρόμμυον, -ύου (nom commun) (n)''' : ognon.&lt;br&gt;
'''κρόμυον, -ύου (nom commun) (n)''' : Variante de ''κρόμμυον''.&lt;br&gt;
'''κρόταφος, -άφου  (nom commun) (m)''' : tempe.&lt;br&gt;	
'''κροῦσις, -ύσεως (nom commun) (f)''' : Choc, collision ; impact, percussion.&lt;br&gt; 
'''κρούω (verbe)''' : heurter, choquer. Frapper l’un contre l’autre. Frapper les cordes d’un instrument. Heurter ou pousser pour mettre en mouvement. Heurter avec le doigt pour l’éprouver et le faire résonner. (Figuré) Piquer, chatouiller en parlant de sensations physiques.&lt;br&gt; 
'''κρυμός, -οῦ (nom commun) (m)''' : gel.&lt;br&gt;
'''κρύος, -ους (nom commun) (n)''' : froid glacial. Frisson (de crainte).&lt;br&gt;
'''κρύσταλλος, -άλλου (nom commun) (m)''' : Eau congelée ; verre transparent.&lt;br&gt;
'''κροκόδειλος, -ίλου (nom commun) (m)''' : crocodile.&lt;br&gt;
'''κρόκος, -ου (nom commun) (m)''' : safran.&lt;br&gt;
'''κρυπτός, -ός, -όν (adjectif)''' :  caché, secret.&lt;br&gt;
'''κρύπτω (verbe)''' : cacher.&lt;br&gt;
'''κρυφᾷ (adverbe)''' : Forme dorienne de ''κρυφῇ''.&lt;br&gt;
'''κρυφῇ (adverbe)''' : secrètement.&lt;br&gt;
'''κρύφος, -ου (nom commun) (f)''' : Action de cacher ; cachette.&lt;br&gt;
'''κρωγμός, -οῦ (nom commun) (m)''' : croassement.&lt;br&gt;
'''κρώζω (verbe)''' : croasser.&lt;br&gt;
'''κρωσσίον, -ου (nom commun) (n)''' : cruche.&lt;br&gt;
'''κρωσσός, -οῦ (nom commun) (m)''' : jarre ; urne.&lt;br&gt;
'''κτείνω (verbe)''' : tuer.&lt;br&gt;
'''κτείς, -ενός (nom commun) (m)''' : Peigne. Râteau. (Au pluriel) Doigts.&lt;br&gt;
'''κτένιον, -ίου (nom commun) (m)''' : Diminutif de ''κτείς''.&lt;br&gt;
'''κτῆνος, -ήνους (nom commun) (n)''' : (Au pluriel) Bétail. (Au singulier) Bête domestique.&lt;br&gt;
'''κτίριον, -ίου (nom commun) (n)''' : bâtiment.&lt;br&gt;
'''κτυπέω (verbe)''' : claquer.&lt;br&gt;
'''κτύπημα, -ήματος (nom commun) (n)''' : claquement.&lt;br&gt; 
'''κτῶμαι (verbe)''' : acquérir.&lt;br&gt;
'''κυανός, -ή, -όν (adjectif)''' : bleu.&lt;br&gt;
'''κυϐέρνησις, -ήσεως (nom commun) (f)''' : pilotage ; gouvernement.&lt;br&gt; 
'''κυϐερνήτης, -ου (nom commun) (m)''' : pilote ; gouverneur.&lt;br&gt;  
'''κυϐερνητικός, -ή, -όν (adjectif)''' : pilotable ; gouvernemental.&lt;br&gt;  
'''κυϐερνισμός, -οῦ (nom commun) (m)''' : pilotage ; gouvernement.&lt;br&gt;
'''κυϐερνῶ (verbe)''' : piloter ; gouverner.&lt;br&gt; 
'''κῦδος, -ύδους (nom commun) (n)''' : gloire ; renommée.&lt;br&gt; 
'''κυῶ (verbe)''' : .&lt;br&gt;
'''κύημα, -ήματος (nom commun) (n)''' : vague.&lt;br&gt; 
'''κύησις, -ήσεως (nom commun) (f)''' : grossesse.&lt;br&gt;  
'''κύκλος, -ου (nom commun) (m)''' : cercle ; rond.&lt;br&gt;  
'''κυκλῶ (verbe)''' : Tourner, rouler. Envelopper, cerner.&lt;br&gt;
'''κύκλωμα, -ώματος (nom commun) (n)''' : circuit.&lt;br&gt; 
'''κυκλών, -ῶνος (nom commun) (m)''' : cyclone.&lt;br&gt;
'''κύκνος, -ου (nom commun) (m)''' : cygne.&lt;br&gt; 
'''κυλινδρικός, -ή, -όν (adjectif)''' : cylindrique.&lt;br&gt;
'''κύλινδρος, -ίνδρου (nom commun) (m)''' : cylindre.&lt;br&gt;
'''κυλίνδω (verbe)''' : rouler.&lt;br&gt;
'''κύλιξ, -κος (nom commun) (f)''' : coupe (récipient).&lt;br&gt;  
'''κυλλός, -ή, -όν (adjectif)''' : Forme chypriote de ''χωλός''.&lt;br&gt; 
'''κῦμα, -ύματος (nom commun) (n)''' : onde ; vague.&lt;br&gt; 
'''κυναλώπηξ, -εκος (nom commun) (f)''' : .&lt;br&gt;
'''κυνηγός, -οῦ (nom commun) (m)''' : chasseur.&lt;br&gt;
'''κυνηγῶ (verbe)''' : chasser.&lt;br&gt;
'''κύνικλος, -ίκλου (nom commun) (m)''' : Forme de ''κόνικλος''.&lt;br&gt; 
'''κυνικός, -ή, -όν (adjectif)''' : canin ; (Philosophie) cynique.&lt;br&gt;
'''κυπάρισσος, -ίσσου (nom commun) (f)''' : cyprès.&lt;br&gt;
'''κυπάριττος, -ίττου (nom commun) (f)''' : Forme attique de ''κυπάρισσος''.&lt;br&gt;
'''κυπρῖνος, -ίνου (nom commun) (m)''' : carpe.&lt;br&gt;
'''κύπτω (verbe)''' : se baisser en avant. Baisser la tête (ou les yeux) de honte.&lt;br&gt;
'''κυρία, -ας (nom commun) (f)''' :  maîtresse ; souveraine.&lt;br&gt;
'''κυριακός, -ή, -όν (adjectif)''' : seigneurial.&lt;br&gt;
'''κύριος, -ίου (nom commun) (m)''' : maître ; souverain.&lt;br&gt;
'''κύρος, -ους (nom commun) (n)''' : prestige.&lt;br&gt;
'''κῦρος, -ύρου (nom commun) (m)''' : décret.&lt;br&gt;
'''κῦρρος, -ύρρου (nom commun) (m)''' : Forme thessalienne de ''κύριος''.&lt;br&gt; 
'''κύρωσις, -ώσεως (nom commun) (f)''' : sanction.&lt;br&gt; 
'''κυρῶ (verbe)''' : confirmer, ratifier ; sanctionner.&lt;br&gt;
'''κυσός, -οῦ (nom commun) (m)''' : sexe de la femme.&lt;br&gt; 
'''κύστιγξ, -γος (nom commun) (f)''' : vésicule.&lt;br&gt; 
'''κύστις, -εως (nom commun) (f)''' : sac ; (Au pluriel) Poches sous les yeux.&lt;br&gt;
'''κύσσω (verbe)''' : Forme poétique de ''κύσω''.&lt;br&gt;
'''κύσω (verbe)''' : donner un baiser.&lt;br&gt;
'''κύτος, -ους (nom commun) (n)''' : Creux d'un navire, d'un bouclier, d'une cuirasse. Objet creux. Qui recouvre ou enveloppe.&lt;br&gt; 
'''κυφός, -ή, -όν (adjectif)''' : Arqué, bossu. Courbé.&lt;br&gt;
'''κυφότατος, -έρα, -ότερον (adjectif)''' : Comparatif de ''κυφός''.&lt;br&gt;
'''κυφότερος, -άτη, -ότατον (adjectif)''' : Superlatif de ''κυφός''.&lt;br&gt;
'''κύφων, -ονος (nom commun) (m)''' : pilori.&lt;br&gt;
'''κύφωσις, -ώσεως (nom commun) (f)''' : .&lt;br&gt;
'''κυφῶς (adverbe)''' : .&lt;br&gt;
'''κύψελος, -έλου (nom commun) (m)''' : martinet (oiseau).&lt;br&gt;
'''κύων, -ός (nom commun) (m/f)''' : chien(ne).&lt;br&gt;
'''κωδωνίζω (verbe)''' : sonner les cloches.&lt;br&gt;
'''κωδώνιον, -ίου (nom commun) (n)''' : clochette.&lt;br&gt;
'''κωδωνόκροτος, - ()''' : .&lt;br&gt;
'''κωδωνοφαλαρόπωλος, - ()''' : .&lt;br&gt;
'''κωδωνοφορέω (verb)''' : .&lt;br&gt;
'''κώδων, -ος (nom commun) (m)''' : cloche.&lt;br&gt;
'''κωκύω (verbe)''' : .&lt;br&gt;  
'''κώληψ, -πος (nom commun) (f)''' : jarret.&lt;br&gt;
'''κωλοϐαθριστής, -οῦ (nom commun) (m)''' : Acrobate marchant sur des échasses.&lt;br&gt;
'''κωλόϐαθρον, -άθρου (nom commun) (n)''' : échasse.&lt;br&gt;
'''κῶλον, -ώλου (nom commun) (n)''' : .&lt;br&gt;
'''κώμη, -ης (nom commun) (f)''' : village ; quartier.&lt;br&gt;
'''κωμικός, -ή -όν (adjectif)''' : comique.&lt;br&gt; 
'''κωµικότατα, -, - (adverbe)''' : Superlatif de ''κωµικῶς''.&lt;br&gt;
'''κωµικότερον, -, - (adverbe)''' : Comparatif de ''κωµικῶς''.&lt;br&gt;
'''κωµικῶς (adverbe)''' : comiquement.&lt;br&gt;
'''κωµικώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''κωµικός''.&lt;br&gt;
'''κωµικώτερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''κωµικός''.&lt;br&gt;
'''κῶμος, -ώμου (nom commun) (m)''' : Festin, banquet. (Par extension) Troupe impétueuse (en parlant des Érinyes), bande.&lt;br&gt;
'''κωμόπολις, -όλεως (nom commun) (n)''' : bourgade.&lt;br&gt;
'''κωμῳδία, -ας (nom commun) (f)''' : poésie satirique.&lt;br&gt;
'''κωνωπεῖον, -ίου (nom commun) (n)''' : moustiquaire.&lt;br&gt;
'''κώνωψ, -ωπος (nom commun) (m)''' : cousin (genre de moustique) ; moucheron.&lt;br&gt;
'''κώπα, -ας (nom commun) (f)''' : Forme dorienne de ''κώπη''.&lt;br&gt;
'''κωπέω (f)''' : ramer.&lt;br&gt;
'''κώπη, -ης (nom commun) (f)''' : Anse, poignée (d’une rame), manche. Rame.&lt;br&gt;
'''κωπίον, -ίου (nom commun) (n)''' : Diminutif de ''κώπη''.&lt;br&gt;
'''κώρα, -ας (nom commun) (f)''' : Forme dorienne de ''κόρη''.&lt;br&gt;  
'''κῶρος, -ώρου (nom commun) (m)''' : Forme dorienne de ''κόρος''.&lt;br&gt;
'''κῶς (adverbe)''' : Forme ionienne de ''πῶς''.&lt;br&gt;
'''κώταλις, - (nom commun) (f)''' : cuillère.&lt;br&gt;
'''κωφός, -ή -όν (adjectif)''' : sourd.&lt;br&gt; 
'''Καικιλία, -ας (nom propre) (f)''' : Cécile.&lt;br&gt; 
'''Καικίλιος, -ίου (nom propre) (m)''' : Cécilius.&lt;br&gt; 
'''Κάϊν (nom propre) (m)''' : Caïn.&lt;br&gt; 
'''Καινὴ Διαθήκη (locution nominale) (f)''' : Nouveau Testament.&lt;br&gt;
'''Καῖσαρ, -ίσαρος (nom propre) (m)''' : César.&lt;br&gt; 
'''Καλλίας, -ου  (nom propre) (m)''' : Callias.&lt;br&gt; 
'''Καλλικρατίδας, -ου (nom propre) (m)''' : Callicratidas.&lt;br&gt;
'''Καλλίμαχος, -άχου (nom propre) (m)''' : Callimaque.&lt;br&gt;
'''Καλλιόπη, -ης (nom propre) (f)''' : Calliope.&lt;br&gt;
'''Καλλιρόη, -ης (nom propre) (f)''' : Callirhoé.&lt;br&gt;
'''Καλλιστώ, -οῦς (nom propre) (f)''' : Callisto.&lt;br&gt;
'''Καλυψώ, -οῦς (nom propre) (f)''' : Calypso.&lt;br&gt;
'''Καμϐύσης, -ου (nom propre) (m)''' : Cambyse.&lt;br&gt; 
'''Κανδάκη, -ης (nom propre) (f)''' : Candace.&lt;br&gt;
'''Καρδοῦχος, -ύχου (nom commun) (m)''' : Kurde.&lt;br&gt;
'''Καρκίνος, -ου (nom propre) (m)''' : Cancer.&lt;br&gt;
'''Κᾶρ, -άρος (nom propre) (f)''' : Forme éolienne de ''Κήρ''.&lt;br&gt;
'''Καρχηδόνιος, -ίου (nom commun) (m)''' : Carthaginois.&lt;br&gt;
'''Καρχηδών, -όνος (nom propre) (f)''' : Carthage.&lt;br&gt;
'''Κασσάνδρα, -ας (nom propre) (f)''' : Cassandre.&lt;br&gt;
'''Κάσσανδρος, -άνδρου (nom commun) (m)''' : Cassandre.&lt;br&gt;
'''Κελτίς, -δος (nom commun) (f)''' : Celte.&lt;br&gt;
'''Κελτός, -οῦ (nom commun) (m)''' : Celte.&lt;br&gt;
'''Κερασούντιος, -α, -ον (adjectif)''' : cérasien.&lt;br&gt;
'''Κερασοῦς, -ῦντος (nom commun) (m)''' : Cérasus.&lt;br&gt;
'''Κέρϐερος, -έρου (nom propre) (m)''' : Cerbère.&lt;br&gt;
'''Κέρκωψ, -πος (nom propre) (m)''' : Cercops.&lt;br&gt;
'''Κήρ, -ός (nom propre) (f)''' : Une des Kères.&lt;br&gt;
'''Κηφισιά, -ᾶς (nom propre) (f)''' : Céphisia.&lt;br&gt;
'''Κικέρων, -ος (nom propre) (m)''' : Cicéron.&lt;br&gt;
'''Κιλικία, -ας (nom propre) (f)''' : Cilicie.&lt;br&gt;
'''Κίρκη, -ης (nom propre) (f)''' : Circé.&lt;br&gt;
'''Κλεάνθης, -ου (nom propre) (m)''' : Cléante.&lt;br&gt;
'''Κλεισθένης, -ους (nom propre) (m)''' : Clisthène.&lt;br&gt;
'''Κλείτανδρος, -άνδρου (nom propre) (m)''' : Clitandre.&lt;br&gt;
'''Κλειτόμαχος, -άχου (nom propre) (m)''' : Clitomaque.&lt;br&gt;
'''Κλεῖτος, -ίτου (nom propre) (m)''' : Cleithos.&lt;br&gt;
'''Κλειτοφῶν, -τος (nom propre) (m)''' : Clitophon.&lt;br&gt;
'''Κλειώ, -οῦς (nom propre) (f)''' : Clio.&lt;br&gt;
'''Κλεoμήδης, -ους (nom propre) (m)''' : Cléomède.&lt;br&gt;
'''Κλεοπᾶς, -ᾶ (nom propre) (m)''' : Cléopas.&lt;br&gt;
'''Κλεοπάτρα, -ας (nom propre) (f)''' : Cléopâtre.&lt;br&gt;
'''Κλεόπατρος, -άτρου (nom propre) (m)''' : Cléopatros.&lt;br&gt;
'''Κλεώνυμος, -ύμου (nom propre) (m)''' : Cléonyme.&lt;br&gt;
'''Κλωθώ, -οῦς (nom propre) (f)''' : Clotho (première Moire).&lt;br&gt;
'''Κόϊντος, -ΐντου (nom propre) (m)''' : Quentin.&lt;br&gt;
'''Κοῖος, -ίου (nom propre) (m)''' : Céos.&lt;br&gt;
'''Κολοφών, -ῶνος (nom commun) (m)''' : Colophon (ville).&lt;br&gt;
'''Κολχίς, -δος (nom propre) (f)''' : Colchide.&lt;br&gt;
'''Κολχός, -οῦ (nom commun) (m)''' : Colchien.&lt;br&gt;
'''Κόνων, -ος (nom commun) (m)''' : Conon.&lt;br&gt;
'''Κόραμα, -ας (nom propre) (f)''' : Göreme.&lt;br&gt;
'''Κορίνθιος, -ίου (nom commun) (f)''' : Corinthien.&lt;br&gt;
'''Κόρινθος, -ίνθου (nom propre) (f)''' : Corinthe.&lt;br&gt;
'''Κορσίς, -δος (nom propre) (f)''' : Corse.&lt;br&gt;
'''Κόρκυρα, -ύρας (nom propre) (f)''' : Corcyre.&lt;br&gt;
'''Κορυφώ, -οῦς (nom propre) (m)''' : Corfou (île).&lt;br&gt;
'''Κότταλος, -άλου (nom propre) (m)''' : Cottalos.&lt;br&gt;
'''Κράτος, -ους (nom propre) (m)''' : Cratos.&lt;br&gt;
'''Κρατύλος, -ου (nom propre) (m)''' : Cratyle.&lt;br&gt;
'''Κρεῖος, -ίου (nom propre) (m)''' : Crios.&lt;br&gt;
'''Κρέουσα, -ας (nom propre) (f)''' : Créuse.&lt;br&gt;
'''Κρέων, -οντος (nom propre) (m)''' : Créon.&lt;br&gt;
'''Κριός, -οῦ (nom propre) (m)''' : Bélier.&lt;br&gt;
'''Κρίτοϐουλος, -ύλου (nom propre) (m)''' : Critobule.&lt;br&gt;
'''Κροῖσος, -ίσου (nom propre) (m)''' : Crésus.&lt;br&gt;
'''Κρίτοϐουλος, -ύλου (nom propre) (m)''' : Critobule.&lt;br&gt;
'''Κροκοδειλόπολις, -όλεως (nom propre) (f)''' : Fayoum.&lt;br&gt;
'''Κτησιφῶν, -τος (nom propre) (m)''' : Ctésiphon.&lt;br&gt;
'''Κτιμένη, -ης (nom propre) (f)''' : Ctimène (sœur d'Ulysse).&lt;br&gt;
'''Κυαξάρης, -ου (nom propre) (m)''' : Cyaxare.&lt;br&gt;
'''Κύθηρα, -ήρων (nom propre) (n)''' : Cythère.&lt;br&gt;
'''Κυθήριος, -ίου (nom commun)''' : Cythérien.&lt;br&gt;
'''Κύκλωψ, -ωπος (nom propre) (m)''' : Cyclope.&lt;br&gt;
'''Κυνόσαργες, -ων (nom propre) (m)''' : Cynosarges.&lt;br&gt;
'''Κύπριος, -ίου  (nom commun) (m)''' : Chypriote.&lt;br&gt; 
'''Κύπρος, -ου (nom propre) (f)''' : Chypre.&lt;br&gt; 
'''Κύριλλος, -ίλλου (nom propre) (m)''' : Cyrille.&lt;br&gt;
'''Κύριος, -ίου (nom propre) (m)''' : Seigneur.&lt;br&gt;
'''Κύρνιος, -ίου  (nom commun) (m)''' : Corse.&lt;br&gt; 
'''Κύρνος, -ου  (nom propre) (f)''' : Corse.&lt;br&gt; 
'''Κῦρος, -ύρου (nom propre) (m)''' : Cyrus.&lt;br&gt;
'''Κύψελος, -έλου (nom propre) (m)''' : Cypsélos.&lt;br&gt;
'''Κωκυτός, -τοῦ (nom propre) (m)''' : Cocyte.&lt;br&gt;
'''Κωνσταντῖνος, -ίνου (nom propre) (m)''' : Constantin.&lt;br&gt;
'''Κωνσταντινούπολις, -όλεως  (nom propre) (f)''' :  Constantinople.&lt;br&gt;

==Λ==
'''λαϐή, -ῆς (nom commun) (f)''' : anse.&lt;br&gt;  
'''λάϐρυς, -εως (nom commun) (f)''' : labrys.&lt;br&gt; 
'''λαϐύρινθος, -ίνθου (nom commun) (m)''' : labyrinthe.&lt;br&gt; 
'''λάγανον, -άνου (nom commun) (n)''' : crêpe.&lt;br&gt;
'''λαγαρός, -ά, -όν (adjectif)''' : Creux, enfoncé ; lâche, ample.&lt;br&gt;  
'''λαγνεία, -ας (nom commun) (f)''' : libertinage.&lt;br&gt;
'''λάγνευμα, -ύματος (nom commun) (n)''' : coït (acte).&lt;br&gt;
'''λαγνεύω (verbe)''' : coïter.&lt;br&gt;
'''λάγνης, -ης, -ες (adjectif)''' : Forme attique de ''λάγνος''.&lt;br&gt;
'''λάγνος, -α, -ον (adjectif)''' : libertin, débauché.&lt;br&gt; 
'''λαγός, -οῦ  (nom commun) (m)''' : lièvre.&lt;br&gt;
'''λάγυνος, -ύνου (nom commun) (m/f)''' : flacon, pichet.&lt;br&gt;
'''λαγών, -όνος (nom commun) (m)''' : flanc.&lt;br&gt;
'''λαγώς, -ώ (nom commun) (m)''' : Forme attique de ''λαγός''.&lt;br&gt;
'''λᾴα -ας (nom commun) (f)''' : Forme dorienne de ''λεία''.&lt;br&gt;
'''λάθος, -ους (nom commun) (n)''' : erreur.&lt;br&gt; 
'''λαϊκός, -ή, -όν (adjectif)''' : populaire.&lt;br&gt; 
'''λαϊκῶς (adverbe)''' : populairement.&lt;br&gt;
'''λαϊκώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''λαϊκός''.&lt;br&gt;
'''λαϊκώτερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''λαϊκός''.&lt;br&gt;
'''λαϊκώτατα, -, - (adverbe)''' : Superlatif de ''λαϊκῶς''.&lt;br&gt;
'''λαϊκώτερον, -, - (adverbe)''' : Comparatif de ''λαϊκῶς''.&lt;br&gt; 
'''λαιµός, -οῦ (nom commun) (m)''' : cou, gorge.&lt;br&gt;
'''λαῖον, -ίου (nom commun) (n)''' : faux.&lt;br&gt; 
'''λαιός, -ά, -όν (adjectif)''' : qui est à gauche.&lt;br&gt; 
'''λαιψηρός, -ά, -όν (adjectif)''' : agile, véhément.&lt;br&gt; 
'''λαιψηρότατος, -άτη, -ότατον (adjectif)''' : Superlatif de ''λαιψηρός''.&lt;br&gt;
'''λαιψηρότερος, -έρα, -ότερον (adjectif)''' : Comparatif de ''λαιψηρός''.&lt;br&gt;
'''λαιψηρῶς (adverbe)''' : agilement, véhémentement.&lt;br&gt;
'''λάκτισμα, -ίσματος (nom commun) (n)''' : coup de pied.&lt;br&gt;	
'''λάκυθος, -ύθου (nom commun) (f)''' : Forme dorienne de ''λήκυθος''.&lt;br&gt;
'''λακωνικός, -ή, -όν (adjectif)''' : concis.&lt;br&gt;
'''λακωνικότης, -τος (nom commun) (f)''' : concision.&lt;br&gt;
'''λακωνικῶς (adverbe)''' : concisément.&lt;br&gt;
'''λακωνικώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''λακωνικός''.&lt;br&gt;
'''λακωνικώτερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''λακωνικός''.&lt;br&gt;
'''λᾳστής, -οῦ (nom commun) (m)''' : Forme dorienne de ''λῃστής''.&lt;br&gt;
'''λαλέω (verbe)''' : Babiller, bavarder.&lt;br&gt;
'''λαλιά, -ᾶς (nom commun) (f)''' : Babil, bavardage.&lt;br&gt;
'''λάλος, -ος, -ον (adjectif)''' : Babillard, bavard.&lt;br&gt;
'''λαμϐάνω (verbe)''' : prendre.&lt;br&gt;
'''λάμϐδα (nom commun) (n)''' : lambda.&lt;br&gt;
'''λαμπάς, -δος (nom commun) (f)''' : torche.&lt;br&gt;
'''λαμπέτης, -ου (nom commun) (m)''' : .&lt;br&gt;
'''λαμπέτις, -δος (nom commun) (f)''' : .&lt;br&gt;
'''λάμπη, -ης (nom commun) (f)''' : Forme homérique et ionienne de ''λαμπάς''.&lt;br&gt;
'''λαμπηδών, -όνος (nom commun) (f)''' : brillance des yeux.&lt;br&gt;
'''λαμπρός, -ά, -όν (adjectif)''' : brillant.&lt;br&gt;
'''λαμπρῶς (verbe)''' : brillamment.&lt;br&gt;
'''λαμπρώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''λαμπρός''.&lt;br&gt;
'''λαμπρώτερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''λαμπρός''.&lt;br&gt;
'''λαμπτήρ, -ῆρος (nom commun) (m)''' : briquet, lanterne ; torche.&lt;br&gt;
'''λαμπυρίς, -δος (nom commun) (f)''' : ver luisant.&lt;br&gt;
'''λάμπω (verbe)''' : briller.&lt;br&gt;
'''λάμψις, -εως (nom commun) (f)''' : brillance des étoiles, des éclairs, du Soleil.&lt;br&gt;
'''λανθάνω (verbe)''' : être caché, faire oublier.&lt;br&gt;
'''λαός, -οῦ (nom commun) (m)''' : peuple.&lt;br&gt;
'''λάριξ, -κος (nom commun) (m)''' : mélèze.&lt;br&gt;
'''λάρυγξ, -γος (nom commun) (m)''' : larynx. (Par suite) Gorge, gosier.&lt;br&gt;
'''λάσανον, -άνου (nom commun) (n)''' : Casserole, marmite ; pot.&lt;br&gt;
'''λατρεία, -ας (nom commun) (f)''' : service à gages. Service d’un dieu ; culte, adoration. Soins à donner au corps ou à l'âme.&lt;br&gt;
'''λατρεύς, -έως (nom commun) (m)''' : serviteur engagé.&lt;br&gt;  
'''λατρεύω (verbe)''' : Être serviteur à gages. (Généralement) Servir que ce soit en parlant d’homme libre ou d’esclaves. (En particulier) Être serviteur de Dieu.&lt;br&gt;
'''λάτρης, -ου (nom commun) (n)''' : adorateur.&lt;br&gt;
'''λάτρον, -ου (nom commun) (n)''' : Gage, salaire ; rémunération.&lt;br&gt;
'''λάφυρον, -ύρου (nom commun) (n)''' : butin.&lt;br&gt;
'''λέαινα, -ίνης (nom propre) (f)''' : lionne.&lt;br&gt;
'''λέϐης, -τος (nom commun) (m)''' : chaudière.&lt;br&gt;
'''λέγω (verbe)''' : choisir.&lt;br&gt;
'''λεία, -ας (nom commun) (f)''' : pillage.&lt;br&gt;
'''λείϐω (verbe)''' : verser.&lt;br&gt;
'''λειμών, -ῶνος (nom commun) (m)''' : pré.&lt;br&gt;
'''λειμωνήρης, -ης, -ες  (adjectif)''' : .&lt;br&gt;
'''λειμωνιάς, -δος (nom commun) (f)''' : lémoniade.&lt;br&gt;
'''λειμώνιον, -ίου (nom commun) (n)''' : .&lt;br&gt;
'''λειμώνιος, -α, -ον (adjectif)''' : .&lt;br&gt;
'''λειμωνίς, -δος (nom commun) (f)''' : lémoniade.&lt;br&gt;
'''λειμωνοειδής, -ής, -ές  (adjectif)''' : .&lt;br&gt;
'''λειμωνόθεν (adverbe)''' : .&lt;br&gt;
'''λεῖος, -ία, -ῖον (adjectif)''' : lisse, uni.&lt;br&gt;
'''λείριον, -ίου (nom commun) (n)''' : lis (fleur).&lt;br&gt; 
'''λειτούργημα, -ήματος (nom commun) (n)''' : .&lt;br&gt; 
'''λειτουργία, -ας (nom commun) (f)''' : Cérémonie publique, service public.&lt;br&gt;
'''λειτουργός, -οῦ (nom commun) (m)''' : Ministre, fonctionnaire. (Religion) Ministre du culte.&lt;br&gt;
'''λειχήν, -ῆνος (nom commun) (m)''' : Lèpre, dartre sur le corps de l’homme. Cal sur la jambe du cheval. Lichen.&lt;br&gt; 
'''λείχω (verbe)''' : lécher.&lt;br&gt;
'''λεξικός, -ή, -όν (adjectif)''' : lexical.&lt;br&gt; 
'''λεξικόν, -οῦ (nom commun) (n)''' : dictionnaire.&lt;br&gt;
'''λεξικῶς (adverbe)''' : lexicalement.&lt;br&gt;
'''λεξικώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''λεξικός''.&lt;br&gt;
'''λεξικώτερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''λεξικός''.&lt;br&gt;
'''λέξις, -εως (nom commun) (f)''' : Parole, action de parler. Élocution, style, manière de parler.&lt;br&gt; 
'''λεόντειος, -ος, -ον (adjectif)''' : léonin.&lt;br&gt; 
'''λεπίς, -δος (nom commun) (f)''' : Coque d’œuf. Lamelle de métal.&lt;br&gt;
'''λεπτότης, -τος (nom commun) (f)''' : Minceur. Délicatesse.&lt;br&gt;
'''λεπτός, -ή, -όν (adjectif)''' : Dépouillé de sa peau, de sa pellicule. Mince. Délicat.&lt;br&gt;	
'''λεπτότατος, -άτη, -ότατον (adjectif)''' : Superlatif de ''λεπτός''.&lt;br&gt;
'''λεπτότερος, -έρα, -ότερον (adjectif)''' : Comparatif de ''λεπτός''.&lt;br&gt;
'''λεπτῶς (adverbe)''' : Mincement. Délicatement&lt;br&gt; 
'''λέπω (verbe)''' : Peler, écosser ; écorcher.&lt;br&gt;
'''λευγαλέος, -α, -ον  (adjectif)''' : Triste, malheureux. Irrité, funeste. Désolé.&lt;br&gt;
'''λευκός, -ή, -όν (adjectif)''' : blanc.&lt;br&gt;
'''λεύκη, -ης (nom commun) (f)''' : peuplier.&lt;br&gt;
'''λεύσσω (verbe)''' : voir.&lt;br&gt;
'''λεώϐατος (nom commun)''' : .&lt;br&gt;
'''λεωλογέω (verbe)''' : .&lt;br&gt;
'''λέων, -οντος (nom commun) (m)''' : lion.&lt;br&gt;
'''λεώς, -ώ (nom commun) (m)''' : Forme attique de ''λαός''.&lt;br&gt;
'''λεωσφέτερος''' : .&lt;br&gt;
'''λεωφόρος, -ου (nom commun) (f)''' : Avenue, boulevard.&lt;br&gt;
'''λήθαιος, -α, -ον (adjectif)''' : .&lt;br&gt;
'''ληθάνω (verbe)''' : faire oublier.&lt;br&gt;
'''ληθαργέω (verbe)''' : oublier.&lt;br&gt;
'''ληθαργία, -ας (nom commun) (f)''' : léthargie.&lt;br&gt;
'''ληθαργικός, -ή, -όν (adjectif)''' : léthargique.&lt;br&gt;
'''ληθαργικῶς (adverbe)''' : léthargiquement.&lt;br&gt;
'''ληθαργικώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''ληθαργικός''.&lt;br&gt;
'''ληθαργικώτερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''ληθαργικός''.&lt;br&gt;
'''ληθαργικώτατα, -, - (adverbe)''' : Superlatif de ''ληθαργικῶς''.&lt;br&gt;
'''ληθαργικώτερον, -, - (adverbe)''' : Comparatif de ''ληθαργικῶς''.&lt;br&gt;
'''λήθαργος, -άργου (nom commun) (m)''' : torpeur.&lt;br&gt;
'''λήθη, -ης (nom commun) (f)''' : oubli.&lt;br&gt;
'''ληΐη, -ης (nom commun) (f)''' : Forme ionienne de ''λεία''.&lt;br&gt;
'''ληΐς, - (nom commun) (f)''' : Forme homérique de ''λεία''.&lt;br&gt;
'''ληϊστής, -οῦ (nom commun) (m)''' : Forme ionienne de ''λῃστής''.&lt;br&gt;
'''λήιτον, -ίτου (nom commun) (n)''' : (En Achaïe) mairie.&lt;br&gt;
'''λήκυθος, -ύθου (nom commun) (f)''' : petit vase.&lt;br&gt;
'''λῃστής, -οῦ (nom commun) (m)''' : voleur, brigand. (en particulier) Pirate.&lt;br&gt;
'''λῆξις, -ήξεως (nom commun) (f)''' : tirage au sort.&lt;br&gt; 
'''λῆμμα, -ήμματος (nom commun) (n)''' : Bénéfice, salaire, recette. Gain, profit. Bénéfice.&lt;br&gt; 	
'''λημματιστής, -οῦ (nom commun) (m)''' : receveur.&lt;br&gt;
'''λῆνος, -ήνους (nom commun) (n)''' : laine.&lt;br&gt;
'''ληός, -οῦ (nom commun) (m)''' : Forme ionienne de ''λαός''.&lt;br&gt;
'''λησμοσύνη, -ης (nom commun) (f)''' : oubli.&lt;br&gt;
'''λῆψις, -ήψεως (nom commun) (f)''' : prise.&lt;br&gt;
'''λίϐανος, -άνου (nom commun) (m)''' : oliban.&lt;br&gt;  
'''λιϐάς, -δος (nom commun) (f)''' : prairie.&lt;br&gt;  
'''λίθος, -ου (nom commun) (m)''' : pierre.&lt;br&gt;
'''λιμήν, -ένος (nom commun) (m)''' : port.&lt;br&gt; 
'''λίμνη, -ης (nom commun) (f)''' : lac.&lt;br&gt; 
'''λιµός, -οῦ (nom commun) (m)''' : faim.&lt;br&gt;
'''λιποθυμῶ (verbe)''' : s’évanouir.&lt;br&gt;
'''λίπος, -ους (nom commun) (n)''' : graisse ; gras.&lt;br&gt;
'''λιπόψυχος, -ος, -ον (adjectif)''' : pusillanime.&lt;br&gt;
'''λιτότης, -τος (nom commun) (f)''' : simplicité.&lt;br&gt; 
'''λιτός, -ή, -όν (adjectif)''' : Uni. Simple, sans apprêts. (Par extension) Pauvre, chétif, faible, petit.&lt;br&gt; 
'''λίψ, -ϐος (nom commun) (m)''' : sud-ouest.&lt;br&gt;
'''λογίζομαι (verbe)''' : .&lt;br&gt; 
'''λογικός, -ή, -όν (adjectif)''' : intellectuel ; rationnel.&lt;br&gt; 
'''λογικότατος, -άτη, -ότατον (adjectif)''' : Superlatif de ''λογικός''.&lt;br&gt;
'''λογικότερος, -έρα, -ότερον (adjectif)''' : Comparatif de ''λογικός''.&lt;br&gt;
'''λογικότατα, -, - (adverbe)''' : Superlatif de ''λογικῶς''.&lt;br&gt;
'''λογικότερον, -, - (adverbe)''' : Comparatif de ''λογικῶς''.&lt;br&gt;
'''λογικῶς (adverbe)''' : intellectuellement ; rationnellement.&lt;br&gt;
'''λόγιον, -ίου (nom commun) (n)''' : oracle.&lt;br&gt; 
'''λόγος, -ου (nom commun) (m)''' : discours, sujet ; parole.&lt;br&gt;
'''λοιμός, -οῦ (nom commun) (m)''' : peste.&lt;br&gt;
'''λοίμωξις, -ώξεως (nom commun) (f)''' : infestation.&lt;br&gt;
'''λοπαδοτεμαχοσελαχογαλεοκρανιολειψανοδριμυποτριμματοσιλφιοκαραϐομελιτοκατακεχυμενοκιχλεπικοσσυφοφαττοπεριστεραλεκτρυονοπτεκεφαλλιοκιγκλοπελειολαγῳ-οσιραιοϐαφητραγανοπτερυγών (nom commun) (m)''' : bigornocabillofricandortolangoustabricobouillabopoulaupococovin (Plat formé de dix-sept ingrédients différents, décrit par Aristophane dans ''L’Assemblée des femmes''. (v. 1169-1174)&lt;br&gt;
'''λόγχη, -ης (nom commun) (f)''' : lance.&lt;br&gt;	
'''λοπάς, -δος (nom commun) (f)''' : écuelle.&lt;br&gt;
'''λορδός, -ή, -όν (adjectif)''' : courbé.&lt;br&gt;	
'''λορδότατος, -έρα, -ότερον (adjectif)''' : Comparatif de ''λορδός''.&lt;br&gt;
'''λορδότερος, -άτη, -ότατον (adjectif)''' : Superlatif de ''λορδός''.&lt;br&gt;
'''λορδῶς (adverbe)''' : .&lt;br&gt;
'''λουτήρ, -ῆρος (nom commun) (m)''' : baignoire.&lt;br&gt;
'''λούω (verbe)''' : baigner.&lt;br&gt;
'''λόφος, -ου (nom commun) (m)''' : colline.&lt;br&gt;
'''λοχαγός, -οῦ (nom commun) (m)''' : capitaine.&lt;br&gt;
'''λόχος, -ου (nom commun) (m)''' : compagnie.&lt;br&gt; 
'''λύγη, -ης (nom commun) (f)''' : crépuscule, pénombre.&lt;br&gt;
'''λύγξ, -γός (nom commun) (f)''' : hoquet.&lt;br&gt;
'''λύγξ, -κός (nom commun) (m/f)''' : lynx.&lt;br&gt;
'''λυγρός, -ά, -όν (adjectif)''' : Fâcheux, triste. Malfaisant.&lt;br&gt;
'''λύκαινα, -ίνης (nom commun) (f)''' : louve.&lt;br&gt;
'''λυκάνθρωπος, -ώπου (nom commun) (m)''' : loup-garou.&lt;br&gt;
'''λυκίσκος, -ου (nom commun) (m)''' : chien-loup.&lt;br&gt;
'''λύκος, -ου (nom commun) (m)''' : loup.&lt;br&gt;
'''λύμα, -ας (nom commun) (f)''' : Forme dorienne de ''λύμη''.&lt;br&gt;
'''λῦμα, -ύματος (nom commun) (n)''' : .&lt;br&gt;
'''λῦμαξ, -ύμακος (nom commun) (m)''' : .&lt;br&gt;
'''λυμαίνομαι (verbe)''' : .&lt;br&gt;
'''λυμαντήρ, -ῆρος (nom commun) (m)''' : destructeur.&lt;br&gt;
'''λυμαντήριος, -α, -ον	(adjectif)''' : injurieux, destructeur.&lt;br&gt;
'''λυμαντής, -οῦ (nom commun) (m)''' : coureur.&lt;br&gt;
'''λυμαντικός, -ή, -όν (adjectif)''' : .&lt;br&gt;
'''λυμάντωρ, - (nom commun) (m)''' : .&lt;br&gt; 
'''λῦμαρ, -ύμαρος (nom commun) (m)''' : .&lt;br&gt; 
'''λύμασις, -εως (nom commun) (f)''' : .&lt;br&gt;
'''λυμάχη, -ης (nom commun) (f)''' : .&lt;br&gt;	
'''λύμη, -ης (nom commun) (f)''' : .&lt;br&gt;
'''λύπη, -ης (nom commun) (f)''' : regret.&lt;br&gt;
'''λυποῦμαι (verbe)''' : être affligé.&lt;br&gt;
'''λυπῶ (verbe)''' : regretter.&lt;br&gt;
'''λύρα, -ας (nom commun) (f)''' : lyre. (Par extension) Constellation de la lyre. (Par extension) Poisson du même nom.&lt;br&gt;
'''λύσσα, -ης (nom commun) (f)''' : Rage. (maladie canine) Fureur belliqueuse, frénésie.&lt;br&gt;
'''λύτρωσις, -ώσεως (nom commun) (f)''' : rédemption.&lt;br&gt;
'''λύττα, -ης (nom commun) (f)''' : Forme attique de ''λύσσα''.&lt;br&gt;
'''λύχνος, -ου (nom commun) (m)''' : lampe.&lt;br&gt;
'''λωρίς, -δος (nom commun) (f)''' : bande.&lt;br&gt;
'''λῶρος, -ώρου (nom commun) (m)''' : bande.&lt;br&gt;
'''Λάζαρος, -άρου (nom propre) (m)''' : Lazare.&lt;br&gt; 
'''Λαέρτης, -ου (nom propre) (m)''' : Laërte (père d’Ulysse).&lt;br&gt;
'''Λαῖλαψ, -ίλαπου (nom propre) (m)''' : Lélaps.&lt;br&gt;
'''Λάκαινα, -ίνης (nom commun) (m)''' : Laconienne.&lt;br&gt;
'''Λακεδαιμόνιος, -ίου (nom commun) (m)''' : Lacédémonien.&lt;br&gt;
'''Λακεδαίμων, -ονος (nom propre) (f)''' : Lacédémone.&lt;br&gt;
'''Λακωνία, -ας (nom propre) (m)''' : Laconie.&lt;br&gt;
'''Λάκων, -ος (nom commun) (m)''' : Laconien.&lt;br&gt;
'''Λάμια, -ας (nom propre) (m)''' : Lamia.&lt;br&gt;
'''Λαμπάς, -δος (nom propre) (f)''' : Lampade.&lt;br&gt;
'''Λαμπετίη, -ης (nom propre) (f)''' : Lampétie.&lt;br&gt;
'''Λάμπος, -ου (nom propre) (m)''' : Lampos.&lt;br&gt;
'''Λαοδίκη, -ης (nom propre) (f)''' : Laodicé.&lt;br&gt;
'''Λαοκόων, -οντος (nom propre) (m)''' : Laocoon.&lt;br&gt;
'''Λαομέδων, -οντος (nom propre) (m)''' : Laomédon (fils d’Ilos et d’Eurydice).&lt;br&gt;
'''Λατῖνος, -ίνου (nom propre) (m)''' : Latinos.&lt;br&gt;
'''Λάτιον, -ίου (nom propre) (n)''' : Latium.&lt;br&gt;
'''Λατώ, -οῦς (nom propre) (f)''' : Forme dorienne de ''Λητώ''.&lt;br&gt;
'''Λαύρειον, -ίου (nom propre) (m)''' : Laurion.&lt;br&gt;
'''Λάχεσις, -εως (nom propre) (f)''' : Lachésis (deuxième Moire).&lt;br&gt;
'''Λέανδρος, -άνδρου (nom propre) (m)''' : Léandre.&lt;br&gt;
'''Λεία, -ας  (nom propre) (f)''' : Léa.&lt;br&gt;
'''Λεύκιππος, -ίππου (nom propre) (m)''' : Leucippe.&lt;br&gt;
'''Λευκοτεκία, -ας  (nom propre) (f)''' : Variante de ''Λoυκoτοκία''.&lt;br&gt;
'''Λεωνίδας, -ου (nom propre) (m)''' : Léonidas.&lt;br&gt;
'''Λέων, -οντος (nom propre) (m)''' : Lion.&lt;br&gt;
'''Λεωχάρης, -ου (nom propre) (m)''' : Léocharès.&lt;br&gt;
'''Λήθη, -ης (nom propre) (f)''' : Léthé.&lt;br&gt;
'''Λητώ, -οῦς (nom propre) (f)''' : Léto.&lt;br&gt;
'''Λιϐύη, -ης (nom propre) (f)''' : Lybie.&lt;br&gt;
'''Λίϐυς, -ος (nom commun) (m)''' : Libyen.&lt;br&gt;
'''Λουκᾶνος, -άνου (nom commun) (m)''' : Lucanien.&lt;br&gt;
'''Λουκᾶς, -ᾶ (nom propre) (m)''' : Luke ; Lucas.&lt;br&gt;
'''Λουκιανός, -οῦ (nom propre) (m)''' : Lucien.&lt;br&gt;
'''Λoυκoτοκία, -ας  (nom propre) (f)''' : Lutèce.&lt;br&gt; 
'''Λουκρητία, -ας  (nom propre) (f)''' : Lucrèce.&lt;br&gt; 
'''Λουκρήτιος, -ίου (nom propre) (m)''' : Lucrèce.&lt;br&gt;
'''Λυγκεύς, -έως  (nom propre) (m)''' : Lyncée.&lt;br&gt;
'''Λυκάμϐης, -ου (nom propre) (m)''' : Lycambès.&lt;br&gt;
'''Λυκάων, -ονος (nom propre) (m)''' : Lycaon.&lt;br&gt;
'''Λύκειον, -ίου (nom propre) (m)''' : Lycée. (Gymnase au nord-est d’Athènes où enseigna Aristote.)&lt;br&gt;
'''Λυκομήδης, -ου (nom propre) (m)''' : Lycomède.&lt;br&gt;
'''Λυκόπολις, -όλεως (nom propre) (f)''' : Assiout.&lt;br&gt;
'''Λυκοῦργος, -ύργου (nom propre) (m)''' : Lycurgue.&lt;br&gt;
'''Λύσανδρος, -άνδρου (nom propre) (m)''' : Lysandre.&lt;br&gt;
'''Λυσιδίκη, -ης (nom propre) (f)''' : Lysidice.&lt;br&gt;
'''Λύσις, -δος (nom propre) (m)''' : Lysis. (œuvre de Platon)&lt;br&gt;
'''Λῦσις, -ύσεως  (nom propre) (m)''' Lysis. (philosophe grec)&lt;br&gt;
'''Λωΐς, -δος  (nom propre) (f)''' Loïs. (Personnage du Nouveau Testament : ''Timothée'', 1-5)&lt;br&gt;

==Μ==
'''-μα, -τος (suffixe)''' : suffixe marquant des noms neutres abstraits.&lt;br&gt;
'''μά (particule)''' : par. (Particule interjective.) (+ nom de divinité a l’accusatif)&lt;br&gt;
'''μαγειρεῖον, -ίρου (nom commun) (n)''' :  cuisine (pièce).&lt;br&gt; 
'''μαγειρεύω (verbe)''' : cuisiner.&lt;br&gt; 
'''μαγείρισσα, -ας (nom commun) (f)''' : cuisinière.&lt;br&gt;
'''μάγειρος, -ίρου (nom commun) (m)''' : cuisinier.&lt;br&gt;
'''μαγικός, -ή, -όν (adjectif)''' : magique.&lt;br&gt;
'''μαγικῶς (adverbe)''' : magiquement.&lt;br&gt;
'''μαγικώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''μαγικός''.&lt;br&gt;
'''μαγικώτερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''μαγικός''.&lt;br&gt;
'''μάγος, -ου (nom commun) (m)''' : Enchanteur, magicien ; sorcier.&lt;br&gt;
'''μαδαρός, -ά, -όν (adjectif)''' : moite ; mouillé.&lt;br&gt;
'''μαδάω (verbe)''' : être moite/mouillé.&lt;br&gt;
'''μᾶζα, -άζης (nom commun) (f)''' : masse (tas).&lt;br&gt;
'''μαζός, -οῦ (nom commun) (m)''' : sein.&lt;br&gt;
'''μάθημα, -ήματος (nom commun) (n)''' : leçon.&lt;br&gt; 
'''μαθητής, -οῦ (nom commun) (m)''' : disciple.&lt;br&gt;
'''μάθησις, -ήσεως (nom commun) (f)''' : apprentissage.&lt;br&gt;
'''µαῖα, -ίας (nom propre) (f)''' : mère ; sage-femme.&lt;br&gt;
'''μαίευμα, -ύµατος (nom commun) (n)''' : accouchement.&lt;br&gt;
'''μαίευσις, -ύσεως  (nom propre) (f)''' : accouchement.&lt;br&gt;
'''μαιευτικός, -ή, -όν (adjectif)''' : maïeutique.&lt;br&gt;
'''μαιεύομαι (verbe)''' : faire accoucher.&lt;br&gt;
'''μαίνομαι (verbe)''' : être fou, délirer ; être enragé.&lt;br&gt;
'''μαίομαι (verbe)''' : .&lt;br&gt;
'''μαιμάω (verbe)''' : .&lt;br&gt;
'''μακάριος, -ία, -άριον (adjectif)''' : béni, bienheureux ; heureux, fortuné.&lt;br&gt; 
'''μακρός, -ά, -όν (adjectif)''' : (idée d’espace) long. (idée de durée) long. (idée de quantité) Grand, fort.&lt;br&gt;
'''μακρύς, -ιά, -ύ (adjectif)''' : long.&lt;br&gt; 
'''μαλακτήρ, -ῆρος (nom commun) (m)''' : .&lt;br&gt;
'''μαλάκτης, -ου (nom commun) (m)''' : masseur.&lt;br&gt;
'''μάλαξις, -άξεως (nom commun) (f)''' : massage.&lt;br&gt;
'''μαλάσσω (verbe)''' : masser.&lt;br&gt;
'''μᾶλον, -άλου (nom commun) (n)''' : Forme dorienne  et éolienne de ''μῆλον''. (Au sens de « pomme ».)&lt;br&gt;
'''μαλλός, -οῦ (nom commun) (m)''' : touffe de laine.&lt;br&gt;
'''μάμμη, -ης (nom commun) (f)''' : maman.&lt;br&gt;
'''μανδύα, -ας (nom commun) (f)''' : cape.&lt;br&gt; 
'''μανδύη, -ης (nom commun) (f)''' : Forme ionienne de ''μανδύα''.&lt;br&gt;
'''μανθάνω (verbe)''' : Apprendre ; s’apercevoir de. (Par suite) Comprendre.&lt;br&gt;
'''μανία, -ας (nom commun) (f)''' : Folie, démence ; enthousiasme, transport.&lt;br&gt;
'''μανίη, -ης (nom commun) (f)''' : Forme ionienne de ''μανία''.&lt;br&gt;
'''μᾶνις, -άνιος (nom commun) (f)''' : Forme dorienne de ''μῆνις''.&lt;br&gt;
'''μαντεία, -ας (nom commun) (f)''' : Prédiction, oracle ; divination.&lt;br&gt;
'''μαντείη, -ης (nom commun) (f)''' : Forme homérique de ''μαντεία''.&lt;br&gt;
'''μαντηΐη, -ης (nom commun) (f)''' : Forme ionienne de ''μαντεία''.&lt;br&gt; 
'''μάντις, -εως (nom commun) (m) ''' : devin.&lt;br&gt;
'''μάραθον, -άθου (nom commun) (n)''' : fenouil.&lt;br&gt; 
'''μαργαρίδης, -ου (nom commun) (m) ''' : Forme ionienne de ''μαργαρίτης''.&lt;br&gt;
'''μαργαρίτα, -ας (nom commun) (f) ''' : marguerite.&lt;br&gt;
'''μαργαρίτης, -ου (nom commun) (m) ''' : perle.&lt;br&gt;
'''μαρμαίρω (verbe)''' : briller.&lt;br&gt;
'''μαρμάρεος, -έα, -άρεον (adjectif) ''' : brillant ; fait de marbre.&lt;br&gt;
'''μαρμάρινος, -η, -ον (adjectif) ''' : marmoréen.&lt;br&gt;
'''μάρμαρος, -άρου (nom commun) (m)''' : marbre.&lt;br&gt;
'''μαρμαρώδης, -ης, -ες (adjectif)''' : marbré.&lt;br&gt;
'''μάρσιπος, -ίπου (nom commun) (m)''' : sac.&lt;br&gt;
'''μαρσίππιον, -ίου (nom commun) (n)''' : petit sac.&lt;br&gt; 
'''μαρτυρέω (verbe)''' : .&lt;br&gt; 
'''μαρτύρημα, -ήματος (nom commun) (n)''' : témoignage.&lt;br&gt;
'''μαρτυρία, -ας (nom commun) (f)''' : témoignage.&lt;br&gt;
'''μαρτύριον, -ίου (nom commun) (n)''' : Témoignage, preuve. Sanctuaire dédié à un martyr.&lt;br&gt;
'''μάρτυρ, -ος (nom commun) (m/f)''' : Forme éolienne de ''μάρτυς''.&lt;br&gt; 
'''μάρτυς, -ρος (nom commun) (m/f)''' : témoin ; témoin de Dieu.&lt;br&gt;
'''μασδός, -οῦ (nom commun) (m)''' : Forme dorienne de ''μαζός''.&lt;br&gt; 
'''μασθός, -οῦ (nom commun) (m)''' : Forme tardive de ''μαζός''.&lt;br&gt; 
'''μάσσω  (verbe)''' : pétrir, masser.&lt;br&gt;
'''μάσταξ, -κος (nom commun) (f)''' : mâchoire.&lt;br&gt;
'''μαστιάω (verbe)''' : Forme homérique de ''μαστίζω''.&lt;br&gt;
'''μαστίγωσις, -ώσεως (nom commun) (f)''' : flagellation.&lt;br&gt;
'''μαστιγῶ (verbe)''' : fouetter.&lt;br&gt;
'''μαστίζω (verbe)''' : flageller.&lt;br&gt;
'''μαστίσδω (verbe)''' : Forme dorienne de ''μαστίζω''.&lt;br&gt;
'''μάστιξ, -ίγος (nom commun) (f)''' : fouet.&lt;br&gt;
'''μαστός, -οῦ (nom commun) (m)''' : mamelle ; sein.&lt;br&gt;
'''μασχάλη, -ης (nom commun) (f)''' : aisselle (cavité placée sous le bras).&lt;br&gt;
'''μάταιος, -ία, -αιον (adjectif)''' : futile, vain ; frivole.&lt;br&gt;
'''ματαιότης, -τος (nom commun) (f)''' : futilité, vanité ; frivolité.&lt;br&gt;
'''μάτημι (verbe)''' : Forme éolienne de ''πατέω''.&lt;br&gt;
'''μάτηρ, -ρός (nom commun) (f)''' : Forme dorienne de ''μήτηρ''.&lt;br&gt;
'''μάττω (verbe)''' : Forme attique de ''μάσσω''.&lt;br&gt;
'''μαυρός, -ός, -όν (adjectif)''' : Forme alternative de ''ἀμαυρός''.&lt;br&gt;
'''μάχαιρα, -ίρας (nom commun) (f)''' : sabre.&lt;br&gt;
'''μαχαιτάς, -δος (nom commun) (m)''' : Forme éolienne de ''μαχητής''.&lt;br&gt;
'''μαχανά, -ᾶς (nom commun) (f)''' : Forme dorienne de ''μηχανή''.&lt;br&gt;
'''μαχατάρ, -ος (nom commun) (m)''' : Forme laconienne de ''μαχητής''.&lt;br&gt;
'''μαχάτας, -ου (nom commun) (m)''' : Forme dorienne de ''μαχητής''.&lt;br&gt;
'''μαχέομαι (verbe)''' : Forme ionienne de ''μάχομαι''.&lt;br&gt;
'''μάχη, -ῆς (nom commun) (f)''' : Combat ; bataille.&lt;br&gt;
'''μαχητής, -οῦ (nom commun) (m)''' : combattant.&lt;br&gt;
'''μάχλος, -ος, -ον (adjectif)''' : libertin, débauché.&lt;br&gt;
'''μάχομαι (verbe)''' : combattre.&lt;br&gt;
'''μᾶχος, -άχου (nom commun) (n)''' : Forme dorienne de ''μῆχος''.&lt;br&gt;
'''μέγαθος, -άθεος (nom commun) (n)''' : Forme ionienne de ''μέγεθος''.&lt;br&gt;
'''μεγαλομανής, -ής, -ές (adjectif)''' : mégalomane.&lt;br&gt;
'''μέγας, -άλη, -α (adjectif)''' : grand.&lt;br&gt;
'''μέγεθος, -έθους (nom commun) (n)''' : Grandeur, hauteur.&lt;br&gt;
'''μεγιστάν, -ᾶνος (nom commun) (m)''' : magnat.&lt;br&gt;
'''μέγιστος, -η, -ον (adjectif)''' : Superlatif de ''μέγας''.&lt;br&gt;
'''μέδος, -ου (nom commun) (m)''' : hydromel.&lt;br&gt;
'''μέδων, -οντος (nom commun) (m)''' : seigneur.&lt;br&gt;
'''μέδω (verbe)''' : Commander, régner.&lt;br&gt;
'''μεθίημι (verbe)''' : .&lt;br&gt;
'''μέθυστος, -ος, -ον (adjectif)''' : ivre.&lt;br&gt; 
'''μέθυ, -ος  (nom commun) (n)''' : vin.&lt;br&gt;
'''μεθύω (verbe)''' : être ivre.&lt;br&gt;
'''μεῖγμα, -ίγματος  (nom commun) (n)''' : mixture.&lt;br&gt;
'''μείζων, -ων, -ον (adjectif)''' : Comparatif de ''μέγας''.&lt;br&gt;
'''μεῖξις, -ίξεως (nom commun) (f)''' : .&lt;br&gt;
'''μεῖλον, -ίλου  (nom commun) (n)''' : Forme béotienne de ''μῆλον''. (Au sens de « petit bétail ».)&lt;br&gt; 
'''μεῖραξ, -ίρακος  (nom commun) (m/f)''' : jeune fille ; jeune garçon.&lt;br&gt;
'''μείρομαι (verbe)''' : attribuer ; prendre.&lt;br&gt;
'''μείωσις, -ώσεως (nom commun) (f)''' : réduction.&lt;br&gt;
'''μειῶ (verbe)''' : réduire.&lt;br&gt;
'''μελάμπυγος, -ος, -ον (adjectif)''' : Qui a les fesses noires.&lt;br&gt;
'''μελάντατος, -άτη, -άντατον (adjectif)''' : Superlatif de ''μέλας''.&lt;br&gt;
'''μελάντερος, -έρα, -άντερον (adjectif)''' : Comparatif de ''μέλας''.&lt;br&gt;
'''μελάνως (adverbe)''' : en noir.&lt;br&gt;
'''μέλας, -αινα, -αν (adjectif)''' : noir ; sombre.&lt;br&gt; 
'''μελεαγρίς, -δος (nom commun) (f)''' : pintade.&lt;br&gt;
'''μελετηρός, -ή, -όν (adjectif)''' : studieux.&lt;br&gt; 
'''μελετῶ (verbe)''' : étudier.&lt;br&gt; 
'''μελία, -ας (nom commun) (f)''' : frêne.&lt;br&gt;
'''μελίζω (verbe)''' : moduler, chanter.&lt;br&gt;
'''μελίη, -ης (nom commun) (f)''' : Forme ionienne de ''μελία''.&lt;br&gt;
'''μέλι, -τος (nom commun) (f)''' : miel.&lt;br&gt;
'''μέλισσα, -ης (nom commun) (f)''' : abeille.&lt;br&gt;
'''μέλος, -ους (nom commun) (n)''' : Membre, articulation. Chant. &lt;br&gt; 
'''μελῳδία, -ας (nom commun) (f)''' : mélodie.&lt;br&gt;
'''μελῳδικός, -ή, -όν (adjectif)''' : mélodieux.&lt;br&gt; 
'''μελῳδός, -ή, -όν (adjectif)''' : musical.&lt;br&gt; 
'''μέλω (verbe)''' : être un objet de soin ; prendre soin de ; (impersonnel) être un sujet de souci.&lt;br&gt;
'''μέλλων, -οντος (nom commun) (m)''' : futur.&lt;br&gt;
'''μέμψις, -εως (nom commun) (f)''' : blâme ; censure.&lt;br&gt;
'''μέμφομαι (verbe)''' : reprocher.&lt;br&gt;
'''μέν (particule)''' : .&lt;br&gt;
'''μένος, -ους (nom commun) (n)''' : Esprit. Courage, cœur, ardeur, volonté. Désir. Force, violence.&lt;br&gt;
'''μέντοι (particule)''' : cependant.&lt;br&gt;
'''μένω (verbe)''' : rester, demeurer. Attendre&lt;br&gt;
'''μερίς, -δος (nom commun) (f)''' : part.&lt;br&gt;
'''μέρος, -ους (nom commun) (n)''' : partie.&lt;br&gt; 
'''μεσαιπόλιος -ος, -ον (adjectif)''' : .&lt;br&gt;
'''µεσοστιχίς, -δος (nom commun) (f)''' : mésostiche.&lt;br&gt;
'''μέσος, -η, -ον (adjectif)''' : médian.&lt;br&gt; 
'''μέσος, -ου (nom commun) (m)''' : majeur.&lt;br&gt; 
'''μεστός, -ή, -όν (adjectif)''' : plein.&lt;br&gt;
'''μεστῶς (adverbe)''' : pleinement.&lt;br&gt;
'''μεστώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''μεστός''.&lt;br&gt; 
'''μεστώτερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''μεστός''.&lt;br&gt; 
'''μεστῶ (verbe)''' : être plein.&lt;br&gt;
'''μέσως (adverbe)''' : au milieu de.&lt;br&gt; 
'''μεσώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''μέσος''.&lt;br&gt; 
'''μεσώτερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''μέσος''.&lt;br&gt; 
'''μεσηγύ (adverbe)''' : au milieu.&lt;br&gt;
'''μετά (adverbe)''' (Devient ''μετ’'' devant un mot commençant par une voyelle à esprit doux, et ''μεθ’'' devant un mot commençant par une voyelle à esprit rude.) : Au milieu, parmi.&lt;br&gt;
'''μετα- (préfixe)''' : .&lt;br&gt;
'''μεταϐαίνω (verbe)''' : changer ; dépasser.&lt;br&gt;
'''μετάϐασις, -άσεως (nom commun) (f)''' : changement ; dépassement.&lt;br&gt;
'''μεταϐίϐασις, -άσεως (nom commun) (f)''' : transfert ; transmission.&lt;br&gt;
'''μεταϐιϐάζω (verbe)''' : transférer ; transmettre.&lt;br&gt;
'''μεταγιγνώσκω (verbe)''' : regretter.&lt;br&gt;
'''μετακινῶ (verbe)''' : .&lt;br&gt;
'''μεταμέλεια, -ας (nom commun) (f)''' : repentir.&lt;br&gt; 	
'''μεταμέλω (verbe)''' : se repentir.&lt;br&gt;
'''μεταμόρφωσις, -ώσεως (nom commun) (f)''' : transformation.&lt;br&gt;
'''μετάνοια, -ίας  (nom commun) (f)''' : repentance ; pénitence.&lt;br&gt;
'''μετανοῶ (verbe)''' : faire pénitence.&lt;br&gt;
'''μέταξα, -άξης (nom commun) (f)''' : soie.&lt;br&gt; 
'''µεταξύ (préposition)''' : entre.&lt;br&gt;
'''μεταφέρω (verbe)''' : transporter.&lt;br&gt;  
'''μεταφορά, -άς (nom commun) (f)''' : transport.&lt;br&gt;
'''μεταφράζω (verbe)''' : traduire.&lt;br&gt; 
'''μετάφρασις, -άσεως (nom commun) (f)''' : traduction.&lt;br&gt;
'''μετέωρος, -ος, -ον (adjectif)''' : élevé.&lt;br&gt;
'''μέτοικος, -ίκου (nom commun) (m/f)''' : Individu étranger à une cité.&lt;br&gt; 
'''μετεωρότατος, -άτη, -ότατον (adjectif)''' : Superlatif de ''μετέωρος''.&lt;br&gt;
'''μετεωρότερος, -έρα, -ότερον (adjectif)''' : Comparatif de ''μετέωρος''.&lt;br&gt;
'''μετεωρότατα (adverbe)''' : Superlatif de ''μετεώρως''.&lt;br&gt;
'''μετεωρότερον (adverbe)''' : Comparatif de ''μετεώρως''.&lt;br&gt;
'''μετεώρως (adverbe)''' : de façon élevée.&lt;br&gt;
'''μέτρον, -ου (nom commun) (n)''' : mesure.&lt;br&gt;  
'''μέτωπον, -ώπου (nom commun) (n)''' : front.&lt;br&gt;
'''μέχρι (conjonction)''' : jusqu'à ce que.&lt;br&gt;
'''μηδέν (adjectif numéral)''' : zéro.&lt;br&gt;
'''μηδέποτε (adverbe)''' : jamais.&lt;br&gt;
'''μηδικός, -ή, -όν (adjectif)''' : mède.&lt;br&gt;
'''μῆδος, -ήδους (nom commun) (n)''' : mesure.&lt;br&gt; 
'''μή (particule)''' : non (subjectif).&lt;br&gt;
'''μηλίτης, -ου (nom commun) (m)''' : cidre.&lt;br&gt; 
'''μῆλον, -ήλου  (nom commun) (n)''' : Petit bétail ; pomme.&lt;br&gt; 
'''μηνιαῖος, -ία -ῖον (suffixe)''' : mensuel.&lt;br&gt; 
'''μηναιότατος, -άτη, -ότατον (suffixe)''' : Forme superlative de ''μηνιαῖος''.&lt;br&gt;
'''μηναιότερος, -έρα, -ότερον (suffixe)''' : Forme comapartive de ''μηνιαῖος''.&lt;br&gt;
'''μηναίως (suffixe)''' : mensuellement.&lt;br&gt;
'''μήνη, -ης (nom commun) (f)''' : mère.&lt;br&gt;
'''μῆνιγξ, -ήνιγγος (nom commun) (f)''' : membrane.&lt;br&gt;
'''μῆνις, -ήνιος (nom commun) (f)''' : colère.&lt;br&gt;
'''μήν, -ός  (nom commun) (m)''' : mois.&lt;br&gt; 
'''μηριαῖος, -ία, -ῖον  (adjectif)''' : fémural.&lt;br&gt;
'''μηρóς, -οῦ (nom commun) (m)''' : côté, flanc ; cuisse, fémur.&lt;br&gt; 
'''μήτηρ, -ρός (nom commun) (f)''' : mère.&lt;br&gt;
'''μητιάω (verbe)''' : ruse.&lt;br&gt;
'''μητιόεις, -εσσα, -εν (adjectif)''' : .&lt;br&gt;
'''μῆτις, -ήτεως (nom commun) (f)''' : ruse.&lt;br&gt;
'''μήτις, -ις, -ι (pronom)''' : personne.&lt;br&gt;
'''μήτρα, -ας (nom commun) (f)''' : matrice ; ventre ou sein de la mère.&lt;br&gt;
'''μήτρη, -ης (nom commun) (f)''' : Forme ionienne de ''μήτρα''.&lt;br&gt; 
'''μητροκτονία, -ας (nom commun) (m)''' : matricide.&lt;br&gt;
'''μητροκτόνος, -ου (nom commun) (m)''' : matricide.&lt;br&gt;
'''μητρυιά, -ᾶς (nom commun) (f)''' : belle-mère.&lt;br&gt;
'''μητρυιός, -οῦ (nom commun) (m)''' : beau-père.&lt;br&gt;
'''μηχανή, -ῆς (nom commun) (f)''' : machine ; engin. Invention.&lt;br&gt;
'''μηχανικός, -ή, -όν (f)''' : mécanique ; ingénieux.&lt;br&gt;
'''μηχανικότατος, -άτη, -ότατον (adjectif)''' : Superlatif de ''μηχανικός''.&lt;br&gt;
'''μηχανικότερος, -έρα, -ότερον (adjectif)''' : Comparatif de ''μηχανικός''.&lt;br&gt;
'''μηχανικῶς (adverbe)''' : mécaniquement ; ingénieusement.&lt;br&gt;
'''μῆχος, -ήχους (nom commun) (n)''' : .&lt;br&gt;
'''μιαίνω (verbe)''' : Salir, souiller, polluer, profaner, teindre, colorer.&lt;br&gt;
'''μιαρός, -ά, -όν (adjectif)''' : impur.&lt;br&gt;
'''μίασμα, -άσματος (nom commun) (n)''' : Souillure provenant d’un meurtre. Personne souillée d’un meurtre.&lt;br&gt;
'''μιασμός, -οῦ (nom commun) (m)''' : Action de salir, souiller, tacher ; deuil, vêtements salis en signe de deuil, teinture.&lt;br&gt;
'''μίγδην (adverbe)''' : confusément.&lt;br&gt;
'''μῖγμα, -ίγματος  (nom commun) (n)''' : .&lt;br&gt; 
'''μικρός, -ά, -όν (adjectif)''' : petit.&lt;br&gt;
'''μικρός, -οῦ (nom commun) (m)''' : auriculaire.&lt;br&gt; 
'''μικρότατος, -άτη, -ότατον (adjectif)''' : Superlatif de ''μικρός''.&lt;br&gt;
'''μικρότερος, -έρα, -ότερον (adjectif)''' : Comparatif de ''μικρός''.&lt;br&gt;
'''μικρῶς (adverbe)''' : .&lt;br&gt;
'''μιμάς, -δος (nom commun) (f)''' : actrice.&lt;br&gt;
'''μιμεῖσθαι  (verbe)''' : imiter.&lt;br&gt; 
'''μίμημα, -ήματος (nom commun) (n)''' : Imitation, copie ; contrefaçon.&lt;br&gt; 
'''μίμησις, -ήσεως (nom commun) (f)''' : Imitation, représentation.&lt;br&gt; 
'''μιμητικός, -ή, -όν (adjectif)''' : représentatif.&lt;br&gt;
'''μιμητικῶς (adverbe)''' : représentativement.&lt;br&gt;
'''μιμητικώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''μιμητικός''.&lt;br&gt;
'''μιμητικώτερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''μιμητικός''.&lt;br&gt;
'''μιμητικώτατα, -, - (adverbe)''' : Superlatif de ''μιμητικῶς''.&lt;br&gt;
'''μιμητικώτερον, -, - (adverbe)''' : Comparatif de ''μιμητικῶς''.&lt;br&gt;
'''μιμναίσκω (verbe)''' : Forme éolienne de ''μιμνήσκω''.&lt;br&gt;
'''μιμνήσκω (verbe)''' : Rappeler à la mémoire. Rappeler une chose, mentionner.&lt;br&gt;
'''μῖμος, -ίμου (nom commun) (m)''' : acteur.&lt;br&gt;
'''μιμοῦμαι (verbe)''' : mimer.&lt;br&gt;
'''μίνθη, -ης (nom commun) (f)''' : menthe.&lt;br&gt;
'''µινώταυρος, -ύρου (nom commun) (m)''' : minotaure.&lt;br&gt;
'''μισανδρία, -ας (nom commun) (f)''' : misandrie.&lt;br&gt; 
'''μισάνδρος, -ος, -ον (adjectif)''' : misandre.&lt;br&gt;
'''μισανθρωπία, -ας  (nom commun) (f)''' : misanthropie.&lt;br&gt; 
'''μισάνθρωπος, -ος, -ον (adjectif)''' : misanthropie.&lt;br&gt;  
'''μισθός, -οῦ (nom commun) (m)''' : salaire.&lt;br&gt;
'''μισθοφόρος, -ου (nom commun) (m)''' : mercenaire.&lt;br&gt;
'''μισογύνης, -ου (nom commun) (m)''' : matcho.&lt;br&gt;
'''μισογυνία, -ας (nom commun) (f)''' : misogynie.&lt;br&gt;
'''μῖσος, -ίσους (nom commun) (n)''' : Haine, aversion ; objet de haine.&lt;br&gt; 
'''μισῶ (verbe)''' : détester, haïr.&lt;br&gt;
'''μίτος, -ου (nom commun) (m)''' : fil.&lt;br&gt;
'''μίτωσις, -ώσεως (nom commun) (f)''' : mitose.&lt;br&gt;
'''μνᾶ, -ᾶς (nom commun) (f)''' : mine (monnaie).&lt;br&gt;
'''μνᾶμα, -άματος (nom commun) (n)''' : Forme dorienne de ''μνῆμα''.&lt;br&gt;
'''μνάμων, -ων, -ον (adjectif)''' : Forme dorienne de ''μνήμων''.&lt;br&gt;
'''μνάομαι (verbe)''' : .&lt;br&gt;
'''μναστήρ, -ῆρος (nom commun) (m)''' :  Forme dorienne de ''μνηστήρ''.&lt;br&gt;
'''μνᾶστις, -άστεως (nom commun) (f)''' : Forme dorienne de ''μνῆστις''.&lt;br&gt;
'''μνῆμα, -ήματος (nom commun) (n)''' : tombe.&lt;br&gt;
'''μνημεῖον, -ίου (nom commun) (n)''' : monument.&lt;br&gt;
'''μνημήιον, -ίου (nom commun) (n)''' : Forme dorienne de ''μνημεῖον''.&lt;br&gt; 
'''μνήμων, -ων, -ον (adjectif)''' : .&lt;br&gt;
'''μνηστήρ, -ῆρος (nom commun) (m)''' : prétendant.&lt;br&gt;
'''μνῆστις, -ήστεως (nom commun) (f)''' : .&lt;br&gt;
'''µvοῦς, -οῦ (nom commun) (m)''' : chatte (sexe féminin).&lt;br&gt;
'''μόγις (adverbe)'''' : à peine.&lt;br&gt;
'''μόγος, -ου (nom commun) (m)''' : peine ; labeur.&lt;br&gt;
'''μόλις (adverbe)''' : Variante de ''μόγις''.&lt;br&gt;
'''µοῖρα, -ίρας (nom commun) (f)''' : part ; portion. Parti politique.&lt;br&gt;
'''μοιχαλίς, -δος (nom commun) (f)''' : adultère (celle qui la commet).&lt;br&gt;
'''μοιχεία, -ας (nom commun) (f)''' : adultère.&lt;br&gt;
'''μοιχεύω (verbe)''' : commettre l’adultère.&lt;br&gt;
'''μοιχός, -οῦ	(nom commun) (m)''' : adultère (celui qui la commet).&lt;br&gt;
'''μόλυϐδος, -ύϐδου (nom commun) (m)''' : plomb.&lt;br&gt;
'''μόλυνσις, -ύνσεως (nom commun) (f)''' : infection.&lt;br&gt;
'''μομφή, -ῆς (nom commun) (f)''' : reproche.&lt;br&gt;
'''μονάς, -δος (nom commun) (f)''' : unité.&lt;br&gt;
'''μοναχεῖον, -ίου (nom commun) (n)''' : monastère.&lt;br&gt;
'''μοναχός, -οῦ (nom commun) (m)''' : moine.&lt;br&gt;
'''μονή, -ῆς (nom commun) (f)''' : action de s’arrêter ; lieu où l’on séjourne.&lt;br&gt;
'''μονόκερως, -έρωτος (nom commun) (f)''' : licorne.&lt;br&gt;
'''μονομαχεῖον, -ίου (nom commun) (n)''' : lieu de duel.&lt;br&gt;
'''μονομαχέω (verbe)''' : se battre en duel.&lt;br&gt;
'''μονομαχία, -ας (nom commun) (f)''' : duel.&lt;br&gt;
'''μονομάχος, -ου (nom commun) (m)''' : duelliste.&lt;br&gt;
'''μονόφθογγος, -όγγου (nom commun) (f)''' : monophtongue.&lt;br&gt;
'''μόνος, -η, -ον (adjectif)''' : Seul, unique ; solitaire.&lt;br&gt;  
'''μόνϝος, -η, -ον (adjectif)''' : Forme ancienne de ''μόνος''.&lt;br&gt;  
'''μονῳδία, -ας (nom commun) (f)''' : .&lt;br&gt;
'''μόνως (adverbe)''' : uniquement.&lt;br&gt;
'''μονώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''μόνος''.&lt;br&gt;
'''μονώτερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''μόνος''.&lt;br&gt;
'''μορμολύκα, -ας (nom commun) (f)''' : Forme dorienne de ''μορμολύκη''.&lt;br&gt;
'''μορμολυκεῖον, -ίου (nom commun) (n)''' : croque-mitaine.&lt;br&gt;
'''μορμολύκη, -ης (nom commun) (f)''' : .&lt;br&gt;
'''μορμωτός, -ή, -όν (adjectif)''' : effroyable.&lt;br&gt;
'''μορμῶ -οῦς (nom commun) (m)''' : monstre marin.&lt;br&gt;
'''μορφή, -ῆς (nom commun) (f)''' : forme.&lt;br&gt;
'''μόρφωσις, -ώσεως (nom commun) (f)''' : formation.&lt;br&gt;
'''μορφῶ (verbe)''' : former.&lt;br&gt;
'''μόσχευμα, -ύματος (nom commun) (n)''' : plant.&lt;br&gt; 
'''μοσχεύω (verbe)''' : planter.&lt;br&gt;
'''μοσχοκαρύδιον, -ίου (nom commun) (n)''' : Diminutif de ''μοσχοκάρυον''.&lt;br&gt; 
'''μοσχοκάρυον, -ύου (nom commun) (n)''' : noix de muscade.&lt;br&gt; 
'''μόσχος, -ου (nom commun) (m)''' : Musc ; pousse.&lt;br&gt;
'''μοχθηρός, -ά, -όν (adjectif)''' : malveillant ; souffrant.&lt;br&gt; 
'''μοχθηρότατος, -άτη, -ότατον (adjectif)''' : Superlatif de ''μοχθηρός''.&lt;br&gt;
'''μοχθηρότερος, -έρα, -ότερον (adjectif)''' : Comparatif de ''μοχθηρός''.&lt;br&gt;
'''μοχθηρῶς, -ά, -όν (adverbe)''' : .&lt;br&gt; 
'''μόχθος, -ου (nom commun) (m)''' : peine ; labeur.&lt;br&gt;
'''μοχθῶ (verbe)''' : être malveillant.&lt;br&gt;
'''μουνάς, -δος (nom commun) (f)''' : Forme ionienne de ''μονάς''.&lt;br&gt;
'''μοῦνος, -ύνη, -ῦνον (adjectif)''' : Forme homérique et ionienne de ''μόνος''.&lt;br&gt; 
'''μῶλυ, -ώλυος (nom commun) (n)''' : moly.&lt;br&gt;
'''μῶνος, -η, -ον (adjectif)''' : Forme dorienne de ''μόνος''.&lt;br&gt;
'''μορμολύκειον, -ίου (nom commun) (n)''' : masque.&lt;br&gt;
'''μορφή, -ῆς (nom commun) (f)''' : forme.&lt;br&gt;
'''μόρφωσις, -ώσεως (nom commun) (f)''' : formation.&lt;br&gt;
'''μουσεῖον, -ίου (nom commun) (n)''' : musée.&lt;br&gt;
'''μούσμων, -ονος (nom commun) (m)''' : mouflon.&lt;br&gt;
'''μυδάω (verbe)''' : être moite.&lt;br&gt;
'''μυγαλῆ, -ς (nom commun) (f)''' : musaraigne.&lt;br&gt; 
'''μύγις (adverbe)''' : Forme éolienne de ''μόγις''.&lt;br&gt;
'''μυελός, -οῦ (nom commun) (m)''' : moelle.&lt;br&gt;
'''μυζῶ (verbe)''' : sucer.&lt;br&gt;
'''μυθικός, -ή, -όν (adjectif)''' : mythique.&lt;br&gt;
'''μυθιστορία, -ας (nom commun) (f)''' : légende.&lt;br&gt;
'''μυθιστορικός, -ή, -όν (adjectif)''' : légendaire.&lt;br&gt;
'''μῦθος, -ύθου (nom commun) (m)''' : mythe.&lt;br&gt;
'''μυῖα, -ίας (nom commun) (f)''' : mouche.&lt;br&gt;
'''μύκης, -τος (nom commun) (m)''' : Champignon. (Par analogie) Toute excroissance fougueuse. Champignon que se forme à la mèche d’une lampe. Virole d’une gaine. Membre viril.&lt;br&gt;
'''μυκτήρ, -ῆρος (nom commun) (m)''' : museau.&lt;br&gt;
'''μύλη, -ης  (nom commun) (f)''' : moulin.&lt;br&gt;
'''μυλεργάτης, -ου (nom commun) (m)''' : meunier.&lt;br&gt;
'''μυλών, -ῶνος	(nom commun) (m)''' : meunier.&lt;br&gt;
'''μύξα, -ας (nom commun) (f)''' : morve.&lt;br&gt; 
'''μυρίαπους, -δος (nom commun) (m)''' : mille-pattes.&lt;br&gt;
'''μυριάς, -δος (nom commun) (f)''' : .&lt;br&gt; 
'''μυρίος, -α, -ον (adjectif)''' : Innombrable, immense ; infini.&lt;br&gt;
'''μύρμηξ, -κος (nom commun) (m)''' : fourmi.&lt;br&gt;
'''μυροϐάλανος, -άνου (nom commun) (f)''' : myrobolan.&lt;br&gt;
'''μύρος, -ου (nom commun) (m)''' : parfum.&lt;br&gt;
'''μυρσίνα, - (nom commun) (f)''' : myrtille.&lt;br&gt; 	
'''μύρτος, -ου (nom commun) (f)''' : myrtille.&lt;br&gt;
'''μῦς, -ός (nom commun) (m)''' : Rat ; souris. Muscle.&lt;br&gt;
'''μύσταξ, -κος (nom commun) (f)''' : Forme dorienne de ''μάσταξ'' ; moustache.&lt;br&gt;
'''μυστήριον, -ίου (nom commun) (n)''' : sacrement.&lt;br&gt;
'''μυστηριώδης, -ης, -ες (adjectif)''' : relatif aux sacrements.&lt;br&gt;
'''μυστικός, -ή, -όν (adjectif)''' : secret.&lt;br&gt;
'''μυστικῶς (adverbe)''' : secrètement.&lt;br&gt;
'''μυστικώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''μυστικός''.&lt;br&gt;
'''μυστικώτερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''μυστικός''.&lt;br&gt;
'''µῦ (nom commun) (n)''' : mu.&lt;br&gt;
'''μύχιος, -α, -ον (adjectif)''' : intime.&lt;br&gt;
'''μυχός, -οῦ (nom commun)''' : cœur.&lt;br&gt; 
'''μῶλυ, -ώλυος (nom commun) (n)''' : moly.&lt;br&gt;
'''μῶμαι (verbe)''' : méditer.&lt;br&gt; 
'''μῶμος, -ώμου (nom commun) (m)''' : blâme.&lt;br&gt;
'''μῶνυξ, -ώνυχος (nom commun) (m)''' : .&lt;br&gt;
'''μωρός, -ά, -όν (adjectif)''' : Émoussé, hébété. Fade, Insipide. Sot, fou, insensé.&lt;br&gt;
'''μῶρος, -ώρα, -ῶρον (adjectif)''' : Forme attique de ''μωρός''.&lt;br&gt;
'''Μάατ (nom propre) (f)''' : Maât.&lt;br&gt; 
'''Μαθθαῖος, -ίου (nom propre) (m)''' : Forme alternative de ''Ματθαῖος''.&lt;br&gt;
'''Μαθουσάλα, -ας (nom propre) (m)''' : Mathusalem.&lt;br&gt;
'''Μαῖα, -ίας (nom propre) (f)''' : Maïa.&lt;br&gt;
'''Μαῖρα, -ίρας (nom propre) (f)''' : Maera.&lt;br&gt;
'''Μακάριος, -ίου (nom propre) (m)''' : Macaire.&lt;br&gt;
'''Μακαρία, -ας (nom propre) (f)''' : Macaria.&lt;br&gt;
'''Μάνης, -ου (nom propre) (m)''' : Mani (prophète).&lt;br&gt;
'''Μαντώ, -οῦς (nom propre) (f)''' : Manto.&lt;br&gt; 
'''Μάξυος, -ου (nom commun) (m)''' : Berbère.&lt;br&gt;  
'''Μαραθών, -ῶνος (nom propre) (m)''' : Marathon.&lt;br&gt;
'''Μαργαρίτα, -ας (nom commun) (f) ''' : Marguerite.&lt;br&gt; 
'''Μαρδοχαῖος, -ίου (nom propre) (m)''' : Mardochée.&lt;br&gt;
'''Μάρθα, -ας (nom propre) (f)''' : Martha.&lt;br&gt;
'''Μαρία, -ας (nom propre) (f)''' : Marie.&lt;br&gt;
'''Μασσαλία, -ας (nom propre) (f)''' : Marseille.&lt;br&gt;
'''Μασσαλιώτης, -ου (nom commun) (m)''' : Marseillais.&lt;br&gt;
'''Μασσαλιῶτις, -ώτιδα (nom commun) (f)''' : Marseillaise.&lt;br&gt;
'''Μαῦρος, -ύρου (nom commun) (m)''' : Maure.&lt;br&gt;
'''Μαυσωλεῖον, -ίου (nom propre) (m)''' : Mausolée.&lt;br&gt;
'''Μαύσωλος, -ώλου (nom propre) (m)''' : Mausole.&lt;br&gt;
'''Ματθαῖος, -ίου (nom propre) (m)''' : Matthieu.&lt;br&gt;
'''Μέγαιρα, -ίρας (nom propre) (f)''' : Mégère (une des Érynies).&lt;br&gt;
'''Μέδουσα, -ας (nom propre) (f)''' : Méduse.&lt;br&gt; 
'''Μελέαγρος, -άγρου (nom propre) (m)''' : Méléagre.&lt;br&gt;
'''Μελησιγενής, -οῦ (nom propre) (m)''' : Mélésigène.&lt;br&gt;
'''Μέλης (nom propre) (m)''' : Mélès (rivière).&lt;br&gt; 
'''Μελέτη, -ης (nom propre) (f)''' : Mélété.&lt;br&gt;
'''Μέλισσα, -ίσσης (nom propre) (f)''' : Mélissa.&lt;br&gt; 
'''Μελίτη, -ης (nom propre) (f)''' : Mélite.&lt;br&gt; 
'''Μελπομένη, -ης (nom propre) (f)''' : Melpomène.&lt;br&gt;
'''Μελχισέδεκ (nom propre) (m)''' : Melchisédech.&lt;br&gt;
'''Μέμφις, -δος (nom propre) (f)''' : Memphis.&lt;br&gt;
'''Μενίππη, -ης (nom propre) (f)''' : Ménippe.&lt;br&gt;  
'''Μένιππος, -ίππου (nom propre) (m)''' : Ménippe.&lt;br&gt; 
'''Μεχείρ (nom commun) (m)''' : Méchir.&lt;br&gt;
'''Μήδεια, -ίας (nom propre) (f)''' : Médée.&lt;br&gt;
'''Μηδία, -ας (nom propre) (f)''' : Médie.&lt;br&gt;
'''Μῆδος, -ήδου (nom commun) (m)''' : Mède.&lt;br&gt;
'''Μηλινόη, -ης (nom propre) (f)''' : Mélinoé.&lt;br&gt;
'''Μῆτις, -ήτιδος (nom propre) (f)''' : [[wikt:Métis|Métis]].&lt;br&gt;
'''Μίδας, -ου (nom propre) (m)''' : Midas.&lt;br&gt;
'''Μίθρας, -ου (nom propre) (m)''' : Mithra.&lt;br&gt;
'''Μίθρης, -ου (nom propre) (m)''' : Forme ionienne de ''Μίθρας''.&lt;br&gt;
'''Μιθριδάτης, -ου (nom propre) (m)''' : Mithridate.&lt;br&gt;
'''Μιχαίας, -ου (nom propre) (m)''' : Michée.&lt;br&gt;
'''Μίνως, -ωος (nom propre) (m)''' : Minos.&lt;br&gt;
'''Μίσφρης, -ου (nom propre) (m)''' : Menkhéperrê.&lt;br&gt;
'''Μνεῦις, -ύιδος (nom propre) (m)''' : Mnévis.&lt;br&gt;
'''Μοῖρα, -ίρας (nom propre) (f)''' : Moire.&lt;br&gt;
'''Μοῖσα, -ίσης (nom propre) (f)''' : Forme éolienne de ''Μοῦσα''.&lt;br&gt;
'''Μόνοικος, -ίκου (nom propre) (f)''' : Monaco.&lt;br&gt;
'''Μορμώ, -οῦς (nom propre) (f)''' : Mormo.&lt;br&gt;
'''Μορφεύς, -έως (nom propre) (m)''' : [[wikt:Morphée|Morphée]].&lt;br&gt;
'''Μοῦσα, -ύσης (nom propre) (f)''' : Muse.&lt;br&gt;
'''Μοϋσῆς, -έως (nom propre) (m)''' : Forme alternative de ''Μωϋσῆς''.&lt;br&gt;
'''Μυκερίνος, -ου (nom propre) (m)''' : Mykérinos.&lt;br&gt;
'''Μύρμηξ, -ηκος (nom propre) (f)''' : Myrmex.&lt;br&gt;
'''Μῶμος, -ώμου (nom propre) (m)''' : Momos.&lt;br&gt;
'''Μωσῆς, -έως (nom propre) (m)''' : Forme alternative de ''Μωϋσῆς''.&lt;br&gt;
'''Μωϋση, -ης (nom propre) (m)''' : Forme alternative de ''Μωϋσῆς''.&lt;br&gt;
'''Μωϋσῆς, -έως (nom propre) (m)''' : Moïse.&lt;br&gt;
'''Μῶσα, -ώσης (nom propre) (f)''' : Forme dorienne de ''Μοῦσα''.&lt;br&gt;
'''Μῶἁ, -ἁς (nom propre) (f)''' : Forme laconienne de ''Μοῦσα''.&lt;br&gt;

==Ν== 
'''ναϝός, -οῦ (nom commun) (m)''' : Forme laconienne de ''ναός''.&lt;br&gt;
'''ναί (particule)''' : oui.&lt;br&gt;
'''ναίχι (adverbe)''' : certes.&lt;br&gt; 
'''ναίω (verbe)''' : Habiter. Héberger. Construire ; s’installer quelque part.&lt;br&gt;
'''νᾶνος, -άνου (nom commun) (m)''' : nain.&lt;br&gt;
'''ναός, -οῦ (nom commun) (m)''' : temple.&lt;br&gt;
'''νᾶπυ, -άπυος (nom commun) (f)''' : moutarde (plante).&lt;br&gt;
'''νάρθηξ, -κος (nom commun) (f)''' : férule.&lt;br&gt;
'''ναρθηκοφόρος, -ου (nom commun) (m)''' : licteur.&lt;br&gt;
'''νάρκη, -ης (nom commun) (f)''' : torpeur.&lt;br&gt;
'''νάρκωσις, -όσεως (nom commun) (f)''' : engourdissement.&lt;br&gt; 
'''ναρκωτικός, -ή, -όν (adjectif)''' : engourdissant.&lt;br&gt; 
'''ναρκῶ (verbe)''' : engourdir.&lt;br&gt;  
'''νάσσω (verbe)''' : Presser, fouler. Bourrer, emplir ; encombrer.&lt;br&gt;
'''ναύκληρος, -ήρου (nom commun) (m)''' : .&lt;br&gt;
'''ναῦος, -ύου (nom commun) (m)''' : Forme éolienne de ''ναός''.&lt;br&gt;
'''ναῦς, -εώς (nom commun) (f)''' : navire.&lt;br&gt;
'''ναυτικός, -ή, -όν (adjectif)''' : marin.&lt;br&gt; 
'''ναύτης, -ου (nom commun) (m)''' : marin.&lt;br&gt;
'''νάφθα, -ης (nom commun) (f)''' : naphte.&lt;br&gt;
'''νεανιεία, -ας (nom commun) (f)''' : jouvence.&lt;br&gt; 
'''νεανίας, -ου (nom commun) (m)''' : jouvenceau.&lt;br&gt;
'''νεᾶνις, -άνιδος (nom commun) (f)''' : jouvencelle.&lt;br&gt;
'''νεανιεύομαι (verbe)''' : .&lt;br&gt; 
'''νεανίζω (verbe)''' : .&lt;br&gt; 
'''νεηνίης, -ου (nom commun) (m)''' : Forme homérique et ionienne de ''νεανίας''.&lt;br&gt; 
'''νεῆνις, -ήνιδος (nom commun) (f)''' : Forme homérique et ionienne de ''νεᾶνις''.&lt;br&gt;
'''νεῖκος, -ίκους (nom commun) (n)''' : Bataille ; combat.&lt;br&gt;
'''νεῖλος, -ίλου (nom commun) (m)''' : rivière de vallée.&lt;br&gt;
'''νεῖος, -ία, -ῖον (adjectif)''' : Forme ionienne de ''νέος''.&lt;br&gt;
'''νεκραγωγός, -οῦ (nom commun) (m)''' : nécragogue.&lt;br&gt;
'''νεκρός, -οῦ (nom commun) (m)''' : mort, cadavre.&lt;br&gt;
'''νεκροψία, -ας (nom commun) (f)''' : nécropsie.&lt;br&gt; 
'''νεκυαγωγός, -οῦ (nom commun) (m)''' : nékyagogue.&lt;br&gt;
'''νεκυάμϐατος, -άτου (nom commun) (m)''' : .&lt;br&gt;
'''νεκυδαίμων, -ονος (nom commun) (m)''' : .&lt;br&gt;	
'''νεκυηπόλος, - (nom commun) (m)''' : .&lt;br&gt;
'''νέκυια, -ίας (nom commun) (f)''' : descente aux Enfers.&lt;br&gt;
'''νεκυοδαίμων, -ονος (nom commun) (m)''' : .&lt;br&gt;
'''νεκυομαντεῖον, -ίου (nom commun) (n)''' : nékyomantien.&lt;br&gt;
'''νεκυοπομπός, -οῦ (nom commun) (m)''' : nékyopompe.&lt;br&gt;
'''νέκυς, -ος (nom commun) (m)''' : mort.&lt;br&gt;
'''νάννα, -ας (nom commun) (f)''' : tante.&lt;br&gt;
'''νέμος, -ους (nom commun) (n)''' : clairière.&lt;br&gt;
'''νέμω (verbe)''' : Distribuer, partager, attribuer une part, diviser, découper. Attribuer à un troupeau la partie du pâturage où on le mène paître. Habiter. Occuper, détenir. Conduire, gouverner, administrer. Tenir pour, regarder comme (avec double accusatif). (Par suite) Choisir pour, admettre comme.&lt;br&gt;
'''νέννος, -ου (nom commun) (m)''' : oncle.&lt;br&gt;
'''νέομαι (verbe)''' : arriver.&lt;br&gt;
'''νεοσσιά, -ᾶς (nom commun) (f)''' : nid.&lt;br&gt;
'''νεοσσός, -οῦ (nom commun) (m)''' : oisillon, poussin.&lt;br&gt;
'''νέος, -α, -ον (adjectif)''' : Nouveau ; jeune. Neuf.&lt;br&gt;
'''νευρόσπαστον, -ου (nom commun) (n)''' : marionnette.&lt;br&gt;
'''νεῦρον, -ύρου (nom commun) (n)''' : Fibre ; nerf.&lt;br&gt;
'''νευρώδης, -ης, -ες (adjectif)''' : nerveux.&lt;br&gt; 
'''νεῦσις, -ύσεως (nom commun) (f)''' : nœud.&lt;br&gt;	
'''νεύω (verbe)''' : hocher la tête.&lt;br&gt;
'''νέφος, -ους (nom commun) (n)''' : nuage.&lt;br&gt;
'''νεφρῖτις, -ίτης (nom commun) (f)''' : néphrite (maladie).&lt;br&gt;
'''νεφρός, -οῦ (nom commun) (m)''' : rein.&lt;br&gt;
'''νεώς, -ώ (nom commun) (m)''' : Forme attique de ''ναός''.&lt;br&gt;
'''νέω (verbe)''' : Flotter ; filer la laine.&lt;br&gt;
'''νή (particule)''' : par. (Particule interjective.) (+ nom de divinité a l’accusatif)&lt;br&gt;
'''νῆμα, -ήματος (nom commun) (n)''' : fil.&lt;br&gt; 
'''νηματικός, -ή, -όν (adjectif)''' : .&lt;br&gt; 
'''νηματώδης, -ης, -ες (adjectif)''' : fibreux.&lt;br&gt; 
'''νηός, -οῦ (nom commun) (m)''' : Forme ionienne de ''ναός''.&lt;br&gt;
'''νήπιον, -ίου (nom commun) (n)''' : bébé.&lt;br&gt; 
'''νήπιος, -ίου (nom commun) (m)''' : bébé.&lt;br&gt; 
'''νήριον, -ίου (nom commun) (n)''' : laurier-rose.&lt;br&gt; 
'''νῆσσα, -ήσσης (nom commun) (f)''' : canard.&lt;br&gt;
'''νηστεία, -ας (nom commun) (f)''' : jeûne.&lt;br&gt;
'''νηστεύω (verbe)''' : jeûner.&lt;br&gt;
'''νῆττα, -ήττης (nom commun) (f)''' : Forme attique de ''νῆσσα''.&lt;br&gt;
'''νίζω (verbe)''' : nettoyer.&lt;br&gt;
'''νικέω (verbe)''' : Forme ionienne de ''νικῶ''.&lt;br&gt;
'''νίννη, -ης (nom commun) (f)''' : grand-mère ; belle-mère.&lt;br&gt;
'''νίκη, -ης (nom commun) (f)''' : victoire.&lt;br&gt;
'''νικῶ (verbe)''' : vaincre.&lt;br&gt;
'''νιπτήρ, -ῆρος (nom commun) (m)''' : lavabo.&lt;br&gt; 
'''νίπτω (verbe)''' : Variante de ''νίζω''.&lt;br&gt;
'''νίφω (verbe)''' : neiger.&lt;br&gt;
'''νίψ, -φος (nom commun) (f)''' : neige.&lt;br&gt;
'''νόημα, -ήµατος (nom commun) (n)''' : Source de la pensée ; intelligence. Pensée (chose).&lt;br&gt; 
'''νόησις, -ήσεως (nom commun) (f)''' : pensée (processus).&lt;br&gt; 
'''νοητικός, -ή, -όν (adjectif)''' : Mental ; intellectuel.&lt;br&gt;
'''νοητικῶς (adverbe)''' : Mentalement ; intellectuellement.&lt;br&gt;
'''νοητικώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''νοητικός''.&lt;br&gt;
'''νοητικώτερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''νοητικός''.&lt;br&gt;
'''νοητικώτατα, -, - (adverbe)''' : Superlatif de ''νοητικῶς''.&lt;br&gt;
'''νοητικώτερον, -, - (adverbe)''' : Comparatif de ''νοητικῶς''.&lt;br&gt;
'''νοητός, -ή, -όν (adjectif)''' : pensable.&lt;br&gt; 
'''νοητῶς (adverbe)''' : .&lt;br&gt;
'''νοητώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''νοητός''.&lt;br&gt;
'''νοητώτερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''νοητός''.&lt;br&gt;
'''νομάς, -δος (nom commun) (m/f)''' : nomade.&lt;br&gt; 
'''νομοθέτης, -ου (nom commun) (m)''' : législateur.&lt;br&gt; 
'''νόμος, -ου (nom commun) (m)''' : Ce qui est attribué en partage. (Par suite) Opinion générale. Maxime. Règle de conduite.&lt;br&gt;
'''νομός, -οῦ (nom commun) (m)''' :  Part, portion. (Par extension) Division de territoire. Pâturage, pacage. Herbe, fourrage.&lt;br&gt;
'''νόννος, -ου (nom commun) (m)''' : grand-père ; beau-père.&lt;br&gt; 
'''νόος, -ου (nom commun) (m)''' :  Faculté de penser.&lt;br&gt; 
'''νόσημα, -ήματος (nom commun) (n)''' : infirmité ; fléau.&lt;br&gt;
'''νοσοκομεῖον, -ίου (nom commun) (n)''' : hôpital.&lt;br&gt;
'''νοσοκόμος, -ος, -ν (adjectif)''' : soignant&lt;br&gt;
'''νόσος, -ου (nom commun) (f)''' : maladie.&lt;br&gt; 
'''νότιος, -ία, -ιον  (adjectif)''' : méridional.&lt;br&gt;
'''νοτιώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''νότιως''.&lt;br&gt;
'''νοτιώτερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''νότιως''.&lt;br&gt;
'''νοτιώτατα, -, - (adverbe)''' : Superlatif de ''νότιως''.&lt;br&gt;
'''νοτιώτερον, -, - (adverbe)''' : Comparatif de ''νότιως''.&lt;br&gt;
'''νότιως (adverbe)''' : méridionalement.&lt;br&gt;
'''νότος, -ου (nom commun) (m)''' : sud.&lt;br&gt;
'''νουθετέω (verbe)''' : Admonester ; avertir. Conseiller.&lt;br&gt;
'''vοῦς, -οῦ (nom commun) (m)''' : Variante de ''νόος''.&lt;br&gt;
'''νοῶ (verbe)''' : Penser. Percevoir, noter, observer. Ourdir. Avoir l’intention de. (Linguistique) Signifier, en parlant des mots.&lt;br&gt;
'''νυκτάλωψ, -πία (nom commun) (f)''' : nyctalopie.&lt;br&gt;
'''νυκτερίς, -δος (nom commun) (f)''' : chauve-souris.&lt;br&gt;
'''νύκτερος, -ος, -ον (adjectif)''' : nocturne.&lt;br&gt;
'''νύμφα, -ῦμφας''' : Forme dorienne de ''νύμφη''.&lt;br&gt;
'''νύμφη, -ης (nom commun) (f)''' : nymphe.&lt;br&gt;
'''νυμφόληπτος, -ος, -ον (adjectif)''' : .&lt;br&gt;
'''νυμφιάω (verbe)''' : Être possédé des nymphes ; être en délire.&lt;br&gt;
'''νυμφομανία, -ας (nom commun) (n)''' : nymphomanie.&lt;br&gt;
'''νῦν (adverbe)''' : maintenant.&lt;br&gt;
'''νύξ, -κτός (nom commun) (f)''' : nuit.&lt;br&gt;
'''νυός, -οῦ (nom commun) (f)''' : belle-fille.&lt;br&gt;
'''νῦ (nom commun) (n)''' : nu.&lt;br&gt;
'''νῶμα, -ώματος (nom commun) (n)''' : Forme ionienne de ''νόημα''.&lt;br&gt;  
'''νωπός, -ή, -όν (adjectif)''' : frais.&lt;br&gt;  
'''νῶσις, -ώσεως (nom commun) (f)''' : Forme ionienne de ''νόησις''.&lt;br&gt; 
'''νωτίζω (verbe)''' : tourner le dos.&lt;br&gt;
'''νῶτον, -ώτου (nom commun) (n)''' : (Anatomie) Derrière, dos. (Figuré) Large surface courbe (mer, ciel).&lt;br&gt;
'''νωτοστροφέω (verbe)''' : tourner le dos.&lt;br&gt;
'''νώ (pronom personnel)''' : nous (nous deux).&lt;br&gt;
'''Ναϐαταῖος, -ίου (nom commun) (m)''' : Nabatéen.&lt;br&gt;
'''Ναϐατηνή, -ῆς (nom propre) (f)''' : Nabatea.&lt;br&gt;
'''Ναϊάς, -δος (nom propre) (f)''' : Naïade.&lt;br&gt; 
'''Νάρκισσος, -ίσσου (nom propre) (m)''' : Narcisse.&lt;br&gt; 
'''Ναυσίθοος, - (nom propre) (m)''' : Nausithoos.&lt;br&gt;
'''Ναυσικάα, -ας (nom propre) (f)''' : Nausicaa.&lt;br&gt;
'''Ναυσίνοoς, - (nom propre) (m)''' : Nausinoos.&lt;br&gt;
'''Νέαιρα, -ίρας (nom propre) (f)''' : Nérée.&lt;br&gt;
'''Νεάπολις, -όλεως (nom propre) (f)''' : Naples.&lt;br&gt;
'''Νεῖλος, -ίλου (nom propre) (m)''' : Nil.&lt;br&gt;
'''Νειλῶτις, -ώτεως (nom propre) (f)''' : Nilotis.&lt;br&gt;
'''Νέμεσις, -έσεως (nom propre) (f)''' : [[wikt:Némésis|Némésis]].&lt;br&gt;
'''Νέσσος, -ου (nom propre) (m)''' : Nessos.&lt;br&gt;
'''Νέστωρ, -ορος (nom propre) (m)''' : Nestor.&lt;br&gt;
'''Νεφέλη, -ης (nom propre) (f)''' : Néphélé.&lt;br&gt;
'''Νεφελοκοκκυγία, -ας (nom propre) (f)''' : Coucouville-les-Nuées. (Ville décrite par Aristophane dans ''Les Oiseaux''.)&lt;br&gt;
'''Νηρεύς, -έως (nom propre) (m)''' : Nérée.&lt;br&gt;
'''Νηρῇς, -δος (nom propre) (f)''' : Néréide.&lt;br&gt;
'''Νίκαια, -ίας (nom propre) (f)''' : Nice.&lt;br&gt;
'''Νίκανδρος, -άνδρου (nom propre) (m)''' : Nicandre.&lt;br&gt;
'''Νίκη, -ης (nom propre) (f)''' : [[wikt:Niké|Niké]].&lt;br&gt;
'''Νικόλαος, -άου (nom propre) (m)''' : Nicolas.&lt;br&gt;
'''Νιόϐη, -ης (nom propre) (f)''' : Niobé.&lt;br&gt; 
'''Νότος, -ου  (nom propre) (m)''' : [[wikt:Notos|Notos]]. (dieu du vent du sud)&lt;br&gt;
'''Νουμιδία, -ας (nom propre) (f)''' : Numidie.&lt;br&gt;
'''Νύξ, -κτός (nom propre) (f)''' : [[wikt:Nyx|Nyx]].&lt;br&gt;
'''Νῶε (nom propre) (m)''' : Noé.&lt;br&gt;

==Ξ== 
'''ξανθóς, -ή, -όν (adjectif)''' : Jaune ; jaunâtre. Blond.&lt;br&gt; 
'''ξενοδοχεῖον, -ίου (nom commun) (n)''' : hôtel.&lt;br&gt;	
'''ξένος, -η, -ον (adjectif)''' : étranger, insolite.&lt;br&gt; 
'''ξένος, -ου (nom commun) (m)''' : étranger ; hôte.&lt;br&gt;
'''ξενών, -ῶνος (nom commun) (f)''' : .&lt;br&gt;
'''ξέσις, -εως (nom commun) (f)''' : .&lt;br&gt;
'''ξεχνῶ (verbe)''' : oublier.&lt;br&gt;
'''ξέω (verbe)''' : gratter ; raser. Polir.&lt;br&gt;
'''ξηρός, -ά, -όν (adjectif)''' : sec.&lt;br&gt; 
'''ξῖ (nom commun) (n)''' : xi.&lt;br&gt;
'''ξιφίας, -ου (nom commun) (m)''' : espadon.&lt;br&gt;
'''ξιφίδιον, -ίου (nom commun) (n)''' : dague.&lt;br&gt; 
'''ξίφος, -ους (nom commun) (n)''' : glaive.&lt;br&gt;
'''ξύλον, -ου (nom commun) (n)''' : bois (matériau). Tout objet en bois.&lt;br&gt;
'''ξυλόσπογγος, -όγγου (nom commun) (m)''' : tersorium.&lt;br&gt;
'''ξύλωσις, -ώσεως (nom commun) (f)''' : charpente.&lt;br&gt;
'''ξυνός, -ή, -όν (adjectif)''' : Forme ionienne de ''κοινός''.&lt;br&gt;
'''ξύω (verbe)''' : Variante de ''ξέω''.&lt;br&gt;
'''Ξενοφῶν, -τος (nom propre) (m)''' : Xénophon.&lt;br&gt;
'''Ξέρξης, -ου (nom propre) (m)''' : Xerxès.&lt;br&gt;
'''Ξοῦθος, -ύθου (nom propre) (m)''' : Xouthos.&lt;br&gt;

==Ο==
'''ὁ (article défini)''' : le.&lt;br&gt;
'''ὄασις, -άσεως (nom commun) (f)''' : Voie, route ; chemin.&lt;br&gt;
'''ὀγδοήκοντα (adjectif numéral)''' : quatre-vingts.&lt;br&gt;
'''ὀγκάομαι (verbe)''' : .&lt;br&gt;
'''ὄγκος, -ου (nom commun) (m)''' : tumeur.&lt;br&gt;
'''ὄγχνη, -ης (nom commun) (f)''' : poirier.&lt;br&gt;
'''ὅδερος, -έρου (nom commun) (m)''' : ventre.&lt;br&gt; 
'''ὁδηγός, -οῦ (nom commun) (m)''' : conducteur.&lt;br&gt;
'''ὁδηγῶ (verbe)''' : conduire.&lt;br&gt;
'''ὁδός, -οῦ (nom commun) (f)''' : Voie, route ; chemin.&lt;br&gt;
'''ὀδούς, -όντος (nom commun) (m)''' : dent.&lt;br&gt;
'''ὀδμή, -ῆς (nom commun) (f)''' : Forme plus ancienne de ''ὀσμή''.&lt;br&gt;
'''ὀδύνη, -ης (nom commun) (f)''' : douleur ; chagrin.&lt;br&gt;
'''ὀδυσάω (verbe)''' : Haïr ; être fâché.&lt;br&gt;
'''ὀδυσσειακός, -ή, -όν (adjectif)''' : odysséen.&lt;br&gt; 
'''ὀδύσσομαι (verbe)''' : Être irrité contre quelqu’un.&lt;br&gt; 
'''ὄζω (verbe)''' : Exhaler une odeur.&lt;br&gt;
'''ὅθεν (adverbe relatif)''' : d’où (je viens).&lt;br&gt;
'''οἷ (adverbe relatif)''' : là où (je vais).&lt;br&gt;
'''ὀθόνη, -ης (nom commun) (f)''' : toile.&lt;br&gt; 
'''οἴ (interjection)''' : hélas ; ouille.&lt;br&gt;
'''οἴκημα, -ήματος (nom commun) (n)''' : résidence.&lt;br&gt;
'''οἰκηματικός, -ή, -όν (adjectif)''' : résidentiel.&lt;br&gt;
'''οἰκημάτιον, -ίου (nom commun) (n)''' : .&lt;br&gt;	
'''οἰκητήριον, -ίου (nom commun) (n)''' : domicile.&lt;br&gt;	
'''οἰκοπεδικός, -ή, -όν (adjectif)''' : .&lt;br&gt;
'''οἰκόπεδον, -έδου (nom commun) (n)''' : .&lt;br&gt;	
'''οἰκοπεδοποίησις, -ήσεως (nom commun) (f)''' : .&lt;br&gt;
'''οἶκος, -ου (nom commun) (m)''' : maison.&lt;br&gt;
'''οἰκοῦμαι (verbe)''' : .&lt;br&gt;
'''οἰκουμένη, -ης (nom commun) (f)''' : .&lt;br&gt;
'''οἰκουμενικός, -ή, -όν (adjectif)''' : .&lt;br&gt;
'''ϝοῖκος, -ίκου (nom commun) (m)''' : Forme ancienne de ''οἶκος''.&lt;br&gt;
'''οἰκεῖος, -ία, -ῖον (adjectif)''' : de la maison.&lt;br&gt;
'''οἰκός, -τος (nom commun) (n)''' : Forme ionienne de ''εἰκός''.&lt;br&gt;
'''οἰκοτροφεῖον, -ίου (nom commun) (n)''' : pensionnat.&lt;br&gt; 
'''οικότροφος, -όφου (nom commun) (m/f)''' : pensionnaire.&lt;br&gt;
'''οἶκτος, -ἴκτου (nom commun) (m)''' : pitié.&lt;br&gt;
'''οἰκτρός, -ά, -όν (adjectif)''' : .&lt;br&gt;
'''οἰκτρότατος, -άτη, -ότατον (adjectif)''' : Superlatif de ''οἰκτρός''.&lt;br&gt;
'''οἰκτρότερος, -έρα, -ότερον (adjectif)''' : Comparatif de ''οἰκτρός''.&lt;br&gt;
'''οἰκτρότατα, -, - (adverbe)''' : Superlatif de ''οἰκτρῶς''.&lt;br&gt;
'''οἰκτρότερον, -, - (adverbe)''' : Comparatif de ''οἰκτρῶς''.&lt;br&gt;
'''οἰκτρῶς (adverbe)''' : .&lt;br&gt;
'''οἰκῶ (verbe)''' : Habiter ; occuper.&lt;br&gt;
'''οἴμοι (interjection)''' : pauvre de moi.&lt;br&gt;
'''οἶνος, -ἴνου (nom commun) (m)''' : vin.&lt;br&gt;
'''ϝοῖνος, -ίνου (nom commun) (m)''' : Forme dorienne de ''οἶνος''.&lt;br&gt;
'''οἰνοχόη, -ης (nom commun) (f)''' : œnochoé ; échansonne.&lt;br&gt;
'''οἰνοχόος, -ου (nom commun) (m)''' : échanson.&lt;br&gt;
'''ὄϊς, -ΐος  (nom commun) (m/f)''' : bélier ; brebis.&lt;br&gt;
'''οἶς, -ός (nom commun) (m/f)''' : Forme attique de ''ὄϊς''.&lt;br&gt;
'''οἷος, -ἵα, -ἷον (adjectif)''' : tel.&lt;br&gt;
'''οἰσοφάγος, -ου (nom commun) (m)''' : œsophage.&lt;br&gt;
'''οἶσος, -ἴσου (nom commun) (m)''' : gattilier.&lt;br&gt;
'''οἶστρος, -ίστρου (nom commun) (m)''' : (au propre) taon. (au figuré) fureur, désir ; passion.&lt;br&gt;
'''οἶτος, -ἴτου (nom commun) (m)''' : destin.&lt;br&gt;
'''οἰφόλης, -ης, ες (adjectif)''' : obscène.&lt;br&gt; 
'''οἴφω (verbe)''' copuler.&lt;br&gt;
'''οἰωνοσκοπία, -ας (nom commun) (f)''' : augure.&lt;br&gt;
'''οἰωνοσκόπος, -ου (nom commun) (m)''' : augure.&lt;br&gt;
'''οἰωνός, -οῦ (nom commun) (m)''' : présage, augure.&lt;br&gt;
'''ὀκνείω (verbe)''' : Forme homérique de ''ὀκνέω''.&lt;br&gt;
'''ὀκνέω (verbe)''' : hésiter.&lt;br&gt;
'''ὄκνος, -ου (nom commun) (m)''' : hésitation.&lt;br&gt;
'''ὀκτώ (adjectif numéral)''' : huit.&lt;br&gt;
'''ὄκχος, -ου (nom commun) (m)''' : Forme poétique de ''ὄχος''.&lt;br&gt;
'''ὀλιγάρχης, -ου (nom commun) (m)''' : oligarque.&lt;br&gt; 
'''ὀλιγαρχία, -ας (nom commun) (f)''' : oligarchie.&lt;br&gt; 
'''ὀλίγος, -η, -ον (adjectif)''' : .&lt;br&gt;	
'''ὁλικός, -ή , -όν (adjectif)''' : total.&lt;br&gt;
'''ὁλικῶς (adverbe)''' : totalement.&lt;br&gt;
'''ὁλικώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''ὁλικός''.&lt;br&gt; 
'''ὁλικώτερος, -έρη, -ώτερον (adjectif)''' : Comparatif de ''ὁλικός''.&lt;br&gt;
'''ὁλικώτατα, -, - (adverbe)''' : Superlatif de ''ὁλικῶς''.&lt;br&gt;
'''ὁλικώτερον, -, - (adverbe)''' : Comparatif de ''ὁλικῶς''.&lt;br&gt; 
'''ὄλισϐος, -ίσϐου (nom commun) (m)''' : godemichet.&lt;br&gt;
'''ὁλκή, -ῆς (nom commun) (f)''' : attraction.&lt;br&gt; 
'''ὄλλυμι (verbe)''' : (Sens actif) Perdre, causer la perte, détruire, annihiler. Mourir. (Sens passif) Périr.&lt;br&gt;
'''ὅλος, -η, -ον  (adjectif)''' : entier, complet.&lt;br&gt; 
'''ὁλοφύρομαι (verbe)''' : .&lt;br&gt;
'''ὄλπη, -ης (nom commun) (f)''' : .&lt;br&gt; 
'''ὀλυμπιακός, -ή, -όν (adjectif)''' : olympien.&lt;br&gt; 
'''ὀλυμπικός, -ή, -όν (adjectif)''' : olympique.&lt;br&gt; 
'''ὀλύμπιος, -ία, -ύμπιον  (adjectif)''' : olympien.&lt;br&gt; 
'''ὁμαδικός, -ήν, -όν (adjectif)''' : .&lt;br&gt; 
'''ὁμαλός, -ή, -όν (adjectif)''' : lisse.&lt;br&gt;
'''ὁμάς, -δος (nom commun) (f)''' : équipe.&lt;br&gt; 
'''ὄμϐρος, -ου (nom commun) (m)''' : tempête de pluie, orage, envoyé par Zeus. Eau. Inondation.&lt;br&gt;
'''ὁμηρικός, -ή, -όν (adjectif)''' : homérique.&lt;br&gt;
'''ὅμηρος, -ήρου (nom commun) (m/f)''' : otage.&lt;br&gt;
'''ὂ μικρόν (nom commun) (n)''' : omicron.&lt;br&gt;
'''ὁμιλία, -ας (nom commun) (f)''' : discours.&lt;br&gt;
'''ὁμιλῶ (verbe)''' : discourir.&lt;br&gt;
'''ὁμίχλη, -ης (nom commun) (f)''' : brouillard.&lt;br&gt;
'''ὄμμα, -τος (nom commun) (n)''' : œil.&lt;br&gt;
'''ὅμοιος, ία, -ον (adjectif)''' : semblable.&lt;br&gt; 
'''ὁμοῖος, -, -ῖον (adjectif)''' : Forme homérique, ionienne, et ancienne attique de ''ὅμοιος''.&lt;br&gt;
'''ὁμοίιος, -, - (adjectif)''' : Forme homérique de ''ὅμοιος''.&lt;br&gt;
'''ὁμοιοκαταληξία, -ας (nom commun) (f)''' : rime.&lt;br&gt;
'''ὁμοιοκατάληκτος, -η, -ο (adjectif)''' : rimique.&lt;br&gt;
'''ὁμοιοκαταληκτῶ (verbe)''' : rimer.&lt;br&gt;
'''ὁμοούσιος, -ος, -ον (adjectif)''' : de même substance.&lt;br&gt;
'''ὁμοιούσιος, -ος, -ον (adjectif)''' : de nature semblable.&lt;br&gt;
'''ὁμοιοτέλευτος, -ύτου (nom commun) (m)''' : homéotéleute.&lt;br&gt; 
'''ὀμοίωμα, -ώματος (nom commun) (n)''' : effigie.&lt;br&gt;
'''ὁμόνοια, -ας (nom commun) (f)''' : concorde.&lt;br&gt;
'''ὁμός, -ή, -όν (adjectif)''' : Pareil ; semblable.&lt;br&gt;
'''ὁμοῦ (adverbe)''' : En un même lieu, ensemble. (Par suite) Ensemble, à la fois. (Par extension) Auprès, proche.&lt;br&gt;
'''ὀμφαλός, -οῦ (nom commun) (m)''' : nombril.&lt;br&gt;
'''ὀμφή, -ῆς (nom commun) (f)''' : oracle, prophétie.&lt;br&gt;
'''ὀμφής, -ής, -ές : (adjectif)''' : prophétique.&lt;br&gt;
'''ὀμφητήρ, -τρός (nom commun) (m)''' : prophète.&lt;br&gt;	
'''ὄνειδος, -ίδους (nom commun) (n)''' : Reproche ; disgrâce.&lt;br&gt; 
'''ὀνειρευτής, -οῦ (nom commun) (m)''' : rêveur.&lt;br&gt;
'''ὄνειρος, -ίρου (nom commun) (m)''' : rêve.&lt;br&gt;
'''ὀνειροπόλος, -ου (nom commun) (m)''' : rêvasseur.&lt;br&gt;
'''ὀνειροπωλῶ (verbe)''' : rêvasser.&lt;br&gt;
'''ὀνοκρόταλος, -άλου (nom commun) (m)''' : pélican.&lt;br&gt;
'''ὄνομα, -όματος (nom commun) (n)''' : nom.&lt;br&gt;
'''ὀνοματοποιία, -ας (nom commun) (f)''' : mot imitant un son.&lt;br&gt;
'''ὄνος, -ου (nom commun) (m/f)''' : Âne ; ânesse.&lt;br&gt; 
'''ὄνυξ, -χος (nom commun) (m)''' : ongle.&lt;br&gt; 
'''ὄνυμα, -ύματος (nom commun) (n)''' : Forme dorienne et éolienne de ''ὄνομα''.&lt;br&gt;
'''ὀνύχιον, -ίου (nom commun) (m)''' : griffe.&lt;br&gt;
'''ὄνω (adverbe)''' : Forme éolienne de ''ἄνω''.&lt;br&gt;
'''ὀξίνης, -ης, -ες (adjectif)''' : aigre.&lt;br&gt;
'''ὀξύα, -ας (nom commun) (f)''' : Hêtre. Arme en bois de hêtre comme un épieu ou un javelot.&lt;br&gt;
'''ὀξύγαλα, -άλακτος (nom commun) (n)''' : petit-lait.&lt;br&gt;
'''ὀξύμωρος, -ος, -ον  (adjectif)''' : .&lt;br&gt;
'''ὀξύς,  -εῖα, -ύ (adjectif)''' : Aigu. Pointu. Tranchant en parlant d’une arme. Piquant en parlant de la sensation (chaleur, froid, douleur), du goût (acidité). Vif. Fin, pénétrant. Prompt à l’action.&lt;br&gt;
'''ὀξύτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''ὀξύς''.&lt;br&gt;
'''ὀξύτερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''ὀξύς''.&lt;br&gt;
'''ὀπαδός, -οῦ (nom commun) (m)''' : fan.&lt;br&gt;  
'''ὀπάζω (verbe)''' : .&lt;br&gt; 
'''ὀπή, -ῆς (nom commun) (f)''' : Trou ; orifice.&lt;br&gt; 
'''ὄπιον, -ίου (nom commun) (n)''' : opium.&lt;br&gt;
'''ὄπισθεν (adverbe)''' : arrière, derrière.&lt;br&gt; 
'''ὄπις, -δος (nom commun) (f)''' : (Sens négatif) Revanche, vengeance. (Sens positif) Regard bienveillant, égard. (Religion) Égards dûs aux dieux par les hommes.&lt;br&gt;
'''ὄπις (adverbe)''' : en arrière (sans mouvement).&lt;br&gt;
'''ὀπίσω (adverbe)''' : en arrière (avec mouvement), vers l’arrière.&lt;br&gt;
'''ὁπλή, -ῆς (nom commun) (f)''' : sabot (corne pédestre de certains animaux).&lt;br&gt;
'''ὅπλη, -ης (nom commun) (f)''' : Forme homérique de ''ὁπλή''.&lt;br&gt;	
'''ὁπλήεις, -εις, -ης (f)''' : .&lt;br&gt;	
'''ὁπλίτης, -ου (nom commun) (m)''' : Soldat pesamment armé.&lt;br&gt; 
'''ὅπλον, -ου (nom commun) (n)''' : Outil. (Au pluriel) Armes.&lt;br&gt; 
'''ὀποπάναξ, -κος (nom commun) (m)''' : jus de légume.&lt;br&gt;
'''ὀπός, -οῦ (nom commun) (m)''' : jus ; suc.&lt;br&gt;
'''ὀπτασία, -ας (nom commun) (f)''' : fantasme.&lt;br&gt;
'''ὀπτικός, -ή, -όν (adjectif)''' : visuel.&lt;br&gt;
'''ὀπτός, -ή, -όν (adjectif)''' : Rôti, grillé. (Par extension) Cuit. Visible, vu.&lt;br&gt;
'''ὀπτῶ (verbe)''' : Rôtir, griller.&lt;br&gt;
'''ὅραμα, -άματος (nom commun) (n)''' : vision, spectacle.&lt;br&gt; 
'''ὄρασις, -άσεως (nom commun) (f)''' : vue.&lt;br&gt;
'''ὁρατός, -ή, -όν, (adjectif)''' : visible.&lt;br&gt;
'''ὁράω (verbe)''' : voir, regarder.&lt;br&gt;
'''ὀρεάς, -δος (nom commun) (f)''' : oréade.&lt;br&gt;
'''ὁρέω (verbe)''' : Forme ionienne de ''ὁράω''.&lt;br&gt;
'''ὄρημι (verbe)''' : Forme éolienne de ''ὁράω''.&lt;br&gt;
'''ὄργανον, -άνου (nom commun) (n)''' : organe, instrument de musique.&lt;br&gt;
'''ὀργασμός, -οῦ (nom commun) (m)''' : point culminant du plaisir sexuel.&lt;br&gt;
'''ὀργάς, -δος (nom commun) (f)''' : .&lt;br&gt;
'''ὀργή, -ῆς (nom commun) (f)''' : colère.&lt;br&gt;
'''ὀργῶ (verbe)''' : enfler, être empli de désir amoureux.&lt;br&gt; 
'''ὄρεξις, -έξεως (nom commun) (f)''' : appétit.&lt;br&gt; 
'''ὀρθογραφία, -ας (nom commun) (f)''' : écriture correcte.&lt;br&gt; 
'''ὀρθόδοξος, -ος, -ον (adjectif)''' : orthodoxe.&lt;br&gt;  
'''ὀρθός, -ή, -όν (adjectif)''' : droit.&lt;br&gt; 
'''ὀρθότατος, -άτη, -ότατον (adjectif)''' : Superlatif de ''ὀρθός''.&lt;br&gt;
'''ὀρθότερος, -έρα, -ότερον (adjectif)''' : Comparatif de ''ὀρθός''.&lt;br&gt;
'''ὀρθῶς (adverbe)''' : droitement.&lt;br&gt;
'''ὁρίζων, -οντος (m)''' : horizon.&lt;br&gt;
'''ὁρίζω (verbe)''' : limiter, borner.&lt;br&gt;
'''ὁρμά, -ᾶς (nom commun) (f)''' : Saut, essor.&lt;br&gt;
'''ὁρμέω (verbe)''' : (Marine) Mouiller, être à l'ancrage.&lt;br&gt;
'''ὁρμή, -ῆς (nom commun) (f)''' : élan (rapidité).&lt;br&gt;
'''ὅρμημα, -ήματος (nom commun) (f)''' : impulsion, désir.&lt;br&gt;
'''ὅρμησις, -ήσεως (nom commun) (f)''' : élan.&lt;br&gt;
'''ὁρμητικός, -ή, -όν (adjectif)''' : impétueux.&lt;br&gt; 
'''ὁρμητικῶς (adverbe)''' : impétueusement.&lt;br&gt;
'''ὁρμητικώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''ὁρμητικός''.&lt;br&gt;
'''ὁρμητικώτερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''ὁρμητικός''.&lt;br&gt;
'''ὁρμητικώτατα, -, - (adverbe)''' : Superlatif de ''ὁρμητικῶς''.&lt;br&gt;
'''ὁρμητικώτερον, -, - (adverbe)''' : Comparatif de ''ὁρμητικῶς''.&lt;br&gt; 
'''ὁρμητικότης, -τος (nom commun) (f)''' : impétuosité.&lt;br&gt;
'''ὁρμῶ (verbe)''' : Pousser, démarrer, mettre en mouvement ; presser, se presser ; aller vite.&lt;br&gt;
'''ὄρνεον, -έου (nom commun) (n)''' : oiseau.&lt;br&gt; 
'''ὄρνις, -θος (nom commun) (m/f)''' : oiseau.&lt;br&gt; 
'''ὄρνυμι (verbe)''' : animer, inciter.&lt;br&gt;
'''ὄρος, -ους (nom commun) (m)''' : Montagne ; colline, hauteur.&lt;br&gt;
'''ὅρος, -ου (nom commun) (m)''' : borne.&lt;br&gt;
'''ὀρός, -οῦ (nom commun) (m)''' : sérum.&lt;br&gt; 
'''ὄρρος, -ου (nom commun) (m)''' : (Familier) cul.&lt;br&gt;
'''ὀροφή, -ῆς (nom commun) (f)''' : plafond.&lt;br&gt;
'''ὁρόω (verbe)''' : Forme homérique de ''ὁράω''.&lt;br&gt;
'''ὄρτυξ, -ύκου (nom commun) (m/f)''' : caille.&lt;br&gt;
'''ὀρυκτήρ, -ῆρος (nom commun) (m)''' : mineur.&lt;br&gt; 
'''ὄρυξ, -γος (nom commun) (m)''' : oryx.&lt;br&gt; 
'''ὀρύσσω (verbe)''' : creuser.&lt;br&gt;
'''ὀρφανία, -ας (nom commun) (f)''' : .&lt;br&gt;
'''ὀρφανίζω (verbe)''' : .&lt;br&gt; 
'''ὀρφανιστής, -οῦ (nom commun) (m)''' : .&lt;br&gt; 
'''ὀρφανός, -ή, -όν (adjectif)''' : orphelin.&lt;br&gt; 
'''ὀρφανός, -οῦ (nom commun) (m)''' : orphelin.&lt;br&gt; 
'''ὀρφανοτροφεῖον, -ίου (nom commun) (n)''' : orphelinat.&lt;br&gt;
'''ὄρανος, -άνου (nom commun) (m)''' : Forme éolienne de ''οὐρανός''.&lt;br&gt; 
'''ὀρείχαλκος, -άλκου (nom commun) (m)''' : orichalque.&lt;br&gt; 
'''ὄρφνα, -ας (nom commun) (f)''' : Forme dorienne de ''ὄρφνη''.&lt;br&gt;
'''ὄρφνη, -ης (nom commun) (f)''' : obscurité.&lt;br&gt;
'''ὀρφνός, -ή, -όν (adjectif)''' : obscur.&lt;br&gt;
'''ὀρφνότατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''ὀρφνός''.&lt;br&gt;
'''ὀρφνότερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''ὀρφνός''.&lt;br&gt;
'''ὀρφνῶς (adverbe)''' : obscurément.&lt;br&gt;
'''ὀρχήστρα, -ας (nom commun) (f)''' : place du chœur.&lt;br&gt;
'''ὀρχηστρίς, -δος (nom commun) (f)''' : danseuse.&lt;br&gt;
'''ὄρχις, -εως (nom commun) (m/f)''' : (Au masculin) Testicule, ovaire, orchidée. (Au féminin) Sorte d’olive.&lt;br&gt;
'''ὀρχοῦμαι (verbe)''' : danser.&lt;br&gt;
'''ὄσδω (verbe)''' : Forme dorienne de ''ὄζω''.&lt;br&gt;
'''ὀσμή, -ῆς (nom commun) (f)''' : odeur.&lt;br&gt;
'''ὀστέον, -ου  (nom commun) (n)''' : os ; noyau.&lt;br&gt;
'''ὀστοῦν, -οῦ (nom commun) (n)''' : Forme attique de ''ὀστέον''.&lt;br&gt;
'''ὀστεῦν, -εῦ (nom commun) (n)''' : Forme poétique de ''ὀστέον''.&lt;br&gt; 
'''ὄστιον, -ίου (nom commun) (n)''' : Forme éolienne de ''ὀστέον''.&lt;br&gt;
'''ὅς, ἥ, ὅ''' : (adjectif démonstratif) Celui-ci, celle-ci, ceci. (pronom relatif) Qui, lequel, laquelle.&lt;br&gt;
'''ὄστρειον, -ίου (nom commun) (n)''' : Forme de ''ὄστρεον''.&lt;br&gt;
'''ὄστρεον, -έου (nom commun) (n)''' : huître.&lt;br&gt;
'''ὀσφραίνομαι (verbe)''' : sentir.&lt;br&gt;
'''ὄσφρησις, -ήσεως (nom commun) (f)''' : odorat.&lt;br&gt;
'''ὀσφυαλγία, -ας (nom commun) (f)''' : lumbago.&lt;br&gt;
'''ὀσφῦς, -ύος (nom commun) (f)''' : flanc.&lt;br&gt;
'''οὐ- (préfixe)''' : préfixe privatif.&lt;br&gt;
'''οὐαί (interjection)''' : ah.&lt;br&gt;
'''οὖας, -τός (nom commun) (n)''' : Forme homérique de ''οὖς''.&lt;br&gt;
'''οὐδείς, -μία, -έν (adjectif indéfini ; pronom indéfini)''' : Aucun, personne.&lt;br&gt;
'''οὐδέποτε (adverbe)''' : jamais.&lt;br&gt;
'''οὐδέτερος, -έρα, -έτερον (adjectif)''' : ni l’un ni l’autre.&lt;br&gt;
'''οὕδωρ, -ατος (nom commun) (n)''' : Forme béotienne de ''ὕδωρ''.&lt;br&gt;
'''οὐκί (adverbe)''' : Forme attique et ionienne de ''οὐ''&lt;br&gt;
'''οὐλή, -ῆς (nom commun) (f)''' : cicatrice.&lt;br&gt;
'''οὔνομα, -όματος (nom commun) (n)''' : Forme homérique et ionienne de ''ὄνομα''.&lt;br&gt;
'''οὖθαρ, -ὔθατος (nom commun) (n)''' : Mamelle. (Anatomie) Pis.&lt;br&gt;
'''οὔποτε (adverbe)''' : jamais.&lt;br&gt;
'''οὐροδοχεῖον, -ίου (nom commun) (n)''' : pot de chambre.&lt;br&gt;
'''οὖρον, -ὔρου (nom commun) (n)''' : urine.&lt;br&gt;
'''οὖρος, -ὔρου (nom commun) (m)''' : gardien.&lt;br&gt;
'''οὗ (adverbe relatif)''' : où (je suis).&lt;br&gt;
'''οὐ (particule)''' (Devient ''οὐκ'' devant un mot commençant par une voyelle à esprit doux, et ''οὐχ'' devant un mot commençant par une voyelle à esprit rude.) : non.&lt;br&gt; 
'''οὖν (adverbe)''' : Sans doute, réellement, en effet. Donc, eh bien.&lt;br&gt;
'''οὐρά, -ᾶς  (nom commun) (f)''' : queue.&lt;br&gt;
'''οὐράνη, -ης (nom commun) (f)''' : pot de chambre.&lt;br&gt;  
'''οὐράνιος, -α, -ον (adjectif)'''  : céleste.&lt;br&gt;
'''οὐρανός, -οῦ  (nom commun) (m)''' : ciel.&lt;br&gt;
'''οὔρησις, -ήσεως (nom commun) (f)''' : miction.&lt;br&gt;
'''οὐρητρίς, -δος (nom commun) (f)''' : pot de chambre.&lt;br&gt; 
'''οὖρον, -ὔρου  (nom commun) (n)''' : urine.&lt;br&gt;
'''οὐρῶ (verbe)''' : uriner.&lt;br&gt;
'''οὐσία, -ας (nom commun) (f)''' : (Philosophie) Essence, substance, être. Élément, substance première.  Biens, fortune, richesse.&lt;br&gt;
'''οὐσιαστικόν, -οῦ (nom commun) (n)''' : substantif.&lt;br&gt;
'''οὐσίη, -ης (nom commun) (f)''' : Forme ionienne de ''οὐσία''.&lt;br&gt; 
'''οὐσιώδης, -ης, -ες (adjectif)''' : essentiel.&lt;br&gt;
'''οὖς, ὠτός (nom commun) (n)''' : oreille.&lt;br&gt;
'''οὔτις, -ις, -ι (pronom)''' : personne.&lt;br&gt;
'''οὐχί (adverbe)''' : Forme attique et homérique de ''οὐ''&lt;br&gt;
'''ὀφείλημα, -ήματος (nom commun) (n)''' : dette.&lt;br&gt;
'''ὀφείλω (verbe)''' : devoir de l'argent.&lt;br&gt;
'''ὀφέλλω (verbe)''' : Forme homérique et de ''ὀφείλω''.&lt;br&gt;
'''ὄφελος, -έλους (nom commun) (n)''' : .&lt;br&gt;
'''ὀφθαλμός, -οῦ (nom commun) (m)''' : œil.&lt;br&gt;
'''ὄφις, -εως (nom commun) (m)''' : serpent.&lt;br&gt;
'''ὀφρῦς, -ύος (nom commun) (f)''' : sourcil.&lt;br&gt;
'''ὀχεύω (verbe)''' copuler.&lt;br&gt;
'''ὄχημα, -ήματος (nom commun) (n)''' : véhicule.&lt;br&gt;
'''ϝόχος, -ου (nom commun) (m)''' : Forme ancienne de ''ὄχος''.&lt;br&gt;
'''ὄχθη, -ης (nom commun) (f)''' : Rive ; berge.&lt;br&gt; 
'''ὀχλοκρατία, -ας (nom commun) (f)''' : ochlocratie.&lt;br&gt;
'''ὄχλος, -ου (nom commun) (m)''' : Foule ; multitude. Tumulte d'une foule.&lt;br&gt;
'''ὄχνη, -ης (nom commun) (f)''' : poire.&lt;br&gt;
'''ὄχος, -ου (nom commun) (m)''' : Réceptacle, abri. Tout ce qui sert à transporter, véhicule.&lt;br&gt;
'''-οχος, -όχου (suffixe) (m)''' : .&lt;br&gt;
'''ὀχυρός, -ά, -όν (adjectif)''' : ferme.&lt;br&gt;
'''ὀχυρότατος, -άτη, -ότατον (adjectif)''' : Superlatif de ''ὀχυρός''.&lt;br&gt;
'''ὀχυρότερος, -έρα, -ότερον (adjectif)''' : Comparatif de ''ὀχυρός''.&lt;br&gt;
'''ὀχυρῶς (adverbe)''' : fermement.&lt;br&gt;
'''ὀχύρωμα, -ώματος (nom commun) (n)''' : forteresse.&lt;br&gt;
'''ὀχυρῶ (verbe)''' : fortifier.&lt;br&gt;
'''ὀχῶ (verbe)''' : .&lt;br&gt;
'''ὄψις, -εως (nom commun) (f)''' : vue. (perception visuelle)&lt;br&gt;
'''ὄψον, -ου (nom commun) (n)''' : (Cuisine) Plat cuisiné, mets. Assaisonnement, sauce. Délicatesse. (Attique) Poisson.&lt;br&gt;
'''ὀψοποιός, -οῦ (nom commun) (m)''' : cuisinier.&lt;br&gt;
'''ὀψώνης, -ου (nom commun) (m)''' : .&lt;br&gt;
'''ὀψώνιον, -ίου (nom commun) (n)''' : Provisions, vivres. Salaire.&lt;br&gt;
'''ὀψωνῶ (verbe)''' : .&lt;br&gt;
'''ὄψ, -πός (nom propre) (f)''' : Voix. Parole, discours. Œil. (Par métonymie) Visage.&lt;br&gt;
'''Ὀδρύσης, -ου (nom commun) (m)''' : Odryse.&lt;br&gt;
'''Ὀδύσσεια, -ίας (nom propre) (f)''' : Odyssée.&lt;br&gt;
'''Ὀδυσσεία, -ας (nom propre) (f)''' : Forme alternative de ''Ὀδύσσεια''.&lt;br&gt;
'''Ὀδυσσεύς, -έως (nom propre) (m)''' : Ulysse.&lt;br&gt;
'''Ὀζυμάνδιος, -ίου (nom propre) (m)''' : Ozymandias.&lt;br&gt;
'''Ὄθων, -ου (nom propre) (m)''' : Othon.&lt;br&gt;
'''Οἰδίπους, -οδος (nom propre) (m)''' : Œdipe.&lt;br&gt;
'''Οἰκλῆς, -έους (nom propre) (m)''' : Oïclès.&lt;br&gt;
'''Οἰνεύς, -έως (nom propre) (m)''' : Œnée.&lt;br&gt;
'''Οἰνόμαος, -άου (nom propre) (m)''' : Œnomaos.&lt;br&gt;
'''Οἰταῖος, -ίη, -ῖον  (adjectif)''' : œtéen.&lt;br&gt;
'''Οἴτη, -ης (nom propre) (f)''' : Œta.&lt;br&gt;
'''Ὄλθφες, - (nom propre) (m)''' : Olivier.&lt;br&gt;
'''Ὀλυμπιάς, -δος (nom propre) (f)''' : olympiade.&lt;br&gt;
'''Ὀλύμπια, -ίων (nom propre) (n)''' : Jeux olympiques.&lt;br&gt;
'''Ὄλυμπος, -ύμπου (nom propre) (m)''' : Olympe.&lt;br&gt;
'''Ὀλυσσεύς, -έως (nom propre) (m)''' : Forme de ''Ὀδυσσεύς''.&lt;br&gt;
'''Ὀλυττεύς, -έως (nom propre) (m)''' : Forme de ''Ὀδυσσεύς''.&lt;br&gt; 
'''Ὅμηρος, -ήρου (nom propre) (m)''' : Homère. (poète grec)&lt;br&gt;
'''Ὄνειρος, -ίρου (nom propre) (m)''' : Oniros.&lt;br&gt;
'''Ὀννῶφρις, -ίδος (nom propre) (m)''' : Onnophris.&lt;br&gt;
'''Ὀνούφριος, -ίου (nom propre) (m)''' : Onuphre.&lt;br&gt;
'''Ὄρανος, -άνου (nom propre) (m)''' : Forme éolienne de ''Οὐρανός''.&lt;br&gt;
'''Ὀρσηίς, -δος (nom propre) (f)''' : Orséis (épouse d'Hellen).&lt;br&gt;
'''Ὄρθρος, -ου (nom propre) (m)''' : Orthros.&lt;br&gt;
'''Ὀρφεύς, -έως (nom propre) (m)''' : Orphée.&lt;br&gt;
'''Ὄσιρις, -ίριδος (nom propre) (m)''' : [[wikt:Osiris|Osiris]].&lt;br&gt;
'''Οὐδαῖος, -ίου (nom propre) (m)''' : Udée.&lt;br&gt;
'''Οὑδυσσεύς, -έως (nom propre) (m)''' : Forme de ''Ὀδυσσεύς''.&lt;br&gt; 
'''Οὐλιξεύς, -έως (nom propre) (m)''' : Forme de ''Ὀδυσσεύς''.&lt;br&gt; 
'''Οὐλίξης, -ους (nom propre) (m)''' : Forme de ''Ὀδυσσεύς''.&lt;br&gt;
'''Οὐόλκος, -ου (nom commun) (m)''' : Volque.&lt;br&gt;
'''Οὐρανία, -ας (nom propre) (f)''' : Uranie.&lt;br&gt;
'''Οὐρανός, -οῦ (nom propre) (m)''' : [[wikt:Ouranos|Ouranos]].&lt;br&gt;
'''Ὀφηλία, -ας (nom propre) (f)''' : Ophélie.&lt;br&gt;
'''Ὀφιοῦχος, -ύχου (nom propre) (f)''' : Serpentaire.&lt;br&gt;
'''Ὄφις, -εως (nom propre) (m)''' : Serpent.&lt;br&gt;

==Π==
'''παγά, -ᾶς (nom commun) (f)''' : Forme dorienne de ''πηγή''.&lt;br&gt;
'''παγίδευσις, -ύσεως (nom commun) (f)''' : .&lt;br&gt;
'''παγιδεύω  (verbe)''' : piéger.&lt;br&gt;
'''παγίς, -δος (nom commun) (f)''' : piège.&lt;br&gt;
'''παγκόσμιος, -α, -ον (adjectif)''' : universel.&lt;br&gt;
'''πάγκοσμος, -όσμου (nom commun) (m)''' : univers.&lt;br&gt;
'''πάγος, -ου  (nom commun) (m)''' : glace (eau à l'état solide).&lt;br&gt; 
'''πάγουρος, -ύρου (nom commun) (m)''' : crabe.&lt;br&gt;
'''πάγχυ (adverbe)''' : totalement.&lt;br&gt;
'''παθοποιός, -ός, -όν (adjectif)''' : Qui afflige le corps ou l’âme.&lt;br&gt;
'''πάθος, -ους (nom commun) (n)''' : Ce que l’on éprouve. Évènement, conjoncture. État de l’âme agitée par diverses circonstances.&lt;br&gt;
'''παιάν, -ᾶνος (nom commun) (m)''' : péan.&lt;br&gt;
'''παίγνιον, -ίου (nom commun) (n)''' : jeu.&lt;br&gt;
'''παιδαγωγός, -οῦ (nom commun) (m)''' : éducateur.&lt;br&gt;
'''παιδάριον, -ίου (nom commun) (n)''' : gamin.&lt;br&gt; 
'''παιδεραστής, -οῦ (nom commun) (m)''' : amant de garçon.&lt;br&gt;
'''παιδιά, -ᾶς (nom commun) (f)''' : jeu.&lt;br&gt;
'''παιδίον, -ου (nom commun) (n)''' :  petit enfant.&lt;br&gt;
'''παιδοτρίϐης, -ου (nom commun) (m)''' : maître de gymnastique.&lt;br&gt;
'''παίδων παῖδες (nom commun) (m/f)''' : Petits-fils/Petites-filles.&lt;br&gt;
'''παίζω (verbe)''' : jouer.&lt;br&gt;
'''παίκτης, -ου (nom commun) (m)''' : joueur.&lt;br&gt;
'''παῖς, -δός (nom commun) (m/f)''' : enfant ; jeune serviteur.&lt;br&gt;
'''παιωνία, -ας (nom commun) (f)''' : pivoine.&lt;br&gt;  
'''παιών, -ος (nom commun) (m)''' : physicien.&lt;br&gt;
'''παλαιός, -ά, -όν (adjectif)''' : ancien.&lt;br&gt;
'''παλιγγενεσία, -ας (nom commun) (f)''' : Renaissance, résurrection. Régénération.&lt;br&gt;
'''παλιγγενεσιακός, -ά, -όν (adjectif)''' : palingénésiaque.&lt;br&gt;
'''πάλιν (adverbe)''' : encore.&lt;br&gt; 
'''παλλακή, -ῆς (nom commun) (f)''' : concubine.&lt;br&gt; 
'''παλλακίς, -δος (nom commun) (f)''' : concubine.&lt;br&gt; 
'''πάλλαξ, -κος (nom commun) (m/f)''' : jeune enfant.&lt;br&gt;
'''πάλληξ, -κος (nom commun) (m/f)''' : Forme ionienne de ''πάλλαξ''.&lt;br&gt;
'''πάλλω (verbe)''' : vibrer.&lt;br&gt;
'''παλμός, -οῦ (nom commun) (m)''' : vibration.&lt;br&gt;
'''παλός, -οῦ (nom commun) (m/f)''' : forme dorienne de ''πηλός''.&lt;br&gt;
'''παμμεγεθέστατος, -άτη, -έστατον (adjectif)''' : Superlatif de ''παμμεγέθης''.&lt;br&gt;
'''παμμεγεθέστερος, -έρα, -έστερον (adjectif)''' : Comparatif de ''παμμεγέθης''.&lt;br&gt;  
'''παμμεγέθης, -ης, -ες (adjectif)''' : immense.&lt;br&gt;
'''παμμεγέθως (adverbe)''' : immensément.&lt;br&gt;
'''πάμπαν (adverbe)''' : totalement.&lt;br&gt;
'''πάμφλεκτος, -ος, -ον (adjectif)''' : .&lt;br&gt;
'''πανάκεια, -ας (nom commun) (f)''' : remède universel.&lt;br&gt;
'''πάναξ, -κος (nom commun) (m)''' : plante médicinale.&lt;br&gt;
'''πανδοκεῖον, -ίου (nom commun) (n)''' : auberge.&lt;br&gt;
'''πανδοκεύς, -έως (nom commun) (m)''' : aubergiste.&lt;br&gt;
'''παράδοσις, -όσεως (nom commun) (f)''' : transmission ; tradition.&lt;br&gt;
'''πανήγυρις, -ύρεως (nom commun) (f)''' : réunion.&lt;br&gt;
'''πάνθηρ, -ος (nom commun) (m)''' : panthère.&lt;br&gt;
'''πανέλοψ, -πος (nom commun) (m)''' : Forme éolienne et dorienne de ''πηνέλοψ''.&lt;br&gt;
'''πανοῦργος, -ύργα, -ῦργον (adjectif)''' : .&lt;br&gt;
'''παντοπωλεῖον, -ίου (nom commun) (n)''' : épicerie.&lt;br&gt;
'''παντοπώλης, -ου (nom commun) (m)''' : épicier.&lt;br&gt;
'''πάνυ (adverbe)''' : totalement.&lt;br&gt;
'''πάππας, -ου (nom commun) (m)''' : papa.&lt;br&gt;
'''πάππος, -ου (nom commun) (m)''' : papi.&lt;br&gt;
'''πάπυρος, -ύρου (nom commun) (m)''' : papyrus.&lt;br&gt;
'''παρά (adverbe ; préposition)''' : (avec le génitif) D’auprès de, du côté de. (avec le datif) Auprès avec l’idée de toute absence de mouvement. Chez, dans, en. (Avec l’accusatif) Auprès de, vers avec l’idée de mouvement.&lt;br&gt;
'''παρά- (préfixe)''' : Auprès. Vers. Le long de. Contre. En détournant.&lt;br&gt;
'''παραϐάλλω (verbe)''' : s’emparer de.&lt;br&gt;
'''παράδειγμα, -ίγματος (nom commun) (n)''' : modèle.&lt;br&gt; 
'''παραδειγματικός, -ή, -όν (adjectif)''' : modèle.&lt;br&gt;
'''παράδεισος, -ίσου (nom commun) (m)''' : parc ; paradis.&lt;br&gt;
'''παραδέχομαι (verbe)''' : admettre.&lt;br&gt;
'''παραδίδωμι (verbe)''' : transmettre ; remettre.&lt;br&gt;
'''παράθυρος, -ου (nom commun) (f)''' : Porte de côté ; porte dérobée.&lt;br&gt; 
'''παρακινῶ (verbe)''' : .&lt;br&gt;
'''παρακλαυσίθυρον, -ύρου (nom commun) (n)''' : paraclausithuron.&lt;br&gt;
'''παραλείπω (verbe)''' : omettre.&lt;br&gt;
'''παράλειψις, -ίψεως (nom commun) (f)''' : omission.&lt;br&gt;
'''πάρδαλις, -άλεως (nom commun) (f)''' : léopard.&lt;br&gt;
'''παράλληλος, -η, -ον (adjectif)''' : Porte de côté ; porte dérobée.&lt;br&gt; 
'''παραλήρησις, -ήσεως (nom commun) (f)''' : délire.&lt;br&gt;
'''παράμεσος, -ου (nom commun) (m)''' : annulaire.&lt;br&gt;
'''παραμυθέομαι (verbe)''' : exhorter.&lt;br&gt;
'''παραμύθιον, -ίου (nom commun) (m)''' : exhortation.&lt;br&gt;
'''παραποίησις, -ήσεως (nom commun) (f)''' : contrefaçon.&lt;br&gt;
'''παραποιῶ (verbe)''' : contrefaire.&lt;br&gt;
'''παράρτημα, -ήματος (nom commun) (n)''' : annexe.&lt;br&gt;
'''παρασάγγης, -ου (nom commun) (m)''' : parasange. (env. 6 km)&lt;br&gt;
'''παράσιτος, -ος, -ον (adjectif)''' : Qui sert de mets en surplus ; Parasite.&lt;br&gt;
'''παραίσθησις, -ήσεως (nom commun) (f)''' : illusion.&lt;br&gt;
'''παράστασις, -άσεως (nom commun) (f)''' : représentation.&lt;br&gt;
'''παραστράτημα, -ήματος (nom commun) (n)''' :  incartade.&lt;br&gt;
'''παρειά, -ᾶς (nom commun) (f)''' : joue.&lt;br&gt;
'''παρελθών, -όντος (nom commun) (m)''' : passé.&lt;br&gt;
'''παρεξήγησις, -ήσεως (nom commun) (f)''' : malentendu.&lt;br&gt;
'''παρεξηγῶ (verbe)''' : méprendre.&lt;br&gt;
'''παρεργάτης, -ου (nom commun) (m)''' : assistant.&lt;br&gt;
'''παρεύνασθαι (verbe)''' : représenter.&lt;br&gt;
'''πάρευνος, -ος, -ον (adjectif)''' : .&lt;br&gt;
'''παρθενεία, -ας (nom commun) (f)''' : virginité .&lt;br&gt;
'''παρθένειος, -α, -ον (adjectif)''' :  virginal.&lt;br&gt;
'''παρθενικός, -ή, -όν (adjectif)''' : de vierge.&lt;br&gt;
'''παρθενικῶς (adverbe)''' : virginalement.&lt;br&gt;
'''παρθενικώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''παρθενικός''.&lt;br&gt;
'''παρθενικώτερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''παρθενικός''.&lt;br&gt;
'''παρθενικώτατα, -, - (adverbe)''' : Superlatif de ''παρθενικῶς''.&lt;br&gt;
'''παρθενικώτερον, -, - (adverbe)''' : Comparatif de ''παρθενικῶς''.&lt;br&gt; 
'''παρθένος, -ος, -ον (adjectif)''' : vierge.&lt;br&gt;
'''παρθενεύω (verbe)''' : devenir jeune fille.&lt;br&gt;
'''παρθενών, -ῶνος (nom commun) (m)''' : parthénon.&lt;br&gt;
'''παρθικός, -ή, -όν (adjectif)''' : parthe.&lt;br&gt;
'''παρθιστί (adverbe)''' : en parthe.&lt;br&gt;
'''παρίσθμιον, -ίου (nom commun) (n)''' : (anatomie) amygdale.&lt;br&gt;
'''παρόρμησις, -ήσεως (nom commun) (f)''' : impulsion.&lt;br&gt;
'''παρορμητικός, -ή, -όν (adjectif)''' : impulsif.&lt;br&gt;
'''παρορμητικῶς (adverbe)''' : impulsivement.&lt;br&gt;
'''παρορμητικώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''παρορμητικός''.&lt;br&gt;
'''παρορμητικώτερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''παρορμητικός''.&lt;br&gt;
'''παρορμῶ (verbe)''' : impulser.&lt;br&gt;
'''παρσένος, -ος, -ον (adjectif)''' : Forme laconienne de ''παρθένος''.&lt;br&gt;
'''παρών, -όντος (nom commun) (m)''' : présent.&lt;br&gt;
'''παρωνυχία, -ας (nom commun) (f)''' : panaris.&lt;br&gt;
'''πᾶς, -σα, -ᾶν (adjectif)''' : (Au singulier) Chaque, chacun. Tout entier, tout. (Au pluriel) Tous.&lt;br&gt;
'''πάσσω (verbe)''' : .&lt;br&gt;
'''παστά, -ᾶς (nom commun) (f)''' : pâte.&lt;br&gt;
'''παστός, -ή, -όν (adjectif)''' : .&lt;br&gt;
'''πάσχω (verbe)''' : Être affecté de telle ou telle façon, telle ou telle affection, sensation ou sentiment.&lt;br&gt;
'''πατήρ, -ρός (nom commun) (m)''' : père.&lt;br&gt;
'''πάτος, -ου (nom commun) (m)''' : sentier.&lt;br&gt;
'''πατριά, -ᾶς (nom commun) (f)''' : tribu, famille.&lt;br&gt;
'''πατριάρχης, -ου (nom commun) (m)''' : patriarche.&lt;br&gt;
'''πατρίς, -δος (nom commun) (f)''' : patrie.&lt;br&gt;
'''πατροφονεύς, -έως (nom commun) (m)''' : patricide.&lt;br&gt;
'''πατροφόνος, -ου (nom commun) (m)''' : patricide.&lt;br&gt; 
'''πατῶ (verbe)''' : Manger, absorber. Fouler aux pieds. Fouler le sol.&lt;br&gt;
'''παῦρος -ύρα, -ῦρον (adjectif)''' : En petit nombre. (Par extension) Petit, court.&lt;br&gt;
'''παῦσις, -ύσεως (nom commun) (f)''' : cessation.&lt;br&gt;
'''παύω (verbe)''' : cesser.&lt;br&gt;
'''πάφλασμα, -άσματος (nom commun) (n)''' : .&lt;br&gt; 
'''πάχνη, -ης (nom commun) (f)''' : givre.&lt;br&gt;
'''παχύς, -εῖα, -ύ (adjectif)''' : Épais, gras.&lt;br&gt; 
'''πεδά (préposition)''' : Forme arcado-chypriote, dorienne et éolienne de ''μετά''.&lt;br&gt;
'''πεδιάς, -δος (nom commun) (f)''' : plaine.&lt;br&gt;
'''πεδίον, -ου (nom commun) (n)''' : champ.&lt;br&gt; 
'''πέζα, -ης (nom commun) (f)''' : cheville du pied.&lt;br&gt;
'''πεζός, -ή, -όν (adjectif)''' : piéton.&lt;br&gt; 
'''πεζῶς (adverbe)''' : .&lt;br&gt;
'''πεζώτατα, -, - (adverbe)''' : Superlatif de ''πεζῶς''.&lt;br&gt;
'''πεζώτερον, -, - (adverbe)''' : Comparatif de ''πεζῶς''.&lt;br&gt;
'''πεζώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''πεζός''.&lt;br&gt;
'''πεζώτερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''πεζός''.&lt;br&gt;
'''πείθομαι (verbe)''' : persuader ; suivre.&lt;br&gt;
'''πείθω (verbe)''' : convaincre ; persuader.&lt;br&gt;
'''πεῖνα, -ίνας (nom commun) (f)''' : faim.&lt;br&gt;
'''πεινῶ (verbe)''' : avoir faim.&lt;br&gt;
'''πεῖρα, -ίρας (nom commun) (f)''' : Essai, tentative ; épreuve.&lt;br&gt;
'''πειράζω (verbe)''' : Essayer ; tenter.&lt;br&gt;
'''πειράομαι (verbe)''' : essayer.&lt;br&gt;
'''πειρασμός, -οῦ (nom commun) (m)''' : Épreuve, essai ; expérience. Tentation.&lt;br&gt;
'''πειρατής, -οῦ (nom commun) (m)''' : pirate.&lt;br&gt;
'''πειρῶ (verbe)''' : .&lt;br&gt;
'''πελεκάν, -ᾶνος (nom commun) (m)''' : pélican.&lt;br&gt;
'''πελεκῖνος, -ίνου (nom commun) (m)''' : pélican.&lt;br&gt;
'''πέλεκυς, -έκεως (nom commun) (m)''' : hache.&lt;br&gt;
'''πέλμα, -τος (nom commun) (n)''' : Plante du pied ; tige des pommes et des poires.&lt;br&gt;
'''πελώριος, -α, -ον (adjectif)''' : prodigieux.&lt;br&gt;
'''πελωρίς, -δος (nom commun) (f)''' : moule.&lt;br&gt;
'''πέλωρ, -ος (nom commun) (n)''' : prodige.&lt;br&gt;
'''πέμμα, -τος (nom commun) (n)''' : gâteau.&lt;br&gt;
'''πεμπτουσία, -ας (nom commun) (f)''' :  quintessence.&lt;br&gt;
'''πεντάφυλλον, -ύλλου (nom commun) (n)''' : potentille.&lt;br&gt;
'''πέντε (adjectif numéral)''' : cinq.&lt;br&gt;
'''πεντήκοντα (adjectif numéral)''' : cinquante.&lt;br&gt;
'''πενθερά, -ᾶς (nom commun) (f)''' : belle-mère.&lt;br&gt;
'''πενθερός, -οῦ (nom commun) (m)''' : beau-père.&lt;br&gt;
'''πένθος, -ους  (nom commun) (n)''' : deuil.&lt;br&gt;
'''πέος, -ους (nom commun) (n)''' : pénis.&lt;br&gt;
'''πέπερι, -τος (nom commun) (n)''' : poivre.&lt;br&gt;
'''πέπλος, -ου (nom commun) (m)''' : péplos.&lt;br&gt;
'''πέπλωμα, -ώματος (nom commun) (n)''' : robe.&lt;br&gt;	
'''πεπτός, -ή, -όν (adjectif)''' : cuit.&lt;br&gt;
'''πέπων, -ονος (nom commun) (m)''' : melon.&lt;br&gt;
'''περαίνω (verbe)''' : Finir, conclure.&lt;br&gt;
'''πέρασμα, -άσματος (nom commun) (n)''' : passage.&lt;br&gt;	
'''πέρας, -τος (nom commun) (n)''' : Fin, limite.&lt;br&gt;	
'''πέρδιξ, -ικος (nom commun) (m/f)''' : perdrix.&lt;br&gt;
'''πέρδομαι (verbe)''' : péter (faire un pet).&lt;br&gt;
'''περιϐόλιον, -ίου (nom commun) (n)''' : .&lt;br&gt;
'''περιδέραιον, -ου (nom commun) (n)''' : collier (bijou).&lt;br&gt;
'''περιδέραιος, -ος, -ου (adjectif)''' : .&lt;br&gt; 
'''περίζωμα, -ώματος (nom commun) (n)''' : caleçon.&lt;br&gt;	
'''περιήγησις, -ήσεως (nom commun) (f)''' : Voyage ; parcours.&lt;br&gt;
'''περιηγοῦμαι (verbe)''' : Voyager ; parcourir.&lt;br&gt;
'''περιηγητής, -οῦ (nom commun) (m)''' : voyageur.&lt;br&gt;
'''περιλαμϐάνω (verbe)''' : .&lt;br&gt;
'''περίληψις, -ήψεως (nom commun) (f)''' : résumé.&lt;br&gt;
'''περίναιον, -ίου (nom commun) (n)''' : périnée.&lt;br&gt;
'''περιπατητικός, -ή, -όν (adjectif)''' : péripatéticien.&lt;br&gt;
'''περιπατῶ (verbe)''' : Circuler, aller et venir ; se promener (Par extension) (Figuré) Se comporter, se conduire, vivre de telle ou de telle manière.&lt;br&gt;
'''περιπέτεια, -ας (nom commun) (f)''' : aventure.&lt;br&gt;
'''περιπίπτω (verbe)''' : tomber autour, sur.&lt;br&gt;
'''περιποιοῦμαι (verbe)''' : s'occuper de.&lt;br&gt;
'''περιποιῶ (verbe)''' : .&lt;br&gt;
'''περιστερά, -ᾶς (nom commun) (f)''' : pigeon, colombe.&lt;br&gt;
'''περιστερός, -οῦ (nom commun) (m)''' : pigeon, colombe. (Pour un mâle de ces espèces.)&lt;br&gt;
'''περιστερεών, -ῶνος (nom commun) (m)''' : pigeonnier, colombier.&lt;br&gt;
'''περιφρονῶ (verbe)''' : mépriser.&lt;br&gt;
'''περιφρούρησις, -ήσεως (nom commun) (f)''' : protection.&lt;br&gt;
'''περιφρουρῶ (verbe)''' : protéger.&lt;br&gt;
'''περκνός, -ή, -όν (adjectif)''' : noirâtre.&lt;br&gt;
'''περκνότατος, -άτη, -ότατον (adjectif)''' : Superlatif de ''περκνός''.&lt;br&gt;
'''περκνότερος, -έρα, -ότερον (adjectif)''' : Comparatif de ''περκνός''.&lt;br&gt;
'''περκνότατα, -, - (adverbe)''' : Superlatif de ''περκνῶς''.
'''περκνότερον, -, - (adverbe)''' : Comparatif de ''περκνῶς''.
'''περκνῶς (adverbe)''' : noirâtrement.&lt;br&gt;
'''πέρνημι (verbe)''' : Exploiter, vendre. (Au passif) Être vendu.&lt;br&gt;
'''περόνη, -ης (nom commun) (f)''' : agrafe, clavette.&lt;br&gt;
'''περῶ (verbe)''' : passer.&lt;br&gt;
'''πέσσω (verbe)''' : Digérer ; cuire. Mûrir.&lt;br&gt;
'''πετάννυμι (verbe)''' : .&lt;br&gt;
'''πέτασος, -άσου (nom commun) (m)''' : pétase.&lt;br&gt;
'''πετεεινός, -ή, -όν (adjectif)''' : Forme homérique de ''πετεινός''.&lt;br&gt;
'''πετεινός, -ή, -όν (adjectif)''' : capable de voler.&lt;br&gt;
'''πετεσοũχος, -ύχου (nom commun) (m)''' : petsuchos.&lt;br&gt;
'''πετηνός, -ή, -όν (adjectif)''' : Forme ionienne de ''πετεινός''.&lt;br&gt;
'''πετῶ (verbe)''' : voler (planer dans le ciel).&lt;br&gt;
'''πεύκη, -ης (nom commun) (f)''' : pin.&lt;br&gt;
'''πεύθομαι (verbe)''' : Forme poétique de ''πυνθάνομαι''.&lt;br&gt;
'''πέψις, -εως (nom commun) (f)''' : digestion.&lt;br&gt;
'''πηγή, -ῆς (nom commun) (f)''' : source.&lt;br&gt;
'''πήγνυμι (verbe)''' : .&lt;br&gt;
'''πηδάλιον, -ίου (nom commun) (n)''' : talaria.&lt;br&gt; 
'''πήδημα, -ήματος (nom commun) (n)''' : saut.&lt;br&gt;
'''πηδόν, -οῦ (nom commun) (n)''' : .&lt;br&gt; 
'''πηδός, -οῦ (nom commun) (f)''' : .&lt;br&gt;
'''πηδῶ (verbe)''' : sauter.&lt;br&gt; 
'''πῇ (adverbe interrogatif)''' : par où.&lt;br&gt;
'''πήληξ, -κος (nom commun) (m)''' : .&lt;br&gt;
'''πηλός, -οῦ (nom commun) (m/f)''' : boue.&lt;br&gt;
'''πήμων, -ων, -ον (adjectif)''' : nuisible.&lt;br&gt;
'''πηνέλοψ, -πος (nom commun) (m)''' : canard sauvage.&lt;br&gt;
'''πήνη, -ης (nom commun) (f)''' : bobine.&lt;br&gt; 
'''πηνήκη, -ης (nom commun) (f)''' : perruque.&lt;br&gt; 
'''πηνηκίζω (verbe)''' : .&lt;br&gt; 
'''πηνήκισμα, -ίσματος (nom commun) (n)''' : .&lt;br&gt;
'''πῆνος, -ήνου (nom commun) (m)''' : .&lt;br&gt; 
'''πῆξις, -ήξεως (nom commun) (f)''' : .&lt;br&gt;
'''πήρα, -ας (nom commun) (f)''' : besace.&lt;br&gt;
'''πήριξ, -ικος (nom commun) (m/f)''' : Forme crétoise de ''πέρδιξ''.&lt;br&gt;
'''πῆχυς, -ήχεως (nom commun) (m)''' :  avant-bras.&lt;br&gt;
'''πιέζω (verbe)''' : Presser ; appuyer.&lt;br&gt;
'''πίεσις, -έσεως (nom commun) (f)''' : pression.&lt;br&gt;
'''πῖ (nom commun) (n)''' : pi.&lt;br&gt;
'''πίθακος, -άκου (nom commun) (m)''' : Forme dorienne de ''πίθηκος''.&lt;br&gt;
'''πιθανός, -ή, -όν (adjectif)''' : probable.&lt;br&gt;
'''πιθανῶς (adverbe)''' : probablement.&lt;br&gt;
'''πιθανώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''πιθανός''.&lt;br&gt;
'''πιθανώτερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''πιθανός''.&lt;br&gt;
'''πιθηκοειδής, -ής, -ές (adjectif)''' : .&lt;br&gt;
'''πίθηκος, -ήκου (nom commun) (m)''' : singe.&lt;br&gt;
'''πίθων, -ονος (nom commun) (m)''' : Singe, petit singe.&lt;br&gt;
'''πῖλος, -ίλου (nom commun) (m)''' : pileus.&lt;br&gt;
'''πίμπλημι (verbe)''' : remplir.&lt;br&gt;
'''πίναξ, -κος (nom commun) (m)''' : tableau.&lt;br&gt;
'''πίπτω (verbe)''' : tomber.&lt;br&gt; 
'''πίσσα, -εως (nom commun) (f)''' : poix.&lt;br&gt; 
'''πιστάκη, -ης (nom commun) (f)''' : pistachier.&lt;br&gt; 
'''πιστάκιον, -ίου (nom commun) (n)''' : pistache.&lt;br&gt; 
'''πίστις, -εως (nom commun) (f)''' : Foi. Confiance en autrui. Ce qui fait foi. Résultat de la confiance. Moyen d’inspirer confiance, de persuader ; preuve.&lt;br&gt;
'''πιστότατος, -άτη, -ότατον (adjectif)''' : Superlatif de ''πιστός''.&lt;br&gt;
'''πιστότερος, -έρα, -ότερον (adjectif)''' : Comparatif de ''πιστός''.&lt;br&gt;
'''πιστός, -ή, -όν (adjectif)''' : fidèle ; loyal.&lt;br&gt;
'''πιστότατα, -, - (adverbe)''' : Superlatif de ''πιστῶς''.&lt;br&gt;
'''πιστότερον, -, - (adverbe)''' : Comparatif de ''πιστῶς''.&lt;br&gt;
'''πιστῶς (adverbe)''' : fidèlement ; loyalement.&lt;br&gt;
'''πίστωσις, -ώσεως (nom commun) (f)''' : crédit.&lt;br&gt; 
'''πισύγγιον, ίου (nom commun) (n)''' : Diminutif de ''πίσυγγος''.&lt;br&gt;
'''πίσυγγος, -ύγγου (nom commun) (m)''' : cordonnier.&lt;br&gt;
'''πίττα, -ας (nom commun) (f)''' : Forme attique de ''πίσσα''.&lt;br&gt; 
'''πίτα, -ας (nom commun) (f)''' : pita.&lt;br&gt;
'''πλαγκτός, -ή, -όν (adjectif)''' : errant.&lt;br&gt;
'''πλαδαρός, -ά, -όν (adjectif)''' : Forme dorienne de ''βλαδαρός''.&lt;br&gt;
'''πλάζω (verbe)''' : errer.&lt;br&gt;
'''πλᾶθος, -άθους (nom commun) (n)''' : Forme dorienne de ''πλῆθος''.&lt;br&gt;
'''πλακοῦς, -ύντος (nom commun) (m)''' : Gâteau ; galette.&lt;br&gt;
'''πλανάτας, -ου (nom commun) (m)''' : Forme dorienne de ''πλανήτης''.&lt;br&gt;
'''πλάνης, -τος (nom commun) (m)''' : vagabond.&lt;br&gt;
'''πλανήτης, -ου (nom commun) (m)''' : planète.&lt;br&gt;
'''πλάν (préposition)''' : Forme dorienne de ''πλήν''.&lt;br&gt;
'''πλανῶ (verbe)''' : vagabonder.&lt;br&gt;
'''πλάξ, -κός (nom commun) (f)''' : plaque.&lt;br&gt;
'''πλάσμα, -τος (nom commun) (n)''' : Ouvrage façonné, modelé ; figure. Modulation de la voix. Contrefaçon, imitation. Travail de composition.&lt;br&gt;
'''πλάσσω (verbe)''' : former, mouler.&lt;br&gt;
'''πλατέως (adverbe)''' : largement.&lt;br&gt;
'''πλατύτατος, -άτη, -ύτατον (adjectif)''' : Superlatif de ''πλατύς''.&lt;br&gt;
'''πλατύτερος, -έρα, -ύτερον (adjectif)''' : Comparatif de ''πλατύς''.&lt;br&gt;
'''πλατύς, -εῖα, -ύ (adjectif)''' : large.&lt;br&gt;
'''πλάττω (verbe)''' : Forme attique de ''πλάσσω''.&lt;br&gt;
'''πλέθρον, -ου (nom commun) (n)''' : plèthre. (env. 30 m)&lt;br&gt;
'''πλεῖστος, -ίστη, -ῖστον (adjectif)''' : Superlatif de ''πολύς''.&lt;br&gt;
'''πλείων, -ων, -ῖον (adjectif)''' : Comparatif de ''πολύς''.&lt;br&gt;
'''πλεῖθος, -ίθους (nom commun) (n)''' : Forme béotienne de ''πλῆθος''.&lt;br&gt;
'''πλῆθος, -ήθους (nom commun) (n)''' : .&lt;br&gt;
'''πληθύς, -ος (nom commun) (n)''' : Forme ionienne de ''πλῆθος''.&lt;br&gt;
'''πληθώρα, -ας (nom commun) (f)''' : plénitude.&lt;br&gt;
'''πλήθω (verbe)''' : remplir.&lt;br&gt;
'''πληκτικός, -ή, -όν (adjectif)''' : ennuyeux.&lt;br&gt;
'''πληκτικότης, -ητος (nom commun) (f)''' : ennui.&lt;br&gt;
'''πλῆκτρον, -ήκτρου (nom commun) (n)''' : plectre.&lt;br&gt;
'''πλῆξις, -ήξεως (nom commun) (f)''' : ennui.&lt;br&gt;
'''πλήν (préposition)''' : plus que.&lt;br&gt;
'''πληρέστατος, -άτη, -έστατον (adjectif)''' : Superlatif de ''πλήρης''.&lt;br&gt;
'''πληρέστερος, -έρα, -έστερον (adjectif)''' : Comparatif de ''πλήρης''.&lt;br&gt; 
'''πλήρης, -ης, -ῆρες (adjectif)''' : complet ; plein.&lt;br&gt;
'''πλήρως (adverbe)''' : complètement ; pleinement.&lt;br&gt;
'''πληρῶ (verbe)''' : compléter ; emplir.&lt;br&gt;
'''πλήσσω (verbe)''' : Frapper, battre. (Au passif) Être battu, subir une défaite.&lt;br&gt;
'''πλήττω (verbe)''' : Forme attique de ''πλήσσω''.&lt;br&gt;
'''πλοῖον, -ίου (nom commun) (n)''' : navire, bateau ; vaisseau.&lt;br&gt;
'''πλούσιος, -α, -ον (adjectif)''' : riche, opulent.&lt;br&gt;
'''πλουσιότατος, -άτη, -ότατον (adjectif)''' : Superlatif de ''πλούσιος''.&lt;br&gt;
'''πλουσιότερος, -έρα, -ότερον (adjectif)''' : Comparatif de ''πλούσιος''.&lt;br&gt;
'''πλουσίως (adverbe)''' : richement.&lt;br&gt;
'''πλουτηρός, -ά, -όν (adjectif)''' : dispensateur de richesse.&lt;br&gt;
'''πλουτίζω (verbe)''' : (voix active) enrichir ; (voix passive) s’enrichir, être enrichi.&lt;br&gt;
'''πλουτίνδην (adverbe)''' : en choisissant parmi les plus riches.&lt;br&gt;
'''πλουτοτήριος, -α, -ον (adjectif)''' : Capable d’enrichir.&lt;br&gt;
'''πλουτοκρατία, -ας (nom commun) (f)''' : ploutocratie.&lt;br&gt;
'''πλοῦτος, -ύτου (nom commun) (m)''' : richesse, opulence.&lt;br&gt;
'''πλουτῶ (verbe)''' : être riche.&lt;br&gt;
'''πλύνω (verbe)''' : laver des vêtements.&lt;br&gt;
'''πνεῦμα, -ύματος (nom commun) (n)''' : Souffle. Exhalaison ; odeur. Esprit.&lt;br&gt;
'''πνευματικός, -ή, -όν (adjectif)''' : spirituel.&lt;br&gt;
'''πνευματικότατος, -άτη, -ότατον (adjectif)''' : Superlatif de ''πνευματικός''.&lt;br&gt;
'''πνευματικότερος, -έρα, -ότερον (adjectif)''' : Comparatif de ''πνευματικός''.&lt;br&gt;
'''πνευματικότατα, -, - (adverbe)''' : Superlatif de ''πνευματικῶς''.&lt;br&gt;
'''πνευματικότερον, -, - (adverbe)''' : Comparatif de ''πνευματικῶς''.&lt;br&gt;
'''πνευματικῶς (adverbe)''' : spirituellement.&lt;br&gt;
'''πνεύμων, -ονος (nom commun) (m)''' : poumon.&lt;br&gt;
'''πνέω (verbe)''' : souffler.&lt;br&gt;
'''πνιγηρός, -ά, -όν (adjectif)''' : étouffant, où l’on étouffe (Par extension) Étroit, resserré.&lt;br&gt;
'''πνίγω (verbe)''' : étrangler, étouffer ; suffoquer.&lt;br&gt;
'''πνίξ, -γός (nom commun) (f)''' : crampe.&lt;br&gt;
'''ποδάριον -ίου (nom commun) (n)''' : Diminutif de ''πούς''.&lt;br&gt;
'''πόδιον, -ίου (nom commun) (n)''' : podium.&lt;br&gt; 
'''πόθεν (adverbe interrogatif)''' : d’où.&lt;br&gt;
'''πόθος, -ου (nom commun) (m)''' : Désir ; regret.&lt;br&gt;
'''ποῖ (adverbe interrogatif)''' : où (avec mouvement).&lt;br&gt;
'''ποίησις, -ήσεως (nom commun) (f)''' : création.&lt;br&gt;
'''ποιμήν, -ένος (nom commun) (m)''' : berger.&lt;br&gt;
'''ποινή, -ῆς (nom commun) (f)''' : Expiation d’un crime. Argent par lequel on paye les parents de la victime, le prix du sang. Rançon, expiation, châtiment, vengeance. Délivrance. Compensation, récompense.&lt;br&gt;
'''ποῖος, -ία, -ῖον (adjectif interrogatif)''' : quel.&lt;br&gt;
'''ποιότης, -τος (nom commun) (f)''' : qualité.&lt;br&gt;
'''ποιῶ (verbe)''' : faire.&lt;br&gt;
'''πολεμικός, -ή, -όν (adjectif)''' : guerrier.&lt;br&gt;
'''πολεμικῶς (adverbe)''' : belliqueusement.&lt;br&gt;
'''πολεμικώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''πολεμικός''.&lt;br&gt;
'''πολεμικώτερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''πολεμικός''.&lt;br&gt;
'''πολεμιστής, -οῦ (nom commun) (m)''' : guerrier.&lt;br&gt;
'''πολεμίστρα, -ας (nom commun) (f)''' : guerrière.&lt;br&gt;
'''πόλεμος, -έμου (nom commun) (m)''' : guerre.&lt;br&gt;
'''πολεμῶ (verbe)''' : guerroyer.&lt;br&gt;
'''πολιός, -ός, -όν (adjectif)''' : gris.&lt;br&gt;
'''πόλις, -εως (nom commun) (f)''' : ville.&lt;br&gt;
'''πολιτεία, -ας (nom commun) (f)''' : citoyenneté.&lt;br&gt;
'''πολίτευμα, -τος (nom commun) (n)''' : gouvernement.&lt;br&gt;
'''πολιτεύω (verbe)''' : Être citoyen. Participer au gouvernement, faire de la politique. (Au passif) Être gouverné, en parlant de l’État.&lt;br&gt;
'''πολίτης, -ου (nom commun) (m)''' : citoyen.&lt;br&gt;
'''πολιτικός, -ή, -όν (adjectif)''' : civique.&lt;br&gt;
'''πολῖτις, -ίτιδος (nom commun) (f)''' : citoyenne.&lt;br&gt; 
'''πολλάκις (adverbe)''' : souvent.&lt;br&gt;
'''πολλῶς (adverbe)''' : .&lt;br&gt;
'''πολυμάθεια, -ας (nom commun) (f)''' : érudition.&lt;br&gt;
'''πολυμαθής, -ής, -ές (adjectif)''' : érudit.&lt;br&gt;	
'''πολυμήτις, -, - (adjectif)''' : .&lt;br&gt;
'''πολυμήχανος, -η, -ον (adjectif)''' : ingénieux.&lt;br&gt;
'''πολύτροπος, -ος, -ον (adjectif)''' : astucieux.&lt;br&gt; 
'''πολύς, -λλή, -ύ (adjectif)''' : nombreux.&lt;br&gt; 
'''πολύχρωμος, -η, -ον (adjectif)''' : multicolore.&lt;br&gt;
'''πομφολυγοπάφλασμα, -άσματος (nom commun) (n)''' : .&lt;br&gt;
'''πομφόλυξ, -γος (nom commun) (m)''' : bulle ; ornement en forme de bulle, de rond. (Chimie) Oxyde de zinc.&lt;br&gt; 
'''πομφός, -οῦ (nom commun) (m)''' : verrue.&lt;br&gt; 
'''πονηρία, -ας (nom commun) (f)''' : ruse.&lt;br&gt; 
'''πονηρός, -ά, -όν (adjectif)''' : mauvais, méchant ; pervers.&lt;br&gt;
'''πονηρότατος, -άτη, -ότατον (adjectif)''' : Superlatif de ''πονηρός''.&lt;br&gt;
'''πονηρότερος, -έρα, -ότερον (adjectif)''' : Comparatif de ''πονηρός''.&lt;br&gt;
'''πονηρῶς (adjectif)''' : mauvaisement, méchamment ; perversement.&lt;br&gt;
'''πόποι (interjection)''' : hélas.&lt;br&gt;
'''πορδή, -ῆς (nom commun) (f)''' : pet. (gaz intestinal)&lt;br&gt;
'''πορθμεῖον, -ίου (nom commun) (n)''' .&lt;br&gt;
'''πορθμεύς, -έως (nom commun) (m)''' nocher.&lt;br&gt; 
'''πορθμεύω (verbe)''' .&lt;br&gt;
'''πορθμός, -οῦ (nom commun) (m)''' : détroit.&lt;br&gt; 
'''πορνεία, -ας (nom commun)''' : Fornication, prostitution.&lt;br&gt; 
'''πορνεῖον, -ίου (nom commun) (n)''' lupanar.&lt;br&gt; 
'''πόρνευμα, -ύµατος (nom commun (n)''' : .&lt;br&gt; 
'''πόρνευσις, -ύσεως (nom commun) (f)''' : .&lt;br&gt;
'''πορνεύτρια, -ας (nom commun) (f)''' : .&lt;br&gt; 
'''πορνεύω (verbe)''' : prostituer.&lt;br&gt; 
'''πόρνη, -ης (nom commun) (f)''' : Prostituée, putain.&lt;br&gt;  
'''πορνικός, -ή, -όν (adjectif)''' : de lupanar.&lt;br&gt; 
'''πορνοϐοσκεῖον, -ίου  (nom commun) (n)''' : lupanar.&lt;br&gt; 
'''πορνοϐοσκία, -ας (nom commun) (f)''' : prostitution.&lt;br&gt; 
'''πορνοϐοσκός, -οῦ (nom commun) (m)''' : tenancier.&lt;br&gt; 
'''πορνοϐοσκῶ (verbe)''' : gérer un lupanar.&lt;br&gt; 
'''πορνοδιάκονος, -όνου (nom commun) (m/f)''' : .&lt;br&gt; 
'''πορνοδιδάσκαλος, -άλου (nom commun) (m) ''' : .&lt;br&gt; 
'''πορνοδύτης, -ου (nom commun) (m)''' .&lt;br&gt; 
'''πορνοφίλης, -ου (nom commun) (m)''' : amateur de prostituées.&lt;br&gt; 
'''πορνογενής, -ής, -ές (adjectif)''' : .&lt;br&gt; 
'''πορνογέννητος, -ος, -ον (adjectif)''' : né dans un lupanar.&lt;br&gt; 
'''πορνογράφος, -ου (nom commun) (m)''' : pornographe.&lt;br&gt; 
'''πορνοκοπέω (verbe)''' : .&lt;br&gt; 
'''πορνοκοπία, -ας (nom commun) (f)''' .&lt;br&gt; 
'''πορνοκόπος, -ου (nom commun) (m)''' : client de lupanar.&lt;br&gt; 
'''πορνομανής, -ής, -ές''' : furieux contre la prostitution.&lt;br&gt; 
'''πόρνος, -ου (nom commun) (m)''' : Prostitué ; gigolo.&lt;br&gt; 
'''πόρπη, -ης (nom commun) (f)''' : broche (bijou).&lt;br&gt; 
'''πόρ, -δός (nom commun) (m)''' : Forme laconienne de ''πούς''.&lt;br&gt;
'''πόρρω (adverbe)''' : Forme attique de ''πρόσω''.&lt;br&gt;
'''πορφύρεος, -α, -ον (adjectif)''' : (chez Homère) Sombre. (grec post-homérique) Pourpre.&lt;br&gt;
'''πορφύρω (verbe)''' : Bouillir, fulminer ; rougir.&lt;br&gt;
'''πόσις, -εως (nom commun) (f)''' : action de boire.&lt;br&gt;
'''πόσις, -ιος (nom commun) (m)''' : époux ; mari.&lt;br&gt;
'''πόσσις, -ιος (nom commun) (m)''' : Forme poétique de ''πόσις''. (au sens d’« époux », « mari »)&lt;br&gt;
'''πόσος, -η, -ον (adjectif interrogatif)''' : combien.&lt;br&gt;
'''ποσότης, -τος (nom commun) (f)''' : quantité.&lt;br&gt;
'''πός, -δός (nom commun) (m)''' : Forme dorienne de ''πούς''.&lt;br&gt; 
'''ποταμός, -οῦ (nom commun) (m)''' : fleuve.&lt;br&gt;
'''πότε (adverbe interrogatif)''' : quand.&lt;br&gt; 
'''ποτέ (adverbe)''' (Devient ''ποτ᾽'' devant un mot commençant par une voyelle à esprit doux, et ''ποθ᾽'' devant un mot commençant par une voyelle à esprit rude.) : jamais.&lt;br&gt; 
'''ποτήριον, -ίου (nom commun) (n)''' : coupe. (récipient)&lt;br&gt;
'''ποτήρ, -ῆρος (nom commun) (m)''' :  verre. (récipient)&lt;br&gt;
'''πότμος, -ου (nom commun) (m)''' : destin ; sort.&lt;br&gt;
'''πότνια, -ίης (nom commun) (f)''' : épouse ; maîtresse.&lt;br&gt;
'''πούς, -δός (nom commun) (m)''' : pied.&lt;br&gt; 
'''ποῦ (adverbe interrogatif)''' : où (sans mouvement) ; comment.&lt;br&gt;
'''πρᾶγμα, -άγματος (nom commun) (n)''' : Chose, évènement ; affaire. Fait.&lt;br&gt;
'''πραγματικός, -ή, -όν (adjectif)''' : évènementiel ; factuel.&lt;br&gt; 
'''πραγματικῶς (adverbe)''' : évènementiellement ; factuellement.&lt;br&gt; 
'''πραγματικώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''πραγματικός''.&lt;br&gt;
'''πραγματικώτερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''πραγματικός''.&lt;br&gt;
'''πραικόκιον, -ίου (nom commun) (n)''' : abricot.&lt;br&gt;
'''πράκτωρ, -ορος (nom commun) (m)''' : agent.&lt;br&gt;
'''πρᾶξις, -άξεως (nom commun) (f)''' : action.&lt;br&gt;
'''πραπίς, -δος (nom commun) (f)''' : intelligence.&lt;br&gt;
'''πράσινος, -ίνη, -άσινον (adjectif)''' : vert poireau.&lt;br&gt;
'''πράσσω (verbe)''' : faire, pratiquer.&lt;br&gt; 
'''πρατήρ, -ῆρος (nom commun) (m)''' : vendeur.&lt;br&gt;
'''πρᾶτος, -άτη, -ᾶτον (adjectif)''' : Forme dorienne de ''πρῶτος''.&lt;br&gt; 
'''πράττω (verbe)''' : Forme attique de ''πράσσω''.&lt;br&gt;
'''πρέπω (verbe)''' : .&lt;br&gt; 
'''πρέσϐυς, -έως (nom commun) (m)''' : Envoyé ; député ; ambassadeur.&lt;br&gt;
'''πρεσϐυτέριον, -ίου (nom commun) (n)''' : assemblée des anciens.&lt;br&gt;
'''πρῆγμα, -ήγματος (nom commun) (f)''' : Forme ionienne de ''πρᾶγμα''.&lt;br&gt;
'''πρηκτήρ, -ός (nom commun) (m)''' : Forme homérique et ionienne de ''πράκτωρ''.&lt;br&gt;
'''πρῆξις, -ήξεως (nom commun) (f)''' : Forme homérique et ionienne de ''πρᾶξις''.&lt;br&gt;
'''πρήσσω (verbe)''' : Forme homérique et ionienne de ''πράσσω''.&lt;br&gt; 
'''πρῆχμα, -ήχματος (nom commun) (f)''' : Autre forme ionienne de ''πρᾶγμα''.&lt;br&gt;
'''πρῖγκιψ, -ίγκιπος (nom commun) (m)''' : prince. (chef d’une principauté)&lt;br&gt;
'''πριγκιπίσσα, -ας (nom commun) (f)''' : princesse. (cheffe d’une principauté)&lt;br&gt;
'''πρίν (conjonction)''' : avant que.&lt;br&gt;
'''πριόνιον, -ίου (nom commun) (n)''' : diminutif de ''πρίων''.&lt;br&gt;
'''πρίων, -ονος (nom commun) (m)''' : scie.&lt;br&gt;
'''προάστειος, -, - (adjectif)''' : suburbain.&lt;br&gt;
'''προάστειον, -ίου (nom commun) (n)''' : banlieue.&lt;br&gt;
'''προϐαίνω (verbe)''' : marcher en avant.&lt;br&gt; 
'''προϐατίνα, -ας (nom commun) (f)''' : brebis.&lt;br&gt;
'''πρόϐατον, -άτου  (nom commun) (n)''' : mouton.&lt;br&gt;
'''πρόϐλημα, -ήματος (nom commun) (n)''' : problème.&lt;br&gt;
'''πρόγνωσις, -ώσεως (nom commun) (f)''' : .&lt;br&gt;
'''πρόγονος, -όνου (nom commun) (m)''' : ancêtre.&lt;br&gt;
'''προπάτωρ, -ορος (nom commun) (m)''' : ancêtre.&lt;br&gt;
'''πρόγραμμα, -άμματος (nom commun) (n)''' : notice écrite publique.&lt;br&gt;
'''προγράφω (verbe)''' : écrire une notice publique.&lt;br&gt;
'''προδίδωμι (verbe)''' : trahir.&lt;br&gt;
'''προδότης, -ου (nom commun) (m)''' : traître.&lt;br&gt;
'''προδοτικός, -ή, -όν (adjectif)''' : traître.&lt;br&gt;
'''προδοσία, -ας (nom commun) (f)''' : trahison.&lt;br&gt; 
'''προοίμιον, -ίου (nom commun) (n)''' : prélude.&lt;br&gt;
'''προκινῶ (verbe)''' : .&lt;br&gt;
'''πρόκοιτος, -ίτου (nom commun) (m)''' : chambellan.&lt;br&gt;
'''προλαμϐάνω (verbe)''' : prévoir.&lt;br&gt;
'''πρόληψις, -ήψεως (nom commun) (f)''' : prévention.&lt;br&gt; 
'''πρόλογος, -όγου (nom commun) (m)''' : préface.&lt;br&gt;
'''προσϐάλλω (verbe)''' : .&lt;br&gt; 
'''προσϐολή, -ῆς (nom commun) (f)''' : .&lt;br&gt; 
'''προσευχή, -ῆς (nom commun) (f)''' : prière.&lt;br&gt; 
'''προσεύχομαι (verbe)''' : Adresser une prière. (Absolu) Adorer, prier, supplier.&lt;br&gt; 
'''προσήλωσις, -ώσεως (nom commun) (f)''' : attachemeent.&lt;br&gt; 
'''πρόσθεν (adverbe)''' Devant ; en avant.&lt;br&gt;
'''προσιτός, -ή, -όν (adjectif)''' : abordable.&lt;br&gt;
'''πρόσειμι (verbe)''' : aborder.&lt;br&gt;
'''προσθιγγάνω (verbe)''' : .&lt;br&gt;
'''προσκέφαλον, -άλου (nom commun) (m)''' : oreiller.&lt;br&gt;
'''πρόσκοπος, -όπου (nom commun) (m)''' : éclaireur.&lt;br&gt;
'''πρόσκοπευω (verbe)''' : .&lt;br&gt;
'''προσποιῶ (verbe)''' : .&lt;br&gt;
'''προσωποποιία, -ας (nom commun) (f)''' : personnification.&lt;br&gt; 
'''πρόσω (adverbe)''' : .&lt;br&gt;
'''πρός (adverbe ; préposition)''' : Auprès, à côté ; en outre.&lt;br&gt;
'''πρότατος, -άτα, -άτετον (adjectif)''' : Superlatif de ''πρῶτος''.&lt;br&gt;
'''πρότερος, -έρα, -ότερον (adjectif)''' : Comparatif de ''πρῶτος''.&lt;br&gt;
'''προτί (adverbe ; préposition)''' : Forme homérique de ''πρός''.&lt;br&gt;
'''ποτί (adverbe ; préposition)''' : Forme homérique et dorienne de ''πρός''.&lt;br&gt;
'''ποί (adverbe ; préposition)''' :  Forme dorienne de ''πρός''.&lt;br&gt;
'''πορτί (adverbe ; préposition)''' : Forme crétoise de ''πρός''.&lt;br&gt;
'''πός (adverbe ; préposition)''' : Forme arcado-chypriote de ''πρός''.&lt;br&gt;
'''πρές (adverbe ; préposition)''' : Forme éolienne de ''πρός''.&lt;br&gt;
'''πέρτι (adverbe ; préposition)''' : Forme pamphylienne de ''πρός''.&lt;br&gt;
'''πρᾶος, -ος, -ᾷον (adjectif)''' : doux ; calmant.&lt;br&gt;
'''πραότης, -τος (nom commun) (f)''' : Douceur, bonté ; facilité de caractère.&lt;br&gt;
'''πραύς, -εῖα, -ύ (adjectif)''' : Variante de ''πρᾶος''.&lt;br&gt;
'''πραΰς, -εΐα, -ΰ (adjectif)''' : Forme poétique de ''πρᾶος''.&lt;br&gt;
'''πρήξιμον, -ίματος (nom commun) (n)''' : Enflure, gonflement ; ballonnement, boursouflure, fluxion.&lt;br&gt; 
'''πρῖγκιψ, -ίγκιπος (nom commun) (m)''' : prince (chef d’une principauté).&lt;br&gt; 
'''πριγκίπισσα, -ας (nom commun) (f)''' : princesse (cheffe d’une principauté).&lt;br&gt;
'''πρό (adverbe ; préposition)''' devant.&lt;br&gt;
'''προ- (préfixe)''' pré-.&lt;br&gt;
'''παράρτημα, -ήματος (nom commun) (n)''' : annexe.&lt;br&gt;
'''προζύμιον, -ίου (nom commun) (n)''' : .&lt;br&gt;
'''προζυμίτης, -ου (nom commun) (m)''' : .&lt;br&gt; 
'''πρόσθεσις, -έσεως (nom commun) (f)''' : addition.&lt;br&gt;
'''προσφορά, -ᾶς (nom commun) (f)''' : offre.&lt;br&gt;
'''προσωπεῖον, -ίου (nom commun) (n)''' : masque.&lt;br&gt;
'''προσωπίς, -δος (nom commun) (f)''' : masque.&lt;br&gt;
'''προσ- (préfixe)''' : Vers, à ; Auprès. En outre, encore. Excessivement ; tout à fait.&lt;br&gt;
'''προσαρτῶ  (verbe)''' : annexer.&lt;br&gt;
'''προστίθημι (verbe)''' : additionner ; ajouter.&lt;br&gt;
'''προσομοίωσις, -ώσεως (nom commun) (f)''' : simulation.&lt;br&gt;
'''προσποιῶ (verbe)''' : simuler.&lt;br&gt;
'''πρότανις, -άνεως (nom commun) (m)''' : Forme éolienne de ''πρύτανις''.&lt;br&gt;
'''προῦμνον, -ύμνου (nom commun) (n)''' : prune.&lt;br&gt; 
'''προφατεία, -ας (nom commun) (f)''' : Forme dorienne de ''προφητεία''.&lt;br&gt; 
'''προφάτης, -ου (nom commun) (m)''' : Forme dorienne de ''προφήτης''.&lt;br&gt; 
'''προφητεία, -ας (nom commun) (f)''' : prophétie.&lt;br&gt; 
'''προφήτης, -ου (nom commun) (m)''' : prophète.&lt;br&gt; 
'''προφυλακτικός, -ή, -όν (adjectif)''' : .&lt;br&gt;
'''προφυλάξις, -εως (nom commun) (f)''' : .&lt;br&gt;
'''προφυλάσσω (verbe)''' : .&lt;br&gt;
'''πρύμνα, -ας (nom commun) (f)''' : poupe.&lt;br&gt; 
'''πρύμνη, -ης (nom commun) (f)''' : Forme ionienne de ''πρύμνα''.&lt;br&gt; 
'''πρυτανεῖον, -ίου (nom commun) (n)''' : (À Athènes) mairie.&lt;br&gt;
'''πρύτανις, -άνεως (nom commun) (m)''' : prytane.&lt;br&gt;
'''πρωΐ (adverbe)''' : tôt.&lt;br&gt;
'''πρῴ (adverbe)''' : Forme attique de ''πρωΐ''.&lt;br&gt;
'''πρωκτός, -οῦ (nom commun) (m)''' : anus.&lt;br&gt;
'''πρωκτόσοφος, -όφου (nom commun) (m/f)''' : Expert en débauche contre nature.&lt;br&gt;
'''πρῷρα, -ῴρας (nom commun) (f)''' : proue.&lt;br&gt; 
'''πρωταγωνιστής, -οῦ (nom commun) (m)''' : protagoniste.&lt;br&gt;
'''πρῶτος, -ώτη, -ῶτον (adjectif)''' : premier.&lt;br&gt;
'''πρωτόκολλον, -όλλου (nom commun) (n)''' : frontispice.&lt;br&gt; 
'''πτελέα, -ας (nom commun) (f)''' : orme.&lt;br&gt; 
'''πτέρινος, -ίνη, -ινον (adjectif)''' : .&lt;br&gt;
'''πτέρις, -δος (nom commun) (f)''' : fougère.&lt;br&gt;
'''πτερόεις, -εσσα, -εν (adjectif)''' : ailé.&lt;br&gt; 
'''πτερόν, -οῦ (nom commun) (n)''' : aile.&lt;br&gt; 
'''πτέρνα, -ης (nom commun) (f)''' : talon. (partie postérieure du pied)&lt;br&gt;
'''πτέρυξ, -υγος (nom commun) (f)''' : Aile ; nageoire.&lt;br&gt;
'''πτηνόν, -οῦ (nom commun) (n)''' : oiseau.&lt;br&gt;
'''πτηνοπέδιλος, -ίλου (nom commun) (m)''' : talaria.&lt;br&gt;
'''πτισάνη, -ης (nom commun) (f)''' : tisane.&lt;br&gt; 
'''πτίσσω (verbe)''' : .&lt;br&gt; 
'''πτίττω (verbe)''' : Forme attique de ''πτίσσω''.&lt;br&gt; 
'''πτόλεμος, -έμου (nom commun) (m)''' : Forme homérique de ''πόλεμος''.&lt;br&gt;
'''πτολίεθρον, -έθρου (nom commun) (n)''' : citadelle.&lt;br&gt; 
'''πτόλις, -εως (nom commun) (f)''' : Forme homérique de ''πόλις''.&lt;br&gt;
'''πτύον, -ου (nom commun) (n)''' : pelle.&lt;br&gt; 
'''πτύω (verbe)''' : cracher.&lt;br&gt;
'''πτῶσις, -ώσεως (nom commun) (f)''' : chute.&lt;br&gt;
'''πτώσσω (verbe)''' : chuter.&lt;br&gt; 
'''πτωχεία, -ας (nom commun) (f)''' : pauvre.&lt;br&gt;
'''πτωχεῖον, -ίου (nom commun) (n)''' : hospice.&lt;br&gt;
'''πτώχευσις, -ύσεως (nom commun) (f)''' : banqueroute.&lt;br&gt;
'''πτωχεύω (verbe)''' : faire banqueroute.&lt;br&gt;
'''πτωχός, -ή, -όν (adjectif)''' : pauvre.&lt;br&gt; 
'''πτωχοτροφεῖον, -ίου (nom commun) (n)''' : hospice.&lt;br&gt;
'''πτωχοτρόφος, -ου (nom commun) (m)''' : ptôchotrophe.&lt;br&gt;
'''πτωχότατος, -άτη, -ότατον (adjectif)''' : Superlatif de ''πτωχός''.&lt;br&gt;
'''πτωχότερος, -έρα, -ότερον (adjectif)''' : Comparatif de ''πτωχός''.&lt;br&gt;
'''πτωχῶς (adverbe)''' : pauvrement.&lt;br&gt;
'''πυγή, -ῆς (nom commun) (f)''' : fesse.&lt;br&gt;
'''πυγηφαvοῦς, -οῦ (nom commun) (m)''' : mooning. (Action de montrer ses fesses nues en baissant son pantalon et en se penchant en avant.)&lt;br&gt;
'''πυγίδιον, -ίου (nom commun) (n)''' : croupion.&lt;br&gt;
'''πυγίζω (verbe)''' : sodomiser.&lt;br&gt;
'''πυγμαῖος, -ία -ῖον (adjectif)''' : pygmée.&lt;br&gt; 
'''πυγμή, -ῆς (nom commun) (f)''' : poing.&lt;br&gt;
'''πύελος, -έλου (nom commun) (f)''' : bassin (os).&lt;br&gt;
'''πυθμήν, -ένος (nom commun) (m)''' : fond.&lt;br&gt; 
'''πυκνός, -ή, -όν (adjectif)''' : dense, sagace.&lt;br&gt; 
'''πυκνότατα, -, - (adverbe)''' : Superlatif de ''πυκνῶς''.&lt;br&gt;
'''πυκνότερον, -, - (adverbe)''' : Comparatif de ''πυκνῶς''.&lt;br&gt;
'''πυκνότατος, -άτη, -ότατον (adjectif)''' : Superlatif de ''πυκνός''.&lt;br&gt;
'''πυκνότερος, -έρα, -ότερον (adjectif)''' : Comparatif de ''πυκνός''.&lt;br&gt;
'''πυκνότης, -τος (nom commun) (f)''' : densité ; sagacité.&lt;br&gt;
'''πυκνῶς (adverbe)''' : densément ; sagacement.&lt;br&gt;
'''πύλη, -ης (nom commun) (f)''' : (Au singulier) battant de porte. (Au pluriel) porte.&lt;br&gt;
'''πυλωρός, -οῦ (nom commun) (m)''' : Portier. (Anatomie) pylore.&lt;br&gt;
'''πύνδαξ, -κος (nom commun) (m)''' : fond.&lt;br&gt;
'''πυνθάνομαι (verbe)''' : chercher à savoir ; s’enquérir ; s’informer de ; apprendre en s’informant ; apprendre&lt;br&gt;
'''πυξίς, -δος (nom commun) (f)''' : pyxide.&lt;br&gt;
'''πύον, -ου (nom commun) (n)''' : ‎pus.&lt;br&gt;
'''πυραμίς, -δος (nom commun) (f)''' : pyramide.&lt;br&gt;
'''πυργίτης, -ου (nom commun) (m)''' : moineau.&lt;br&gt;
'''πύργος, -ου (nom commun) (m)''' : Tour. (Par extension) Enceinte garnie de tours. (Par extension) Citadelle, remparts. (Par analogie) Sorte de bataillon carré.&lt;br&gt;
'''πύρινος, -η, -ον (adjectif)''' : enflammé.&lt;br&gt;
'''πυρινότατος, -άτη, -ότατον (adjectif)''' : Superlatif de ''πύρινος''.&lt;br&gt;
'''πυρινότερος, -έρα, -ότερον (adjectif)''' : Comparatif de ''πύρινος''.&lt;br&gt;
'''πύρινως (adverbe)''' : .&lt;br&gt;
'''πῦρ, -ός (nom commun) (n)''' : feu.&lt;br&gt;
'''πυρρός, -ά, -όν (adjectif)''' : .&lt;br&gt;
'''πυρρότατος, -άτη, -ότατον (adjectif)''' : Superlatif de ''πυρρός''.&lt;br&gt;
'''πυρρότερος, -έρα, -ότερον (adjectif)''' : Comparatif de ''πυρρός''.&lt;br&gt;
'''πυρρῶς (adverbe)''' : .&lt;br&gt;
'''πύσμα, -τος (nom commun) (n)''' : question ouverte.&lt;br&gt;
'''πύστις, -εως (nom commun) (f)''' : Enquête, question. Apprentissage, chose apprise.&lt;br&gt;
'''πυστός, -ή, -όν (adjectif)''' : .&lt;br&gt;
'''πωγώνιον, -ίου (nom commun) (m)''' : menton.&lt;br&gt; 
'''πώγων, -ονος (nom commun) (m)''' : Barbe ; barbe d’animal, de plante. Barbelure. Langue de feu.&lt;br&gt; 
'''πωλέω (verbe)''' : vendre.&lt;br&gt; 
'''πώλης, -ου (nom commun) (m)''' : vendeur.&lt;br&gt;
'''πωλητής, -οῦ (nom commun) (m)''' : vendeur.&lt;br&gt;
'''πῶμα, -ώματος (nom commun) (n)''' : bouchon.&lt;br&gt;
'''πῶυ, -ώεος (nom commun) (n)''' : Troupeau d’ovins ou de chèvres.&lt;br&gt;
'''πῶς (adverbe)''' : comment.&lt;br&gt;
'''Παιάν, -ᾶνος (nom commun) (m)''' : péan. (nom propre) : Péan.&lt;br&gt;
'''Πακτωλός, -οῦ (nom propre) (m)''' : Pactole.&lt;br&gt;
'''Παλαιὰ Διαθήκη (locution nominale) (f)''' : Ancien Testament.&lt;br&gt;
'''Παλλάδιον, -ίου (nom propre) (n)''' : Palladium.&lt;br&gt; 
'''Πάλλας, -αντος (nom propre) (m)''' : Pallas (nom masculin).&lt;br&gt;
'''Παλλάς, -δος (nom propre) (f)''' : Pallas (nom féminin).&lt;br&gt;
'''Πάλμυρα, -ύρας (nom propre) (f)''' : Palmyre.&lt;br&gt;
'''Πάμφιλος, -ίλου (nom propre) (m)''' : Pamphile.&lt;br&gt;
'''Πανάκεια, -ας (nom propre) (f)''' : [[wikt:Panacée|Panacée]].&lt;br&gt;
'''Πανδώρα, -ας (nom propre) (f)''' : [[wikt:Pandore|Pandore]].&lt;br&gt;
'''Πάν, -ός (nom propre) (m)''' : [[wikt:Pan|Pan]].&lt;br&gt;
'''Πανοῦργος, -ύργου (nom propre) (m)''' : Panurge.&lt;br&gt;
'''Πάνθειον, -ίου (nom propre) (m)''' : Panthéon.&lt;br&gt;
'''Παρθένος, -ου (nom propre) (f)''' : Vierge.&lt;br&gt;
'''Παρθενών, -ῶνος (nom commun) (m)''' : Parthénon.&lt;br&gt;
'''Παρθία, -ας (nom propre) (f)''' : Parthie.&lt;br&gt;
'''Πάρθος, -ου (nom commun) (m)''' : Parthe.&lt;br&gt;
'''Πάρις, -δος (nom propre) (m)''' : Pâris.&lt;br&gt;
'''Παρμενίδης, -ου (nom propre) (m)''' : Parménide.&lt;br&gt;
'''Πασιφάη, -ης (nom propre) (f)''' : Pasiphaé.&lt;br&gt;
'''Παῦλος, -ύλου (nom propre) (m)''' : Paul.&lt;br&gt; 
'''Παῦνι (nom propre) (m)''' : Payni.&lt;br&gt; 
'''Παυσανίας, -ου (nom propre) (m)''' : Pausanias.&lt;br&gt;   
'''Παχώμιος, -ίου (nom propre) (m)''' :  Pacôme.&lt;br&gt;
'''Παχών (nom propre) (m)''' :  Pachon.&lt;br&gt;
'''Πελοπόννησος, -ήσου (nom propre) (f)''' : Péloponnèse.&lt;br&gt;
'''Πέλοψ, -πος (nom propre) (m)''' : Pélops.&lt;br&gt;
'''Πεμφρηδώ, -οῦς (nom propre) (f)''' :  Pemphrédo (une des Grées).&lt;br&gt;
'''Πεντάτευχος, -ύχου (nom propre) (f)''' : Pentateuque.&lt;br&gt;
'''Πέργαμον, -άμου (nom propre) (n)''' : Pergame.&lt;br&gt;
'''Περίϐοια, -ίας (nom propre) (f)''' :  Périboée.&lt;br&gt;
'''Περικλῆς, -έους (nom propre) (m)''' : Périclès.&lt;br&gt;
'''Περίλεως, -εω (nom propre) (m)''' : Périléos.&lt;br&gt;
'''Περσέπολις, -όλεως (nom propre) (f)''' : Persépolis.&lt;br&gt;
'''Περσεπολίτης, -ου (nom commun) (m)''' : Persépolitain.&lt;br&gt;
'''Πέρσης, -ου (nom commun) (m)''' : Perse.&lt;br&gt;
'''Περσίς, -δος (nom propre) (f)''' : Perse.&lt;br&gt;
'''Περσίς, -δος (nom commun) (f)''' : Perse.&lt;br&gt;
'''Πετεφρής, -οῦ (nom propre) (m)''' : Potiphar.&lt;br&gt;
'''Πήγασος, -άσου (nom propre) (m)''' : Pégase.&lt;br&gt;
'''Πηλεύς, -έως (nom propre) (m)''' : Pélée.&lt;br&gt;
'''Πηνειός, -οῦ (nom propre) (m)''' : Pénée.&lt;br&gt;
'''Πηνελόπη, -ης (nom propre) (f)''' : Pénélope.&lt;br&gt;
'''Πίστις, -εως (nom propre) (f)''' : Pistis.&lt;br&gt;
'''Πιτθεύς, -έως (nom propre) (m)''' : Pitthée. (Grand-père de Thésée.)&lt;br&gt;
'''Πλάτων, -ωνος (nom propre) (m)''' : Platon.&lt;br&gt;
'''Πλευρών, -ῶνος (nom propre) (m/f)''' : Pleuron.&lt;br&gt;
'''Πλούταρχος, -άρχου (nom propre) (m)''' : Plutarque.&lt;br&gt;
'''Πλουτεύς, -έως (nom propre) (m)''' : Autre nom de Pluton.&lt;br&gt;
'''Πλουτίς, -δος (nom propre) (f)''' : Ploutis.&lt;br&gt;
'''Πλοῦτος, -ύτου (nom propre) (m)''' : [[wikt:Ploutos|Ploutos]].&lt;br&gt;
'''Πλούτων, -ωνος (nom propre) (m)''' : [[wikt:Pluton|Pluton]].&lt;br&gt;
'''Πόθος, - (nom propre) (m)''' : [[wikt:Pothos|Pothos]].&lt;br&gt;
'''Ποικίλη, -ης  (nom propre) (f)''' : Pœcile. (portique au nord de l’Agora d’Athènes.)&lt;br&gt;
'''Πολύϐιος, -ίου (nom propre) (m)''' : Polybe.&lt;br&gt;
'''Πολυμνία, -ας (nom propre) (f)''' : Polymnie.&lt;br&gt;
'''Πολύαινος, -ίνου (nom propre) (m)''' : Polyen.&lt;br&gt;
'''Πολυνείκης, -ους (nom propre) (m)''' : Polynice.&lt;br&gt;
'''Πολυπήμων, -ονος (nom propre) (m)''' : Polypémon (véritable nom de Procuste).&lt;br&gt;
'''Πολύφημος, -ήμου (nom propre) (m)''' : Polyphème.&lt;br&gt;
'''Πομπηία, -ας (nom propre) (f)''' : Pompéi.&lt;br&gt;
'''Πομπήϊος, -ΐου (nom propre) (m)''' : Pompée.&lt;br&gt;
'''Ποσειδώνιος, - (nom propre) (m)''' : Posidonios (Philosophe grec stoïcien né à Apamée en 135 av. J.-C. et mort à Rome en 51 av. J.-C. .).&lt;br&gt;
'''Ποσειδάν, - (nom propre) (m)''' : Forme dorienne de ''Ποσειδῶν''.&lt;br&gt;
'''Ποσειδάων, - (nom propre) (m)''' : Forme homérique de ''Ποσειδῶν''.&lt;br&gt;
'''Ποσειδέων, - (nom propre) (m)''' : Forme ionienne de ''Ποσειδῶν''.&lt;br&gt;
'''Ποσειδῶν, -ῶνος (nom propre) (m)''' : [[wikt:Poséidon|Poséidon]].&lt;br&gt;
'''Ποτειδάν, - (nom propre) (m)''' : Autre forme dorienne de ''Ποσειδῶν''.&lt;br&gt;
'''Ποτείδαν, - (nom propre) (m)''' : Forme éolienne de ''Ποσειδῶν''.&lt;br&gt;
'''Ποτειδᾶς, - (nom propre) (m)''' : Forme de ''Ποσειδῶν''.&lt;br&gt;
'''Ποτειδάων, - (nom propre) (m)''' : Forme crétoise et béotienne de ''Ποσειδῶν''.&lt;br&gt;
'''Πραξιτέλης, -ους (nom propre) (m)''' : Praxitèle.&lt;br&gt;
'''Πρίαμος, -άμου (nom propre) (m)''' : Priam.&lt;br&gt;
'''Πρόκνη, -ης (nom propre) (f)''' : Procné.&lt;br&gt;
'''Προκρούστης, -ου (nom propre) (m)''' : Procuste (surnom de Polypémon.).&lt;br&gt;
'''Προκύων, -ός (nom propre) (m)''' : Procyon.&lt;br&gt;
'''Προμηθεύς,  -έως (nom propre) (m)''' : Prométhée.&lt;br&gt;
'''Προξένος, -ρου (nom propre) (m)''' : Proxenos.&lt;br&gt;
'''Προυσίας, -ου (nom propre) (m)''' : Prusias.&lt;br&gt;
'''Πρωταγόρας, -ου (nom propre) (m)''' : Protagoras.&lt;br&gt;
'''Πυγμαλίων, -ωνος (nom propre) (m)''' : Pygamlion.&lt;br&gt;
'''Πυθαγόρας, -ου (nom propre) (m)''' : Pythagore.&lt;br&gt;
'''Πυθόπολις, -όλεως (nom propre) (f)''' : Antioche du Méandre.&lt;br&gt;
'''Πύθων, -ωνος (nom propre) (m)''' : Python.&lt;br&gt;
'''Πυθώ, -οῦς (nom propre) (f)''' : Ancien nom de Delphes.&lt;br&gt;
'''Πυλάδας, -ου (nom propre) (m)''' : Forme dorienne de ''Πυλάδης''.&lt;br&gt;
'''Πυλάδης, -ου (nom propre) (m)''' : Pylade.&lt;br&gt;
'''Πύραμος, -άμου (nom propre) (m)''' : Pyrame.&lt;br&gt;
'''Πυρετός, -οῦ (nom propre) (m)''' :  (fleuve d’Europe de l’Est).&lt;br&gt;
'''Πυργοπολυνείκης, -ους (nom propre) (m)''' : Pyrgopolinice.&lt;br&gt;
'''Πύργος, -ου (nom propre) (m)''' : Pyrgos.&lt;br&gt;
'''Πύρρα, -ας (nom propre) (f)''' : Pyrrha.&lt;br&gt;
'''Πύρρος, -ου (nom propre) (m)''' : Pyrrhus.&lt;br&gt;
'''Πύρρων, -ωνος (nom propre) (m)''' : Pyrrhon.&lt;br&gt;
'''Πῶλος, -ώλου (nom propre) (m)''' : Polos.&lt;br&gt;

==Ρ==
'''ῥᾶ (nom commun) (n)''' : rhubarbe.&lt;br&gt;
'''ῥαϐϐί (nom commun) (m)''' : rabbin.&lt;br&gt;
'''ῥαϐδομαντεία, -ας (nom commun) (f)''' : Divination pratiquée grâce à une baguette.&lt;br&gt;
'''ῥαϐδονόμος, -ου (nom commun) (m)''' : licteur.&lt;br&gt;
'''ῥαϐδοῦχος, -ύχου (nom commun) (m)''' : licteur.&lt;br&gt;
'''ῥάϐδος, -ου (nom commun) (f)''' : baguette.&lt;br&gt;
'''ῥαγάς, -δος (nom commun) (f)''' : .&lt;br&gt;
'''ῥαιϐηδόν, -οῦ (nom commun) (n)''' .&lt;br&gt;
'''ῥαιϐοειδής, -ής, -ές (adjectif) ''' .&lt;br&gt;
'''ῥαιϐόκρανος, -άνου (nom commun) (m)''' .&lt;br&gt;
'''ῥαιϐοσκελής, -ής, -ές (adjectif) ''' .&lt;br&gt;
'''ῥαιϐός, -ή, -όν (adjectif)''' : tendu.&lt;br&gt;
'''ῥαιϐότης, -τος (nom commun) (f)''' .&lt;br&gt;
'''ῥαιϐῶς (adverbe)''' : de façon tendue.&lt;br&gt;
'''ῥαιϐῶ (verbe)''' tendre.&lt;br&gt;
'''ῥαδινός, -ή -όν (adjectif)''' : souple.&lt;br&gt;
'''ῥᾴδιος, -α, -ον (adjectif)''' : facile.&lt;br&gt;
'''ῥᾳδίως (adverbe)''' : facilement.&lt;br&gt;
'''ῥᾷστος, -, - (adjectif)''' : Superlatif de ''ῥᾴδιος''.&lt;br&gt; 
'''ῥᾴων, -, - (adjectif)''' : Comparatif de ''ῥᾴδιος''.&lt;br&gt; 
'''ῥάμνος, -ου (nom commun) (f)''' nerprun épineux.&lt;br&gt;
'''ῥάμφος, -ους (nom commun) (n)''' : bec (d’un oiseau).&lt;br&gt;
'''ῥάξ, -γός (nom commun) (m)''' : téton.&lt;br&gt; 
'''ῥάπισμα, -ίσματος (nom commun) (n)''' : gifle.&lt;br&gt;
'''ῥαπίς, -δος (nom commun) (f)''' : verge ; bâton.&lt;br&gt;
'''ῥάπτης, -ου (nom commun) (n)''' : tailleur (de vêtements).&lt;br&gt;
'''ῥαπτός, -ή, -όν (adjectif)''' : cousu.&lt;br&gt;
'''ῥάπτω (verbe)''' : coudre.&lt;br&gt;
'''ῥάπυς, -ος (f)''' : navet.&lt;br&gt;
'''ῥάσσω (verbe)''' : .&lt;br&gt;
'''ῥάττω (verbe)''' : Forme attique de ''ῥάσσω''.&lt;br&gt;
'''ῥαφανιδῶ (verbe)''' : .&lt;br&gt;
'''ῥαφανίδωσις, -ώσεως (nom commun) (f)''' : .&lt;br&gt;
'''ῥαφανός, -οῦ (nom commun) (m)''' : radis.&lt;br&gt;
'''ῥαφεύς, -έως (nom commun) (m)''' : couturier.&lt;br&gt;
'''ῥαφή, -ῆς (nom commun) (f)''' : couture.&lt;br&gt;
'''ῥαφίς, -δος (nom commun) (f)''' : Aiguille, poinçon. Aiguille (poisson de mer).&lt;br&gt;
'''ῥάφυς, -ος (nom commun) (f)''' : Variante de ''ῥάπυς''.&lt;br&gt;
'''ῥαχίζω (verbe)''' : .&lt;br&gt;
'''ῥάχις, -εως (nom commun) (f)''' : épine dorsale.&lt;br&gt;
'''ῥαχιστής, -οῦ (nom commun) (m)''' : .&lt;br&gt;
'''ῥαχιστός, -ός, -όν (adjectif)''' : .&lt;br&gt;
'''ῥαχίτης, -ης, -ες, (adjectif)''' : .&lt;br&gt;
'''ῥαχός, -ή, -όν, (adjectif)''' : superficiel.&lt;br&gt;
'''ῥαχός, -οῦ (nom commun) (m)''' : .&lt;br&gt; 
'''ῥάψις, -εως (nom commun) (f)''' : .&lt;br&gt;
'''ῥαψῳδία, -ας (nom commun) (f)''' : récitation d’un poème épique.&lt;br&gt;
'''ῥαψῳδός, -οῦ (nom commun) (m)''' : barde.&lt;br&gt;
'''ῥέδδω (verbe)''' : Forme béotienne et dorienne de ''ῥέζω''.&lt;br&gt;
'''ῥέζω (verbe)''' : Travailler, faire, exécuter.&lt;br&gt;
'''ῥέπω (verbe)''' : incliner.&lt;br&gt;
'''ῥεῦμα, -ύματος (nom commun) (n)''' : rhume.&lt;br&gt;
'''ῥευματίζομαι (verbe)''' : souffrir de rhumatismes.&lt;br&gt;
'''ῥευματισμός, -οῦ (nom commun) (m)''' : rhumatisme.&lt;br&gt; 
'''ῥευστός, -ή -όν (adjectif)''' : liquide.&lt;br&gt;
'''ῥέω (verbe)''' : couler.&lt;br&gt;
'''ῥῆγμα, -ήγματος  (nom commun) (n)''' : .&lt;br&gt;
'''ῥήγνυμι (verbe)''' : .&lt;br&gt;
'''ῥῆμα, -ήματος (nom commun) (n)''' : verbe.&lt;br&gt;
'''ῥῆξις, -ήξεως (nom commun) (f)''' : déchirure.&lt;br&gt;
'''ῥῆον, -ήου (nom commun) (n)''' : rhubarbe.&lt;br&gt;
'''ῥῆσις, -ήσεως (nom commun) (f)''' : citation.&lt;br&gt;
'''ῥήσσω (verbe)''' : Forme ionienne de ''ῥάσσω''.&lt;br&gt;
'''ῥητορικός, -ή, -όν (adjectif)''' : oratoire.&lt;br&gt;
'''ῥητορικῶς (adverbe)''' : oratoirement.&lt;br&gt;
'''ῥητορικώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''ῥητορικός''.&lt;br&gt;
'''ῥητορικώτερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''ῥητορικός''.&lt;br&gt;
'''ῥητορικώτατα, -, - (adverbe)''' : Superlatif de ''-ικῶς''.&lt;br&gt;
'''ῥητορικώτερον, -, - (adverbe)''' : Comparatif de ''-ικῶς''.&lt;br&gt; 
'''ῥητός, -ή, -όν (adjectif)''' : Dit ; dicible, (Mathématiques) rationnel.&lt;br&gt; 
'''ῥήτρα, -ας (nom commun) (f)''' : clause.&lt;br&gt;
'''ῥήτωρ, -ορος (nom commun) (m/f)''' : orateur.&lt;br&gt; 
'''ῥηχός, -ή -όν (adjectif)''' : Forme ionienne de ''ῥαχός''.&lt;br&gt; 
'''ῥῖγος, -ίγους (nom commun) (n)''' : frisson.&lt;br&gt;
'''ῥιγῶ (verbe)''' : frissonner.&lt;br&gt;
'''ῥίζα, -ης (nom commun) (f)''' : racine.&lt;br&gt;
'''ῥινόκερως, -έρωτος (nom commun) (m)''' : rhinocéros.&lt;br&gt;
'''ῥίον, -ου (nom commun) (n)''' : sommet.&lt;br&gt;
'''ῥιπή, -ῆς (nom commun) (f)''' : .&lt;br&gt;
'''ῥίπτω (verbe)''' : lancer, jeter ; projet.&lt;br&gt;
'''ῥίς, -νός (nom commun) (f)''' : nez.&lt;br&gt;
'''ῥίψασπις, -δος (nom commun) (f)''' : .&lt;br&gt;
'''ῥίψις, -πός (nom commun) (f)''' : entrelac.&lt;br&gt;
'''ῥιπίζω (verbe)''' : éventer.&lt;br&gt;
'''ῥιπίς, -δος (nom commun) (f)''' : éventail.&lt;br&gt;
'''ῥοά, -ᾶς (nom commun) (f)''' : Forme dorienne de ''ῥοή''.&lt;br&gt;
'''ῥοή, -ῆς (nom commun) (f)''' : écoulement.&lt;br&gt;
'''ῥοδόεις, -εσσα, -εν (adjectif)''' : rosé.&lt;br&gt; 
'''ῥοδοέντως (adverbe)''' : .&lt;br&gt;
'''ῥοδοέστατος, -άτη, -έστατον (adjectif)''' : Superlatif de ''ῥοδόεις''.&lt;br&gt;
'''ῥοδοέστερος, -έρα, -ερον (adjectif)''' : Comparatif de ''ῥοδόεις''.&lt;br&gt;
'''ῥόδον, -ου (nom commun) (n)''' : rose (fleur).&lt;br&gt;
'''ϝρόδον, -ου (nom commun) (n)''' : Forme éolienne de ''ῥόδον''.&lt;br&gt;
'''ῥοιά, -ᾶς (nom commun) (f)''' : grenade (fruit).&lt;br&gt;
'''ῥόκα, -ας (nom commun) (f)''' : roquette (plante).&lt;br&gt;
'''ῥόμος, -ου (nom commun) (m)''' : ver.&lt;br&gt; 
'''ῥομφαία, -ας (nom commun) (f)''' : estramaçon.&lt;br&gt;
'''ῥόπαλον, -άλου (nom commun) (n)''' : gourdin.&lt;br&gt; 
'''ῥοφῶ (verbe)''' : sucer.&lt;br&gt;
'''ῥύαξ, -κος (nom commun) (n)''' : ruisseau.&lt;br&gt;
'''ῥύγχος, -ους (nom commun) (n)''' : Trompe, museau. Bec d’un oiseau.&lt;br&gt;
'''ῥυθμός, -οῦ (nom commun) (m)''' : mouvement régulier.&lt;br&gt;
'''ῥύμη, -ης (nom commun) (f)''' : rue.&lt;br&gt;
'''ῥυπαίνω (verbe)''' : polluer.&lt;br&gt;
'''ῥύπανσις, -άνσεως (nom commun) (f)''' : pollution.&lt;br&gt;
'''ῥυπαρός, -ά, -όν (adjectif)''' : crasseux.&lt;br&gt;
'''ῥυπαρῶς (adverbe)''' : crasseusement.&lt;br&gt;
'''ῥυπαρώτατα, -, - (adverbe)''' : Superlatif de ''ῥυπαρῶς''.&lt;br&gt;
'''ῥυπαρώτερον, -, - (adverbe)''' : Comparatif de ''ῥυπαρῶς''.&lt;br&gt; 
'''ῥυπαρώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''ῥυπαρός''.&lt;br&gt;
'''ῥυπαρώτερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''ῥυπαρός''.&lt;br&gt;
'''ῥύπος, -ου (nom commun) (m)''' : polluant.&lt;br&gt;
'''ῥυσμός, -οῦ (nom commun) (m)''' : Forme ionienne de ''ῥυθμός''.&lt;br&gt;
'''ῥυτίς, -δος (nom commun) (f)''' : ride.&lt;br&gt;
'''ῥωγμή, -ῆς (nom commun) (f)''' : fissure.&lt;br&gt;
'''ῥώθων, -ος (nom commun) (m)''' : narine.&lt;br&gt;
'''ῥωμαϊκός, -ή, -όν (adjectif)''' : romain.&lt;br&gt;
'''ῥωμαϊκῶς (adverbe)''' : romainement.&lt;br&gt;
'''ῥωμαϊκώτατα, -, - (adverbe)''' : Superlatif de ''ῥωμαϊκῶς''.&lt;br&gt;
'''ῥωμαϊκώτερον, -, - (adverbe)''' : Comparatif de ''ῥωμαϊκῶς''.&lt;br&gt; 
'''ῥωμαϊκώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''ῥωμαϊκός''.&lt;br&gt;
'''ῥωμαϊκώτερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''ῥωμαϊκός''.&lt;br&gt;
'''ῥωμαλέος, -α, -ον (adjectif)''' : fort, robuste (en parlant des personnes) ; solide (en parlant des choses).&lt;br&gt;	
'''ῥωμαλεότης, -τος (nom commun) (f)''' : force, robustesse (en parlant des personnes) ;  solidité (en parlant des choses).&lt;br&gt;
'''ῥώμη, -ης (nom propre) (f)''' : force.&lt;br&gt;   
'''ῥώομαι (verbe)''' : se précipiter, fondre sur.&lt;br&gt;
'''ῥωσικός, -ή, -όν (adjectif)''' : russe.&lt;br&gt;
'''ῥώξ, -γός (nom commun) (m)''' : Forme ionienne de ''ῥάξ''.&lt;br&gt; 
'''ῥῶ (nom commun) (n)''' : rhô.&lt;br&gt;
'''Ῥαάβ (nom propre) (f)''' : Rahab.&lt;br&gt;
'''Ῥα (nom propre) (m)''' : Rê.&lt;br&gt;
'''Ῥᾶ (nom propre) (n)''' : Volga.&lt;br&gt;
'''Ῥαδάμανθυς, -άνθυος (nom propre) (m)''' : Rhadamanthe.&lt;br&gt;
'''Ῥαθούρης, -ου (nom propre) (m)''' : Niouserrê.&lt;br&gt;
'''Ῥαθωτις, -ίδος (nom propre) (m)''' : Toutânkhamon.&lt;br&gt; 
'''Ῥαμέσσης, -ου (nom propre) (m)''' : Ramsès.&lt;br&gt;
'''Ῥαμνοῦς, -ντος (nom propre) (m)''' : Rhamnonte.&lt;br&gt;
'''Ῥαφαήλ (nom propre) (m)''' : Raphaël.&lt;br&gt;
'''Ῥεϐέκκα, -ας (nom propre) (f)''' : Rebecca.&lt;br&gt;
'''Ῥῆνος, -ήνου (nom propre) (m)''' : Rhin.&lt;br&gt; 
'''Ῥίον, -ου (nom propre) (m)''' : Río (ville de Grèce).&lt;br&gt; 
'''Ῥοδανός, -οῦ (nom propre) (m)''' : Rhône.&lt;br&gt;
'''Ῥόδη, -ης (nom propre) (f)''' : Rhodé.&lt;br&gt;
'''Ῥόδιος, - (nom propre) (m)'''  : Rhodien.&lt;br&gt;
'''Ῥοδόπη, -ης (nom propre) (f)''' : Rhodope.&lt;br&gt;
'''Ῥόδος, -ου (nom propre) (f)''' : Rhodes.&lt;br&gt;
'''Ῥούθ (nom propre) (f)''' : Ruth.&lt;br&gt;
'''Ῥοῦφος, -ύφου (nom propre) (m)'''  : Rufus.&lt;br&gt;
'''Ῥωμαῖος, -ίου (nom commun) (m)''' : Romain.&lt;br&gt;
'''Ῥώμη, -ης (nom propre) (f)''' : Rome.&lt;br&gt;
'''Ῥῶμος, -ώμου (nom propre) (m)''' : Rémus.&lt;br&gt;
'''Ῥώμυλος, -ύλου (nom propre) (m)''' : Romulus.&lt;br&gt;
'''Ῥωξάνη, -ης (nom propre) (f)''' : Roxane (Épouse d'Alexandre le Grand.)&lt;br&gt;
'''Ῥωσία, -ας (nom propre) (f)''' : Russie.&lt;br&gt;
'''Ῥωσίς, -δος (nom propre) (f)''' : Russe.&lt;br&gt;
'''Ῥῶς, -ώσος (nom commun) (m)''' : Russe.&lt;br&gt;

==Σ==
'''σάϐϐατον, -άτου (nom commun) (n)''' : shabbat.&lt;br&gt;
'''σαϐϐατισμός, -οῦ (nom commun) (n)''' : sabbatisme.&lt;br&gt;
'''σαδδουκαῖος, -ίου (nom commun) (m)''' : sadducéen.&lt;br&gt;
'''σάγμα, -τος (nom commun) (n)''' : bât.&lt;br&gt;
'''σάκκος, -ου (nom commun) (m)''' : sac.&lt;br&gt;
'''σάκος, -ους (nom commun) (n)''' : bouclier.&lt;br&gt;
'''σάκχαρις, -άρεως (nom commun) (f)''' : sucre.&lt;br&gt;
'''σάλπιγξ, -γoς (nom commun) (f)''' : trompette.&lt;br&gt;
'''σᾶμα, -άματος (nom commun) (n)''' : Forme dorienne de ''σῆμα''.&lt;br&gt;
'''σάμερον (adverbe)''' : Forme dorienne de ''σήμερον''.&lt;br&gt;
'''σάμιος, -ος, -ον (adjectif)''' : samosien.&lt;br&gt;
'''σαμψήρα, -ας (nom commun) (f)''' : cimeterre.&lt;br&gt;
'''σάνδαλον, -άλου (nom commun) (n)''' : sandale.&lt;br&gt;
'''σανίς, -δος (nom commun) (f)''' : planche.&lt;br&gt;
'''σαρδονικός, -ή, -όν (adjectif)''' : sarde.&lt;br&gt;
'''σαρδονικότατος, -άτη, -ότατον (adjectif)''' : Superlatif de ''σαρδονικός''.&lt;br&gt;
'''σαρδονικότερος, -έρα, -ότερον (adjectif)''' : Comparatif de ''σαρδονικός''.&lt;br&gt;
'''σαρδονικότατα, -, - (adverbe)''' : Superlatif de ''σαρδονικῶς''.&lt;br&gt;
'''σαρδονικότερον, -, - (adverbe)''' : Comparatif de ''σαρδονικῶς''.&lt;br&gt;
'''σαρδονικῶς (adverbe)''' : sardoniquement.&lt;br&gt; 
'''σαρκικός, -ή, -όν (adjectif)''' : charnel.&lt;br&gt;
'''σαρκικότατος, -άτη, -ότατον (adjectif)''' : Superlatif de ''σαρκικός''.&lt;br&gt;
'''σαρκικότερος, -έρα, -ότερον (adjectif)''' : Comparatif de ''σαρκικός''.&lt;br&gt;
'''σαρκικότατα, -, - (adverbe)''' : Superlatif de ''σαρκικῶς''.&lt;br&gt;
'''σαρκικότερον, -, - (adverbe)''' : Comparatif de ''σαρκικῶς''.&lt;br&gt;
'''σαρκικῶς (adverbe)''' : charnellement.&lt;br&gt;
'''σάρκινος, -ίνη, -άρκινον (adjectif)''' : charnu.&lt;br&gt;
'''σάρξ, -κός (nom commun) (f)''' : chair.&lt;br&gt;
'''σατυρίασις, -άσεως (nom commun) (f)''' : satyriasis.&lt;br&gt;
'''σατυρικός, -ή, -όν (adjectif)''' : satyrique.&lt;br&gt;
'''σατύριον, -ίου (nom commun) (n)''' : satyrion.&lt;br&gt;
'''σατυρίσκος, -ου (nom commun) (m)''' : satyreau.&lt;br&gt;
'''σάτυρος, -ύρου (nom commun) (m)''' : satyre.&lt;br&gt;
'''σατυρώδης, -ης, -ες (adjectif)''' : satyrode.&lt;br&gt;
'''σαύρα, -ας (nom commun) (f)''' : lézard ; quéquette.&lt;br&gt;
'''σαύρη, -ης (nom commun) (f)''' : Forme ionienne de ''σαύρα''.&lt;br&gt;
'''σαυροματικός, -ή, -όν (adjectif)''' : sarmate.&lt;br&gt;
'''σαυροματικῶς (adverbe)''' : .&lt;br&gt;
'''σαυροματικώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''σαυροματικός''.&lt;br&gt;
'''σαυροματικώτερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''σαυροματικός''.&lt;br&gt;
'''σαῦρος, -ύρου (nom commun) (m)''' : lézard.&lt;br&gt;
'''σάπφειρος, -ίρου (nom commun) (f)''' : saphir.&lt;br&gt;
'''σαφέστερος, -άτη, -έστατον (adjectif)''' : Superlatif de ''σαφής''.&lt;br&gt;
'''σαφέστατος, -έρα, -έσερον (adjectif)''' : Comparatif de ''σαφής''.&lt;br&gt;
'''σαφής, -ής, -ές (adjectif)''' : Clair, évident ; manifeste.&lt;br&gt; 
'''σαφῶς (adverbe)''' : Clairement, évidemment ; manifestement.&lt;br&gt;
'''σεϐάζω (verbe)''' : respecter.&lt;br&gt;
'''σεϐασμός, -οῦ (nom commun) (m)''' : respect.&lt;br&gt;
'''σεϐαστός, -ός, -όν (adjectif)''' : respectable ; respecté.&lt;br&gt;
'''σέϐομαι (verbe)''' : Craindre les dieux. Vénérer.&lt;br&gt;
'''σείριος, -ίου (nom commun) (m)''' : destructeur.&lt;br&gt; 
'''σελάνα, -ας (nom commun) (f)''' : Forme dorienne de ''σελήνη''.&lt;br&gt; 
'''σελάννα, -ας (nom commun) (f)''' : Forme éolienne de ''σελήνη''.&lt;br&gt; 
'''σέλας, -τος (nom commun) (n)''' : Éclat, lumière ; lueur brillante.&lt;br&gt;
'''σελάχιον, -ίου (nom commun) (n)''' : raie (poisson).&lt;br&gt;
'''σέλαχος, -άχους (nom commun) (n)''' : requin.&lt;br&gt;
'''σελήνη, -ης (nom commun) (f)''' : lune.&lt;br&gt; 
'''σεληνιακός, -ή, -όν (adjectif)''' : lunaire.&lt;br&gt;
'''σέλινον, -ίνου (nom commun) (n)''' : céleri.&lt;br&gt;
'''σελίς, -δος (nom commun) (f)''' : page. (Face d'une feuille de papier, de parchemin, de vélin, servant à l'écriture.)&lt;br&gt; 
'''σεμίδαλις, -άλεως (nom commun) (f)''' : semoule.&lt;br&gt;	
'''σεμνός, -ή, -όν (adjectif)''' : modeste.&lt;br&gt;
'''σεμνότατα, -, - (adverbe)''' : Superlatif de ''σεμνῶς''.&lt;br&gt;
'''σεμνότερον, -, - (adverbe)''' : Comparatif de ''σεμνῶς''.&lt;br&gt;
'''σεμνότατος, -άτη, -ότατον (adjectif)''' : Superlatif de ''σεμνός''.&lt;br&gt;
'''σεμνότερος, -έρα, -ότερον (adjectif)''' : Comparatif de ''σεμνός''.&lt;br&gt;
'''σεμνότης, -τος (nom commun) (f)''' : modestie.&lt;br&gt;
'''σεμνῶς (adverbe)''' : modestement.&lt;br&gt;
'''σῆμα, -ήματος (nom commun) (n)''' : signe.&lt;br&gt;
'''σημαντικός -ή -όν (adjectif)''' : significatif.&lt;br&gt;
'''σημαντικῶς (adverbe)''' : significativement.&lt;br&gt;
'''σημαντικώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''σημαντικός''.&lt;br&gt;
'''σημαντικώτερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''σημαντικός''.&lt;br&gt;
'''σημαντικώτατα, -, - (adverbe)''' : Superlatif de ''σημαντικῶς''.&lt;br&gt;
'''σημαντικώτερον, -, - (adverbe)''' : Comparatif de ''σημαντικῶς''.&lt;br&gt; 
'''σημεῖον, -ίου (nom commun) (n)''' : signal.&lt;br&gt;
'''σήμερον (adverbe)''' : aujourd’hui.&lt;br&gt;
'''σημύδα, -ης (nom commun) (f)''' : bouleau.&lt;br&gt;
'''σῆραγξ, -ήραγγος (nom commun) (f)''' : tunnel.&lt;br&gt;
'''σήσαμον, άμου (nom commun) (n)''' : sésame.&lt;br&gt;
'''σής, -τός (nom commun) (m)''' : mite.&lt;br&gt;
'''σητόδοκις, -εως (nom commun) (f)''' : papillon.&lt;br&gt;
'''σῆψις, -ήψεως (nom commun) (f)''' : putréfaction.&lt;br&gt;
'''σιαγών, -όνος (nom commun) (f)''' : mâchoire.&lt;br&gt;
'''σιηγών, -όνος (nom commun) (f)''' : Forme ionienne de ''σιαγών''.&lt;br&gt;
'''σῖγμα (nom commun) (n)''' : sigma.&lt;br&gt;
'''σικάριος, -ίου (nom commun) (m)''' : assassin.&lt;br&gt;
'''σικελικός, -ή, -όν (adjectif)''' : sicilien.&lt;br&gt;
'''σικυός, -οῦ (nom commun) (m)''' : concombre.&lt;br&gt;
'''σικυώνιος, -ος, -ον (adjectif)''' : .&lt;br&gt;
'''σίλφιον, -ίου (nom commun) (n)''' : silphium.&lt;br&gt;
'''σιμός, -ή, -όν (adjectif)''' : Camus ; montant.&lt;br&gt;
'''σιμῶ (verbe)''' : lever le nez.&lt;br&gt;
'''σίναπι, -άπεως (nom commun) (n)''' : moutarde (plante).&lt;br&gt;
'''σιός, -οῦ (nom commun) (m)''' : Forme laconienne de ''θεός''.&lt;br&gt;
'''σίσυς, -ος (nom commun) (m)''' : fourrure.&lt;br&gt;
'''-σις, -εως (suffixe) (f)''' : Suffixe formant des noms d'action.&lt;br&gt;
'''σῖτος, -ίτου (nom commun) (m)''' : Grain, à la fois le blé et l'orge. (Par extension) Toute nourriture végétale (par opposition à la viande ou la boisson). Pension alimentaire. (Droit athénien) Distribution de blé aux indigents.&lt;br&gt;
'''σιωπή, -ῆς (nom commun) (f)''' : calme, silence.&lt;br&gt;
'''σιωπηρός, -ός, -όν (adjectif)''' : silencieux, tacite.&lt;br&gt;
'''σιωπηρότατος, -άτη, -ότατον (adjectif)''' : Superlatif de ''σαρκικός''.&lt;br&gt;
'''σιωπηρότερος, -έρα, -ότερον (adjectif)''' : Comparatif de ''σαρκικός''.&lt;br&gt;
'''σιωπηρότατα, -, - (adverbe)''' : Superlatif de ''σαρκικῶς''.&lt;br&gt;
'''σιωπηρότερον, -, - (adverbe)''' : Comparatif de ''σαρκικῶς''.&lt;br&gt;
'''σιωπηρῶς (adverbe)''' : tacitement.&lt;br&gt;
'''σιωπηρότης, -τος (nom commun) (f)''' : tacité.&lt;br&gt;
'''σιωπῶ (verbe)''' : se taire.&lt;br&gt;
'''σκαιός, -ά, -όν (adjectif)''' : qui est à gauche.&lt;br&gt; 
'''σκάνδαλον, -άλου (nom commun) (n)''' : Piège placé sur le chemin.&lt;br&gt;
'''σκανδάληθρον, -ήθρου (nom commun) (n)''' : .&lt;br&gt; 
'''σκανδαλίζω (verbe)''' : Placer un piège sur le chemin.&lt;br&gt; 
'''σκαπανεύς, -έως (nom commun) (m)''' : .&lt;br&gt;
'''σκαπάνη, -ης (nom commun) (f)''' : .&lt;br&gt;
'''σκᾶπτρον, -άπτρου (nom commun) (n)''' : Forme dorienne de ''σκῆπτρον''.&lt;br&gt;
'''σκάπτω (verbe)''' : creuser.&lt;br&gt; 
'''σκεδάννυμι (verbe)''' : disperser, répandre.&lt;br&gt;
'''σκέλος, -ους (nom commun) (n)''' : (Anatomie) Jambe de l’homme et des animaux. (Au pluriel) Les murs (entre Athènes et le Pirée, entre Mégare et Nisæa).&lt;br&gt;
'''σκεπτικός, -ή, -όν (adjectif)''' : observateur.&lt;br&gt;
'''σκεπτικῶς (adverbe)''' : sceptiquement.&lt;br&gt;
'''σκεπτικώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''σκεπτικός''.&lt;br&gt;
'''σκεπτικώτερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''σκεπτικός''.&lt;br&gt;
'''σκέπτομαι (verbe)''' : Considérer ; examiner avec soin.&lt;br&gt;
'''σκευαρίδιον, -ίου (nom commun) (n)''' : .&lt;br&gt;
'''σκευάριον, -ίου (nom commun) (n)''' : .&lt;br&gt;
'''σκευωρία, -ας (nom commun) (f)''' : machination.&lt;br&gt;
'''σκεῦος, -ύους (nom commun) (n)''' : ustensile.&lt;br&gt; 
'''σκέψις, -εως (nom commun) (f)''' : pensée. (opération de l’intelligence.)&lt;br&gt; 
'''σκηπτός, -οῦ (nom commun) (m)''' : ouragan.&lt;br&gt; 
'''σκῆπτρον, -ήπτρου (nom commun) (n)''' : Étai, sceptre.&lt;br&gt;
'''σκήπτω (verbe)''' : Étayer, soutenir. Brandir.&lt;br&gt;
'''σκίουρος, -ύρου (nom commun) (m)''' : écureuil.&lt;br&gt; 
'''σκολιός, -ά, -όν (adjectif)''' : tordu.&lt;br&gt;
'''σκολόπαξ, -άκος (nom commun) (m)''' : bécasse.&lt;br&gt; 
'''σκολόπενδρα, -ένδρας (nom commun) (f)''' : scolopendre.&lt;br&gt;
'''σκολοπένδριον, -ίου (nom commun) (n)''' : Diminutif de ''σκολόπενδρα''.&lt;br&gt; 
'''σκόλοψ, -πος (nom commun) (m)''' : écharde.&lt;br&gt; 
'''σκόπελος, -έλου (nom commun) (m)''' : écueil.&lt;br&gt; 
'''σκοπῶ (verbe)''' : observer.&lt;br&gt;
'''σκόροδον, -όδου (nom commun) (n)''' : ail.&lt;br&gt;
'''σκορπιός, -οῦ (nom commun) (m)''' : scorpion.&lt;br&gt; 
'''σκοτεινός, -ή, -όν (adjectif)''' : obscur.&lt;br&gt;
'''σκοτεινῶς (adverbe)''' : obscurément.&lt;br&gt;
'''σκοτεινώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''σκοτεινός''.&lt;br&gt;
'''σκοτεινώτερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''σκοτεινός''.&lt;br&gt;
'''σκότιος, -ία, -ότιον (adjectif)''' : bâtard.&lt;br&gt;
'''σκότος, -ου (nom commun) (m)''' : obscurité.&lt;br&gt; 
'''σκυθικός, -ή, -όν (adjectif)''' : scythe.&lt;br&gt;
'''σκυθικῶς (adverbe)''' : .&lt;br&gt;
'''σκυθικώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''σκυθικός''.&lt;br&gt;
'''σκυθικώτερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''σκυθικός''.&lt;br&gt;
'''σκύλαξ, -κος (nom commun) (m)''' : chiot.&lt;br&gt; 
'''σκυλεύω (verbe)''' : dépouiller.&lt;br&gt; 
'''σκύλλω (verbe)''' : Déchirer, troubler.&lt;br&gt; 
'''σκῦλον, -ύλου (nom commun) (n)''' : butin.&lt;br&gt;  
'''σκῦτος, -ύτου (nom commun) (m)''' : .&lt;br&gt; 
'''σκώληξ, -κος (nom commun) (m)''' : ver.&lt;br&gt; 
'''σκῶμμα, -ώμματος (nom commun) (n)''' : .&lt;br&gt; 
'''σκωραμίς, -δος (nom commun) (f)''' : pot de chambre.&lt;br&gt;
'''σκωρία, -ας (nom commun) (f)''' : scorie.&lt;br&gt;
'''σκῶρ, -ατός (nom commun) (n)''' : excrément.&lt;br&gt;
'''σκώψ, -πός  (nom commun) (m)''' : hibou.&lt;br&gt;
'''σμάραγδος, -άγδου (nom commun) (f)''' : émeraude.&lt;br&gt;
'''σμάω (verbe)''' : frotter, nettoyer.&lt;br&gt;
'''σμῆγμα, -ήγματος (nom commun) (n)''' : savon, détergent ; onguent.&lt;br&gt;
'''σμήχω (verbe)''' : essuyer.&lt;br&gt;
'''σμῖλαξ, -ίλακος (nom commun) (f)''' : if.&lt;br&gt;
'''σμίλη, -ης (nom commun) (f)''' : Ciseau. Bistouri, lancette.&lt;br&gt;
'''σμύραινα, -ίνης (nom commun) (f)''' : murène.&lt;br&gt;
'''σμῶδιξ, -ώδιγγος (nom commun) (f)''' : contusion.&lt;br&gt;
'''σμώχω (verbe)''' : frotter.&lt;br&gt;
'''σοϐαρός, -ή, -όν (adjectif)''' : Effrayant. Fuyant, rapide. Hautain, dédaigneux ; pompeux.&lt;br&gt; 
'''σοϐαρῶς (adverbe)''' : Effrayamment, rapidement. Hautainement, dédaigneusement ; pompeusement.&lt;br&gt;
'''σοϐαρώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''σοϐαρός''.&lt;br&gt;
'''σοϐαρώτερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''σοϐαρός''.&lt;br&gt;
'''σοϐῶ (verbe)''' : Chasser, effrayer les oiseaux. Bouger rapidement.&lt;br&gt;
'''σαπρός, -ή, -όν (adjectif)''' : Pourri, putride&lt;br&gt; 
'''σαπρότατος, -άτη, -ότατον (adjectif)''' : Superlatif de ''σαπρός''.&lt;br&gt;
'''σαπρότερος, -έρα, -ότερον (adjectif)''' : Comparatif de ''σαπρός''.&lt;br&gt;
'''σαπρῶς (adverbe)''' : putridement.&lt;br&gt;
'''σός, -ή, -όν (adjectif possessif)''' : ton.&lt;br&gt;
'''σοφία, -ας (nom commun) (f)''' : sagesse.&lt;br&gt;
'''σοφίη, -ης (nom commun) (f)''' : Forme ionienne de ''σοφία''.&lt;br&gt;
'''σοφός, -ή, -όν (adjectif)''' : Habile. (En parlant de l’intelligence ou du caractère) Prudent, sage. (En particulier) Initié à la sagesse. Ingénieux, fin, rusé.&lt;br&gt; 
'''σοφῶς (adverbe)''' : Habilement, sagement. Ingénieusement, finement.&lt;br&gt;
'''σοφώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''σοφός''.&lt;br&gt;
'''σοφώτερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''σοφός''.&lt;br&gt;
'''σπαδωνισμός, -οῦ (nom commun) (m)''' : castration.&lt;br&gt;
'''σπάδων, -ος (nom commun) (m)''' : castrat ; eunuque.&lt;br&gt;
'''σπάθη, -ης (nom commun) (f)''' : épée.&lt;br&gt;
'''σπαθίον, -ου (nom commun) (m)''' : Diminutif de ''σπάθη''.&lt;br&gt;  
'''σπανακόν, -οῦ (nom commun) (n)''' : épinard.&lt;br&gt;
'''σπάναξ, -κος (nom commun) (m)''' : épinard.&lt;br&gt;
'''σπάνιος, -ία, -ιον (adjectif)''' : rare.&lt;br&gt; 
'''σπανίως (adverbe)''' : rarement.&lt;br&gt;
'''σπανιώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''σπάνιος''.&lt;br&gt;
'''σπανιώτερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''σπάνιος''.&lt;br&gt;
'''σπαργάνιον, -ίου (nom commun) (n)''' : rubanier.&lt;br&gt;
'''σπάργανον, -άνου (nom commun) (n)''' : lange.&lt;br&gt; 
'''σπάργω (verbe)''' : langer.&lt;br&gt; 
'''σπαρτιατικός, -ή, -όν (adjectif)''' : spartiate.&lt;br&gt; 
'''σπασμός, -οῦ (nom commun) (m)''' : spasme.&lt;br&gt; 
'''σπαστικός, -ή, -όν (adjectif)''' : .&lt;br&gt; 
'''σπάω (verbe)''' : briser.&lt;br&gt; 
'''σπεῖρα, -ίρας (nom commun) (f)''' : spire.&lt;br&gt; 
'''σπεῖρον, -ίρου (nom commun) (n)''' : .&lt;br&gt; 
'''σπέος, -ους (nom commun) (n)''' : grotte.&lt;br&gt;
'''σπεύδω (verbe)''' : se hâter.&lt;br&gt;
'''σπήλαιον, -ίου (nom commun) (n)''' : caverne, grotte ; cavité.&lt;br&gt;
'''σπῆλυγξ, -ήλυγγος (nom commun) (m)''' : caverne, antre ; grotte.&lt;br&gt;
'''σπογγιά, -ᾶς (nom commun) (f)''' : éponge.&lt;br&gt; 
'''σπόγγος, -ου (nom commun) (m)''' : éponge ; (anatomie) amygdale.&lt;br&gt; 
'''σποδός, -οῦ (nom commun) (m)''' : cendre.&lt;br&gt; 
'''σπολεύς, -έως (nom commun) (m)''' : sorte de pain.&lt;br&gt; 
'''σπονδεῖος, -ίου (nom commun) (m)''' : spondée.&lt;br&gt;  
'''σπόνδυλος, -ύλου (nom commun) (m)''' : Forme attique de ''σφόνδυλος''.&lt;br&gt;
'''σπουδαῖος, -ία, -ῖον (adjectif)''' : important.&lt;br&gt;  
'''σπουδή, -ῆς (nom commun) (f)''' : hâte.&lt;br&gt;
'''στάδιον, -ου (nom commun) (n)''' : stade. (env. 180 m)&lt;br&gt;
'''σταγών, -όνος (nom commun) (f)''' : goutte.&lt;br&gt;	
'''στάζω (verbe)''' : couler goutte à goutte.&lt;br&gt;
'''σταθερός, -ή, -όν (adjectif)''' : fixe, constant, ferme.&lt;br&gt;
'''στακτός, -οῦ (nom commun) (m)''' : cendre.&lt;br&gt; 
'''στάλα, -ας (nom commun) (f)''' : Forme dorienne de ''στήλη''.&lt;br&gt;
'''στάλαγμα, -άγματος (nom commun) (n)''' : goutte.&lt;br&gt;
'''σταλαγμός, -οῦ (nom commun) (m)''' : écoulement, égouttage.&lt;br&gt;
'''σταλάσσω (verbe)''' : tomber, couler.&lt;br&gt;
'''στάλλα, -ας (nom commun) (f)''' : Forme éolienne de ''στήλη''.&lt;br&gt;
'''στάσις, -εως (nom commun) (f)''' : .&lt;br&gt;
'''σταυρός, -οῦ (nom commun) (m)''' : croix.&lt;br&gt;
'''σταυρόω (verbe)''' : crucifier.&lt;br&gt;
'''σταύρωσις, -ώσεως (nom commun) (f)''' : crucifixion.&lt;br&gt;
'''σταφυλή, -ῆς (nom commun) (f)''' : grappe de raisin mûr.&lt;br&gt;
'''σταφυλίς, -δος (nom commun) (f)''' : luette.&lt;br&gt;
'''στέαρ, -ατος (nom commun) (n)''' : Graisse compacte ; lard ; suif. Graisse.&lt;br&gt;
'''στεατοπυγός, -ός, -όν (adjectif)''' : Qui a de grosses fesses.&lt;br&gt;
'''στέγασις, -άσεως (nom commun) (f)''' : accommodation.&lt;br&gt;
'''στέγος, -ους (nom commun) (n)''' : Abri. Toit. Maison. Tombeau. Urne funéraire.&lt;br&gt;
'''στέγω (verbe)''' : Couvrir. Supporter, résister.&lt;br&gt;
'''στεῖρος, -ίρα, -ῖρον (adjectif)''' : stérile.&lt;br&gt;
'''στειρότατος, -άτη, -ότατον (adjectif)''' : Superlatif de ''στεῖρος''.&lt;br&gt;
'''στειρότερος, -έρα, -ότερον (adjectif)''' : Comparatif de ''στεῖρος''.&lt;br&gt;
'''στείρως (adverbe)''' : stérilement.&lt;br&gt;
'''στελεά, -ᾶς (nom commun) (f)''' : axe, pôle.&lt;br&gt;
'''στελεόν, -οῦ (nom commun) (n)''' : manche.&lt;br&gt;
'''στέλεχος, -έχους (nom commun) (n)''' : .&lt;br&gt;
'''στέλλω (verbe)''' : .&lt;br&gt;
'''στέμμα, -τος (nom commun) (n)''' : guirlande.&lt;br&gt;	
'''στεμματηφορῶ (verbe)''' : .&lt;br&gt;	
'''στεμματιαῖον, -ίου (nom commun) (n)''' : .&lt;br&gt;		
'''στεμματία, -ας (nom commun) (f)''' : .&lt;br&gt;	
'''στεμματοφορία, -ας (nom commun) (n)''' : .&lt;br&gt;	
'''στεμματοφόρος, -ό, -όν (adjectif)''' : étroit, resserré.&lt;br&gt;	
'''στεμματῶ (verbe)''' : .&lt;br&gt;	
'''στενός, -ή, -όν (adjectif)''' : étroit, resserré.&lt;br&gt;
'''στενῶς (adverbe)''' : étroitement.&lt;br&gt;
'''στενώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''στενός''.&lt;br&gt;
'''στενώτερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''στενός''.&lt;br&gt;
'''στερεός, -ά, -όν (adjectif)''' : ferme, dur.&lt;br&gt; 
'''στερέωμα, -ώματος (nom commun) (n)''' : firmament.&lt;br&gt;
'''στερεῶς (adverbe)''' : fermement, durement.&lt;br&gt;
'''στερεώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''στερεός''.&lt;br&gt;
'''στερεώτερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''στερεός''.&lt;br&gt;
'''στερεῶ (verbe)''' : .&lt;br&gt;
'''στέφανος, -άνου (nom commun) (m)''' : cercle d'une armée sur un champ de bataille. Couronne.&lt;br&gt;
'''στέφω (verbe)''' : couronner.&lt;br&gt;
'''στηθόδεσμος -ου (nom commun) (m)''' : .&lt;br&gt;
'''στῆθος, -ήθους (nom commun)''' : poitrine.&lt;br&gt; 
'''στήλη, -ης (nom commun) (f)''' : stèle.&lt;br&gt;
'''στήνιον, -ίου (nom commun) (n)''' : sein.&lt;br&gt; 
'''στιϐάς, -δος (nom commun) (f)''' : .&lt;br&gt;
'''στίϐι, -τος (nom commun) (n)''' : antimoine.&lt;br&gt; 
'''στιγμή, -ῆς (nom commun) (f)''' : moment.&lt;br&gt;
'''στοργή, -ῆς (nom commun) (f)''' : amour familial.&lt;br&gt;
'''στοιχεῖον, -ίου (nom commun) (n)''' : élément.&lt;br&gt; 
'''στοιχειωδέστατος, -άτη, -έστατον (adjectif)''' : Superlatif de ''στοιχειώδης''.&lt;br&gt;
'''στοιχειωδέστερος, -έρη, -έστερον (adjectif)''' : Comparatif de ''στοιχειώδης''.&lt;br&gt;
'''στοιχειώδης, -ης, -ῶδες (m)''' : élémentaire.&lt;br&gt;
'''στοιχειωδῶς (adverbe)''' : élémentairement.&lt;br&gt;
'''στολίζω (verbe)''' : .&lt;br&gt;
'''στόμα, -τος (nom commun) (n)''' : bouche.&lt;br&gt;
'''στομάχιον, -ίου (nom commun) (n)''' : estomac.&lt;br&gt;
'''στώμυλμα, -τος (nom commun) (n)''' : bavard.&lt;br&gt;
'''στοχάζομαι (verbe)''' : Conjecturer. Viser.&lt;br&gt;
'''στοχαστής, -οῦ (nom commun) (m)''' : Conjectureur, penseur.&lt;br&gt;
'''στοχαστικός, -ή, -όν (adjectif)''' : Qui vise bien, qui tend directement vers. Habile à conjecturer, conjectural.&lt;br&gt;
'''στοχαστικῶς (adverbe)''' : conjecturalement.&lt;br&gt;
'''στοχαστικώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''στοχαστικός''.&lt;br&gt;
'''στοχαστικώτερος, -έρη, -ώτερον (adjectif)''' : Comparatif de ''στοχαστικός''.&lt;br&gt;
'''στόχος, Cible, but, point visé. Conjecture.&lt;br&gt;
'''στορέννυμι (verbe)''' : étendre, recouvrir.&lt;br&gt; 
'''στραγγαλίζω (verbe)''' : étrangler.&lt;br&gt;
'''στραγγαλίς, -δος (nom commun) (f)''' : nœud.&lt;br&gt;
'''στραγγαλοῦμαι (verbe)''' : tordre.&lt;br&gt;
'''στραγγίζω (verbe)''' : essorer.&lt;br&gt;
'''στραγγουρία, -ας (nom commun) (f)''' : strangurie.&lt;br&gt;
'''στράγξ, -γός (nom commun) (f)''' : goutte.&lt;br&gt;
'''στρατός, -οῦ (nom commun) (m)''' : armée.&lt;br&gt;
'''στρατηγός, -οῦ (nom commun) (m)''' : général.&lt;br&gt;
'''στραταγός, -οῦ (nom commun) (m)''' : Forme arcadienne et dorienne de ''στρατηγός''.&lt;br&gt; 
'''στρατήγημα, -ήματος (nom commun) (n)''' : stratagème.&lt;br&gt;
'''στρατηγία, -ας (nom commun) (f)''' : stratégie.&lt;br&gt;
'''στρέμμα, -τος (nom commun) (n)''' : Tournure ; rouleau. Conspiration.&lt;br&gt;
'''στρεπτικός, -ή, -όν (adjectif)''' : .&lt;br&gt;
'''στρεπτικῶς (adverbe)''' : .&lt;br&gt;
'''στρεπτικώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''στρεπτικός''.&lt;br&gt;
'''στρεπτικώτερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''στρεπτικός''.&lt;br&gt;
'''στρεπτικώτατα, -, - (adverbe)''' : Superlatif de ''στρεπτικῶς''.&lt;br&gt;
'''στρεπτικώτερον, -, - (adverbe)''' : Comparatif de ''στρεπτικῶς''.&lt;br&gt; 
'''στρεπτός, -ή, -όν (adjectif)''' : Tourné ; docile.&lt;br&gt;
'''στρεπτῶς (adverbe)''' : docilement.&lt;br&gt;
'''στρεπτώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''στρεπτός''.&lt;br&gt;
'''στρεπτώτερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''στρεπτός''.&lt;br&gt;
'''στρέφω (verbe)''' : Tourner, retourner.&lt;br&gt;
'''στρέψις, -εως (nom commun) (f)''' : .&lt;br&gt;
'''στρίζω (verbe)''' : strider.&lt;br&gt;
'''στρίξ, -γός (nom commun) (f)''' : chouette.&lt;br&gt;
'''στρόταγος, -άγου (nom commun) (m)''' : Forme éolienne de ''στρατηγός''.&lt;br&gt; 
'''στρατιώτης, -ου (nom commun) (m)''' : soldat.&lt;br&gt; 
'''στρόϐιλος, -ίλου (nom commun) (m)''' : Ce qui tourne ou tournoie. Toupie. Tourbillon, ouragan. Objet divers en spirale ou de forme conique. Pomme de pin ou fruit des arbres résineux. Coquillage en spirale. Enroulement du hérisson sur lui-même. Qui tournoie en spirale.&lt;br&gt; 
'''στροϐιλόω (verbe)''' : tourner.&lt;br&gt;
'''στραγγός, -ή, -όν (adjectif)''' tordu.&lt;br&gt;
'''στρογγύλλω (verbe)''' : arrondir.&lt;br&gt;
'''στρογγύλος, -η, -ον (adjectif)''' : arrondi.&lt;br&gt;
'''στρογγυλότης, -τος (nom commun) (f)''' : rondeur.&lt;br&gt;
'''στρουθιοκάμηλος, -ήλου (nom commun) (m)''' : autruche.&lt;br&gt; 
'''στρουθίον, -ου (nom commun) (n)''' : moineau.&lt;br&gt;
'''στροφή, -ῆς (nom commun) (f)''' : tour.&lt;br&gt;
'''στρόφιγξ, -γος (nom commun) (m)''' : charnière.&lt;br&gt; 
'''στρόφιον, -ίου (nom commun) (n)''' : strophium.&lt;br&gt; 
'''στρόφος, -ου (nom commun) (m)''' : corde.&lt;br&gt; 
'''στύφω (verbe)''' : contracter.&lt;br&gt; 
'''στῦψις, -ύψεως (nom commun) (f)''' : contraction.&lt;br&gt; 
'''στρῶμα, -ώματος (nom commun) (n)''' : matelas.&lt;br&gt; 
'''στρώννυμι (verbe)''' : .&lt;br&gt; 
'''στυγερός, -ά, -όν (adjectif)''' : horrible.&lt;br&gt; 
'''στυγερώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''στυγερός''.&lt;br&gt;
'''στυγερώτερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''στυγερός''.&lt;br&gt;
'''στυγερῶς (adverbe)''' : horriblement.&lt;br&gt;
'''στῦλος, -ύλου (nom commun) (m)''' : Pilier, colonne.&lt;br&gt; 
'''στῦσις, -ύσεως (nom commun) (f)''' : érection (action physiologique).&lt;br&gt; 
'''στύω (verbe)''' : avoir une érection.&lt;br&gt; 
'''συγάτηρ, -τρός (nom commun) (f)''' : Forme dorienne de ''θυγάτηρ''.&lt;br&gt;
'''συγγνώμη, -ης (nom commun) (f)''' : .&lt;br&gt;
'''συγγιγνώσκω (verbe)''' : .&lt;br&gt;
'''συγκέντρωσις, -ώσεως (nom commun) (f)''' : concentration.&lt;br&gt; 
'''συγκεντρῶ (verbe)''' : concentrer.&lt;br&gt; 
'''συγκεράννυμι (verbe)''' : .&lt;br&gt;
'''συγκρητισμός, -οῦ (nom commun) (m)''' : .&lt;br&gt;  
'''συγκινῶ (verbe)''' : émouvoir.&lt;br&gt; 
'''συγκίνησις, -ήσεως (nom commun) (f)''' : émotion.&lt;br&gt;
'''συγκινητικός, -ή, -όν (adjectif)''' : émouvant.&lt;br&gt;
'''συγκρίνω (verbe)''' : comparer.&lt;br&gt; 
'''σύγκρισις, -ίσεως (nom commun) (f)''' : comparaison.&lt;br&gt;
'''συγκριτικός, -ή, -όν (adjectif)''' : comparatif.&lt;br&gt;
'''σύγκρουσις, -ύσεως (nom commun) (f)''' : collision.&lt;br&gt;
'''συγχώρησις, -εως (nom commun) (f)''' : .&lt;br&gt;
'''συγχωρητέος, -α, -ον (adjectif)''' : .&lt;br&gt;
'''συζήτησις, -ήσεως (nom commun) (f)''' : discussion, conversation ; débat.&lt;br&gt;
'''συζητῶ (verbe)''' : discuter, converser ; débattre.&lt;br&gt;
'''σῦκον, -ύκου (nom commun) (n)''' : Figue ; vulve.&lt;br&gt;
'''συκοφάντης, -ου (nom commun) (m)''' : Délateur, calomniateur. Chicaneur de mauvaise foi.&lt;br&gt; 
'''σύκχος, -ους (nom commun) (n)''' : pantoufle.&lt;br&gt;
'''συλάω (verbe)''' : Saisir, prendre ; emporter. Dépouiller, prendre les armes de son ennemi mort. Piller.&lt;br&gt;
'''σύλη, -ης (nom commun) (f)''' : Prise ; saisie.&lt;br&gt;
'''σύλησις, -ήσεως (nom commun) (f)''' : profanation.&lt;br&gt;
'''σύλον, -ου (nom commun) (n)''' : Forme attique de ''ξύλον''.&lt;br&gt;
'''συλλαμϐάνω (verbe)''' : .&lt;br&gt;
'''σύλληψις, -ήψεως (nom commun) (f)''' : Action de prendre ensemble. Compréhension. Réunion par prononciation de deux voyelles. Action de s’emparer, de saisir. Conception dans le sein de la mère. Assistance, secours.&lt;br&gt;
'''συμϐάλλω (verbe)''' : .&lt;br&gt;
'''σύμϐασις, -άσεως (nom commun) (f)''' : convention.&lt;br&gt;
'''συμϐίωσις, -ώσεως (nom commun) (f)''' : vie commune.&lt;br&gt;
'''συμϐιῶ (verbe)''' : vivre ensemble.&lt;br&gt;
'''συμϐόλαιον, -ίου (nom commun) (n)''' : contrat.&lt;br&gt;
'''συμϐολικός, -ή, -όν (adjectif)''' : relatif aux signes de reconnaissance.&lt;br&gt;
'''σύμϐολον, -όλου (nom commun) (n)''' : signe de reconnaissance.&lt;br&gt;
'''συμμετρία, -ας (nom commun) (f)''' : bonne proportion.&lt;br&gt;
'''συμπάθεια, -ίας (nom commun) (f)''' : Communauté de sentiments ou d’impressions. (Philosophie), (Terme stoïcien) Rapport de certaines choses entre elles.&lt;br&gt;
'''συμπεραίνω (verbe)''' : accomplir, finir, trancher, décider.&lt;br&gt;
'''συμπέρασμα, -άσματος (nom commun) (n)''' : conclusion.&lt;br&gt;
'''συμπερασματικός, -ή, -όν (adjectif)''' : conclusif.&lt;br&gt; 
'''συμπερασματικῶς (adverbe)''' : conclusivement.&lt;br&gt;
'''συμπεριφέρομαι (verbe)''' : se comporter.&lt;br&gt;
'''συμπεριφορά, -ᾶς (nom commun) (f)''' : comportement.&lt;br&gt;
'''συμπεριφορικός, -ή, -όν (adjectif)''' : comportemental.&lt;br&gt;
'''συμπεριφορισμός, -οῦ (nom commun) (m)''' : comportementalisme.&lt;br&gt;
'''συμπεριφοριστής, -οῦ (nom commun) (m)''' : comportementaliste.&lt;br&gt;
'''συμπίνω (verbe)''' : festoyer.&lt;br&gt;
'''συμπονῶ (verbe)''' : compatir.&lt;br&gt;
'''συμπόσιον, -ίου (nom commun) (n)''' : Banquet, festin. (Collectif) Les convives. Salle de festin.&lt;br&gt;
'''σύμπτωμα, -ώματος (nom commun) (n)''' : Accident, malchance ; symptôme.&lt;br&gt;
'''σύμπτωσις, -ώσεως (nom commun) (f)''' : coïncidence.&lt;br&gt;
'''συμπίπτω (verbe)''' : coïncider.&lt;br&gt;
'''συμφορά, -ᾶς (nom commun) (f)''' : désastre.&lt;br&gt;
'''συμφοράζω (verbe)''' : .&lt;br&gt;
'''συμφοραίνω (verbe)''' : .&lt;br&gt;
'''συμφορηδόν, -οῦ (nom commun) (n)''' : .&lt;br&gt;
'''συμφόρημα, -ήματος (nom commun) (n)''' : .&lt;br&gt;
'''συμφόρησις, -ήσεως (nom commun) (f)''' : congestion.&lt;br&gt;
'''συμφορή, -ῆς (nom commun) (f)''' : Forme ionienne de ''συμφορά''.&lt;br&gt;
'''συμφέρω (verbe)''' : accumuler.&lt;br&gt;
'''συμφύρομαι (verbe)''' : .&lt;br&gt;
'''σύμφυσις, -εως (nom commun) (f)''' : symphyse.&lt;br&gt;
'''σύμφωνον, -ώνου (nom commun) (n)''' : consonne.&lt;br&gt;
'''συναγωγή, -ῆς (nom commun) (f)''' : Rassemblement, assemblée de gens. Rassemblement, regroupement, mis en tas, etc., de choses.&lt;br&gt;
'''συνάγω (verbe)''' : rassembler.&lt;br&gt;
'''συναίσθημα, -ήματος (nom commun) (n)''' : émotion.&lt;br&gt;
'''συναισθάνομαι (verbe)''' : .&lt;br&gt;
'''σύν (préposition)''' : Avec, à côté de.&lt;br&gt; 
'''σύν- (préfixe)''' (Devient ''σύγ-'' devant ''γ'', ''κ'', ''ξ'', ''χ'' ; ''σύλ-'' devant ''λ'' ; ''σύμ-'' devant ''β'', ''π'', ''φ'', ''μ'', ''ψ''.) : syn-.&lt;br&gt; 
'''σύναψις, -άψεως (nom commun) (f)''' : connexion.&lt;br&gt; 
'''συνάπτω (verbe)''' : connecter.&lt;br&gt; 
'''συνέδριον, -ίου (nom commun) (n)''' : conseil, congrégation.&lt;br&gt;
'''σύνεδρος, -έδρου (nom commun) (n)''' : conseiller, congrégationniste.&lt;br&gt;
'''συνείδησις, -ήσεως (nom commun) (f)''' : conscience.&lt;br&gt; 
'''συνεργάτης, -ου (nom commun) (m)''' : collaborateur.&lt;br&gt;
'''σύνεσις, -έσεως (nom commun) (f)''' : connexion.&lt;br&gt; 
'''συνίημι (verbe)''' : rejoindre.&lt;br&gt; 
'''συνίστημι (verbe)''' : .&lt;br&gt; 
'''συνουσία, -ας (nom commun) (f)''' : copulation.&lt;br&gt; 
'''συνουσιάζω  (verbe)''' : copuler.&lt;br&gt;
'''σύνοψις, -όψεως (nom commun) (f)''' : Vue d'ensemble. Coup d'œil général. Table des matières. (Figuré) Examen.&lt;br&gt;
'''σύνταγμα, -άγματος (nom commun) (n)''' : constitution.&lt;br&gt;
'''συνταγματικός, -ή, -όν (adjectif)''' : constitutionnel.&lt;br&gt; 
'''συνταγματικότατα, -, - (adverbe)''' : Superlatif de ''συνταγματικῶς''.&lt;br&gt;
'''συνταγματικότερον, -, - (adverbe)''' : Comparatif de ''συνταγματικῶς''.&lt;br&gt;
'''συνταγματικότης, -τος (nom commun) (f)''' : constitutionnalité.&lt;br&gt;
'''συνταγματικώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''συνταγματικός''.&lt;br&gt;
'''συνταγματικώτερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''συνταγματικός''.&lt;br&gt;
'''συνταγματικῶς (adverbe)''' : constitutionnellement.&lt;br&gt; 
'''σύνταξις, -άξεως (nom commun) (f)''' : mise en ordre.&lt;br&gt; 
'''συντάσσω (verbe)''' : mettre en ordre.&lt;br&gt; 
'''συνύπαρξις, -άρξεως (nom commun) (f)''' : coexistence.&lt;br&gt;
'''συνυπάρχω (verbe)''' : coexister.&lt;br&gt;  
'''συνωμοσία, -ας (nom commun) (f)''' : conspiration.&lt;br&gt;
'''συνωμότης, -ου (nom commun) (m)''' : conspirateur.&lt;br&gt; 
'''συνωμότρια, -ας (nom commun) (f)''' : conspiratrice.&lt;br&gt; 
'''συνωμοτῶ  (verbe)''' : conspirer.&lt;br&gt; 
'''σῦριγξ, -ύριγγος (nom commun) (f)''' : Roseau. (Musique) Flûte de Pan.&lt;br&gt;
'''συριστί (adverbe)''' : .&lt;br&gt; 
'''σύρξ, -κός (nom commun) (f)''' : Forme éolienne de ''σάρξ''.&lt;br&gt;
'''σύρραξις, -άξεως (nom commun) (f)''' : .&lt;br&gt;
'''συρτός, -οῦ (nom commun) (m)''' : tiroir.&lt;br&gt; 
'''συσκευή, -ῆς (nom commun) (f)''' : appareil.&lt;br&gt;
'''συσσώρευσις, -ύσεως (nom commun) (f)''' : accumulation.&lt;br&gt;
'''σύσταμα, -άματος (nom commun) (n)''' : Forme dorienne de ''σύστημα''.&lt;br&gt;
'''συστέλλω (verbe)''' : Resserrer, contracter. Réprimer.&lt;br&gt;
'''σύστημα, -ήματος (nom commun) (n)''' : Réunion en un unique corps.&lt;br&gt;  
'''συστολή, -ῆς (nom commun) (f)''' : Resserrement, contraction. Répression.&lt;br&gt;
'''σύ (pronom personnel)''' : tu.&lt;br&gt;
'''σφαγεύς, -έως (nom commun) (m)''' : tueur.&lt;br&gt;
'''σφαγή, -ῆς (nom commun) (f)''' : abattage.&lt;br&gt;
'''σφάζω (verbe)''' : tuer, sacrifier.&lt;br&gt;
'''σφαῖρα, -ίρας (nom commun) (f)''' : Balle, ballon ; globe.&lt;br&gt; 
'''σφάκελος, -έλου (nom commun) (m)''' : nécrose.&lt;br&gt;
'''σφάλλω (verbe)''' : Faire tomber. faire chuter ; renverser. Défaire, avoir le dessus. Avoir lieu (bien ou mal tomber). Tromper, abuser. (Au passif) Se tromper, fauter. Emballer, rouler.&lt;br&gt; 
'''σφάλμα, -τος (nom commun) (n)''' : Chute, faux pas. Erreur. Perte.&lt;br&gt;
'''σφεδανός, -ή, -όν (adjectif)''' : .&lt;br&gt;
'''σφένδαμνος, -άμνου (nom commun) (f)''' : érable.&lt;br&gt; 
'''σφενδόνη, -ης (nom commun) (f)''' : fronde.&lt;br&gt;
'''σφενδονήτης, -ου (nom commun) (m)''' : frondeur.&lt;br&gt;
'''σφενδονητικός, -ή, -όν (adjectif)''' : frondeur.&lt;br&gt;
'''σφενδονητικῶς (adverbe)''' : -ment.&lt;br&gt;
'''σφενδονητικώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''σφενδονητικός''.&lt;br&gt;
'''σφενδονητικώτερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''σφενδονητικός''.&lt;br&gt;
'''σφενδονητικώτατα, -, - (adverbe)''' : Superlatif de ''σφενδονητικῶς''.&lt;br&gt;
'''σφενδονητικώτερον, -, - (adverbe)''' : Comparatif de ''σφενδονητικῶς''.&lt;br&gt; 
'''σφήν, -ός (nom commun) (m)''' : coin (instrument).&lt;br&gt;
'''σφηνάριον, -ίου (nom commun) (n)''' : .&lt;br&gt; 
'''σφηνεύς, -έως (nom commun) (m)''' : coin.&lt;br&gt;
'''σφηνίσκος, -ου (nom commun) (m)''' : .&lt;br&gt;
'''σφηνοειδής, -ής, -ές (adjectif)''' : cunéiforme.&lt;br&gt;
'''σφηνοκέφαλος, -ος, -ον (adjectif)''' : .&lt;br&gt;
'''σφηνόπους, -δός (nom commun) (m)''' : .&lt;br&gt;
'''σφηνοπώγων, -ονος (nom commun) (m)''' : coin.&lt;br&gt;
'''σφηνῶ (verbe)''' : .&lt;br&gt;
'''σφήνωσις, -ώσεως (nom commun) (f)''' : .&lt;br&gt;
'''σφήξ, -ῆκος (nom commun) (f)''' : guêpe.&lt;br&gt;
'''σφίγγω (verbe)''' : attacher fortement.&lt;br&gt;
'''σφιγκτήρ, -ῆρος (nom commun) (m)''' : sphincter.&lt;br&gt; 
'''σφιγμός, -οῦ (nom commun) (m)''' : .&lt;br&gt;
'''σφόγγος, -ου (nom commun) (m)''' : Forme attique de ''σπόγγος''.&lt;br&gt; 
'''σφοδρός, -ά, -όν (adjectif)''' : véhément.&lt;br&gt;
'''σφοδρότατα, -, - (adverbe)''' : Superlatif de ''σφοδρῶς''.&lt;br&gt;
'''σφοδρότερον, -, - (adverbe)''' : Comparatif de ''σφοδρῶς''.&lt;br&gt;
'''σφοδρότατος, -άτη, -ότατον (adjectif)''' : Superlatif de ''σφοδρός''.&lt;br&gt;
'''σφοδρότερος, -έρα, -ότερον (adjectif)''' : Comparatif de ''σφοδρός''.&lt;br&gt;
'''σφοδρότης, -τος (nom commun) (f)''' : véhémence.&lt;br&gt;
'''σφοδρῶς (adverbe)''' : véhémentement.&lt;br&gt;
'''σφόνδυλος, -ύλου (nom commun) (m)''' : vertèbre.&lt;br&gt;
'''σφραγίς, -δος (nom commun) (f)''' : sceau.&lt;br&gt;
'''σφράγισμα, -ατος (nom commun) (n)''' : .&lt;br&gt;
'''σφραγισμός, -οῦ (nom commun) (m)''' : .&lt;br&gt;
'''σφραγιστήρ, -ῆρος (nom commun) (m)''' : .&lt;br&gt;
'''σφραγιστήριον, -ίου (nom commun) (n)''' : .&lt;br&gt;
'''σφραγιστής, -οῦ (nom commun) (m)''' : .&lt;br&gt;	
'''σφραγιστός, -ή, -όν (adjectif)''' : .&lt;br&gt;
'''σφυγμός, -οῦ (nom commun) (m)''' : pouls.&lt;br&gt;	
'''σφύζω (verbe)''' : .&lt;br&gt;
'''σφύξις, -εως (nom commun) (f)''' : palpitation.&lt;br&gt;
'''σφῦρα, -ύρας (nom commun) (f)''' : marteau.&lt;br&gt;
'''σφώ (pronom personnel)''' : vous (vous deux).&lt;br&gt;
'''σχεδίασμα, -τος (nom commun) (n)''' : caprice.&lt;br&gt;
'''σχῆμα, -ήματος (nom commun) (n)''' : Manière d'être. Forme, figure, extérieur. Apparence, faux-semblant.&lt;br&gt; 
'''σχίζω (verbe)''' : Fendre, séparer en fendant. Séparer en douze parts, avec l’idée de violence. Déchirer la peau avec ses griffes. Fendre, séparer, partager en deux.&lt;br&gt; 
'''σχίσμα, -ατος (nom commun) (n)''' : division.&lt;br&gt; 
'''σχοῖνος, -ίνου (nom commun) (m)''' : corde.&lt;br&gt; 
'''σχολαστικός, -ή, -όν (adjectif)''' : Désœuvré. Inoccupé ; studieux.&lt;br&gt;
'''σχολαστικός, -οῦ (nom commun) (m)''' : Homme d'étude. (Péjoratif) Homme d'étude détaché des réalités de la vie ; pédant, nigaud, etc.&lt;br&gt;
'''σχολεῖον, -ίου (nom commun) (n)''' : école.&lt;br&gt;
'''σχολή, -ῆς (nom commun) (f)''' : Repos. Temps libre. Philosophie, méditation. École.&lt;br&gt; 
'''σχολιάζω (verbe)''' : commenter.&lt;br&gt;
'''σχολιαστής, -οῦ (nom commun) (m)''' : commentateur.&lt;br&gt; 
'''σχολιάστρια, -ας (nom commun) (f)''' : commentatrice.&lt;br&gt;
'''σχολιογράφος, -ου (nom commun) (m/f)''' : chroniqueur.&lt;br&gt; 
'''σχόλιον, -ίου (nom commun) (n)''' : commentaire.&lt;br&gt; 
'''σῴζω (verbe)''' : sauver.&lt;br&gt;
'''σωλήν, -ῆνος (nom commun) (m)''' : Tube ; tuyau.&lt;br&gt;
'''σωληνοειδής -ής -ές (adjectif)''' : .&lt;br&gt;
'''σῶμα, -ώματος (nom commun) (n)''' : corps.&lt;br&gt;
'''σωματικός, -ή, -όν (adjectif)''' : corporel.&lt;br&gt;
'''σωματικῶς (adverbe)''' : corporellement.&lt;br&gt;
'''σωματικώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''σωματικός''.&lt;br&gt;
'''σωματικώτερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''σωματικός''.&lt;br&gt;
'''σωματικώτατα, -, - (adverbe)''' : Superlatif de ''σωματικῶς''.&lt;br&gt;
'''σωματικώτερον, -, - (adverbe)''' : Comparatif de ''σωματικῶς''.&lt;br&gt; 
'''σωμάτιον, -ίου (nom commun) (n)''' : codex.&lt;br&gt;
'''σώος, -α, -ον (adjectif)''' : sain.&lt;br&gt;
'''σωτήρ, -ῆρος (nom commun) (m)''' : Sauveur ; libérateur.&lt;br&gt;
'''σωφρονιστήριον, -ίου (nom commun) (n)''' : .&lt;br&gt; 
'''σωφρονιστήρ, -ῆρος (nom commun) (m)''' : .&lt;br&gt;
'''σωφρονίζω (verbe)''' : modérer, tempérer.&lt;br&gt; 
'''σωφροσύνη, -ης (nom commun) (f)''' : modération, tempérence.&lt;br&gt;
'''σώφρων, -ων, -ῶφρον (adjectif)''' : prudent.&lt;br&gt;
'''σϝάδυς, -εια, -υ (adjectif)''' : Forme ancienne de ''ἡδύς''.&lt;br&gt;
'''Σάϊς, -εως (nom commun) (f)''' : Saïs.&lt;br&gt;
'''Σαλμακίς, - (nom commun) (f)''' : Salmacis.&lt;br&gt;
'''Σαλομών, -ος (nom propre) (m)''' : Salomon.&lt;br&gt;
'''Σαλμωνεύς, -έως (nom propre) (m)''' : Salmonée.&lt;br&gt;
'''Σαμάρεια, -ίας (nom propre) (f)''' : Samarie.&lt;br&gt;
'''Σαμοθρᾴκη, -ης (nom propre) (f)''' : Samothrace.&lt;br&gt;
'''Σαμόθρᾳξ, -κος (nom commun) (m)''' : Samothracien.&lt;br&gt;
'''Σάμος, -ου (nom propre) (f)''' : Samos.&lt;br&gt;
'''Σανδρόκυπτος, -ύπτου (nom propre) (m)''' : Chandragupta.&lt;br&gt;
'''Σαγχουνιάθων, - (nom propre) (m)''' : Sanchoniathon.&lt;br&gt; 
'''Σαούλ (nom propre) (m)''' : Saül.&lt;br&gt; 
'''Σαπφώ, -οῦς (nom propre) (f)''' : Sapphô.&lt;br&gt;
'''Σαπώρης, -ου (nom commun) (m)''' : Shapur.&lt;br&gt;
'''Σάρα, -ας (prénom) (f)''' : Sarah.&lt;br&gt;
'''Σαρδόνιος, -ίου (nom commun) (m)''' : Sarde.&lt;br&gt;
'''Σαρδώ, -οῦς (nom propre) (f)''' : Sardaigne.&lt;br&gt;
'''Σαυρομάτης, -ου (nom commun) (m)''' : Sarmate.&lt;br&gt;
'''Σαυροματία, -ας (nom propre) (f)''' : Sarmatie.&lt;br&gt;
'''Σαυρομάτις, -δος (nom commun) (f)''' : Sarmate.&lt;br&gt;
'''Σατάν (nom propre) (m)''' : Satan.&lt;br&gt;
'''Σδεύς, -έως (nom propre) (f)''' : Autre forme éolienne de ''Ζεύς''.&lt;br&gt;
'''Σεϐάστεια, -ίας (nom propre) (f)''' : Sivas.&lt;br&gt;
'''Σεϐαστή, -ῆς (nom propre) (f)''' : .&lt;br&gt;
'''Σεϐαστός, -οῦ (nom propre) (m)''' : Sébastien.&lt;br&gt;
'''Σειρήν, -ῆνος (nom propre) (f)''' : sirène.&lt;br&gt;
'''Σείριος, -ίου (nom propre) (m)''' : Sirius.&lt;br&gt; 
'''Σελεύκεια, -ίας (nom propre) (f)''' : Séleucie.&lt;br&gt; 
'''Σελεύκειος, -α, -ον (adjectif)''' : séleucien.&lt;br&gt;  
'''Σελευκεύς, -έως (nom commun) (m)''' : Séleucien.&lt;br&gt; 
'''Σελευκίδης, -ου (nom commun) (m)''' : Séleucide.&lt;br&gt; 
'''Σελευκίς, -δος (nom commun) (f)''' : Séleucienne.&lt;br&gt; 
'''Σέλευκος, -ύκου (nom propre) (m)''' : Séleuce.&lt;br&gt; 
'''Σελήνη, -ης (nom propre) (f)''' : [[wikt:Séléné|Séléné]].&lt;br&gt;
'''Σεντικλῆς, -έους (nom propre) (m)''' : Senticlès.&lt;br&gt;
'''Σέργιος, -ίου (nom propre) (m)''' : Serge.&lt;br&gt;
'''Σέσορθος, -όρθου (nom commun) (m)''' : Djéser.&lt;br&gt;
'''Σεύθης, -ου (nom commun) (m)''' : Seuthès.&lt;br&gt;
'''Σευθόπολις, -όλεως (nom propre) (f)''' : .&lt;br&gt;
'''Σῆθ (nom propre) (m)''' : Seth.&lt;br&gt;
'''Σηρική, -ῆς (nom propre) (f)''' : Chine.&lt;br&gt;
'''Σθεννώ, -οῦς (nom propre) (f)''' : Sthéno.&lt;br&gt;
'''Σίϐυλλα, -ύλλης (nom propre) (f)''' : Sibylle.&lt;br&gt;
'''Σιδών, -ῶνος (nom propre) (f)''' : Sidon.&lt;br&gt;
'''Σικελία, -ας (nom propre) (f)''' : Sicile.&lt;br&gt;
'''Σικελιώτης, -ου (nom commun) (m)''' : Sicéliote.&lt;br&gt;
'''Σικελιῶτις, -ώτιδος (nom commun) (f)''' : Sicéliotide.&lt;br&gt;
'''Σίκελος, -έλου (nom commun) (m)''' : Sicule.&lt;br&gt;
'''Σικυών, -ῶνος (nom propre) (f)''' : Sicyone.&lt;br&gt;
'''Σίσυφος, -ύφου (nom propre) (m)''' : Sisyphe.&lt;br&gt;
'''Σίνη, -ης (nom propre) (f)''' : Chine.&lt;br&gt;
'''Σíνων, -ος (nom propre) (m)''' : Sinon. (cousin d'Ulysse)&lt;br&gt;
'''Σιός, -οῦ (nom propre) (m)''' : Autre forme béotienne de ''Ζεύς''.&lt;br&gt;
'''Σίσυφος, -ύφου (nom propre) (m)''' : Sisyphe.&lt;br&gt;
'''Σκορπιός, -οῦ (nom commun) (m)''' : Scorpion.&lt;br&gt; 
'''Σκύθαινα, -ίνης (nom propre) (f)''' : Scythe.&lt;br&gt;
'''Σκύθης, -ου (nom propre) (m)''' : Scythe.&lt;br&gt;
'''Σκυθία, -ας (nom propre) (f)''' : Scythie.&lt;br&gt;
'''Σκύλλα, -ης (nom propre) (f)''' : Scylla.&lt;br&gt;
'''Σκύλλη, -ης (nom propre) (f)''' : Forme homérique de ''Σκύλλα''.&lt;br&gt;
'''Σόλλαξ, -κος (nom propre) (m)''' : Sollax (ancien nom du Tigre).&lt;br&gt;
'''Σολομών, -ος (nom propre) (m)''' : Salomon.&lt;br&gt;
'''Σόλων, -ος (nom propre) (m)''' : Solon. (cousin d’Ulysse)&lt;br&gt;
'''Σούηϐος, -ήϐου (nom propre) (m)''' : Suève.&lt;br&gt;
'''Σουοϐηνός, -οῦ (nom commun) (m)''' : Slave.&lt;br&gt;
'''Σουσάννα, -ας (nom propre) (f)''' : Suzanne.&lt;br&gt;
'''Σοῦφις, -ύφιδος (nom propre) (m)''' : Souphis.&lt;br&gt;
'''Σοῦχος, -ύχου (nom propre) (m)''' : Sobek.&lt;br&gt;
'''Σοφία, -ας (nom propre) (f)''' : Sophie.&lt;br&gt;
'''Σοφοκλῆς, -έους (nom propre) (m)''' : Sophocle.&lt;br&gt;
'''Σπάρτα, -ας (nom propre) (f)''' : Forme dorienne de ''Σπάρτη''.&lt;br&gt;
'''Σπάρτη, -ης (nom propre) (f)''' : Sparte.&lt;br&gt;
'''Σπαρτιάτης, -ου (nom commun) (m)''' : Spartiate.&lt;br&gt;
'''Σπαρτιᾶτις, -άτιδος (nom commun) (f)''' : Spartiate.&lt;br&gt;
'''Σταυανός, -οῦ (nom commun) (m)''' : Slave.&lt;br&gt;
'''Στέφανος, -άνου (nom propre) (m)''' : Étienne ; Stéphane.&lt;br&gt;
'''Στράϐων, -ος (nom propre) (m)''' : Strabon.&lt;br&gt;
'''Στρογγύλη, ης (nom propre) (f)''' : Stromboli. (île)&lt;br&gt;
'''Στρούθας, -ου (nom propre) (m)''' : Struthas.&lt;br&gt;
'''Στύξ, -γός (nom propre) (f)''' : Styx.&lt;br&gt;
'''Σύϐαρις, -άριδος (nom propre) (f)''' : Sybaris (ville).&lt;br&gt;
'''Σύϐαρις, -άρεως (nom propre) (m)''' : Sybaris (fleuve).&lt;br&gt;
'''Συδύκ (nom propre) (m)''' : Sydyk.&lt;br&gt;
'''Συρία, -ας (nom propre) (f)''' : Syrie.&lt;br&gt;
'''Συριακός, -ός, -όν (adjectif)''' : syrien.&lt;br&gt; 
'''Σύριος, -ίου  (nom commun) (m)''' : Syrien.&lt;br&gt;
'''Σῦριγξ, -ύριγγος (nom propre) (f)''' : Syrinx.&lt;br&gt;
'''Σφίγξ, -γός (nom propre) (f)''' : Sphinx, Sphinge.&lt;br&gt;
'''Σωσίας, -ου (nom propre) (m)''' : Sosie.&lt;br&gt;
'''Σωσίπατρος, -άτρου (nom propre) (m)''' : Sosipatros.&lt;br&gt;

==Τ==
'''τάγηνον, -ήνου  (nom commun) (n)''' : Forme dorienne de ''τήγανον''.&lt;br&gt;
'''τάγμα, -τος (nom commun) (n)''' : Arrangement. (Militaire) Régiment.&lt;br&gt;
'''ταινία, -ας (nom commun) (f)''' : ruban.&lt;br&gt;
'''ταινίη, -ης (nom commun) (f)''' : Forme ionienne de ''ταινία''.&lt;br&gt;
'''τακτική, -ῆς (nom commun) (f)''' : tactique.&lt;br&gt;
'''τακτικός, -ή, -όν (adjectif)''' : tactique.&lt;br&gt;
'''τακτικῶς (adverbe)''' : tactiquement.&lt;br&gt;
'''τακτικώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''τακτικός''.&lt;br&gt;
'''τακ τικώτερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''τακτικός''.&lt;br&gt;
'''τακτικώτατα, -, - (adverbe)''' : Superlatif de ''τακτικῶς''.&lt;br&gt;
'''τακτικώτερον, -, - (adverbe)''' : Comparatif de ''τακτικῶς''.&lt;br&gt;
'''τάλαντον, -άντου (nom commun) (n)''' : plateau de balance.&lt;br&gt;
'''ταλαντοῦμαι (verbe)''' : osciller.&lt;br&gt;
'''ταλάντωσις, -ώσεως (nom commun) (f)''' : oscillation.&lt;br&gt;
'''ταμεῖον, -ίου (nom commun) (n)''' : .&lt;br&gt;
'''ταμία, -ας (nom commun) (f)''' : maîtresse de maison.&lt;br&gt;
'''ταμιακόν, -οῦ (nom commun) (m)''' : fisc.&lt;br&gt;
'''ταμιακός, -ή, -όν (adjectif)''' : fiscal.&lt;br&gt;
'''ταμιακότατος, -άτη, -ότατον (adjectif)''' : Superlatif de ''ταμιακός''.&lt;br&gt;
'''ταμιακότερος, -έρα, -ότερον (adjectif)''' : Comparatif de ''ταμιακός''.&lt;br&gt;
'''ταμιακῶς (adverbe)''' : fiscalement.&lt;br&gt;
'''ταμίας, -ου (nom commun) (m)''' : Dispensateur, distributeur ; partageur. Intendant, économe. Gardien d’un trésor. Directeur, ordonnateur ; arbitre.&lt;br&gt;
'''ταμιεῖον, -ίου (nom commun) (n)''' : caisse.&lt;br&gt;
'''ταμιεύω (verbe)''' : .&lt;br&gt;
'''τάμνω (verbe)''' : Forme homérique et ionienne de ''τέμνω''.&lt;br&gt;
'''τάξις, -εως (nom commun) (f)''' : disposition.&lt;br&gt;
'''τάξος, -ου (nom commun) (f)''' : if.&lt;br&gt;
'''τάπης, -τος (nom commun) (m)''' : tapis.&lt;br&gt;
'''τάραγμα, -άγματος (nom commun) (m)''' : inquiétude ; trouble.&lt;br&gt;
'''ταραξίας, -ου (nom commun) (m)''' : trouble-fête.&lt;br&gt; 
'''τάραξις, -άξεως (nom commun) (f)''' : trouble.&lt;br&gt;
'''ταράσσω (verbe)''' : troubler.&lt;br&gt;
'''ταραχή, -ῆς (nom commun) (f)''' : trouble.&lt;br&gt;
'''ταρταροῦχος, -ος, -ον (adjectif)''' : du Tartare.&lt;br&gt;
'''τάσις, -εως  (nom commun) (f)''' : tension.&lt;br&gt;
'''τάσσω (verbe)''' : disposer.&lt;br&gt;
'''τατᾶ (interjection)''' : papa ; maman.&lt;br&gt;
'''ταταλίζω (verbe)''' : .&lt;br&gt;
'''ταῦρος, -ύρου (nom commun) (m)''' : taureau.&lt;br&gt;
'''ταυρῶ (verbe)''' : tirer.&lt;br&gt;
'''ταῦ (nom commun) (n)''' : tau.&lt;br&gt;
'''τάφος, -ου (nom commun) (m)''' : tombeau.&lt;br&gt;
'''τάχα (adverbe)'''  (Devient ''τάχ’'' devant un mot commençant par une voyelle à esprit doux.) : bientôt.&lt;br&gt;
'''ταχέως (adverbe)''' : rapidement.&lt;br&gt;
'''ταχύς, -εῖα, -ύ (adjectif)''' : rapide ; pressé.&lt;br&gt; 
'''ταχύτατος, -άτη, -ύτατον (adjectif)''' : Superlatif de ''ταχύς''.&lt;br&gt;
'''ταχύτερος, -έρα, -ύτερον (adjectif)''' : Comparatif de ''ταχύς''.&lt;br&gt;
'''ταχυτής, -ῆτος (nom commun) (f)''' : rapidité.&lt;br&gt;
'''ταώς, -ώ (nom commun) (m)''' : paon.&lt;br&gt;
'''τείνω (verbe)''' : étirer ; tendre.&lt;br&gt;
'''τέκτων, -ονος (nom commun) (m)''' : Auteur, créateur. Ouvrier, artisan.&lt;br&gt;
'''τεῖχος, -ίχους (nom commun) (n)''' : mur de ville.&lt;br&gt;
'''τέλειος, -ία, -ιον (adjectif)''' : terminé ; parfait.&lt;br&gt;
'''τελειότατος, -άτη, -ότατον (adjectif)''' : Superlatif de ''τέλειος''.&lt;br&gt;
'''τελειότερος, -έρα, -ότερον (adjectif)''' : Comparatif de ''τέλειος''.&lt;br&gt;
'''τελείως (adverbe)''' : parfaitement.&lt;br&gt;
'''τελειῶ (verbe)''' : terminer.&lt;br&gt;
'''τέλεσμα, -έσματος (nom commun) (n)''' : Paiement, taxe. Certificat.&lt;br&gt;
'''τελεστιχίς, -δος (nom commun) (f)''' : téléstiche.&lt;br&gt; 
'''τελετή, -ῆς  (nom commun) (f)''' : cérémonie.&lt;br&gt; 
'''τελευταῖος, -ία, -ῖον (adjectif)''' : dernier.&lt;br&gt;
'''τελευτή, -ῆς  (nom commun) (f)''' : fin ; finalité.&lt;br&gt; 
'''τελέω (verbe)''' : Accomplir. Mettre un terme à.&lt;br&gt;
'''τέλος, -ους (nom commun) (n)''' : Achèvement ; accomplissement ; réalisation. Prix dans les luttes.&lt;br&gt;  
'''τέμαχος, -άχους (nom commun) (n)''' : tranche ; morceau.&lt;br&gt;
'''τέμενος, -ένους (nom commun) (n)''' : téménos.&lt;br&gt;
'''τέμνω (verbe)''' : couper.&lt;br&gt;
'''τέρας, -τος (nom commun) (n)''' : Signe divin ; monstre.&lt;br&gt;
'''τεράστιος -α -ον (adjectif)''' : monstrueux.&lt;br&gt;
'''τερπνός, -ή, -όν (adjectif)''' : Amusant ; plaisant.&lt;br&gt;
'''τερπνότατος, -άτη, -ότατον (adjectif)''' : Superlatif de ''τερπνός''.&lt;br&gt;
'''τερπνότερος, -έρα, -ότερον (adjectif)''' : Comparatif de ''τερπνός''.&lt;br&gt;
'''τερπνότης, -τος (nom commun) (f)''' : amusement.&lt;br&gt;
'''τερπνῶς (adverbe)''' : plaisamment.&lt;br&gt;
'''τέρπω (adverbe)''' : Prendre plaisir ; s’amuser.&lt;br&gt;
'''τέσσαρες (adjectif numéral)''' : quatre.&lt;br&gt;
'''τετράδιον, -ίου (nom commun) (n)''' : cahier.&lt;br&gt;
'''τετραίνω (verbe)''' : trouer.&lt;br&gt;
'''τετράλημμα, -ήμματος (nom commun) (n)''' : tétralemme.&lt;br&gt;
'''τετράπους, -δος (nom commun) (m)''' : quadrupède.&lt;br&gt;
'''τετράς, -δος (nom commun) (f)''' : .&lt;br&gt;
'''τετράων, -ος (nom commun) (m)''' : coq de bruyère.&lt;br&gt;
'''τετράστιχον, -ίχου (nom commun) (n)''' : quatrain.&lt;br&gt;
'''τετταράκοντα (adjectif numéral)''' quarante.&lt;br&gt;
'''τέττιξ, -γος (nom commun) (m)''' : cigale.&lt;br&gt;
'''τεῦτλον, -ύτλου (nom commun) (n)'''' : blette.&lt;br&gt;
'''τεῦχος, -ύχους (nom commun) (n)''' : Ustensile, instrument. (Au pluriel) Armes, armure. (Au pluriel) Agrès de navire (voiles, cordages, rames). Urne pour les libations. Urne funéraire. Baignoire. Tonneau de bois. Huche pour la farine. Ruche d’abeilles.(Par analogie) Vaisseau du corps. Enveloppe qui enferme les petits. Livre.&lt;br&gt;
'''τεύχω (verbe)''' : .&lt;br&gt;
'''τέφρα, -ας (nom commun) (f)''' : cendre.&lt;br&gt;
'''τέφρη, -ης (nom commun) (f)''' : Forme homérique et ionienne de ''τέφρα''.&lt;br&gt;
'''τεχνάζω (verbe)''' : faire avec art.&lt;br&gt;
'''τέχνασμα, -άσματος (nom commun) (n)'''' : Artifice, machination, ruse.&lt;br&gt;
'''τέχνη, -ης (nom commun) (f)''' : Art ; habileté.&lt;br&gt;
'''τέχνημα, -ήματος (nom commun) (n)''' : artéfact.&lt;br&gt;
'''τεχνητός, -ή, -όν (adjectif)''' : artificiel.&lt;br&gt;
'''τεχνητῶς (adverbe)''' : artificiellement.&lt;br&gt;
'''τεχνητώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''τεχνητός''.&lt;br&gt;
'''τεχνητώτερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''τεχνητός''.&lt;br&gt;
'''τεχνικός, -ή, -όν  (adjectif)''' : artistique.&lt;br&gt;
'''τεχνικῶς (adverbe)''' : artistiquement.&lt;br&gt;
'''τεχνικώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''τεχνικός''.&lt;br&gt;
'''τεχνικώτερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''τεχνικός''.&lt;br&gt;
'''τεχνῶμαι (verbe)''' : .&lt;br&gt;
'''τηγάνιον, -ίου (nom commun) (n)''' : Diminutif de ''τήγανον''.&lt;br&gt;
'''τήγανον, -άνου (nom commun) (n)''' : poêle à frire.&lt;br&gt;
'''τήκω (verbe)''' : fondre.&lt;br&gt;
'''τῆλε (adverbe ; préposition)''' Loin, au loin. (Avec le génitif) Loin de.&lt;br&gt;
'''τήμερον (adverbe)''' : Forme attique de ''σήμερον''.&lt;br&gt;
'''-τήρ, -ῆρος (suffixe) (m)''' : Suffixe nominal.&lt;br&gt;
'''-τής, -ῆτος (suffixe) (f)''' : Suffixe permettant de créer à partir d’un adjectif le nom désignant la qualité correspondante.&lt;br&gt;
'''-της, -τος (suffixe) (f)''' : Suffixe de même usage que ''-τής''.&lt;br&gt;
'''τίγρις, -εως (nom commun) (m/f)''' : Tigre ; tigresse.&lt;br&gt;
'''τίθημι (verbe)''' : Poser ; placer.&lt;br&gt;
'''τιθήνη, -ης (nom commun) (f)''' : nourrice.&lt;br&gt;
'''τεκμηρίωσις, -ώσεως (nom commun) (f)''' : documentation.&lt;br&gt;
'''τεκμηριῶ (verbe)''' : documenter.&lt;br&gt;
'''τίκτω (verbe)''' : Engendrer, produire ; mettre au monde.&lt;br&gt;
'''τιμή, -ῆς (nom commun) (f)''' : (Sens positif) Évaluation, estimation. Prix attaché à un honneur. Ce qui est tenu en honneur ; objet de l’estime, du respect ; autorité, magistrature. (Sens négatif) Peine, châtiment, vengeance.&lt;br&gt;
'''τίμιος, -α, -ον (adjectif)''' : honnête.&lt;br&gt;
'''τιμιότης, -τος (nom commun) (f)''' : honnêteté.&lt;br&gt; 
'''τιμωρητέος, -α, -ον (adjectif)''' : punissable.&lt;br&gt;
'''τιμωρητικός, -ή, -όν (adjectif)''' : punitif.&lt;br&gt;
'''τιμωρητικῶς (adverbe)''' : punitivement.&lt;br&gt;
'''τιμωρητικώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''τιμωρητικός''.&lt;br&gt;
'''τιμωρητικώτερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''τιμωρητικός''.&lt;br&gt;
'''τιμωρητικώτατα, -, - (adverbe)''' : Superlatif de ''τιμωρητικῶς''.&lt;br&gt;
'''τιμωρητικώτερον, -, - (adverbe)''' : Comparatif de ''τιμωρητικῶς''.&lt;br&gt; 
'''τιμωρία, -ας (nom commun) (f)''' : punition.&lt;br&gt;
'''τιμωρῶ (verbe)''' : punir.&lt;br&gt;
'''τιμῶ (verbe)''' : honorer.&lt;br&gt;
'''τίνω (verbe)''' : Payer ; payer pour ses fautes, expier.&lt;br&gt;
'''τιούχα, -ας (nom commun) (f)''' : Autre forme béotienne de ''τύχη''.&lt;br&gt;
'''τίσις, -εως (nom commun) (f)''' : Paiement, récompense. Pénalité, vengeance.&lt;br&gt;
'''τιταίνω (verbe)''' : étendre.&lt;br&gt;
'''τίταξ, -κos (nom commun) (m)''' : roi.&lt;br&gt;
'''τίτας, -αντος (nom commun) (m)''' : vengeur.&lt;br&gt;
'''τίτης, -ου (nom commun) (m)''' : Forme dorienne de ''τίτας''.&lt;br&gt;
'''τῖφος, -ίφου (nom commun) (m)''' : Étang, marais.&lt;br&gt;
'''τίω (verbe)''' : rendre (i.e. payer) des hommages à quelqu’un, estimer une personne. Évaluer, estimer.&lt;br&gt;
'''τμῆμα, -ήµατος (nom commun) (n)''' : Partie, secteur ; section.&lt;br&gt;
'''τμῆσις, -ήσεως (nom commun) (f)''' : césure.&lt;br&gt;
'''τοιοῦτος, -αύτη, -οῦτο (pronom)''' : .&lt;br&gt;
'''τοῖχος, -ίχου (nom commun) (m)''' : Mur de maison ; bord ou paroi d’un navire.&lt;br&gt;
'''τοιχωρύχημα, -ήµατος (nom commun) (n)''' : cambriolage.&lt;br&gt;
'''τοιχώρυχος, -ύχου (nom commun) (m)''' : cambrioleur.&lt;br&gt;
'''τοιχωρυχῶ (verbe)''' : cambrioler.&lt;br&gt;
'''τοκογλυφία, -ας (nom commun) (f)''' : usure.&lt;br&gt;
'''τοκογλυφικός, -ή, -όν (adjectif)''' : usurier.&lt;br&gt;
'''τοκογλύφος, -ου (nom commun) (m)''' : usurier.&lt;br&gt;
'''τόκος, -ου (nom commun) (m)''' : Parturition, accouchement. Descendance. Intérêt de l'argent prêté.&lt;br&gt;
'''τόλμα, -ης (nom commun) (f)''' : Audace ; courage.&lt;br&gt;
'''τολμηρός, -ή, -όν (adjectif)''' : hardi.&lt;br&gt;
'''τολμηρότατος, -άτη, -ότατον (adjectif)''' : Superlatif de ''τολμηρός''.&lt;br&gt;
'''τολμηρότερος, -έρα, -ότερον (adjectif)''' : Comparatif de ''τολμηρός''.&lt;br&gt;
'''τολμηρότης, -τος (nom commun) (f)''' : hardiesse.&lt;br&gt;
'''τολμηρῶς (adverbe)''' : hardiment.&lt;br&gt;
'''τολμηρώτατα, -, - (adverbe)''' : Superlatif de ''τολμηρῶς''.&lt;br&gt;
'''τολμηρώτερον, -, - (adverbe)''' : Comparatif de ''τολμηρῶς''.&lt;br&gt;
'''τολμῶ (verbe)''' : oser.&lt;br&gt;
'''-τομία, -ας (suffixe) (f)''' : Suffixe signifiant « coupure », « césure ».&lt;br&gt;
'''τόμος, -ου (nom commun) (m)''' : Tranche, pièce ; chose coupée.&lt;br&gt;
'''τομός, -οῦ (nom commun) (m)''' : Coupure, action de couper.&lt;br&gt;
'''τοπικός, -ή, -όν (adjectif)''' : local.&lt;br&gt;
'''τοπικῶς (adverbe)''' : localement.&lt;br&gt;
'''τοπικώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''τοπικός''.&lt;br&gt;
'''τοπικώτερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''τοπικός''.&lt;br&gt;
'''τοπικώτατα, -, - (adverbe)''' : Superlatif de ''τοπικῶς''.&lt;br&gt;
'''τοπικώτερον, -, - (adverbe)''' : Comparatif de ''τοπικῶς''.&lt;br&gt;
'''τοξάριον, -ίου (nom commun) (n)''' : archet.&lt;br&gt; 
'''τοξικός, -ή, -όν (adjectif)''' : qui convient pour un arc ou pour des flèches.&lt;br&gt;
'''τόξον, -ου (nom commun) (n)''' : arc ; arc-en-ciel.&lt;br&gt;
'''τοξότης, -ου (nom commun) (m)''' : archer.&lt;br&gt;
'''τὸ (article défini)''' : le (neutre).&lt;br&gt;
'''τούχα, -ας (nom commun) (f)''' : Forme béotienne de ''τύχη''.&lt;br&gt;
'''τράγημα, -ατος (nom commun) (n)''' : friandise.&lt;br&gt;
'''τραγικός, -ή, -όν (adjectif)''' : tragique.&lt;br&gt;
'''τραγικότατα, -, - (adverbe)''' : Superlatif de ''τραγικῶς''.&lt;br&gt;
'''τραγικότερον, -, - (adverbe)''' : Comparatif de ''τραγικῶς''.&lt;br&gt;
'''τραγικῶς (adverbe)''' : comiquement.&lt;br&gt;
'''τραγικώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''τραγικός''.&lt;br&gt;
'''τραγικώτερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''τραγικός''.&lt;br&gt;
'''τραγίσκος, -ου (nom commun) (m)''' : chevreau.&lt;br&gt;
'''τράγος, -ου (nom commun) (m)''' : bouc.&lt;br&gt; 
'''τραγῳδία, -ας (nom commun) (f)''' : tragédie.&lt;br&gt;
'''τραγωδῶ (verbe)''' : chanter.&lt;br&gt;
'''τράπεζα, -ης (nom commun) (f)''' : table.&lt;br&gt;
'''τραυλίζω (verbe)''' : bégayer, bafouiller.&lt;br&gt;
'''τραυλισμός, -οῦ (nom commun) (m)''' : bégaiement, bafouillis.&lt;br&gt;
'''τραυλός, -οῦ (nom commun) (m)''' : bègue, bafouilleur.&lt;br&gt;
'''τραῦμα, -ύματος (nom commun) (n)''' : Blessure. Déroute, désastre.&lt;br&gt;
'''τράχηλος, -ήλου  (nom commun) (m)''' : Cou. (En particulier) Derrière du cou, nuque.&lt;br&gt;
'''τραχύς, -εῖα, -ύ (adjectif)''' : rude.&lt;br&gt;
'''τράχω (verbe)''' : Forme dorienne de ''τρέχω''.&lt;br&gt;
'''τρεῖς (adjectif numéral)''' : trois.&lt;br&gt;
'''τρέμω (verbe)''' : trembler, s’agiter ; s’ébranler.&lt;br&gt;
'''τρέπω (verbe)''' : tourner.&lt;br&gt;
'''τρέστης, -ου (nom commun) (m)''' : couard ; peureux.&lt;br&gt;
'''τρέφω (verbe)''' : Rendre compact. Rendre gras, engraisser, nourrir. Nourrir, élever. (Par extension) Élever, former, façonner, instruire. Pourvoir aux besoins de. S’épaissir, se condenser. Être nourri ou élevé.&lt;br&gt;
'''τρέχω (verbe)''' : courir.&lt;br&gt; 
'''τρέω (verbe)''' : avoir peur.&lt;br&gt;
'''τρῆμα, -ήµατος (nom commun) (n)''' : trou.&lt;br&gt;
'''τρηρός, -ή, -όν (adjectif)''' : fou.&lt;br&gt;
'''τρήρων, -ος (nom commun) (m/f)''' : timide.&lt;br&gt;
'''τριάκοντα (adjectif numéral)''' : trente.&lt;br&gt;
'''τρίϐω (verbe)''' : frotter.&lt;br&gt;
'''τρίλημμα, -ήμματος (nom commun) (n)''' : trilemme.&lt;br&gt;
'''τρίμμα, -τος (nom commun) (n)''' : .&lt;br&gt;
'''τρίπος, -ου (nom commun) (m)''' : trépied.&lt;br&gt;
'''τρίπους, -δος (adjectif)''' : tripède.&lt;br&gt;
'''τρισκελής, -οῦ (nom commun) (m)''' : triskèle.&lt;br&gt;
'''τρισκέλιον, -ίου (nom commun) (n)''' : Diminutif de ''τρισκελής''.&lt;br&gt;
'''τριταγωνιστής, -οῦ (nom commun) (m)''' : tritagoniste.&lt;br&gt;
'''τρίτος, -η, -ον (adjectif numéral)''' : troisième.&lt;br&gt;
'''τρίφυλλον, -ύλλου (nom commun) (n)''' : trèfle.&lt;br&gt;
'''-τρον, -ου (suffixe) (n)''' : Suffixe servant à former des noms d’instruments.&lt;br&gt;
'''τρόπαιον, -ίου (nom commun) (n)''' : trophée.&lt;br&gt;
'''τροπή, -ῆς (nom commun) (f)''' : Tour. Fuite. Révolution, changement. (Rhétorique) Tournure de phrase.&lt;br&gt;
'''τροπικός, -ή, -όν (adjectif)''' : tournant.&lt;br&gt;
'''τρόπος, -ου (nom commun) (m)''' : Tour, direction ; façon, mode, manière.&lt;br&gt;
'''τροχαῖος, -ίου (nom commun) (m)''' : trochée.&lt;br&gt;
'''τροχαλία, -ας (nom commun) (f)''' : poulie.&lt;br&gt;
'''τροχίλος, -ου (nom commun) (m)''' : poulie.&lt;br&gt;
'''τρόχος, -ου (nom commun) (m)''' : blaireau.&lt;br&gt;
'''τροχός, -οῦ (nom commun) (m)''' : Roue. Tour de potier. Pain (de forme ronde) de suif ou de cire.&lt;br&gt;
'''τρύϐλιον, -ίου (nom commun) (n)''' : bol ; coupe.&lt;br&gt;
'''τρυγόνιον, -ίου (nom commun) (n)''' : Diminutif de ''τρυγών ''.&lt;br&gt;
'''τρυγών, -όνος (nom commun) (f)''' : tourterelle.&lt;br&gt;
'''τρύζω (verbe)''' : .&lt;br&gt; 
'''τρῦπα, -ύπας (nom commun) (f)''' : trou.&lt;br&gt;
'''τρύπημα, -ήματος (nom commun) (n)''' : trou.&lt;br&gt;	
'''τρύω (verbe)''' : user.&lt;br&gt; 
'''τύρρις, -ος (nom commun) (f)''' : variante de ''τύρσις''.&lt;br&gt;
'''τύρσις, -ος (nom commun) (f)''' : tour (construction élevée).&lt;br&gt;
'''τρύφαξ, -κος (nom commun) (m)''' : débauché.&lt;br&gt;
'''τρυφερός, -ά, -όν (adjectif)''' : délicat.&lt;br&gt;
'''τρυφερότης, -τος (nom commun) (f)''' : délicatesse.&lt;br&gt;
'''τρυφερώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''τρυφερός''.&lt;br&gt;
'''τρυφερώτερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''τρυφερός''.&lt;br&gt;
'''τρυφερῶς (adverbe)''' : délicatement.&lt;br&gt;
'''τρυφή, -ῆς (nom commun) (f)''' : Douceur, mollesse. Luxe, délicatesse. Dissolution, débauche.&lt;br&gt;
'''τρύφημα, -ήματος (nom commun) (n)''' : orgueil.&lt;br&gt;
'''τρυφητής, -ής, -ές (adjectif)''' : voluptueux.&lt;br&gt;
'''τρυφῶ (verbe)''' : être extravagant, se donner des airs.&lt;br&gt;
'''τρῦχος, -ύχους (nom commun) (n)''' : Haillon, lambeau.&lt;br&gt;
'''τρύχω (verbe)''' : épuiser, user.&lt;br&gt;
'''τρώγω (verbe)''' : ronger, grignoter.&lt;br&gt;
'''τρωϊκός, -ή -όν (adjectif)''' : troyen.&lt;br&gt;
'''τρῶ (verbe)''' : avoir peur.&lt;br&gt;
'''τῦκον, -ύκου (nom commun) (m)''' : Forme béotienne de ''σῦκον''.&lt;br&gt; 
'''τύμϐος, -ου (nom commun) (m)''' : tumulus.&lt;br&gt;  
'''τυνδάρειος, -ος, -ον (nom commun) (m)''' : tyndaréen.&lt;br&gt;
'''τυπικός, -ή -όν (adjectif)''' : figuré.&lt;br&gt;
'''τυπικῶς (adverbe)''' : figurativement.&lt;br&gt;
'''τυπικώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''τυπικός''.&lt;br&gt;
'''τυπικώτερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''τυπικός''.&lt;br&gt;
'''τυπικώτατα, -, - (adverbe)''' : Superlatif de ''τυπικῶς''.&lt;br&gt;
'''τυπικώτερον, -, - (adverbe)''' : Comparatif de ''τυπικῶς''.&lt;br&gt; 
'''τύπος, -ου (nom commun) (m)''' : Coup ; frappe. Frappe, marque du coup ; sceau, impression.&lt;br&gt;  
'''τύπτω (verbe)''' : frapper.&lt;br&gt; 
'''τύραννος, -άννου (nom commun) (m)''' : Maître, dominateur. (Péjoratif) Tyran, dictateur ; despote.&lt;br&gt;
'''τύρϐη, -ης (nom commun) (f)''' : tumulte, désordre.&lt;br&gt;
'''τυρός, -οῦ (nom commun) (m)''' : fromage.&lt;br&gt;
'''τυτώ, -οῦς (nom commun) (f)''' : chouette.&lt;br&gt;
'''τύ (pronom personnel)''' : Forme dorienne de ''σύ''.&lt;br&gt;
'''τυφλός, -ή -όν (adjectif)''' : aveugle.&lt;br&gt;
'''τῦφος, -ύφου (nom commun) (m)''' : fumée, vapeur qui monte au cerveau ; orgueil.&lt;br&gt;
'''τῦφω (verbe)''' : enfumer.&lt;br&gt;
'''τυχαῖος, -ία, -ῖον (adjectif)''' : chanceux.&lt;br&gt;
'''τυχερῶς (adverbe)''' : .&lt;br&gt;
'''τύχη, -ης (nom commun) (f)''' : chance.&lt;br&gt;
'''τυχηρός, -ά, -όν, (adjectif)''' : chanceux.&lt;br&gt;
'''τύψις, -εως (nom commun) (f)''' : remords.&lt;br&gt;
'''Ταλθύϐιος, -ίου (nom propre) (m)''' : Talthybios.&lt;br&gt; 
'''Τάλως, -ώ (nom propre) (m)''' : Talos.&lt;br&gt;
'''Τάμεσις, -έσεως (nom propre) (f)''' : Tamise.&lt;br&gt;
'''Τάναϊς, -άϊδος (nom propre) (m)''' : Tanaïs.&lt;br&gt; 
'''Τάν, -ός (nom propre) (m)''' : Forme crétoise de ''Ζεύς''.&lt;br&gt;
'''Ταραντῖνος, -ίνου (nom commun) (m)''' : Tarentin.&lt;br&gt; 
'''Τάρας, -αντος (nom propre) (m)''' : Tarente.&lt;br&gt;
'''Τάρταρος, -άρου (nom propre) (m)''' : Tartare.&lt;br&gt;
'''Ταῦρος, -ύρου (nom propre) (m)''' : Taureau.&lt;br&gt;
'''Τειρεσίας, -ου (nom propre) (m)''' : Tirésias.&lt;br&gt;
'''Τεΐσπης, -ου (nom propre) (m)''' : Teispès.&lt;br&gt;
'''Τελεύτας, -αντος (nom propre) (m)''' : Téleutas.&lt;br&gt;
'''Τελευτίας, -ου (nom propre) (m)''' : Téleutias.&lt;br&gt;
'''Τερψιχόρα, -ας (nom propre) (f)''' : Terpsichore.&lt;br&gt;
'''Τεύτων, -ονος  (nom commun) (m)''' : Teuton.&lt;br&gt;
'''Τηθύς, -ος (nom propre) (f)''' : [[wikt:Téthys|Téthys]].&lt;br&gt;
'''Τηλέγονος, -όνου (nom propre) (m)''' : Télégonos.&lt;br&gt;
'''Τηλέμαχος, -άχου (nom propre) (m)''' : Télémaque.&lt;br&gt;
'''Τηρεύς, -έως (nom propre) (m)''' : Térée.&lt;br&gt;
'''Τίγρης, -τος (nom propre) (m)''' : Tigre (fleuve du Moyen-Orient).&lt;br&gt; 
'''Τίγρις, -δος (nom propre) (f)''' : Forme alternative de ''Τίγρης''.&lt;br&gt;
'''Τιθωνός, -οῦ (nom propre) (m)''' : Tithon.&lt;br&gt; 
'''Τιμασίθεος, -έου (nom propre) (m)''' : Timasithée.&lt;br&gt;
'''Τιμόθεος, -έου (nom propre) (m)''' : Timothée.&lt;br&gt;
'''Τίμων, -ωνος (nom propre) (m)''' : Timon.&lt;br&gt;
'''Τισαμενός, -οῦ (nom propre) (m)''' : Tisamène.&lt;br&gt;
'''Τίσανδρος, -άνδρου (nom propre) (m)''' : Tisandre.&lt;br&gt;
'''Τισίας, -ου (nom propre) (m)''' : Tisias.&lt;br&gt;
'''Τισικράτης, -ου (nom propre) (m)''' : Tisicrate.&lt;br&gt;
'''Τισιφόνη, -ης (nom propre) (f)''' : Tisiphone (une des Érynies).&lt;br&gt;
'''Τισσαφέρνης, -ου (nom propre) (m)''' : Tissapherne.&lt;br&gt;
'''Τιτάν, -ᾶνος (nom propre) (m)''' : Titan.&lt;br&gt;
'''Τιτανίς, -δος (nom propre) (f)''' : Titanide.&lt;br&gt;
'''Τιτυός, -οῦ (nom propre) (m)''' : Tityos.&lt;br&gt;
'''Τόσορθρος, -όρθου (nom commun) (m)''' : Djéser.&lt;br&gt;
'''Τοξότης, -ου (nom propre) (m)''' : Sagittaire.&lt;br&gt;
'''Τρίπολις, -όλεως (nom propre) (f)''' : Tripoli.&lt;br&gt;
'''Τρίτων, -ος (nom propre) (m)''' : Triton.&lt;br&gt;
'''Τροία, -ας (nom propre) (f)''' : Troie.&lt;br&gt;
'''Τρωάς, -δος (nom commun) (f)''' : Troyenne.&lt;br&gt;
'''Τρώς, -ός (nom commun) (m)''' : Troyen.&lt;br&gt; 
'''Τῦϐι (nom propre) (m)''' : Tybi.&lt;br&gt;
'''Τυδεύς, -έως (nom propre) (m)''' : Tydée.&lt;br&gt;
'''Τυνδάρεως, -εω (nom propre) (m)''' : Tyndare.&lt;br&gt;
'''Τυνδαρίδης, -ου (nom propre) (m)''' : Tyndaride.&lt;br&gt;
'''Τυνδαρίς, -δος (nom propre) (f)''' : Tyndaride.&lt;br&gt;
'''Τυφάων, -ος (nom propre) (m)''' : Forme de ''Τυφῶν''.&lt;br&gt;
'''Τυφωεύς, -έως (nom propre) (m)''' : Forme de ''Τυφῶν''.&lt;br&gt;
'''Τυφώς, - (nom propre) (m)''' : Forme de ''Τυφῶν''.&lt;br&gt;
'''Τυφῶν, -ος (nom propre) (m)''' : Typhon.&lt;br&gt;
'''Τύχη, -ης (nom propre) (f)''' : [[wikt:Tyché|Tyché]].&lt;br&gt;
'''Τύχων, -ος (nom propre) (m)''' : Tychon.&lt;br&gt;

==Υ==
'''ὕαινα, -ίνης (nom commun) (f)''' : hyène.&lt;br&gt;
'''ὕαλος, -άλου (nom commun) (m)''' : verre. (matière)&lt;br&gt;
'''ὑϐριζω (verbe)''' : maltraiter, outrager.&lt;br&gt;
'''ὕϐρις, -εως (nom commun) (f)''' : démesure, violence ; excès, outrage.&lt;br&gt;
'''ὑγίεια, -ίας (nom commun) (f)''' : propreté.&lt;br&gt;
'''ὑγιεινή, -ῆς (nom commun) (f)''' : santé.&lt;br&gt;
'''ὑγιεινός, -ή, -όν (adjectif)''' : salubre.&lt;br&gt; 
'''ὑγραίνω (verbe)''' : humidifier.&lt;br&gt;
'''ὑγρασία, -ας (nom commun) (f)''' : humidité.&lt;br&gt;
'''ὑγρός, -ά, -όν (adjectif)''' : humide.&lt;br&gt; 
'''ὑγρότατα, -, - (adverbe)''' : Superlatif de ''ὑγρῶς''.&lt;br&gt;
'''ὑγρότερον, -, - (adverbe)''' : Comparatif de ''ὑγρῶς''.&lt;br&gt;
'''ὑγρότατος, -άτη, -ότατον (adjectif)''' : Superlatif de ''ὑγρός''.&lt;br&gt;
'''ὑγρότερος, -έρα, -ότερον (adjectif)''' : Comparatif de ''ὑγρός''.&lt;br&gt;
'''ὑγρῶς (adverbe)''' : humidement.&lt;br&gt;
'''ὑδραγωγεῖον, -ίου (nom commun) (n)''' : aqueduc.&lt;br&gt;
'''ὑδράργυρος, -ύρου (nom commun) (m)''' : mercure.&lt;br&gt;
'''ὑδρόμελι, -τος (nom commun) (n)''' : Boisson à base d'eau et de miel.&lt;br&gt; 
'''ὑδρο- (préfixe)''' : hydro-.&lt;br&gt; 
'''ὕδωρ, -ατος (nom commun) (n)''' : Eau ; sueur.&lt;br&gt;
'''ὕενος, -ένου (nom commun) (m)''' : mercure.&lt;br&gt;
'''υἱός, -οῦ (nom commun) (m)''' : fils.&lt;br&gt; 
'''ὕλη, -ης (nom commun) (f)''' : matière ; bois.&lt;br&gt; 
'''ὑμεῖς (pronom personnel)''' : vous.&lt;br&gt;
'''ὑμέτερος, -έρα, -έτερον (adjectif possessif)''' : votre.&lt;br&gt;
'''ὑμήν, -ένος (nom commun) (m)''' : Membrane ; pellicule enveloppant les organes du corps.&lt;br&gt;
'''ὕμνος, -ου (nom commun) (m)''' : trame ; chant.&lt;br&gt; 
'''ὑμνῳδία, -ας (nom commun) (f)''' : hymne.&lt;br&gt; 
'''ὑμνῶ (verbe)''' : .&lt;br&gt; 
'''ὔμοι (adverbe)''' : Forme éolienne de ''ὁμοῦ''.&lt;br&gt; 
'''ὔμοιος, -, - (adjectif)''' : Forme éolienne de ''ὅμοιος''.&lt;br&gt;
'''ὑμοῖος, -, -ῖον (adjectif)''' : Forme arcado-chypriote de ''ὅμοιος''.&lt;br&gt;
'''ὑπαγόρευσις, -ύσεως (nom commun) (f)''' : dictée.&lt;br&gt;
'''ὑπάγω (verbe)''' : mener sous.&lt;br&gt;
'''ὑπακτικός -ή -όν (adjectif)''' : .&lt;br&gt;
'''ὑπακοή, -ῆς (nom commun) (f)''' : obéissance.&lt;br&gt;
'''ὑπάκουος, -η, -ον (adjectif)''' : obéissant.&lt;br&gt;
'''ὑπακούω (verbe)''' : obéir.&lt;br&gt;  
'''ὑπαρξιακός, -ή, -όν (adjectif)''' : existentiel.&lt;br&gt;
'''ὕπαρξις, -άρξεως (nom commun) (f)''' : existence.&lt;br&gt;
'''ὑπάρχω (verbe)''' : exister.&lt;br&gt;  
'''ὑπεξαίρεσις, -έσεως (nom commun) (f)''' : malversation.&lt;br&gt;
'''ὑπεξαιρῶ (verbe)''' : .&lt;br&gt; 
'''ὑπερκόσμιος, -α, -ο (adjectif)''' : .&lt;br&gt;
'''ὑπέρ (adverbe ; préposition)''' : au-dessus.&lt;br&gt;  
'''ὑπερϐάλλω (verbe)''' : exagérer.&lt;br&gt;
'''ὑπερϐολή, -ῆς (nom commun) (f)''' : exagération.&lt;br&gt; 
'''ὑπερϐολικός, -ή, -όν (adjectif)''' : excessif.&lt;br&gt; 
'''ὑπερθετικός, -ή, -όν (adjectif)''' : superlatif.&lt;br&gt;
'''ὑπεριώδης, -ης, -ες (adjectif)''' : ultraviolet.&lt;br&gt; 
'''ὑπεροπτικός, -ή, -όν (adjectif)''' : arrogant.&lt;br&gt;
'''ὑπέροπτος, -ος, -ον (adjectif)''' : .&lt;br&gt;
'''ὑπεροψία, -ας (nom commun) (f)''' : arrogance.&lt;br&gt;
'''ὑπέρυθρος, -η, -ον (adjectif)''' : infrarouge.&lt;br&gt;
'''ὑπερφυσικός, -ή, -όν (adjectif)''' : surnaturel.&lt;br&gt;
'''ὑπεύθυνος, -ος, -ον (adjectif)''' : responsable.&lt;br&gt;
'''ὑπευθυνότητα, -ας (nom commun) (f)''' : responsabilité.&lt;br&gt;
'''ὑπηρεσία, -ας (nom commun) (f)''' : service.&lt;br&gt;
'''ὑπηρέτης, -ου (nom commun) (m)''' : serviteur.&lt;br&gt;
'''ὑπηρετικός, -ή, -όν (adjectif)''' : de service.&lt;br&gt;
'''ὑπηρετικῶς (adverbe)''' : -ment.&lt;br&gt;
'''ὑπηρετικώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''ὑπηρετικός''.&lt;br&gt;
'''ὑπηρετικώτερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''ὑπηρετικός''.&lt;br&gt;
'''ὑπηρετικώτατα, -, - (adverbe)''' : Superlatif de ''ὑπηρετικῶς''.&lt;br&gt;
'''ὑπηρετικώτερον, -, - (adverbe)''' : Comparatif de ''ὑπηρετικῶς''.&lt;br&gt; 
'''ὑπηρέτρια, -ας (nom commun) (f)''' : servante.&lt;br&gt;  
'''ὑπηρετῶ (verbe)''' : servir.&lt;br&gt;  
'''ὑπνολαλία, -ας (nom commun) (f)''' : somniloquie.&lt;br&gt; 
'''ὑπνολαλῶ (verbe)''' : somniloquer.&lt;br&gt; 
'''ὕπνωσις, -ώσεως (nom commun) (f)''' : hypnose.&lt;br&gt;
'''ὑπνωτικός, -ή, -όν (adjectif)''' : hypnotique.&lt;br&gt;
'''ὑπνῶ (adjectif)''' : hypnotiser.&lt;br&gt;
'''ὑπόϐαθρον, -άθρου (nom commun) (n)''' : arrière-plan.&lt;br&gt;
'''ὑπόγειον, -ίου (nom commun) (n)''' : cave.&lt;br&gt;
'''ὑπόδειγμα, -ίγματος (nom commun) (n)''' : exemple.&lt;br&gt; 
'''ὑποδειγματικός, -ή, -όν (adjectif)''' : exemplaire.&lt;br&gt;
'''ὑποδείκνυμι (verbe)''' : .&lt;br&gt;
'''ὑπόδημα, -ήματος (nom commun) (n)''' : chaussure.&lt;br&gt;
'''ὑποδηματοποιεῖον, -ίου (nom commun) (n)''' : boutique du cordonnier.&lt;br&gt;
'''ὑποδηματοποιός, -οῦ (nom commun) (m)''' : cordonnier.&lt;br&gt;
'''ὑποζύγιον, -ίου (nom commun) (n)''' : attelage.&lt;br&gt;
'''ὑπόθεσις, -έσεως (nom commun) (f)''' : supposition.&lt;br&gt;
'''ὑποκινῶ (verbe)''' : .&lt;br&gt;  
'''ὑποκορίζομαι (verbe)''' : parler comme un enfant.&lt;br&gt; 
'''ὑποκόρισμα, -τος (nom commun) (n)''' : sobriquet.&lt;br&gt;
'''ὑποκοριστικός, -ή, -όν (adjectif)''' : caressant, propre à atténuer.&lt;br&gt;
'''ὑποκρίνομαι (verbe)''' : jouer une pièce.&lt;br&gt; 
'''ὑπόκρισις, -ίσεως (nom commun) (f)''' : Réponse. Action de jouer un rôle, une pièce, une pantomime. Débit théâtral, déclamation. Feinte, faux-semblant.&lt;br&gt; 
'''ὑποκριτής, -οῦ (nom commun) (m)''' : Donneur de réponse. Acteur, comédien.&lt;br&gt;
'''ὑπόκωφος, -η, -ον (adjectif)''' : sourd.&lt;br&gt;
'''ὑποκώφως (adverbe)''' : sourdement.&lt;br&gt;
'''ὑπολογίζομαι (verbe)''' : calculer.&lt;br&gt;
'''ὑπολογισμός, -οῦ (nom commun) (m)''' : calcul.&lt;br&gt; 
'''ὑπομιμνήσκω (verbe)''' : .&lt;br&gt;
'''ὑπομονή, -ῆς (nom commun) (f)''' : .&lt;br&gt;
'''ὑπόμνημα, -ήματος (nom commun) (n)''' : .&lt;br&gt;
'''ὑπόνομος, -ου (nom commun) (m)''' : égout.&lt;br&gt;
'''ὑπόστασις, -άσεως (nom commun) (f)''' : .&lt;br&gt;
'''ὑποταγή, -ῆς (nom commun) (f)''' : Subordination, soumission.&lt;br&gt;
'''ὑποτάσσω (verbe)''' : Subordonner, soumettre. Dominer, contrôler.&lt;br&gt;
'''ὑποτίθημι (verbe)''' : supposer.&lt;br&gt;
'''ὑπότριμμα, -ίμματος (nom commun) (n)''' : Sauce aux herbes, sauce verte et piquante.&lt;br&gt;
'''ὑπουργεῖον, -ίου (nom commun) (n)''' : ministère.&lt;br&gt;
'''ὑπουργικός, -ή, -όν (adjectif)''' : ministériel.&lt;br&gt;
'''ὑπουργός, -οῦ (nom commun) (m)''' : ministre.&lt;br&gt;
'''ὑποχώρησις, -ήσεως (nom commun) (f)''' : régression.&lt;br&gt;
'''ὑποχωρητικός, -ή, -όν (adjectif)''' : régressif.&lt;br&gt;
'''ὑποψήφιος, -ίου (nom commun) (m)''' : candidat.&lt;br&gt;
'''ὑπό (adverbe ; préposition)''' : en dessous.&lt;br&gt;  
'''ὑπο- (préfixe)''' : relatif au dessous.&lt;br&gt;
'''ὕραξ, -κος (nom commun) (m)''' : souris.&lt;br&gt;
'''ὕσσωπος, -ώπου (nom commun) (f)''' : hysope.&lt;br&gt;
'''ὕστατος, -η, -ον (adjectif)''' : dernier.&lt;br&gt;
'''ὑστερέω (verbe)''' : .&lt;br&gt;
'''ὑστέρησις, -ήσεως (nom commun) (f)''' : hystérèse.&lt;br&gt;
'''ὑστερικός, -ή, -όν (adjectif)''' : utérin ; hystérique.&lt;br&gt;
'''ὑστερο- (préfixe)''' : suivant ; tardif.&lt;br&gt;
'''ὕστερος, -α, -ον (adjectif)''' : postérieur.&lt;br&gt;
'''ὕστερος, -έρου (nom commun) (m)''' : matrice ; utérus.&lt;br&gt;
'''ὑστέρως (adverbe)''' : .&lt;br&gt;
'''ὕστριξ, -χός (nom commun) (m/f)''' : porc-épic.&lt;br&gt;
'''ὗς, -ός (nom commun) (m/f)''' : Porc, sanglier. Truie, laie.&lt;br&gt;
'''ὑφαίνω (verbe)''' : tisser.&lt;br&gt;
'''ὕφαλος, -άλου (nom commun) (m)''' : récif.&lt;br&gt;
'''ὑφή, -ῆς (nom commun) (f)''' : toile d’araignée.&lt;br&gt;
'''ὕφος, -ους (nom commun) (n)''' : tissu.&lt;br&gt;
'''ὑψηλός, -ή, -όν (adjectif)''' : .&lt;br&gt;
'''ὕψι (adverbe)''' : en haut.&lt;br&gt;
'''ὖ ψιλόν (nom commun) (n)''' : upsilon.&lt;br&gt;
'''ὑψίτερος, -έρη, -ερον (adverbe)''' : Comparatif de ''ὕψι''.&lt;br&gt;
'''ὕψιστος, -ίστη, -ιστον (adverbe)''' : Superlatif de ''ὕψι''.&lt;br&gt;
'''ὕψος, -ους (nom commun) (n)''' : hauteur.&lt;br&gt;
'''ὕψωμα, -ώματος (nom commun) (n)''' : élévation.&lt;br&gt; 
'''ὕψωσις, -ώσεως (nom commun) (f)''' : élévation.&lt;br&gt; 
'''ὑψῶ (verbe)''' : élever.&lt;br&gt;
'''ὕω (verbe)''' : pleuvoir.&lt;br&gt;
'''Ὕϐρις, -εως (nom propre) (f)''' : Hybris.&lt;br&gt;
'''Ὑδροχόος, -ου (nom propre) (m)''' : Verseau.&lt;br&gt;
'''Ὑγίεια, -ίας (nom propre) (f)''' : [[wikt:Hygie|Hygie]].&lt;br&gt;
'''Ὕηττος, -ήττου (nom propre) (m)''' : Hyettos.&lt;br&gt;
'''Ὑκσώς, -οῦς (nom commun) (m)''' : Hyksôs.&lt;br&gt; 
'''Ὕλλος, -ου (nom propre) (m)''' : Hyllos.&lt;br&gt;
'''Ὑμέναιος, -ίου (nom propre) (m)''' : [[wikt:Hyménée|Hyménée]].&lt;br&gt;
'''Ὑμήν, -ένος (nom propre) (m)''' : Variante de ''Ὑμέναιος''.&lt;br&gt;
'''Ὑπερίων, -ος (nom propre) (m)''' : Hypérion.&lt;br&gt;
'''Ὕπνος, -ου  (nom propre) (m)''' : [[wikt:Hypnos|Hypnos]].&lt;br&gt;
'''Ὑστάσπης, -ου (nom propre) (m)''' : Hystaspès.&lt;br&gt;
'''Ὕψιστος, -ίστου (nom propre) (m)''' : Très-Haut.&lt;br&gt;

==Φ==
'''φαγός, -οῦ (nom commun) (m)''' : Forme dorienne de ''φηγός''.&lt;br&gt;
'''φαιδρός, -ίδρα, -ιδρόν (adjectif)''' : brillant ; rayonnant, enjoué ; gai, jovial.&lt;br&gt;
'''φαίνεσθαι (verbe)''' : se montrer.&lt;br&gt;
'''φαινόμενον, -ένου  (nom commun) (n)''' : phénomène.&lt;br&gt;
'''φαίνω (verbe)''' : faire briller.&lt;br&gt;
'''φακός, -οῦ (nom commun) (m)''' : Lentille. (Anatomie) Cristallin. Tache de rousseur.&lt;br&gt;
'''φακόχοιρος, -ίρου (nom commun) (m)''' : phacochère.&lt;br&gt;
'''φάλαγξ, -γος (nom commun) (f)''' : phalange.&lt;br&gt;
'''φάλλαινα, -ίνης (nom commun) (f)''' : baleine.&lt;br&gt; 
'''φαλλός, -οῦ (nom commun) (m)''' : phallus.&lt;br&gt;
'''φάμη, -ης (nom commun) (f)''' : Forme dorienne de ''φήμη''.&lt;br&gt;
'''φαμί (verbe)''' : Forme dorienne de ''φημί''.&lt;br&gt;
'''φάναξ, -κος (nom commun) (m)''' : .&lt;br&gt;
'''φανερός, -ά, -όν (adjectif)''' : Apparent. En vue.&lt;br&gt;
'''φανερῶς (adverbe)''' : .&lt;br&gt;
'''φανερώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''φανερός''.&lt;br&gt;
'''φανερώτερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''φανερός''.&lt;br&gt;
'''φανερῶ (verbe)''' : .&lt;br&gt;
'''φανός, -οῦ (nom commun) (m)''' : .&lt;br&gt;
'''φάνταγμα, -άγματος (nom commun) (n)''' : Forme ionienne de ''φάντασμα''.&lt;br&gt; 
'''φαντάζω (verbe)''' : Dénoncer ; Se montrer, apparaître.&lt;br&gt;
'''φαντασία, -ας (nom commun) (f)''' : imagination.&lt;br&gt;
'''φάντασμα, -άσματος (nom commun) (n)''' : Apparition, vision, songe ; fantôme, spectre.&lt;br&gt;
'''φανταστής, -οῦ (nom commun) (m)''' : vantard.&lt;br&gt;
'''φανταστικός, -ή, -όν (adjectif)''' : imaginaire.&lt;br&gt;
'''φάραγξ, -γος (nom commun) (m)''' : canyon.&lt;br&gt; 
'''φαραώ (nom commun) (m)''' : pharaon.&lt;br&gt; 
'''φαρέτρα, -ας (nom commun) (f)''' : carquois.&lt;br&gt;
'''φαρέτρη, -ης (nom commun) (f)''' : Forme dorienne de ''φαρέτρα''.&lt;br&gt;
'''φαρετρεών, -ῶνος (nom commun) (m)''' : .&lt;br&gt;
'''φαρισαϊκός, -ή, -όν (adjectif) (f)''' : pharisien.&lt;br&gt;
'''φαρισαϊκότατα, -, - (adverbe)''' : Superlatif de ''φαρισαϊκῶς''.&lt;br&gt;
'''φαρισαϊκότερον, -, - (adverbe)''' : Comparatif de ''φαρισαϊκῶς''.&lt;br&gt;
'''φαρισαϊκῶς (adverbe)''' : pharisiennement.&lt;br&gt; 
'''φαρισαϊκώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''φαρισαϊκός''.&lt;br&gt;
'''φαρισαϊκώτερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''φαρισαϊκός''.&lt;br&gt;
'''φαρισαῖος, -ίου (nom commun) (m)''' : pharisien.&lt;br&gt;
'''φαρμακεία, -ας (nom commun) (f)''' : ensemble des médicaments.&lt;br&gt;
'''φαρμακεύς, -έως (nom commun) (m)''' : Apothicaire, empoisonneur. Sorcier.&lt;br&gt;
'''φαρμακευτικός, -ή, -όν (adjectif) (f)''' : de remède.&lt;br&gt;
'''φαρμακευτικότατα, -, - (adverbe)''' : Superlatif de ''φαρμακευτικῶς''.&lt;br&gt;
'''φαρμακευτικότερον, -, - (adverbe)''' : Comparatif de ''φαρμακευτικῶς''.&lt;br&gt;
'''φαρμακευτικῶς (adverbe)''' : .&lt;br&gt; 
'''φαρμακευτικώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''φαρμακευτικός''.&lt;br&gt;
'''φαρμακευτικώτερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''φαρμακευτικός''.&lt;br&gt;
'''φαρμακίς, -δος (nom commun) (f)''' :  Apothicaire, empoisonneuse. Sorcière.&lt;br&gt;
'''φάρμακον, -άκου (nom commun) (n)''' : Médicament, remède ; poison, préparation magique. Teinture, fard.&lt;br&gt; 
'''φαρμακοποσία, -ας''' : action de boire une potion.&lt;br&gt;
'''φαρμακοπώλης, -ου (nom commun) (m)''' : pharmacien.&lt;br&gt;
'''φαρμακός, -οῦ (nom commun) (m)''' : victime expiatoire.&lt;br&gt;
'''φαρμακοτρίϐης, -ου (nom commun) (m)''' : laborantin.&lt;br&gt;
'''φαρμακώδης, -ης, -ες (adjectif)''' : médicinal ; vénéneux.&lt;br&gt;
'''φαρμακῶ (verbe)''' : empoisonner.&lt;br&gt;
'''φάρυγξ, -γος (nom commun) (m)''' : gosier.&lt;br&gt;
'''φάσηλος, -ήλου (nom commun) (m)''' : haricot sec.&lt;br&gt;
'''φασιανικός, -ή, -όν (adjectif)''' : phasianien.&lt;br&gt;
'''φασιανός, -οῦ (nom commun) (m)''' : faisan.&lt;br&gt;
'''φάκελος, -έλου (nom commun) (m)''' : fagot, faisceau.&lt;br&gt;
'''φάσκος, -ου (nom commun) (m)''' : .&lt;br&gt;
'''φασκώλιον, -ίου (nom commun) (n)''' : valisette.&lt;br&gt; 
'''φάσκωλος, -ώλου (nom commun) (m)''' : valise.&lt;br&gt;
'''φάσμα, -τος (nom commun) (n)''' : spectre.&lt;br&gt;
'''φασματικός, -ή, -όν (adjectif)''' : spectral.&lt;br&gt;
'''φασματικώτατος, -άτη, -ότατον (adjectif)''' : Superlatif de ''φασματικός''.&lt;br&gt;
'''φασματικώτερος, -έρα, -ότερον (adjectif)''' : Comparatif de ''φασματικός''.&lt;br&gt;
'''φασματικῶς (adverbe)''' : spectralement.&lt;br&gt;
'''φασματικώτατα, -, - (adverbe)''' : Superlatif de ''φασματικῶς''.&lt;br&gt;
'''φασματικώτερον, -, - (adverbe)''' : Comparatif de ''φασματικῶς''.&lt;br&gt;
'''φάτις, -εως (nom commun) (f)''' : rumeur, parole.&lt;br&gt;
'''φάττα, -ης (nom commun) (f)''' : palombe ; ramier.&lt;br&gt;
'''φαῦλος, -ύλη, -ῦλον (adjectif)''' : vicieux.&lt;br&gt;
'''φέγγος, -ους (nom commun) (n)''' : .&lt;br&gt; 
'''φέρετρον, -έτρου (nom commun) (n)''' : cercueil.&lt;br&gt; 
'''φέρω (verbe)''' : porter.&lt;br&gt;
'''φεύγω (verbe)''' : fuir (prendre la fuite).&lt;br&gt;
'''φεῦξις, -ύξεως (nom commun) (f)''' : échappée, évasion ; fuite.&lt;br&gt;
'''φεῦ (interjection)''' : Hélas ; ah.&lt;br&gt;
'''φή (conjonction)''' : Forme homérique de ''ὡς''.&lt;br&gt;
'''φηγός, -οῦ (nom commun) (f)''' : chêne.&lt;br&gt;
'''φηλητής, -οῦ (nom commun) (m)''' : trompeur.&lt;br&gt;
'''φῆλος, -ος, -ον (adjectif)''' : trompeur.&lt;br&gt;
'''φήμη, -ης (nom commun) (f)''' : Voix prophétique, oracle. Rumeur, réputation.&lt;br&gt;
'''φημί (verbe)''' : dire.&lt;br&gt;
'''φήρ, -ός (nom commun) (m)''' : Forme éolienne de ''θήρ''.&lt;br&gt;
'''φθέγγομαι (verbe)''' : proférer.&lt;br&gt;
'''φθειρρός, -οῦ (nom commun) (m)''' : pou.&lt;br&gt;
'''φθείρω (verbe)''' : user.&lt;br&gt;
'''φθινόπωρον, -ώρου (nom commun) (n)''' : automne.&lt;br&gt;
'''φθίσις, -εως (nom commun) (f)''' : Déclin, ruine. Atrophie, consomption. Contraction, réduction de la pupille.&lt;br&gt;
'''φθίω (verbe)''' : périr, disparaitre.&lt;br&gt;
'''φθόγγος, -ου (nom commun) (m)''' : son.&lt;br&gt;
'''φθονερός, -ή, -όν (adjectif) (f)''' : envieux.&lt;br&gt;
'''φθόνησις, -ήσεως (nom commun) (f)''' : dénégation.&lt;br&gt;
'''φθόνος, -ου (nom commun) (m)''' : envie.&lt;br&gt;	
'''φθονῶ (verbe)''' : envier.&lt;br&gt;
'''φθορά, -ᾶς (nom commun) (f)''' : Perdition, perte, ruine, destruction. Action de corrompre, corruption, séduction. (Peinture) Dégradation de couleur, affaiblissement de teinte.&lt;br&gt;
'''φῖ (nom commun) (n)''' : phi.&lt;br&gt;
'''φίλαμα, -άματος (nom commun) (n)''' : Forme dorienne de ''φίλημα''.&lt;br&gt;
'''φιλαδελφία, -ας (nom commun) (f)''' philadelphie.&lt;br&gt;
'''φιλανδρία, -ας (nom commun) (f)''' philandrie.&lt;br&gt;
'''φιλανθρωπία, -ας (nom commun) (f)''' philanthropie.&lt;br&gt;
'''φιλάνθρωπος, -ος, -ον (adjectif)''' : Humain, bon ; bienveillant, affable. Qui aime les hommes (en parlant des dieux). Qui plaît aux hommes, agréable.&lt;br&gt;	
'''φιλαργυρία, -ας (nom commun) (f)''' : avarice.&lt;br&gt;
'''φιλάργυρος, -ος, -ον (adjectif)''' : avare.&lt;br&gt;
'''φίλειμι (verbe)''' : Forme béotienne de ''φιλῶ''.&lt;br&gt;
'''φίλημμι (verbe)''' : Forme éolienne de ''φιλῶ''.&lt;br&gt;
'''φιλία, -ας (nom commun) (f)''' : amitié, amour absolu, plaisir de la compagnie.&lt;br&gt;
'''φιλίη, -ης (nom commun) (f)''' : Forme ionienne de ''φιλία''.&lt;br&gt;
'''φίλημα, -ήματος (nom commun) (n)''' : baiser.&lt;br&gt;
'''φίλημμι (verbe)''' : Forme éolienne de ''φιλῶ''.&lt;br&gt;
'''φιλόγελως, -ωτος (nom commun) (m)''' : Amateur d'histoires drôles.&lt;br&gt;
'''φιλόπαις, -δός (nom commun) (m)''' : philopaide.&lt;br&gt;
'''φίλος, -η, -ον (adjectif)''' : amical.&lt;br&gt;
'''φίλος, -ου (nom commun) (m)''' : ami.&lt;br&gt;
'''φιλο- (préfixe)''' : qui aime.&lt;br&gt;
'''φιλογυνία, -ας (nom commun) (f)''' : philogynie.&lt;br&gt;
'''φιλοπαιδία, -ας (nom commun) (f)''' : philopaidie.&lt;br&gt; 
'''φιλόπαις, -αίδος (nom commun) (m)''' : philopaide.&lt;br&gt;
'''φιλοσοφία, -ας (nom commun) (f)''' : philosophie.&lt;br&gt; 
'''φιλοσοφικός, -ή, -όν (adjectif)''' : philosophique.&lt;br&gt;
'''φιλοσοφικότατος, -άτη, -ότατον (adjectif)''' : Superlatif de ''φιλοσοφικός''.&lt;br&gt;
'''φιλοσοφικότερος, -έρα, -ότερον (adjectif)''' : Comparatif de ''φιλοσοφικός''.&lt;br&gt;
'''φιλοσοφικῶς (adverbe)''' : philosophiquement.&lt;br&gt;
'''φιλοσοφικώτατα, -, - (adverbe)''' : Superlatif de ''φιλοσοφικῶς''.&lt;br&gt;
'''φιλοσοφικώτερον, -, - (adverbe)''' : Comparatif de ''φιλοσοφικῶς''.&lt;br&gt;
'''φιλόσοφος, -όφου (nom commun) (m)''' : philosophe.&lt;br&gt;
'''φιλοσοφῶ (verbe)''' : philosopher.&lt;br&gt;
'''φιλότης, -τος (nom commun) (f)''' : Amitié ; relation sexuelle.&lt;br&gt;
'''φιλύρα, -ας (nom commun) (f)''' : tilleul.&lt;br&gt;
'''φιλῶ (verbe)''' : Aimer d'amitié. Éprouver de l'amitié. Traiter en ami, regarder comme un ami. Donner un signe d'amitié. Aimer d'amour. (Par extension) Aimer. Voir volontiers, accueillir avec plaisir, approuver, agréer. Rechercher, poursuivre. Se plaire à.&lt;br&gt;
'''φίλως ‎(adverbe)''' : amicalement.&lt;br&gt;
'''φιμός, -οῦ (nom commun) (m)''' : .&lt;br&gt;
'''φίμωσις, -ώσεως (nom commun) (f)''' : musellement.&lt;br&gt;
'''φίμωτρον, -ου (nom commun) (m)''' : muselière.&lt;br&gt;
'''φιμῶ (verbe)''' : museler.&lt;br&gt;
'''φιτύω (verbe)''' : engendrer.&lt;br&gt;
'''φλέγμα, -τος (nom commun) (n)''' : flegme.&lt;br&gt;
'''φλέγω (verbe)''' : brûler.&lt;br&gt;   
'''φλέψ, -ϐός (nom commun) (f)''' : veine (vaisseau sanguin).&lt;br&gt;
'''φλέω (verbe)''' : sourdre.&lt;br&gt;  
'''φλίϐω (verbe)''' : étendre, presser.&lt;br&gt;
'''φλόγωσις, -ώσεως (nom commun) (m)''' : inflammation.&lt;br&gt;
'''φλογῶ (verbe)''' : flamber.&lt;br&gt;
'''φλοιός, -οῦ (nom commun) (m)''' : écorce.&lt;br&gt;  
'''φλόξ, -γός (nom commun) (m)''' : flamme.&lt;br&gt;
'''φλύαρος, -ος, -ον (adjectif)''' : bavard.&lt;br&gt;
'''φλυαρῶ (verbe)''' : bavarder.&lt;br&gt;
'''φλύκταινα, -ίνας (nom commun) (f)''' : cloque.&lt;br&gt; 
'''φλύζω (verbe)''' : Forme de ''φλύω''.&lt;br&gt;
'''φλύω (verbe)''' : couler.&lt;br&gt;
'''φοϐερός, -ά, -όν (adjectif)''' : effrayant.&lt;br&gt;
'''φόϐος, -ου (nom commun) (m)''' : peur.&lt;br&gt;
'''φοῖϐος, -η, -ον (adjectif)''' : .&lt;br&gt;
'''φοῖνιξ, -ίνικος (nom commun) (m)''' : palmier-dattier ; phénix.&lt;br&gt;
'''φονεύς, -έως (nom commun) (m)''' : meurtrier.&lt;br&gt;
'''φονεύω (verbe)''' : assassiner.&lt;br&gt;
'''φονικός, -ή, -όν (adjectif)''' : meurtrier.&lt;br&gt;
'''φόνος, -ου (nom commun) (m)''' : meurtre.&lt;br&gt;
'''φόρημα, -ήματος (nom commun) (n)''' : .&lt;br&gt;
'''φόρμιγξ, -γος (nom commun) (f)''' : (poésie) lyre.&lt;br&gt;
'''φορτίζω (verbe)''' : charger.&lt;br&gt;
'''φόρτισις, -ίσεως (nom commun) (f)''' : charge.&lt;br&gt;
'''φόρτος, -ου (nom commun) (m)''' : .&lt;br&gt;
'''φοῦκτα, -ύκτας (nom commun) (m)''' : poignée de main.&lt;br&gt;
'''φοῦρνος, -ύρνου (nom commun) (m)''' : four.&lt;br&gt;
'''φραγή, -ῆς (nom commun) (f)''' : bloc.&lt;br&gt;
'''φράγμα, -ατος (nom commun) (n)''' : clôture.&lt;br&gt;
'''φραγμός, -οῦ (nom commun) (m)''' : bloc.&lt;br&gt;
'''φράν, -ός (nom commun) (f)''' : Forme dorienne de ''φρήν''.&lt;br&gt;
'''φράσις, -εως (nom commun) (f)''' : Suite de mots.&lt;br&gt;
'''φράσσω (verbe)''' : déclarer.&lt;br&gt;
'''φράτηρ, -ερος (nom commun) (m)''' : Membre d'une phratrie.&lt;br&gt;
'''φρατήρ, -έρος (nom commun) (m)''' : Forme dorienne de ''φράτηρ''.&lt;br&gt;
'''φρατρία, -ας  (nom commun) (f)''' : phratrie.&lt;br&gt;
'''φρέαρ, -τος (nom commun) (n)''' : puits.&lt;br&gt;
'''φρενητικός, -ή, -όν (adjectif)''' : délirant.&lt;br&gt;  
'''φρενητικῶς (adverbe)''' : -ment.&lt;br&gt;
'''φρενητικώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''φρενητικός''.&lt;br&gt;
'''φρενητικώτερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''φρενητικός''.&lt;br&gt;
'''φρενητικώτατα, -, - (adverbe)''' : Superlatif de ''φρενητικῶς''.&lt;br&gt;
'''φρενητικώτερον, -, - (adverbe)''' : Comparatif de ''φρενητικῶς''.&lt;br&gt;
'''φρενῖτις, -ίτιδος (nom commun) (f)''' : délire.&lt;br&gt;
'''φρήν, -ενός (nom commun) (f)''' : Toute membrane qui enveloppe un organe. (Au pluriel) Viscères, entrailles. (Par suite) (Poésie) Cœur, âme.&lt;br&gt;
'''φρήτηρ, -ερος (nom commun) (m)''' : Forme ionienne de ''φράτηρ''.&lt;br&gt;
'''φρίκη, -ης (nom commun) (f)''' : terreur.&lt;br&gt;
'''φρίξ, -ικός (nom commun) (f)''' : terreur.&lt;br&gt;	
'''φριξός, -ή, -όν (adjectif)''' : terrifiant.&lt;br&gt;
'''φρίσσω (verbe)''' : terroriser.&lt;br&gt;
'''φρόνημα, -ήματος (nom commun) (n)''' : Intelligence, pensée. Manière de penser.&lt;br&gt;
'''φρόνησις, -ήσεως (nom commun) (f)''' : Pensée, dessein. Intelligence raisonnable, sagesse. Intelligence (ou sagesse) divine.&lt;br&gt;
'''φρόνιμος, -ος, -ον (adjectif)''' : sensé.&lt;br&gt;
'''φρονῶ (verbe)''' : Penser, avoir la faculté de penser ou de sentir, vivre. Être dans son bon sens. Penser. Être sensé. Avoir dans l’esprit. Songer à, projeter de.&lt;br&gt;
'''φρουρά, -ᾶς (nom commun) (m)''' : garde (corps d’armée).&lt;br&gt;
'''φρουρή, -ῆς (nom commun) (m)''' : Forme ionienne de ''φρουρή''.&lt;br&gt;
'''φρούρημα, -ήματος (nom commun) (n)''' : bannissement.&lt;br&gt; 
'''φρούρησις, -ήσεως (nom commun) (f)''' : fuite, bannissement.&lt;br&gt;
'''φρουρητός, -ός, -όν (adjectif)''' : banni.&lt;br&gt;
'''φρούριον, -ίου (nom commun) (n)''' : forteresse.&lt;br&gt; 
'''φρουρός, -οῦ (nom commun) (m)''' : garde (surveillant).&lt;br&gt;
'''φρουρῶ (verbe)''' : bannir.&lt;br&gt;
'''φρύγω (verbe)''' : rôtir.&lt;br&gt;
'''φρῦνος, -ύνου (nom commun) (m)''' : crapaud.&lt;br&gt;
'''φυγάς, -δος (nom commun) (m)''' : fugitif.&lt;br&gt;
'''φυγή, -ῆς (nom commun) (f)''' : fuite, bannissement.&lt;br&gt;
'''φύζω (verbe)''' : Forme ionienne de ''φεύγω''.&lt;br&gt;
'''φυίω (verbe)''' : Forme éolienne de ''φύω''.&lt;br&gt;
'''φυλακή, -ῆς (nom commun) (f)''' : garde, surveillance ; vigilance.&lt;br&gt;
'''φυλακτήριον, -ίου (nom commun) (n)''' : amulette.&lt;br&gt; 
'''φυλακτήρ, -ῆρος (nom commun) (m)''' : garde.&lt;br&gt;
'''φυλάξις, -εως (nom commun) (f)''' : garde.&lt;br&gt;
'''φύλαξ, -κος (nom commun) (m)''' : observateur, garde ; protecteur.&lt;br&gt;
'''φυλάσσω (verbe)''' : garder.&lt;br&gt;
'''φυλάττω (verbe)''' : Forme attique de ''φυλάσσω''.&lt;br&gt;
'''φυλετικός, -ή, -όν (adjectif)''' : racial.&lt;br&gt;
'''φυλή, -ῆς (nom commun) (f)''' : Tribu, groupe de familles de même races ; (Militaire) Corps de troupes au nombre de 10.  (Par extension) Classe, genre ; espèce.&lt;br&gt;
'''φύλλον, -ου (nom commun) (n)''' : feuille.&lt;br&gt;
'''φυλλόω (verbe)''' : .&lt;br&gt;
'''φῦλον, -ύλου (nom commun) (n)''' : groupe, tribu ; nation.&lt;br&gt;
'''φῦμα, -ύματος (nom commun) (n)''' : .&lt;br&gt;
'''φυμάτιον, -ίου (nom commun) (n)''' : .&lt;br&gt;
'''φύραμα, -τος (nom commun) (n)''' : .&lt;br&gt;
'''φυράω (verbe)''' : .&lt;br&gt;
'''φύρδην (adverbe)''' : .&lt;br&gt;
'''φυρατέον, -ου (nom commun) (n)''' : .&lt;br&gt;
'''φυρατής, -οῦ (nom commun) (m)''' : .&lt;br&gt;
'''φύρμα, -τος (nom commun) (n)''' : .&lt;br&gt;
'''φυρμός, -οῦ (nom commun) (m)''' : .&lt;br&gt;
'''φύρσιμος, -ίµου (nom commun) (m)''' : .&lt;br&gt;
'''φύρσις, -εως (nom commun) (f)''' : .&lt;br&gt;
'''φύρω (verbe)''' : .&lt;br&gt;
'''φυσσαλίς, -δος (nom commun) (m)''' : bulle.&lt;br&gt; 
'''φῦσα, -ύσας (nom commun) (f)''' : .&lt;br&gt;
'''φυσάω (verbe)''' : .&lt;br&gt; 
'''φυσητήρ, -ῆρος (nom commun) (m)''' : soupirail.&lt;br&gt;
'''φῦσιγξ, -ύσιγγος (nom commun) (m)''' : cartouche.&lt;br&gt; 
'''φύσις, -εως (nom commun) (f)''' : nature.&lt;br&gt; 
'''φυσικός, -ή, -όν, (adjectif)''' : naturel.&lt;br&gt;
'''φυσικῶς (adverbe)''' : naturellement.&lt;br&gt;
'''φυσικώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''φυσικός''.&lt;br&gt;
'''φυσικώτερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''φυσικός''.&lt;br&gt;
'''φυσικώτατα, -, - (adverbe)''' : Superlatif de ''φυσικῶς''.&lt;br&gt;
'''φυσικώτερον, -, - (adverbe)''' : Comparatif de ''φυσικῶς''.&lt;br&gt;
'''φύσκα, -ας (nom commun) (f)''' : Forme dorienne de ''φύσκη''.&lt;br&gt;
'''φύσκη, -ης (nom commun) (f)''' : .&lt;br&gt;
'''φύτευμα, -ύματος (nom commun) (n)''' : raiponce.&lt;br&gt;
'''φυτεύω (verbe)''' : planter.&lt;br&gt;  
'''φυτόν, -οῦ (nom commun) (n)''' : végétal, plante.&lt;br&gt; 
'''φυτο- (préfixe)''' : relatif aux plantes.&lt;br&gt;
'''φῦ (interjection)''' : pouah.&lt;br&gt;
'''φύω (verbe)''' : croître.&lt;br&gt;
'''φώκη, -ης (nom commun) (f)''' : phoque.&lt;br&gt;
'''φώκιος, -ος, -ον (adjectif)''' : phocidien.&lt;br&gt;
'''φωλεός, -οῦ (nom commun) (m)''' : tanière, terrier.&lt;br&gt;
'''φωνήεις, -σσα, -ῆεν (adjectif)''' : vocalique.&lt;br&gt;
'''φωνῆεν, -ήεντος (nom commun) (n)''' : voyelle.&lt;br&gt;
'''φωνή, -ῆς (nom commun) (f)''' : voix.&lt;br&gt;
'''φώνημα, -ήματος (nom commun) (n)''' : phonème.&lt;br&gt;
'''φωνητικός, -ή, -όν (adjectif)''' : phonétique.&lt;br&gt; 
'''φωνητικῶς (adverbe)''' : phonétiquement.&lt;br&gt;
'''φωνητικώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''φωνητικός''.&lt;br&gt;
'''φωνητικώτερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''φωνητικός''.&lt;br&gt;
'''φωνῶ (verbe)''' : Faire entendre un son de voix. Parler haut, dire d'une voix forte, élever la voix Ordonner, commander, prescrire. Parler de. Chanter.&lt;br&gt;
'''φώς, -τός (nom commun) (m)''' : homme.&lt;br&gt;
'''φῶς, -τός (nom commun) (n)''' : lumière, éclair.&lt;br&gt;
'''φωσφορίζων, -ουσα, -ον (adjectif)''' : fluorescent.&lt;br&gt;
'''φωσφορίζω (verbe)''' : fluorescer.&lt;br&gt;
'''φωσφόρος, -ος, -ον (adjectif)''' : qui apporte la lumière.&lt;br&gt; 
'''Φαέθουσα, -ας (nom propre) (f)''' : Phaéthuse.&lt;br&gt; 
'''Φαέθων, -οντος (nom propre) (m)''' : Phaéton.&lt;br&gt;
'''Φαίδρα, -ας (nom propre) (f)''' : Phèdre.&lt;br&gt;
'''Φαῖδρος, -ίδρου (nom propre) (f)''' : Phèdre.&lt;br&gt;
'''Φαιδρία, -ας (nom propre) (f)''' : Phédrie.&lt;br&gt;
'''Φαμενώθ (nom propre) (m)''' : Phaminoth.&lt;br&gt;
'''Φαντασός, -οῦ (nom propre) (m)''' : Phantasos.&lt;br&gt;
'''Φάρος, -ου (nom propre) (f)''' : Pharos.&lt;br&gt;
'''Φαρμουθί (nom propre) (m)''' : Pharmouti.&lt;br&gt;
'''Φασιανός, -οῦ (nom commun) (m)''' : Phasien.&lt;br&gt;
'''Φᾶσις, -άσιος (nom propre) (m)''' : Phase.&lt;br&gt;
'''Φαῶφι (nom propre) (m)''' : Phaophi.&lt;br&gt;
'''Φειδίας, -ου (nom propre) (m)''' : Phidias.&lt;br&gt;
'''Φερεκύδης, -ου (nom propre) (m)''' : Phérécyde.&lt;br&gt;
'''Φερενίκη, -ης (nom propre) (f)''' : Véronique.&lt;br&gt;
'''Φηγεύς, -έως (nom propre) (m)''' : Phégée.&lt;br&gt;
'''Φθόνος, -ου (nom propre) (m)''' : [[wikt:Phtonos|Phtonos]].&lt;br&gt;
'''Φιλάμμων, -ονος (nom propre) (m)''' : Philammon. (Demi-frère d'Autolycos.)&lt;br&gt; 
'''Φιλέας, -ου (nom propre) (m)''' : Philéas.&lt;br&gt;
'''Φίλιππος, -ίππου (nom propre) (m)''' : Philippe.&lt;br&gt;
'''Φιλόγελως, -τος (nom propre) (m)''' : Philogélos. (Recueil d’histoires drôles probablement rédigé au V{{e}} siècle apr. J.-C., attribué à Hiéroclès et Philagrios)&lt;br&gt;
'''Φιλοκτήτης, -ου (nom propre) (m)''' : Philoctète.&lt;br&gt; 
'''Φιλομήλη, -ης (nom propre) (f)''' : Philomèle.&lt;br&gt;
'''Φιλότης, -τος (nom propre) (f)''' : [[wikt:Philotès|Philotès]].&lt;br&gt;
'''Φίλων, -ος (nom propre) (m)''' : Philo.&lt;br&gt;
'''Φιλώτας, -ου (nom propre) (m)''' : Philinte.&lt;br&gt;
'''Φινεές, -οῦ (nom propre) (m)''' : Phinées.&lt;br&gt;
'''Φινεύς, -έως (nom propre) (m)''' : Phinée.&lt;br&gt;
'''Φίξ, -γγός  (nom propre) (f)''' : Forme béotienne de ''Σφίγξ''.&lt;br&gt;
'''Φλεγέθων, -οντος (nom propre) (m)''' : Phlégéthon.&lt;br&gt;
'''Φλεγύας, -ντος (nom propre) (m)''' : Phlégias. (père de Coronis)&lt;br&gt;
'''Φλέγων, -ος (nom propre) (m)''' : Phlégon.&lt;br&gt;
'''Φοϐητώρ, -όρος (nom propre) (m)''' : Phobétor.&lt;br&gt;
'''Φοίϐη, -ης (nom propre) (f)''' : [[wikt:Phœbé|Phœbé]].&lt;br&gt;
'''Φοιϐίδας, -ου (nom propre) (m)''' : [[wikt:Phébidas|Phébidas]].&lt;br&gt;
'''Φοῖϐος, -ίϐου (nom propre) (m)''' : [[wikt:Phébus|Phébus]].&lt;br&gt;
'''Φοῖνιξ, -ίνικος (nom commun) (m/f)''' : Phénicien. Carthaginois. (les descendants de Phénicie.)&lt;br&gt;
'''Φόϐος, -ου (nom propre) (m)''' : Phobos.&lt;br&gt;
'''Φραόρτης, -ου (nom propre) (m)''' : .&lt;br&gt;
'''Φρυγία, -ας (nom propre) (f)''' : Phrygie.&lt;br&gt; 
'''Φρύξ, -γός (nom commun) (m)''' : Phrygien.&lt;br&gt;
'''Φυλεύς, -έως (nom propre) (m)''' : Phylée (fils d’Augias).&lt;br&gt; 
'''Φυλλίς, -δος (nom propre) (f)''' :  Phyllis.&lt;br&gt;
'''Φυσίγναθος, -άθου (nom propre) (f)''' : Physignathe.&lt;br&gt; 
'''Φωκεύς, -έως (nom commun) (m)''' : Phocidien.&lt;br&gt;
'''Φώκαια, -ίας (nom propre) (f)''' : Phocée. (Ancienne cité grecque d’Asie Mineure.)&lt;br&gt; 
'''Φωκαιεύς, -έως (nom commun) (m)''' : Phocéen.&lt;br&gt;
'''Φωκαιίς, -δος (nom commun) (f)''' : Phocéenne.&lt;br&gt; 
'''Φωκίς, -δος (nom propre) (f)''' : Phocide.&lt;br&gt; 
'''Φῶκος, -ώκου (nom propre) (m)''' : Phocus.&lt;br&gt;
'''Φορμίων, -ος (nom propre) (m)''' : Phormion.&lt;br&gt;
'''Φωτεινή, -ῆς (nom propre) (f)''' : Photine.&lt;br&gt;

==Χ==
'''χαίνω (verbe)''' : .&lt;br&gt;
'''χαῖρε (interjection)''' (Devient ''χαίρετε'' au pluriel.) : bonjour ; salut.&lt;br&gt;
'''χαίρω (verbe)''' : se réjouir ; être joyeux. Se réjouir d'ordinaire, se plaire d'ordinaire à ou dans. Avoir sujet de se réjouir.&lt;br&gt;
'''χάλαζα, -άζης  (nom commun) (f)''' : grêle.&lt;br&gt; 
'''χαλαρός, -ά, -όν (adjectif)''' : détendu.&lt;br&gt;
'''χαλαρότης, -τος (nom commun) (f)''' : détente.&lt;br&gt; 
'''χαλάρωσις, -ώσεως (nom commun) (f)''' : détente.&lt;br&gt; 
'''χαλαρῶς (adverbe)''' : .&lt;br&gt;
'''χαλαρῶ (verbe)''' : détendre.&lt;br&gt;
'''χαλάω (verbe)''' : Lâcher, relâcher. Laisser tomber, baisser, rabaisser. Laisser aller. (Au passif) Être adouci. Être indulgent. Céder le passage. Affaiblir.&lt;br&gt;
'''χάλασις, -άσεως (nom commun) (f)''' : Relâchement, relaxation.&lt;br&gt; 
'''χαλεπός, -ή, -όν (adjectif)''' : difficile.&lt;br&gt;
'''χαλεπῶς (adverbe)''' : difficilement.&lt;br&gt;
'''χαλεπώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''χαλεπός''.&lt;br&gt;
'''χαλεπώτερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''χαλεπός''.&lt;br&gt;
'''χάλιξ, -κος (nom commun) (m/f)''' : galet ; gravier.&lt;br&gt;
'''χαλκεύς, -έως (nom commun) (m)''' : forgeron.&lt;br&gt;
'''χαλκός, -οῦ (nom commun) (m)''' : cuivre ; bronze, fer.&lt;br&gt;
'''χαλυϐήϊος, -ΐα, -ήϊον (adjectif)''' : d’acier.&lt;br&gt;
'''χάλυψ, -ϐος (nom commun) (m)''' : acier.&lt;br&gt;
'''χαμᾶζε (adverbe)''' : à terre (avec mouvement).&lt;br&gt;
'''χαμαί (adverbe)''' : à terre (sans mouvement).&lt;br&gt;
'''χαμαικέρασος, -άσου (nom commun) (f)''' : fraise.&lt;br&gt;
'''χαμαιλέων, -οντος (nom commun) (m)''' : caméléon.&lt;br&gt;
'''χαμαίμηλον, -ήλου (nom commun) (f)''' : camomille.&lt;br&gt;
'''χαμαιτυπεῖον, -ίου (nom commun) (n)''' : lupanar.&lt;br&gt;
'''χαμαιτύπη, -ης (nom commun) (f)''' : prostituée.&lt;br&gt;	
'''χάν, -ός (nom commun) (m/f)''' : Forme dorienne de ''χήν''.&lt;br&gt;
'''χάος, -ους (nom commun) (n)''' : chaos.&lt;br&gt;
'''χαρά, -ᾶς (nom commun) (f)''' : joie ; plaisir.&lt;br&gt;
'''χαρακτηρίζω (verbe)''' : inscrire, marquer.&lt;br&gt;
'''χαρακτήρ, -ῆρος (nom commun) (m)''' : Fer pour marquer le bétail, marque faite au fer rouge. Marque, signe, empreinte, stigmate. Cachet, caractère, genre de style, style.&lt;br&gt;
'''χαράσσω (verbe)''' : Aiguiser. Gratter, couper.&lt;br&gt;
'''χάραξ, -κος (nom commun) (m)''' : pieu.&lt;br&gt;
'''χαριέντως (adverbe)''' : gracieusement.&lt;br&gt;
'''χαρίεις, -εσσα, -εν (adjectif)''' : gracieux.&lt;br&gt;
'''χαρίϝεις, -εσσα, -εν (adjectif)''' : Forme homérique de ''χαρίεις''.&lt;br&gt;
'''χαριέστατος, -άτη, -έστατον (adjectif)''' : Superlatif de ''χαρίεις''.&lt;br&gt;
'''χαριέστερος, -έρα, -ερον (adjectif)''' : Comparatif de ''χαρίεις''.&lt;br&gt;
'''χαρίϝεττα, -, - (adjectif)''' : Forme béotienne de ''χαρίεις''.&lt;br&gt;
'''χαρίζομαι (verbe)''' : .&lt;br&gt;
'''χάρις, -τος (nom commun) (f)''' : Ce qui brille ; ce qui réjouit. Grâce.&lt;br&gt;
'''χάρισμα, -ίσματος (nom commun) (n)''' : grâce accordée par Dieu.&lt;br&gt;
'''χαριτῶ (verbe)''' : .&lt;br&gt;
'''χάρμα, -τος (nom commun) (n)''' : source de joie, délice.&lt;br&gt;
'''χάσμα, -τος (nom commun) (n)''' : béance, ouverture ; creux, gouffre. Abysse.&lt;br&gt;
'''χάσκω (verbe)''' : bayer, béer.&lt;br&gt;
'''χαῦνος, -ύνη, -ῦνον (adjectif)''' : .&lt;br&gt;
'''χαυνότης, -τος (suffixe) (f)''' : .&lt;br&gt;
'''χαυνῶ (verbe)''' : .&lt;br&gt;
'''χέζω (verbe)''' : chier.&lt;br&gt;
'''χεῖμα, -ίματος (nom commun) (n)''' : hiver.&lt;br&gt;
'''χείμαρρος, -άρρου (nom commun) (m)''' : torrent.&lt;br&gt;
'''χειμών, -ῶνος  (nom commun) (m)''' : (sens propre) Mauvais temps. (sens figuré) Trouble.&lt;br&gt;
'''χειραφέτησις, -ήσεως (nom commun) (f)''' : émancipation.&lt;br&gt;
'''χείριστος, -ίστη, -ίριστον  (adjectif)''' : Superlatif de ''κακός''.&lt;br&gt;
'''χείρ, -ός (nom commun) (f)''' : main.&lt;br&gt;
'''χειρόγραφον, -άφου (nom commun) (n)''' : manuscrit.&lt;br&gt;
'''χειρόγραφος, -η, -ον (adjectif)''' : manuscrit.&lt;br&gt;
'''χείρων, -ων, -ῖρον (adjectif)''' : Comparatif de ''κακός''.&lt;br&gt;
'''χελιδών, -ονός  (nom commun) (f)''' : hirondelle.&lt;br&gt;
'''χελώνη, -ης (nom commun) (f)''' : tortue.&lt;br&gt;
'''χερνίϐιον, -ίου (nom commun) (n)''' : pot de chambre.&lt;br&gt;
'''χερσόνησος, -ήσου (nom commun) (f)''' : péninsule.&lt;br&gt;
'''χέρσος, -ος, -ον (adjectif)''' : sec ; stérile.&lt;br&gt;
'''χέω (verbe)''' : jouir. (Profiter d'une chose que l'on possède.)&lt;br&gt;
'''χηλή, -ῆς (nom commun) (f)''' : pince ; serre de certains animaux.&lt;br&gt;
'''χηλός, -οῦ  (nom commun) (m)''' : coffre.&lt;br&gt;
'''χήν, -ός (nom commun) (m/f)''' : jars ; oie.&lt;br&gt;
'''χήρα, -ας (nom commun) (f)''' : veuve.&lt;br&gt;
'''χῆρος, -ήρου (nom commun) (m)''' : veuf.&lt;br&gt;
'''χθές (adverbe)''' : hier.&lt;br&gt;
'''χθόνιος, -α, -ον (adjectif)'''  : Relatif aux divinités infernales.&lt;br&gt;
'''χθών, -ονός  (nom commun) (f)''' : Sol, terre. Terre, pays, contrée. Ensemble du sol terrestre, terre entière. Terre comme séjour des vivants et des morts.&lt;br&gt;
'''χῖ (nom commun) (n)''' : chi.&lt;br&gt;
'''χίλιοι (adjectif numéral)''' : mille.&lt;br&gt;
'''χιόνεος, -έα, -εον (verbe)''' : enneigé.&lt;br&gt;
'''χιονίζω (verbe)''' : enneiger.&lt;br&gt;
'''χιονόχρως (adjectif)''' : blanc comme neige.&lt;br&gt;
'''χιτών, -ῶνος (nom commun) (m)''' : chiton.&lt;br&gt;
'''χιών, -όνος (nom commun) (f)''' : neige.&lt;br&gt;
'''χλαμύς, -δος (nom commun) (n)''' : chlamyde.&lt;br&gt;
'''χλευάζω (verbe)''' : se moquer.&lt;br&gt;
'''χλευασία, -ας (nom commun) (f)''' : moquerie.&lt;br&gt;
'''χλευασμός, -οῦ (nom commun) (m)''' : Moquerie ; blague.&lt;br&gt;
'''χλιαρός, -ή, -όν (adjectif)''' : tiède.&lt;br&gt;
'''χλωμός -ή -όν (adjectif)''' : pâle.&lt;br&gt;
'''χλωρός, -ά, -όν (adjectif)''' : Vert ; jaune verdâtre.&lt;br&gt; 
'''χοῖρος, -ίρου (nom commun) (m)''' : Petit cochon. (Par extension) Cochon engraissé, porc.&lt;br&gt;
'''χόνδρος, -ου (nom commun) (m)''' : Petit corps dur et rond, grain. Grain de froment et d’épeautre. Froment, épeautre. Cartilage.&lt;br&gt;
'''χονδρός, -ά, -όν (adjectif)''' : gros.&lt;br&gt;  
'''χονδρότατος, -άτη, -ότατον (adjectif)''' : Superlatif de ''χονδρός''.&lt;br&gt;
'''χονδρότερος, -έρα, -ότερον (adjectif)''' : Comparatif de ''χονδρός''.&lt;br&gt;
'''χονδρύνω (verbe)''' : grossir.&lt;br&gt;
'''χονδρῶς (adverbe)''' : .&lt;br&gt;	
'''χοραύλης, -ου (nom commun) (m)''' : choraule.&lt;br&gt;
'''χοραυλικός, -ή, -όν (adjectif)''' : choraulique.&lt;br&gt;
'''χορδή, -ῆς (nom commun) (f)''' : ficelle.&lt;br&gt; 
'''χορεία, -ας (nom commun) (f)''' : danse.&lt;br&gt;
'''χορεῖος, -ίου (nom commun) (m)''' : chorée.&lt;br&gt;
'''χορευτής, -οῦ (nom commun) (m)''' : danseur.&lt;br&gt;
'''χορεύω (verbe)''' : danser.&lt;br&gt;
'''χορήγιον, -ίου (nom commun) (m)''' : chorégie.&lt;br&gt;
'''χορηγός, -οῦ (nom commun) (m)''' : chorège.&lt;br&gt;
'''χορικός, -ή, -όν (adjectif)''' : chorique.&lt;br&gt;
'''χοροκιθαριστής, -οῦ (nom commun) (m)''' : chorocithariste.&lt;br&gt;
'''χορός, -οῦ (nom commun) (m)''' : danse en ronde.&lt;br&gt;
'''χόρτος, -ου (nom commun) (m)''' : Enclos. Pré clôturé ; pâturage. Nourriture.&lt;br&gt;
'''χορῳδία, -ας (nom commun) (f)''' : .&lt;br&gt;
'''χράω (verbe)''' : Frapper, attaquer. Infliger, asséner. Désirer ardemment. Proclamer. (Au passif) Être déclaré par un oracle. (Voix moyenne) Consulter un oracle, être averti par un oracle. Fournir, prêter. Utiliser. Avoir besoin de.&lt;br&gt;
'''χρεία, -ας  (nom commun) (f)''' : Usage, emploi. Manière dont on fait usage. Profit qu'on retire d'un usage. Besoin, nécessité.&lt;br&gt;
'''χρείη, -ης  (nom commun) (f)''' : Forme ionienne de ''χρεία''.&lt;br&gt;
'''χρεώ (verbe)''' : avoir besoin.&lt;br&gt;
'''χρῄζω (verbe)''' : nécessiter, désirer ; vouloir.&lt;br&gt;
'''χρή (verbe)''' : il faut.&lt;br&gt;
'''χρῆμα, -ήματος (nom commun) (n)''' : Chose dont on se sert, ou dont on a besoin. (Au singulier) Ce dont on se sert, chose, affaire. Évènement, occurrence. (Au pluriel) Bien, avoir.&lt;br&gt;
'''χρῆσις, -ήσεως (nom commun) (f)''' : .&lt;br&gt;
'''χρησμός, -οῦ (nom commun) (f)''' : oracle.&lt;br&gt;
'''χρηστομάθεια, -ίας  (nom commun) (f)''' : savoir utile.&lt;br&gt;
'''χρηστός, -ή	-όν (adjectif)''' : Dont on peut se servir. Qui rend service.&lt;br&gt;
'''χρηστότης, -τος (nom commun) (f)''' : Bonne qualité, bonté. (En particulier) Bonté de cœur.&lt;br&gt;
'''χρίζω (verbe)''' : oindre.&lt;br&gt;
'''χρῖσμα, -ίσματος (nom commun) (n)''' : onction.&lt;br&gt;
'''χρονικός, -ή	-όν (adjectif)''' : temporel.&lt;br&gt;
'''χρονικῶς (adverbe)''' : temporellement.&lt;br&gt;
'''χρονικώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''χρονικός''.&lt;br&gt;
'''χρονικώτερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''χρονικός''.&lt;br&gt;
'''χρόνιος, -ία	-όνιον (adjectif)''' : tardif.&lt;br&gt;
'''χρονίως (adverbe)''' : tardivement.&lt;br&gt;
'''χρονιώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''χρονίως''.&lt;br&gt;
'''χρονιώτερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''χρονίως''.&lt;br&gt;
'''χρόνος, -ου (nom commun) (m)''' : temps (durée).&lt;br&gt;
'''χρυσαίετος, -ου (nom commun) (m)''' : aigle royal.&lt;br&gt;
'''χρυσάνθεμον, -έμου (nom commun) (n)''' : chrysanthème.&lt;br&gt;
'''χρυσόγονον, -όνου (nom commun) (n)''' : navet noir.&lt;br&gt;
'''χρυσομηλιά, -ᾶς (nom commun) (f)''' : orange.&lt;br&gt;
'''χρυσός, -οῦ (nom commun) (m)''' : or.&lt;br&gt;
'''χρῶμα, -ώματος (nom commun) (n)''' : couleur.&lt;br&gt;
'''χυδαῖος, -ίη ,-ῖον (adjectif)''' : s’affaissant ; commun. Vulgaire.&lt;br&gt;
'''χυδαιολογία, -ας (nom commun) (f)''' : .&lt;br&gt;
'''χυλός, οῦ (nom commun) (m)''' : gruau.&lt;br&gt;
'''χυλοπίτα, -ας (nom commun) (f)''' : .&lt;br&gt;
'''χυλώδης, -ης, -ες (adjectif)''' : .&lt;br&gt;
'''χύλωμα, -τος (nom commun) (n)''' : .&lt;br&gt;
'''χυλώνω (verbe)''' : .&lt;br&gt;
'''χύμα, -τος (nom commun) (n)''' : suc.&lt;br&gt; 
'''χυμεία, -ας (nom commun) (f)''' : .&lt;br&gt;
'''χυµός, -οῦ (nom commun) (m)''' : jus.&lt;br&gt;
'''χωλαίνω (verbe)''' : boiter.&lt;br&gt;
'''χωλίαμϐος, -άμϐου  (nom commun) (m)''' : choliambe.&lt;br&gt;	
'''χωλός, -ή, -όν (adjectif)''' : boiteux. (En parlant de l'intelligence) Dont l'esprit cloche, infirme d'esprit. Mal équilibré, instable, chancelant.(Rhétorique) Boiteux. (Métrique) Qui n'est pas sur ses pieds, boiteux.&lt;br&gt;
'''χωλότης, -τος (nom commun) (f)''' : .&lt;br&gt;
'''χωλῶς (adverbe)''' : en boitant.&lt;br&gt;
'''χωλότατος, -άτη, -ότατον (adjectif)''' : Superlatif de ''χωλός''.&lt;br&gt;
'''χωλότερος, -έρα, -ότερον (adjectif)''' : Comparatif de ''χωλός''.&lt;br&gt;
'''χῶμα, -ώματος (nom commun) (n)''' : (Militaire) Terrassement. (Par extension) Toute jetée, même en pierres, môle.&lt;br&gt;
'''κώμη, -ης (nom commun) (f)''' : village.&lt;br&gt;
'''χώρα, -ας  (nom commun) (f)''' : Lieu. Place, endroit. (Militaire) Poste, position. (Au sens abstrait) Moment. Pays, région. Campagne. Champ, ferme.&lt;br&gt; 
'''χώρη, -ης (nom commun) (f)''' : Forme ionienne de ''χώρα''.&lt;br&gt;
'''χωρίζω (verbe)''' : séparer.&lt;br&gt;
'''χωρίον, -ου (nom commun) (n)''' : district.&lt;br&gt;
'''χωρισμός, -οῦ (nom commun) (m)''' : séparation.&lt;br&gt;
'''χωρίς (adverbe)''' : Séparément ; à part. (Avec le génitif) sans. (Par suite) différemment.&lt;br&gt;
'''Χαιρέας, -ου (nom propre) (m)''' : Chéréas.&lt;br&gt;
'''Χαιρεφῶν, -ῶντος (nom propre) (m)''' : Chariphon.&lt;br&gt;
'''Χαιρώνεια, -ίας (nom propre) (f)''' : Chéronée (cité de Béotie).&lt;br&gt;
'''Χαιρωνεύς, -έως (nom propre) (m)''' : Chéronéen.&lt;br&gt;
'''Χαλδαία, -ας (nom propre) (f)''' : Chaldée.&lt;br&gt;
'''Χαλδαῖα, -ίας (nom commun) (f)''' : Chaldéenne.&lt;br&gt;
'''Χαλδαϊκός, -ή, -όν (adjectif)''' : chaldéen.&lt;br&gt;
'''Χαλδαῖος, -ίου (nom commun) (m)''' : Chaldéen.&lt;br&gt;
'''Χαλκηδών, -όνος (nom commun) (f)''' : Chalcédoine.&lt;br&gt;
'''Χαλκίς, -δος (nom commun) (f)''' Chalcis.&lt;br&gt;
'''Χάλυψ, -ϐος (nom propre) (m)''' : Chalybe.&lt;br&gt;
'''Χαπύ (nom propre) (m)''' : Hâpy.&lt;br&gt;
'''Χάρις, -τος (nom propre) (f)''' : Charite.&lt;br&gt;
'''Χαρίτων, -ος (nom propre) (m)''' : Chariton.&lt;br&gt;
'''Χάρυϐδις, -ύϐδεως (nom propre) (f)''' : Charybde.&lt;br&gt;
'''Χάρων, -ος (nom propre) (m)''' : Charon. (nocher des Enfers)&lt;br&gt;
'''Χέϐρης, -ου (nom propre) (m)''' : Toutânkhamon.&lt;br&gt; 
'''Χείρων, -ος (nom propre) (m)''' : Chiron.&lt;br&gt;
'''Χένερης, -ου (nom propre) (m)''' : Khâsekhemoui.&lt;br&gt; 
'''Χέοψ, -πος (nom propre) (m)''' : Khéops.&lt;br&gt;
'''Χεφρήν, -ένος (nom propre) (m)''' : Khéphren.&lt;br&gt;
'''Χθών, -ονός (nom propre) (f)''' : Chthon.&lt;br&gt;
'''Χιόνη, -ης (nom propre) (f)''' : Chioné.&lt;br&gt;
'''Χλόη, -ης (nom propre) (f)''' : Chloé.&lt;br&gt;
'''Χλωρίς, -δος (nom propre) (f)''' : Chloris (nymphe).&lt;br&gt;
'''Χνοῦϐις, -ύϐιδος (nom propre) (m)''' : [[wikt:Khnoum|Khnoum]].&lt;br&gt;
'''Χοίακ (nom propre) (m)''' : Choeac.&lt;br&gt; ‎
'''Χοσρόης, -ου (nom propre) (m)''' : Chosroès.&lt;br&gt; ‎
'''Χριστόφορος, -όρου (prénom) (m)''' : Christophe.&lt;br&gt;
'''Χριστός, -οῦ  (nom commun) (m)''' : Christ.&lt;br&gt;
'''Χρυσάωρ, -ου (nom propre) (m)''' : Chrysaor.&lt;br&gt;
'''Χρύσιππος, -ίππου (nom propre) (m)''' : Chrysippe.&lt;br&gt;
'''Χρυσόμαλλον Δέρας (locution nominale)''' : Toison d'or.&lt;br&gt;
'''Χρυσόμαλλος, -ου (nom propre) (m)''' : Chrysomallos.&lt;br&gt;
'''Χρυσόπολις, -όλεως (nom propre) (m)''' : Üsküdar.&lt;br&gt;

==Ψ==
'''ψάλλω (verbe)''' : chanter.&lt;br&gt;
'''ψαλμός, -οῦ (nom commun) (m)''' : psaume.&lt;br&gt;
'''ψαλτήριον, -ίου (nom commun) (n)''' : psaltérion.&lt;br&gt; 
'''ψάλτιγξ, -γος (nom commun) (m)''' : psaltinx.&lt;br&gt;
'''ψάρ, -ός (nom commun) (m)''' : étourneau.&lt;br&gt;
'''ψαρός, -ά, -όν (adjectif)''' : .&lt;br&gt;
'''ψαῦμα, -ύματος (nom commun) (n)''' : palpation.&lt;br&gt;
'''ψαῦσις, -ύσεως (nom commun) (f)''' : palpation.&lt;br&gt;
'''ψαύω (verbe)''' : palper.&lt;br&gt; 
'''ψᾶφαξ, -άφακου (nom commun) (m)''' : Forme éolienne de ''ψῆφος''.&lt;br&gt;
'''ψᾶφος, -άφου (nom commun) (m)''' : Forme dorienne de ''ψῆφος''.&lt;br&gt;
'''ψάω (verbe)''' : Frotter, gratter.&lt;br&gt;
'''ψέγω (verbe)''' : Blâmer, reprocher.&lt;br&gt;
'''ψευδής, -ής, -ές (adjectif)''' : faux.&lt;br&gt; 
'''ψεύδομαι (verbe)''' : mentir.&lt;br&gt;
'''ψεῦδος, -ύδους (nom commun) (n)''' : tromperie.&lt;br&gt; 
'''ψευδῶς (adverbe)''' : faussement.&lt;br&gt;
'''ψευδώτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''ψευδής''.&lt;br&gt; 
'''ψευδώτερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''ψευδής''.&lt;br&gt;  
'''ψεύδω (verbe)''' : tromper.&lt;br&gt;
'''ψεῦσμα, -ύσματος (nom commun) (n)''' : mensonge.&lt;br&gt; 
'''ψεύστης, -ου (nom commun) (m)''' : menteur.&lt;br&gt;
'''ψεύστρα, -ας (nom commun) (f)''' : menteuse.&lt;br&gt;
'''ψῆγμα, -ήγματος (nom commun) (n)''' : pépite.&lt;br&gt;
'''ψηλάφησις, -ήσεως (nom commun) (f)''' : palpation.&lt;br&gt;
'''ψηλαφῶ (verbe)''' : palper.&lt;br&gt; 
'''ψήρ, -ός (nom commun) (m)''' : Forme ionienne de ''ψάρ''.&lt;br&gt; 
'''ψῆφος, -ήφου (nom commun) (m)''' : Galet, caillou, pierre, en particulier utilisée pour le calcul. Gemme, pierre précieuse.&lt;br&gt;
'''ψήχω (verbe)''' : racler.&lt;br&gt;
'''ψῖ (nom commun) (n)''' : psi.&lt;br&gt;
'''ψιλός, -ή, -όν (adjectif)''' : Nu ; simple.&lt;br&gt;
'''ψίξ, -χός (nom commun) (m/f)''' : Mie ; miette.&lt;br&gt; 
'''ψιττακός, -οῦ (nom commun) (m)''' : perroquet.&lt;br&gt; 
'''ψιχίον, -ου (nom commun) (n)''' : miette.&lt;br&gt; 
'''ψίω (verbe)''' : .&lt;br&gt; 
'''ψόα, -ας (nom commun) (f)''' : lombes.&lt;br&gt;
'''ψόγος, -ου (nom commun) (m)''' : Blâme, reproche.&lt;br&gt;
'''ψόλος, -ου (nom commun) (m)''' : suie.&lt;br&gt;
'''ψό (interjection)''' : beurk.&lt;br&gt;
'''ψυχεινός, -ή, -όν (adjectif)''' : frais.&lt;br&gt;
'''ψυχή, -ῆς (nom commun) (f)''' : Âme ; papillon.&lt;br&gt;
'''ψύθος, -ους (nom commun) (n)''' : Forme homérique de ''ψεῦδος''.&lt;br&gt; 
'''ψυχοπομπός, -ός, -όν (adjectif)''' : psychopompe.&lt;br&gt; 
'''ψυχοπομπός, -οῦ (nom commun) (m)''' : psychopompe.&lt;br&gt;
'''ψῦχος, -ύχους (nom commun) (n)''' : fraîcheur.&lt;br&gt; 
'''ψυχραίνω (verbe)''' : refroidir.&lt;br&gt; 
'''ψυχρός, -ά, -όν (adjectif)''' : Froid ; glacial.&lt;br&gt;
'''ψυχρότατος, -άτη, -ότατον (adjectif)''' : Superlatif de ''ψυχρός''.&lt;br&gt;
'''ψυχρότερος, -έρη, -ότερον (adjectif)''' : Comparatif de ''ψυχρός''.&lt;br&gt;
'''ψυχρῶς (adverbe)''' : Froidement ; glacialement.&lt;br&gt;
'''ψύχω (verbe)''' : Souffler, respirer. Se refroidir.&lt;br&gt;
'''ψχέντ (nom commun) (m)''' : pschent.&lt;br&gt;
'''ψωμός, -οῦ (nom commun) (m)''' : bouchée de pain.&lt;br&gt;
'''Ψαπφώ, -οῦς (nom propre) (f)''' : Forme éolienne de ''Σαπφώ''.&lt;br&gt;
'''Ψίλαξ, -κος (nom propre) (m)''' : Psilax.&lt;br&gt; 
'''Ψιχάρπαξ, -γος (nom propre) (m)''' : Psicharpax.&lt;br&gt; 
'''Ψουσέννης, -ου (nom propre) (m)''' : Psousennès.&lt;br&gt; 
'''Ψυχή, -ῆς (nom propre) (f)''' : Psyché.&lt;br&gt;
'''Ψωφίς, -δος (nom propre) (f)''' : Psophis.&lt;br&gt;

==Ω==
'''ᾠδή, -ῆς (nom commun) (f)''' : chant.&lt;br&gt;
'''ὠδυσάμην, - ()''' : .&lt;br&gt;
'''ὠθῶ (verbe)''' : pousser, forcer ; (militaire) repousser l’ennemi.&lt;br&gt;
'''ὠκεανός, -οῦ (nom commun) (m)''' : océan.&lt;br&gt;
'''ὠκέως (adverbe)''' : rapidement.&lt;br&gt;
'''ὠκύς, -εῖα, -ύ (adjectif)''' : rapide.&lt;br&gt;
'''ὠκύτατος, -άτη, -ώτατον (adjectif)''' : Superlatif de ''ὠκύς''.&lt;br&gt;
'''ὠκύτερος, -έρα, -ώτερον (adjectif)''' : Comparatif de ''ὠκύς''.&lt;br&gt;
'''ὦλαξ, ὤλακος (nom commun) (m)''' : Forme dorienne de ''αὖλαξ''.&lt;br&gt;
'''ὠλένη, -ης (nom commun) (f)''' : coude, coudée ; avant-bras.&lt;br&gt;
'''ὠμοπλάτη, -ης (nom commun) (f)''' : omoplate.&lt;br&gt;
'''ὦμος, ὤμου (nom commun) (m)''' : épaule.&lt;br&gt;
'''ὠνέομαι (verbe)''' : acheter.&lt;br&gt;
'''ὠνητής, -οῦ (nom commun) (m)''' : client.&lt;br&gt;
'''ὦνος, ὤνου (nom commun) (m)''' : prix.&lt;br&gt;
'''ᾠόν, -οῦ (nom commun) (n)''' : œuf.&lt;br&gt;
'''ὦ μέγα (nom commun) (n)''' : oméga.&lt;br&gt;
'''ὤρα, -ας (nom commun) (f)''' : soin ; souci.&lt;br&gt;
'''ὥρα, -ας (nom commun) (f)''' : heure.&lt;br&gt;
'''ὡραῖος, -ία, -ῖον (adjectif)''' : Qui est de la saison. Qui se fait à une époque, dans une saison déterminée. Qui est dans la fleur de l’âge.&lt;br&gt;
'''ὠρανός, -οῦ (nom commun) (m)''' : Forme dorienne et béotienne de ''οὐρανός''.&lt;br&gt; 
'''ὡρεῖον‎, -ίου (nom commun) (n)''' : grenier.&lt;br&gt;
'''ὤρη, -ης (nom commun) (f)''' : Forme ionienne de ''ὤρα''.&lt;br&gt; 
'''ὥρη, -ης (nom commun) (f)''' : Forme ionienne de ''ὥρα''.&lt;br&gt; 
'''ὥριμος, -ος, -ον (adjectif)''' : mûr.&lt;br&gt;
'''ὡρολόγιον, -ίου (nom commun) (n)''' : horloge.&lt;br&gt;
'''ὡσαννά (interjection)''' : hosanna.&lt;br&gt;
'''ὦσις, ὤσεως (nom commun) (f)''' : poussée.&lt;br&gt; 
'''ὦς, -τός (nom commun) (n)''' : Forme dorienne de ''οὖς''.&lt;br&gt;
'''ὡς (adverbe ; conjonction)''' : .&lt;br&gt;
'''ὥτερος, -έρα, -ερον (adjectif)''' : Autre forme dorienne de ''ἕτερος''.&lt;br&gt;
'''ὠτικός, -ή, -όν (adjectif)''' : otique.&lt;br&gt;
'''ὠτίον, -ίου (nom commun) (n)''' : Diminutif de '' οὖς''.&lt;br&gt;
'''ὠτίς, -δος (nom commun) (f)''' : outarde.&lt;br&gt;
'''ὦτος, ὤτου (nom commun) (m)''' : hibou.&lt;br&gt;
'''ὠφέλεια, -ίας (nom commun) (f)''' : Aide ; secours.&lt;br&gt;
'''ὠφέλημα, -ήματος (nom commun) (n)''' : .&lt;br&gt;	
'''ὠφέλησις, -ήσεως (nom commun) (f)''' : Aide ; secours.&lt;br&gt;  
'''ὠφελῶ (verbe)''' : Aider ; secourir.&lt;br&gt; 
'''ὠχρός, -ά, -όν (adjectif)''' : pâle.&lt;br&gt;
'''ὤψ, -πός (nom commun) (f)''' : Vue ; visage.&lt;br&gt; 
'''ὦ (particule)''' : ô.&lt;br&gt;
'''ὤ (interjection)''' : ah !, oh !&lt;br&gt;
'''Ὠγυγία, -ας (nom propre) (f)''' : Ogygie.&lt;br&gt;
'''Ὠγυγίη, -ης (nom propre) (f)''' : Forme ionienne de ''Ὠγυγία''.&lt;br&gt;
'''Ὠκεανίς, -δος (nom propre) (f)''' : Océanide.&lt;br&gt;
'''Ὠκεανός, -οῦ (nom propre) (m)''' : Océan.&lt;br&gt;
'''Ὠρανός, -οῦ (nom propre) (m)''' : Forme dorienne et béotienne de ''Οὐρανός''.&lt;br&gt;
'''Ὠρείθυια, -ίας (nom commun) (f)''' : Orithye (fille d'Érechthée).&lt;br&gt;
'''Ὠριγένης, -ου (nom propre) (m)''' : Origène.&lt;br&gt;
'''Ὠρομέδων, -οντος (nom propre) (m)''' : Oromédon.&lt;br&gt;
'''Ὧρος, Ὥρου (nom propre) (m)''' : [[wikt:Horus|Horus]].&lt;br&gt;</text>
      <sha1>siulqlif69ryizp1rgd5pq4jzzvhl65</sha1>
    </revision>
  </page>
  <page>
    <title>Livre de cuisine/Spritz</title>
    <ns>0</ns>
    <id>34367</id>
    <revision>
      <id>744182</id>
      <parentid>710312</parentid>
      <timestamp>2025-06-05T21:19:36Z</timestamp>
      <contributor>
        <username>Ptyx</username>
        <id>24987</id>
      </contributor>
      <comment>relu</comment>
      <origin>744182</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="1915" sha1="gmwudywdo29r126o3igg3gt2td1co4v" xml:space="preserve">{{livre de cuisine}}

[[File:Spritz canelle.jpg|thumb|Spritz et ancien ustensile permettant de les façonner]]

Les '''spritz''' ou '''sprits''' sont de petits gâteaux traditionnellement préparés au moment de Noël en Alsace, en Moselle et en Allemagne.

== Ingrédients ==
* 500 g de {{i|farine}} ;
* 250 g de {{i|sucre}} ;
* 250 g de {{i|beurre}} ;
* 2 [[w:œuf (cuisine)|œuf]]s ;
* 125 g de d’amandes moulues ou de la {{i|noix de coco}} râpée.

== Préparation ==
# Mélanger le beurre fondu avec le sucre, puis ajouter les œufs entiers.
# Incorporer ensuite la farine et enfin des amandes moulues ou de la noix de coco.
# Faire une boule de pâte et la laisser reposer une heure.
# Si on préfère, à la place des amandes moulues ou de la {{i|noix de coco}} râpée, on peut utiliser de la cannelle. Dans ce cas, il faut utiliser une cuillère à café bombée de {{i|cannelle}} et ajouter 75 grammes de farine et 50 grammes de sucre.
# Former de longues bandes de pâte d'une trentaine de centimètres de long. Pour cela, il faut se servir d'un hachoir à viande électrique ou à manivelle, muni d'un embout à la forme des spritz (ou une poche à douille, mais c'est moins pratique).
# Répartir ces formes sur une tôle à pâtisserie. Il est possible de les serrer, car les spritz ne gonflent quasiment pas.
# Cuire 20 minutes à 180°C et laisser refroidir dans une boîte en métal ouverte. Une fois enfermés dans la boîte, les gâteaux peuvent se conserver toute une année. '''Attention :''' il faut absolument enlever les gâteaux de la tôle lorsqu'ils sont encore chaud, car sinon ils vont coller.

== Conservation ==
Ils peuvent se conserver plusieurs mois (voir une année) en les gardant dans une boîte métallique.

Mettre un morceau de sucre dans la boîte métallique.

[[Catégorie:Desserts|Spritz]]
[[Catégorie:Recettes de Noël]]
[[Catégorie:Recettes végétariennes|Spritz]]</text>
      <sha1>gmwudywdo29r126o3igg3gt2td1co4v</sha1>
    </revision>
  </page>
  <page>
    <title>Astrologie/Préliminaires astronomiques/La mesure du temps/Le temps stellaire et le temps sidéral</title>
    <ns>0</ns>
    <id>55241</id>
    <revision>
      <id>744064</id>
      <parentid>415014</parentid>
      <timestamp>2025-06-03T18:56:24Z</timestamp>
      <contributor>
        <username>Kad'Astres</username>
        <id>30330</id>
      </contributor>
      <origin>744064</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="184" sha1="czwztj0zp5smgorjasyvvl9iw44sq1y" xml:space="preserve">{{SI|refonte totale}}

temps stellaire // culmination d'une étoile de référence

temps sidéral // culmination du point vernal (assimilé à une étoile)


[[Catégorie:Astrologie]]</text>
      <sha1>czwztj0zp5smgorjasyvvl9iw44sq1y</sha1>
    </revision>
    <revision>
      <id>744074</id>
      <parentid>744064</parentid>
      <timestamp>2025-06-03T19:14:46Z</timestamp>
      <contributor>
        <username>Kad'Astres</username>
        <id>30330</id>
      </contributor>
      <origin>744074</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="21" sha1="ehonxiv34l7r9zetnh7ih45v7soi8vy" xml:space="preserve">{{SI|refonte totale}}</text>
      <sha1>ehonxiv34l7r9zetnh7ih45v7soi8vy</sha1>
    </revision>
  </page>
  <page>
    <title>Astrologie/Préliminaires astronomiques/La mesure du temps/Le jour sidéral et le jour solaire vrai</title>
    <ns>0</ns>
    <id>55242</id>
    <revision>
      <id>744065</id>
      <parentid>415013</parentid>
      <timestamp>2025-06-03T18:57:21Z</timestamp>
      <contributor>
        <username>Kad'Astres</username>
        <id>30330</id>
      </contributor>
      <origin>744065</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="200" sha1="idpyez2k0r7rciogenbwkhtq418jq3p" xml:space="preserve">{{SI|refonte totale}}

jour sidéral // temps requis pour revenir à angle droit d'une étoile

jour solaire vrai : prise en compte du Soleil comme une étoile particulière

[[Catégorie:Astrologie]]</text>
      <sha1>idpyez2k0r7rciogenbwkhtq418jq3p</sha1>
    </revision>
    <revision>
      <id>744073</id>
      <parentid>744065</parentid>
      <timestamp>2025-06-03T19:14:23Z</timestamp>
      <contributor>
        <username>Kad'Astres</username>
        <id>30330</id>
      </contributor>
      <origin>744073</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="21" sha1="ehonxiv34l7r9zetnh7ih45v7soi8vy" xml:space="preserve">{{SI|refonte totale}}</text>
      <sha1>ehonxiv34l7r9zetnh7ih45v7soi8vy</sha1>
    </revision>
  </page>
  <page>
    <title>Astrologie/Préliminaires astronomiques/La mesure du temps/Le jour solaire moyen et l'équation du temps</title>
    <ns>0</ns>
    <id>55243</id>
    <revision>
      <id>744066</id>
      <parentid>743751</parentid>
      <timestamp>2025-06-03T18:58:12Z</timestamp>
      <contributor>
        <username>Kad'Astres</username>
        <id>30330</id>
      </contributor>
      <origin>744066</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="385" sha1="1bnjbfbyjkrrr9vk6uj4kdw4zdfxsfu" xml:space="preserve">{{SI|refonte totale}}

jour solaire moyen: prise en compte d'un Soleil fictif (à marche régulière)

équation du temps : passage du temps du Soleil  moyen (celui de nos horloges, avec une marche régulière de 24 heures) au temps des cadrans solaires (celui mesuré par la position réelle du Soleil dans le ciel : temps solaire vrai), et réciproquement.

[[Catégorie:Astrologie]]</text>
      <sha1>1bnjbfbyjkrrr9vk6uj4kdw4zdfxsfu</sha1>
    </revision>
    <revision>
      <id>744072</id>
      <parentid>744066</parentid>
      <timestamp>2025-06-03T19:14:00Z</timestamp>
      <contributor>
        <username>Kad'Astres</username>
        <id>30330</id>
      </contributor>
      <comment>Contenu remplacé par « {{SI|refonte totale}} »</comment>
      <origin>744072</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="21" sha1="ehonxiv34l7r9zetnh7ih45v7soi8vy" xml:space="preserve">{{SI|refonte totale}}</text>
      <sha1>ehonxiv34l7r9zetnh7ih45v7soi8vy</sha1>
    </revision>
  </page>
  <page>
    <title>Fonctionnement d'un ordinateur</title>
    <ns>0</ns>
    <id>65764</id>
    <revision>
      <id>744155</id>
      <parentid>727979</parentid>
      <timestamp>2025-06-05T13:50:39Z</timestamp>
      <contributor>
        <username>Mewtow</username>
        <id>31375</id>
      </contributor>
      <minor />
      <comment>/* Liens divers */</comment>
      <origin>744155</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="2462" sha1="kn44yolhq0v9e6gtl6rxrrwfu6rguk6" xml:space="preserve">{{Page de garde|image=Personal computer, exploded 6.svg|description=

Dans ce cours, vous allez apprendre quels sont les composants d'un ordinateur et comment ceux-ci fonctionnent. Ce cours commencera par des choses simples, comme le binaire, pour arriver progressivement jusqu'au fonctionnement des derniers processeurs, en passant par plein de choses passionnantes comme l'assembleur, les mémoires caches, etc. Ce cours est accessible à n'importe qui, sans prérequis, mais se veut cependant assez complet et riche en informations.

|avancement=Terminé
|cdu=
* {{CDU item|6/68/681|681.3/681.31}}
|versions=
{{version imprimable|page=Fonctionnement d'un ordinateur/Version imprimable 2}}
{{version PDF}}
}}

__NOTOC__

: '''L'auteur du livre tient à remercier vivement Dominus Carnufex et Vayel, qui se sont chargés de la relecture et de la correction orthographique d'une ancienne version de ce cours. Merci à eux pour le travail titanesque qui a été fourni.'''

{{/Sommaire}}

==Liens vers ressources externes==

===Sur wikilivres===

* [[Les cartes graphiques|Les cartes graphiques]], un livre du même auteur qui aborde spécifiquement l'architecture des cartes vidéo.
* [[Monter_un_PC|Monter un PC]], pour une approche bien plus pratique et utile.
* [[Les systèmes d'exploitation|Les systèmes d'exploitation]], un cours qui explique l'interaction entre systèmes d'exploitation et matériel. Le sujet (les systèmes d'exploitation) est si lié au matériel informatique qu'il peut être vu comme un prolongement du présent cours, ou tout du moins comme un très bon complément.
* [[Électronique numérique : logique|Électronique numérique : logique]], un cours d'électronique numérique, disponible sur Wikilivre. Un excellent complément pour les premiers chapitres du cours.

===Liens divers===

* [http://users.ece.cmu.edu/~koopman/stack_computers/index.html Stack Computers: the new wave] : un livre sur les architectures à pile.
* [https://homes.cs.washington.edu/~levy/capabook/ Capability-Based Computer Systems] : un livre sur les architectures à capacités.
* [http://www.analogmuseum.org/english/ Museum of analog computing]. Ce site en anglais parle d'un sujet qui n'a pas été abordé dans ce livre : les calculateurs analogiques.
* [https://www.icsa.inf.ed.ac.uk/research/groups/hase/models/ Des simulateurs pour des architectures réelles ou fictives.]

{{AutoCat}}
[[Catégorie:Informatique]]
[[Catégorie:Électronique]]</text>
      <sha1>kn44yolhq0v9e6gtl6rxrrwfu6rguk6</sha1>
    </revision>
  </page>
  <page>
    <title>Fonctionnement d'un ordinateur/La carte mère, chipset et BIOS</title>
    <ns>0</ns>
    <id>65773</id>
    <revision>
      <id>744186</id>
      <parentid>738688</parentid>
      <timestamp>2025-06-06T00:16:53Z</timestamp>
      <contributor>
        <username>Mewtow</username>
        <id>31375</id>
      </contributor>
      <minor />
      <comment>/* Le Management Engine d'Intel et l'AMD Platform Security Processor */</comment>
      <origin>744186</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="94459" sha1="ozqvw0f9fmtljq6dqxzjzqtguhlunya" xml:space="preserve">Dans un ordinateur, les composants sont placés sur un circuit imprimé (la '''carte mère'''), un circuit sur lequel on vient connecter les différents composants d'un ordinateur, et qui les relie via divers bus. Si on regarde une carte mère de face, on voit un grand nombre de connecteurs, mais aussi des circuits électroniques soudés à la carte mère.

[[File:Architecture matérielle d'une carte mère.png|centre|vignette|upright=2.0|Architecture matérielle d'une carte mère]]

Les '''connecteurs''' sont là où on branche les périphériques, la carte graphique, le processeur, la mémoire, etc. Dans l'ensemble, toute carte mère contient les connecteurs suivants :
* Le processeur vient s’enchâsser dans la carte mère sur un connecteur particulier : le '''socket'''. Celui-ci varie suivant la carte mère et le processeur, ce qui est source d'incompatibilités.
* Les barrettes de mémoire RAM s’enchâssent dans un autre type de connecteurs: les '''slots mémoire'''.
* Les mémoires de masse disposent de leurs propres connecteurs : connecteurs P-ATA pour les anciens disques durs, et S-ATA pour les récents.
* Les périphériques (clavier, souris, USB, Firewire, ...) sont connectés sur un ensemble de connecteurs dédiés, localisés à l'arrière du boitier de l'unité centrale. 
* Les autres périphériques sont placés dans l'unité centrale et sont connectés via des connecteurs spécialisés. Ces périphériques sont des cartes imprimées, d'où leur nom de '''cartes filles'''. On peut notamment citer les cartes réseau, les cartes son, ou les cartes vidéo.

Une observation plus poussée de la carte mère vous permettra de remarquer quelques puces électroniques soudées à la carte mère. Elles ont des fonctions très diverses mais sont indispensables à son bon fonctionnement. Un bon exemple est celui du '''circuit d'alimentation''', qui est en charge de la gestion de la tension d'alimentation. Il contient des composants aux noms à coucher dehors pour qui n'est pas électronicien : régulateurs de tension, convertisseurs alternatif vers continu, condensateurs de découplage, et autres joyeusetés. Il y a aussi le BIOS, des générateurs de fréquence, des circuits support pour le processeur et les mémoires, et d'autres, que nous détaillerons dans la suite du chapitre.

Enfin, et surtout, une carte mère est là où se trouvent les bus qui interconnectent tout ce beau monde. Si vous observez la carte mère de près, vous verrez des lignes métalliques, de couleur cuivre, qui ne sont autre que les bus en question. Une ligne métallique est un fil qui transmet un courant électrique, qui sert à faire passer un bit d'un composant/connecteur à un autre.

L'organisation de ce chapitre est la suivante : nous allons d'abord voir les circuits soudés sur la carte mère, avant de parler de la manière dont les bus sont organisés sur la carte mère. À la fin de ce chapitre, nous allons voir que la façon dont les composants sont connectés entre eux par des bus a beaucoup changé au fil du temps et que l'organisation de la carte mère a évoluée au fil du temps. Les cartes mères se sont d'abord complexifiées, pour faire face à l'intégration de plus en plus de périphériques et de connecteurs. Mais par la suite, les processeurs ayant de plus en plus de transistors, ils ont incorporé des composants autrefois présents sur la carte mère, comme le contrôleur mémoire.

==Le Firmware : BIOS et UEFI==

La plupart des ordinateurs contiennent une mémoire ROM qui lui permet de fonctionner. Les plus simples stockent le programme à exécuter dans cette ROM, et n'utilisent pas de mémoire de masse. On pourrait citer le cas des appareils photographiques numériques, qui stockent le programme à exécuter dans la ROM. D'autres utilisent cette ROM pour amorcer le système d'exploitation : la ROM  contient le programme qui initialise les circuits de l'ordinateur, puis exécute un mini programme qui démarre le système d'exploitation (OS). Cette ROM, et par extension le programme qu'elle contient, est appelée le '''firmware'''.

Le firmware est placé sur la carte mère, du moins sur les ordinateurs qui ont une carte mère. Sur les PC modernes, ce firmware s'occupe du démarrage de l'ordinateur et notamment du lancement de l'OS. Il existe quelques standards de firmware, utilisés sur les ordinateurs PC, utilisés pour garantir la compatibilité entre ordinateurs, leur permettre d'accepter divers OS, et ainsi de suite. Il existe deux standards : le BIOS, format ancien pour le firmware qui a eu son heure de gloire, et l'EFI ou UEFI, utilisés sur les ordinateurs récents.

===Le BIOS, l'EFI et l'UEFI===

Sur les PC avec un processeur x86, il existe un programme, lancé automatiquement lors du démarrage, qui se charge du démarrage avant de rendre la main au système d'exploitation. Ce programme s'appelle le '''BIOS système''', communément appelé BIOS (''Basic Input-Output System''). Ce programme est mémorisé dans de la mémoire EEPROM, ce qui permet de mettre à jour le programme de démarrage : on appelle cela flasher le BIOS. De nos jours, il tend à être remplacé par l'EFI et l'UEFI, qui utilise un standard différent, mais n'est pas différent dans les grandes lignes.

L'EFI (Extensible Firmware Interface) est un nouveau standard de firmware, similaire au BIOS, mais plus récent et plus adapté aux ordinateurs modernes. Le BIOS avait en effet quelques limitations, notamment le fait que la table des partitions utilisée par le BIOS ne permettait pas de gérer des partitions de plus de 2,1 téraoctets. De plus, le BIOS devait gérer les anciens modes d'adressage mémoire des PC x86 : mémoire étendue, haute, conventionnelle, ce qui forçait le BIOS à utiliser des registres 16 bits lors de l’amorçage, ainsi qu'un ancien jeu d'instruction aujourd’hui obsolète. L'EFI a été conçu sans ces limitations, lui permettant d'utiliser tout l'espace d'adressage 64 bits, et sans limitations de taille de partition.

Les normes de l'EFI et de l'UEFI (une version plus récente) vont plus loin que simplement modifier le BIOS. Ils ajoutent diverses fonctionnalités supplémentaire, qui ne sont pas censées être du ressort d'un firmware de démarrage. Certains UEFI disposent de programmes de diagnostic mémoire, de programmes de restauration système, de programmes permettant d’accéder à internet et bien d'autres. L'EFI peut ainsi être vu comme un logiciel intermédiaire entre le firmware et l'OS. Cependant, l'UEFI gère la rétrocompatibilité avec les anciens BIOS, ce qui fait qu'ils conservent les anciennes fonctionnalités du BIOS. Aussi, tout ce qui est dit dans cette section sera aussi valide pour l'UEFI, dans une certaine mesure.

En plus du BIOS système, les cartes d'extension peuvent avoir un BIOS. Par exemple, les cartes graphiques actuelles contiennent toutes un '''BIOS vidéo''', une mémoire ROM ou EEPROM qui contient des programmes capables d'afficher du texte et des graphismes monochromes ou 256 couleurs à l'écran. Lors du démarrage de l'ordinateur, ce sont ces routines qui sont utilisées pour gérer l'affichage avant que le système d'exploitation ne lance les pilotes graphiques. On peut aussi citer le cas des cartes réseaux, certaines permettant de démarrer un ordinateur sur le réseau. Ces BIOS sont ce qu'on appelle des '''BIOS d'extension'''. Le contenu des BIOS d'extension dépend fortement du périphérique en question, contrairement au BIOS système dont le contenu est relativement bien standardisé.

===L'accès au BIOS===

[[File:OrganisationMémoirePC.png|vignette|Organisation de la mémoire d'un PC doté d'un BIOS.]]

Il faut noter que le processeur démarre systématiquement en mode réel, un mode d'exécution spécifique aux processeurs x86, où le processeur n'a accès qu'à 1 mébioctet de mémoire (les adresses font 20 bits maximum). C'est un mode de compatibilité qui existe parce que les premiers processeurs x86 avaient des adresses de 20 bits, ce qui fait 1 mébioctet de mémoire adressable. En mode réel, Le premier mébioctet de mémoire est décomposé en deux portions de mémoire : les premiers 640 kibioctets sont ce qu'on appelle la mémoire '''conventionnelle''', alors que les octets restants forment la '''mémoire haute'''.

Les deux premiers kibioctets de la mémoire conventionnelle sont réservés au BIOS, le reste est utilisé par le système d'exploitation (MS-DOS, avant sa version 5.0) et le programme en cours d’exécution. Pour être plus précis, les premiers octets contiennent non pas le BIOS, mais la BIOS Data Area utilisée par le BIOS pour stocker des données diverses, qui commence à l'adresse 0040:0000h, a une taille de 255 octets, et est initialisée lors du démarrage de l'ordinateur.

La mémoire haute est réservée pour communiquer avec les périphériques. On y trouve aussi le BIOS de l'ordinateur, mais aussi les BIOS des périphériques (dont celui de la carte vidéo, s'il existe), qui sont nécessaires pour les initialiser et parfois pour communiquer avec eux. De plus, on y trouve la mémoire de la carte vidéo, et éventuellement la mémoire d'autres périphériques comme la carte son.

Par la suite, le BIOS démarre le système d'exploitation, qui bascule en mode protégé, un mode d'exécution où il peut utiliser des adresses mémoires de 32/64 bits et utiliser la '''mémoire étendue''' au-delà du premier mébioctet.

===Le démarrage de l'ordinateur===

Au démarrage de l'ordinateur, le processeur est initialisé de manière à commencer l'exécution des instructions à partir de l'adresse 0xFFFF:0000h là où se trouve le BIOS. Pour info, cette adresse est l'adresse maximale en mémoire réelle moins 16 octets. Le BIOS s’exécute et initialise l'ordinateur avant de laisser la main au système d'exploitation.

Le BIOS commence la séquence de démarrage avec le '''POST''' ('''Power On Self Test'''), qui effectue quelques vérifications. Il commence par vérifier que le BIOS est OK, en vérifiant une somme de contrôle présente à la fin du BIOS lui-même. Il vérifie ensuite l'intégrité des 640 premiers kibioctets de la mémoire.

Ensuite, les périphériques sont détectés, testés et configurés pour garantir leur fonctionnement. Pour cela, le BIOS explore la mémoire haute pour '''détecter les BIOS d'extension'''. Si un BIOS d'extension est détecté, le BIOS système lui passe la main, grâce à un branchement vers l'adresse du code du BIOS d'extension. Ce BIOS peut alors faire ce qu'il veut, mais il finit par rendre la main au BIOS (avec un branchement) quand il a terminé son travail.

Pour détecter les BIOS d'extension, le BIOS lit la mémoire haute par pas de 2 kibioctets. En clair, il analyse toutes les adresses multiples de 2 kibioctets, dans la mémoire haute. Par exemple, le BIOS regarde s'il y a un BIOS vidéo aux adresses mémoire 0x000C:0000h et 0x000E:0000h. Il y recherche une valeur bien précise qui indique qu'une ROM est présente à cet endroit : la valeur en question vaut 0x55AA. Cette valeur est suivie par un octet qui indique la taille de la ROM, lui-même suivi par le code du BIOS d'extension. 

Ensuite, le BIOS effectue quelques opérations de configuration assez diverses, aux description assez barbares (initialiser le vecteur d'interruption de l'ordinateur, passage en mode protégé, et bien d'autres). En cas d'erreur à cette étape, le BIOS émet une séquence de bips, la séquence dépendant de l'erreur et de la carte mère. Pour cela, le BIOS est relié à un buzzer placé sur la carte mère. Si vous entendez cette suite de bips, la lecture du manuel de la carte mère vous permettra de savoir quelle est l'erreur qui correspond.

Si tout fonctionne bien, une '''interface graphique''' s'affiche. La majorité des cartes mères permettent d'accéder à une interface pour configurer le BIOS, en appuyant sur F1 ou une autre touche lors du démarrage. Cette interface donne accès à plusieurs options modifiables, qui permettent de configurer le matériel. Le BIOS utilise une interface assez basique, limitée à du texte, alors que l'UEFI gère une vraie interface graphique, avec un affichage pixel par pixel.

Par la suite, le BIOS démarre le système d'exploitation. Le processus est totalement différent entre BIOS et UEFI. Dans les deux cas, le BIOS lit une structure de données sur le disque dur, qui contient toutes les informations pertinentes pour lancer le système d'exploitation. Elle est appelée le MBR pour le BIOS, la GPT pour l'UEFI. La première est limitée à des partitions de 2 téraoctets, pas la seconde, la structure n'est pas la même, de même que le mécanisme de boot. Mais on rentre alors dans un domaine différent, celui du fonctionnement logiciel des systèmes d'exploitation. Je renvoie ceux qui veulent en savoir plus à mon wikilivre sur les systèmes d'exploitation, et plus précisément au chapitre sur [[Les systèmes d'exploitation/Le démarrage de l'ordinateur|Le démarrage d'un ordinateur]].

===Les paramètres du BIOS===

Si vous avez déjà fouillé dans l'interface graphique du BIOS, vous avez remarqué que celui-ci fournit beaucoup d'options de configuration. Ils sont peu nombreux sur les PC constructeurs, mais en grand nombre sur les PC montés à la main. La raison est que les PC constructeurs utilisent des BIOS personnalisés, qui réduisent volontairement le nombre d'options accessibles à l'utilisateur. Le but est de réduire les appels au SAV ou les retour garanties faisant suite à une mauvaise manipulation du BIOS. Les cartes mères vendues à l'unité, dans les PC fait maison, n'ont pas ces contraintes et fournissent toutes les options disponibles.

Mais le fait qu'il y ait des options dans le BIOS devrait nous poser une question. Le BIOS est stocké dans une mémoire ROM, qu'on peut lire, mais pas modifier. Vous me rétorquerez sans doute que le fait qu'on puisse flasher le BIOS contredit cela, que le BIOS est stocké dans une FLASH, pas dans de la ROM. Mais malgré tout, cela n'est pas compatible avec une modification rapide des options du BIOS : on n'efface pas toute la FLASH du BIOS en modifiant une simple option. Alors où sont stockés ces paramètres de configuration ?

La réponse est qu'ils sont stockés dans une mémoire FLASH ou EEPROM séparée du BIOS, appelée la '''''Non-volatile BIOS memory'''''. L'implémentation exacte dépend du BIOS. Au tout début, sur les premiers PC IBM et autres, il s'agissait d'une EEPROM séparée. Mais rapidement, elle a été fusionnée avec d'autres mémoires naturellement présentes sur la carte mère. Elle a ensuite été fusionnée avec la CMOS RAM, une mémoire RAM que nous verrons plus bas dans la suite du chapitre. De nos jours, elle est intégrée dans le ''chipset'' de la carte mère, avec la CMOS RAM et bien d'autres composants.

===Une fonction obsolète : la gestion des périphériques===

Autrefois, la gestion des périphériques était intégralement le fait du BIOS. Ce n'est pas pour rien que « BIOS » est l'abréviation de ''Basic Input Output System'', ce qui signifie « programme basique d'entrée-sortie ». Pour cela, il intégrait des morceaux de code dédiés qui servaient à gérer le disque dur, la carte graphique, etc. Intuitivement, si je dis morceau de code, les programmeurs se disent qu'il doit s'agir de fonctions logicielles, en référence à une fonctionnalité commune de tous les langages de programmation modernes. Pour être plus précis, il s'agit en réalité de routines d'interruptions, mais la différence sera expliquée dans un chapitre ultérieur portant justement sur les interruptions, dans lequel nous étudierons rapidement les interruptions du BIOS.

==Les circuits de surveillance matérielle : RESET et NMI==

Les circuits de surveillance matérielle vérifient en permanence la tension d'alimentation, la fréquence d'horloge, les températures, le bon fonctionnement de la mémoire, et bien d'autres choses. En cas de problèmes, ils peuvent redémarrer l'ordinateur ou l'éteindre. Pour cela, ces circuits communiquent directement avec le processeur, grâce à deux entrées sur processeur : l'entrée RESET, et l'entrée d'interruption non-masquable NMI (''Non-Maskable Interrupt''). L'entrée RESET a nom un assez transparent et on comprend qu'elle redémarre le processeur. L'entrée d'interruption non-masquable mérite cependant quelques explications.

===L'entrée RESET du processeur===

Le processeur dispose d'une '''entrée RESET''' qui, comme son nom l'indique, le réinitialise quand on met le niveau logique ou front adéquat dessus. Lorsqu'on envoie le signal adéquat sur l'entrée RESET, le processeur remet à zéro tous ses registres et lance la procédure d'initialisation du ''program counter''. Il peut être initialisé de deux façons différentes. Avec la première, il est initialisé à une valeur fixe, déterminée lors de la conception du processeur, souvent l'adresse 0. L'autre solution ajoute une indirection, elle précise l'adresse d’initialisation dans le firmware. Le processeur lit le firmware à une adresse fixée à l'avance, pour récupérer l'adresse de la première instruction et effectuer un branchement.

L'entrée RESET est lié de près ou de loin au bouton d'alimentation de l'ordinateur. Quand vous allumez votre ordinateur, cette broche RESET est activée, le processeur démarre. Aussi, si vous appuyez environ 10/15 secondes sur le bouton d'alimentation, l'ordinateur redémarre. C'est parce que l'entrée RESET a été activé par l'appui continu du bouton. Attention cependant, certains ordinateurs ou certaines consoles de jeu vidéo avaient un bouton RESET directement connectée au signal RESET : appuyer et relâcher le bouton active le signal RESET sans délai.

Le signal RESET n'est pas produit directement par le bouton d'allumage. En effet, au démarrage de l’ordinateur, le processeur ne peut pas être RESET immédiatement. Il doit attendre que la tension d'alimentation se stabilise, que le signal d'horloge se stabilise, etc. Pour cela, des circuits aux noms barbares de ''Power On Reset'' et d'''Oscilator startup timer'' vérifient la stabilité de la tension et de l'horloge. Le signal RESET n'est généré que si les conditions adéquates sont remplies.

Le signal RESET est donc produit au démarrage, mais il peut aussi être produit lors du fonctionnement de l'ordinateur, pour redémarrer en urgence l'ordinateur en cas de gros problème matériel. Par exemple, en cas de défaillance de l'alimentation, un signal RESET peut être produit pour limiter les dégats. Nous verrons aussi l'exemple du ''watchdog timer'' dans ce qui suit. Pour résumer, le signal RESET est produit en combinant plusieurs signaux, provenant de circuits de surveillance matérielle dispersés sur la carte mère. Nous verrons ceux-ci dans la suite du chapitre, car nous les verrons indépendamment les uns des autres.

Vous vous demandez sans doute pourquoi j'ai parlé de redémarrage d'urgence en cas de problème, au lieu d'un banal redémarrage. La raison est que les deux ne sont pas du tout les mêmes, surtout au regarde de l'entrée RESET. Le redémarrage via l'entrée de RESET est aussi appelée un ''reset hardware'', et on l'oppose au ''reset'' logiciel. Un ''reset'' logiciel est simplement le ''reset'' qui a lieu quand vous redémarrez votre ordinateur normalement, en demandant à Windows/linux de redémarrer. Il n'implique pas l'usage de l'entrée RESET, du moins il n'est pas censé le faire. Les méthodes pour RESET un processeur de manière logicielle dépendent beaucoup du processeur considéré. Sur les processeurs x86, il a une demi-douzaine de méthodes différentes.

Une méthode courante sur les CPU x86 et ARM utilise un '''registre de reset'''. Les processeur écrivent dans ce registre pour déclencher un RESET. Suivant ce qu'ils écrivent dedans, ils peuvent déclencher tel ou tel type de reset (''cold reset'', ''warm reset'', éteindre l'ordinateur, autres). Avec l'UEFI, le firwmare dispose d'une fonction faite pour, que le système d'exploitation peut appeler à volonté. Il peut aussi tenter d'exécuter des branchements spécifiques. Mais un tel reset logiciel ne fait pas usage de l'entrée RESET proprement dit.

Il y avait cependant une exception de taille, où le logiciel pouvait déclencher un ''reset hardware'', par l'intermédiaire d'un circuit appelé le contrôleur de clavier 8279. Le contrôleur de clavier 8279, comme son nom l'indique, est un circuit connecté au port clavier/souris. Les anciens PC avaient des ports PS/2 pour le clavier et la souris, et le contrôleur de clavier 8279 était situé de l'autre côté du connecteur. Il s'agissait d'un microcontroleur qui recevait les touches appuyées sur le clavier, configurait les LED pour le verr num, l'arret defil et autres. Mais une des broche de sortie de ce microcontroleur était directement reliée à l'entrée RESET du processeur, il y avait juste quelques portes logiques entre les deux. En configurant le controleur de clavier, on pouvait lui faire faire un RESET via l'entrée RESET !

===L'entrée NMI d'interruption non-masquable===

L'entrée RESET est plus rarement utilisée lorsqu'une défaillance matérielle irrécupérable est détectée. Le résultat de telles défaillances est que l'ordinateur est arrêté de force, redémarré de force, ou affiche un écran bleu. Redémarrer l'ordinateur est possible avec un signal RESET, mais pas l'affichage d'un écran bleu ou éteindre l'ordinateur. Pour cela, le processeur dispose d'une seconde entrée, séparée du RESET, appelée l''''entrée NMI'''. Pour simplifier, il s'agit d'une entrée pour l'arrêt d'urgence. Lorsqu'on envoie le signal adéquat sur l'entrée NMI, le processeur stoppe immédiatement ce qu'il est en train de faire, puis exécute un programme d'arrêt urgence. Ce dernier détecte l'origine de l'erreur et réagit en conséquence : soit en réparant l'erreur, soit en affichant un écran bleu, soit en éteignant l'ordinateur.

: Nous verrons dans quelques chapitres le concept d'interruption, et précisément d'interruption non-masquable. Pour simplifier, une interruption est ce qui permet de stopper le processeur pour lui faire exécuter un programme d'urgence, avant de reprendre l'exécution. L'acronyme NMI signifie ''Non Maskable Interrupt'', ce qui veut dire interruption non-masquable, non-masquable dans le sens où l'interruption ne peut pas être ignorée ou retardée.

Les deux entrées NMI et RESET semblent foncièrement différentes et s'utilisent dans des circonstances distinctes. Cependant, quelques circuits sur la carte mère sont reliées aux deux entrées. C'est le cas des circuits qui surveillent la tension d'alimentation et l'horloge. Un ordinateur ne peut pas fonctionner si la tension d'alimentation n'est pas stable, idem pour la fréquence d'horloge, idem si les températures sont trop élevées. Si les conditions ne sont pas remplies, l'ordinateur ne peut pas démarrer. De même, en cas de défaillance de la tension d'alimentation ou de la fréquence, le processeur doit être éteint via l'entrée NMI. Aussi, divers circuits vérifient ces paramètres en permanence. Ils autorisent le démarrage de l’ordinateur via l'entrée RESET, mais peuvent aussi le redémarrer ou activer l'entrée NMI si besoin. Les entrées NMI et RESET sont donc reliées à des circuits communs.

===Le ''watchdog timer'' est reliée à l'entrée RESET===

Un autre exemple d'utilisation de l'entrée RESET du processeur est lié au ''watchdog timer''. Pour rappel, le ''watchdog timer'' est un mécanisme de sécurité qui redémarre automatiquement l'ordinateur s'ils suspecte que celui-ci a planté. Le ''watchdog timer'' est un compteur/décompteur qui est connecté à l'entrée RESET du processeur. Si le compteur/décompteur déborde (au sens débordement d'entier), alors il génère un signal RESET pour redémarrer le processeur. On part du principe que si l'ordinateur ne réinitialise par le ''watchdog timer'', c'est qu'il a planté.

Le processeur réinitialise le ''watchdog timer'' régulièrement, ce qui signifie que le compteur est remis à zéro avant de déborder, et le système n'est pas censé redémarrer. Pour cela, il utilise l'entrée NMI, d'une manière assez particulière. Régulièrement, un ''timer'' séparé envoie un 1 sur l'entrée NMI. Le processeur exécute alors son programme d'urgence, qui cherche la source de l'interruption. Il remarque alors que l'activation de l'entrée NMI provient de ce ''timer''. Le programme d'urgence réinitialise alors le ''watchdog timer''.

[[File:SimpleWatchdogTimer.gif|centre|vignette|upright=2|Le ''Watchdog Timer'' et l'ordinateur.]]

==La gestion des fréquences et les ''timers''==

Les composants d'un ordinateur sont cadencés à des fréquences très différentes. Par exemple, le processeur fonctionne avec une fréquence plus élevée que l'horloge de la mémoire RAM. Les différents signaux d'horloge sont générés par la carte mère. Intuitivement, on se dit qu'il y a un circuit dédié par fréquence. Mais c'est en fait une erreur : en réalité, il n'y a qu'un seul générateur d'horloge. Il produit une horloge de base, qui est « transformée » en plusieurs horloges, grâce à des montages électroniques spécialisés. Les avantages de cette méthode sont la simplicité et l'économie de circuits.

===Les multiplieurs et diviseurs de fréquence===

La fréquence de base est souvent très petite comparée à la fréquence du processeur ou de la mémoire, ce qui est contre-intuitif. Mais la fréquence de base est multipliée par les circuits transformateurs pour obtenir la fréquence du processeur, de la RAM, etc. Ainsi, la fréquence du processeur et de la RAM sont des multiples de cette fréquence de base. Naturellement, les circuits de conversion de fréquence sont donc appelés des '''multiplieurs de fréquence'''.

[[File:Génération des signaux d'horloge d'un ordinateur.png|centre|vignette|upright=2|Génération des signaux d'horloge d'un ordinateur]]

De nos jours, les ordinateurs font faire la multiplication de fréquence par un composant appelé une '''PLL''' (''Phase Locked Loop''), qui sont des composants assez versatiles et souvent programmables, mais il est aussi possible d'utiliser des circuits à base de portes logiques plus simples mais moins pratiques. Comprendre le fonctionnement des PLLs et des générateurs de fréquence demande des bases assez solides en électronique analogique, ce qui fait que nous n'en parlerons pas en détail dans ce cours.

Une carte mère peut aussi contenir des diviseurs de fréquences, pour générer des fréquences très basses. C'était surtout le cas avec les anciens systèmes, où certains bus allaient à quelques kiloHertz. Les diviseurs de fréquences sont fabriqués avec des compteurs, comme nous l'avions vu dans le chapitre sur les ''timers'' et diviseurs de fréquence. Vu que nous avons déjà abordé ces composants, nous ne reviendrons pas dessus.

===Le générateur de fréquence : un oscillateur à Quartz===

Le '''générateur de fréquence''' est le circuit qui génère le signal d'horloge envoyé au processeur, la mémoire RAM, et aux différents bus. Sans lui, le processeur et la mémoire ne peuvent pas fonctionner, vu que ce sont des circuits synchrones dans les PC actuels.

Il existe de nombreux circuits générateurs de fréquence, qui sont appelés des '''oscillateurs''' en électronique. Ils sont très nombreux, tellement qu'on pourrait écrire un livre entier sur le sujet. Entre les oscillateurs basés sur un circuit RLC (avec une résistance, un condensateur et une bobine), ceux basés sur une résistance négative, ceux avec des amplificateurs opérationnels, ceux avec des lampes à néon, et j'en passe ! Mais nous n'allons pas parler de tous les oscillateurs, la plupart n'étant pas utilisés dans les ordinateurs modernes.

[[File:3Com OfficeConnect ADSL Wireless 11g Firewall Router 2012-10-28-0866.jpg|vignette|Oscillateur à Quartz, sur une carte mère.]]

La quasi-totalité des générateurs de fréquences des ordinateurs modernes sont des '''oscillateurs à quartz''', similaires à celui présent dans les montres électroniques. Ils sont fabriqués en combinant un amplificateur avec un cristal de Quartz. Ils fournissent une fréquence de base qui varie suivant le modèle considéré, mais qui est souvent de 32 768 Hertz, soit 2^15 cycles d'horloge par seconde. Le cristal de Quartz a une forme facilement reconnaissable, comme montré dans l'image ci-contre. Vous pouvez le repérer assez facilement sur une carte mère si jamais vous en avez l'occasion.

: Pour ceux qui voudraient en savoir plus sur le sujet, sachez que le wikilivre d'électronique a un chapitre dédié à ce sujet, disponible via le lien suivant. Attention cependant : le chapitre n'est compréhensible que si vous avez déjà lu les chapitres précédents du wikilivre sur l'électronique et il est recommandé d'avoir une bonne connaissance des circuits RLC/LC, sans quoi vous ne comprendrez pas grand-chose au chapitre.
* [[Électronique/Les oscillateurs (générateurs de fréquence)]]

===Les ''timers'' intégrés à la carte mère===

Le générateur de fréquence est souvent combiné à des ''timers'', des circuits qui comptent des durées bien précises et sont capables de générer des fréquences. Pour rappel, les ''timers'' sont des compteurs/décompteurs qui génèrent un signal quand ils atteignent une valeur limite. Ils permettent de compter des durées, exprimées en cycles d’horloge. Les fonctions de Windows ou de certains logiciels se basent là-dessus, comme celles pour baisser la luminosité à une heure précise, passer les couleurs de l'écran en mode nuit, certaines notifications, les tâches planifiées, et j'en passe.

Ils permettent aussi d’exécuter un tâche précise à intervalle régulier, ou après une certaine durée. Par exemple, on peut vouloir générer une interruption à une fréquence de 60 Hz, pour gérer le rafraichissement de l'écran. Une telle fonctionnalité s'utilisait autrefois sur les anciens ordinateurs ou sur les anciennes consoles de jeux vidéo et portait le nom de ''raster interrupt''.

Un ordinateur est rempli de ''timers'' divers, qui se trouvent sur la carte mère ou dans le processeur, tout dépend du ''timer''. Sur les anciens PC, la carte mère incorpore deux ''timers'' : l'horloge temps réel et le PIT. L'horloge temps réel génère une fréquence de 1024 Hz, alors que le PIT est un Intel 8253 ou un Intel 8254 programmable par l'utilisateur. Les PC récents n'ont qu'un seul ''timer'' sur la carte mère, qui remplace les deux précédents : le ''High Precision Event Timer''. Un ordinateur contient d'autres ''timers'', comme le ''timer'' ACPI, le ''timer'' APIC, ou le ''Time Stamp Counter'', mais ces derniers sont intégrés dans le processeur et non sur la carte mère. Plus rarement, certaines cartes mères possèdent un ''watchdog timer''.

===L'''Oscillator start-up timer'' : la stabilité de l'horloge au démarrage===

Au démarrage de l'ordinateur, la tension d'horloge n'est pas stable. Il faut un certain temps pour que les circuits de génération d'horloge se stabilisent et fournissent un signal d'horloge stable. Et tant que le signal d'horloge n'est pas stable, le processeur n'est pas censé démarrer. L''''''Oscillator start-up timer''''' est un circuit qui temporise en attendant que le signal d'horloge se stabilise. Le signal RESET, nécessaire pour démarrer le processeur, n'est mis à 1 que si l'''Oscillator start-up timer'' lui donne le feu vert.

Dans son implémentation la plus simple, il s'agit d'un simple ''timer'', un vulgaire compteur qui attend qu'un certain nombre de cycles d'horloge se soient écoulés. Il est supposé que la fréquence est stable après ce nombre de cycles. Par exemple, sur les microcontrôleurs PIC 8-bits, l'OST compte 1024 cycles d'horloge avant d'autoriser le RESET. D'autres processeurs attendent durant un nombre de cycles plus important, le nombre de cycles exact dépend de la fréquence. Notez que l'OST attend un certain nombre de cycles. Les premiers cycles sont irréguliers, le tout se stabilise vers la fin, ce qui ne correspond pas à un temps bien défini, une petite variabilité est toujours présente.

===Un exemple de circuit générateur de fréquence : l'Intel 8284===

L'''Oscillator start-up timer'' est parfois fusionné avec d'autres circuits, dont des multiplieurs/divisieurs de fréquence et des ''timers''. Un bon exemple est celui de l''''Intel 8284''', un circuit qui fusionne ''Oscillator start-up timer'', diviseur de fréquence et générateur de fréquence.

[[File:Intel 8284.svg|thumb|Intel 8284]]

Il est possible de le relier à un cristal de Quartz sur deux entrées nommée X1 et X2, et il génère alors un signal d'horloge à partir de ce qu'il reçoit du cristal. Le signal d'horloge généré est alors disponible sur une sortie dédiée, la sortie OSC. C'est la fonction générateur d'horloge. Dans le détail, pour générer une fréquence, il faut combiner un cristal de Quartz avec un circuit dit oscillateur. L'Intel 8284 incorpore l’oscillateur, mais pas le cristal de Quartz.

Il est aussi possible de l'utiliser en tant que diviseur de tension, bien que ce soit rudimentaire. La fréquence d'entrée est divisée par trois et le résultat est présenté sur la sortie PCLK. La fréquence de sortie a alors un rapport cyclique de 1/3. L'implémentation de la division par trois se fait avec un simple compteur. Un second signal d'horloge est disponible sur la sortie nommée CLK. Il a une de fréquence deux fois moindre que le premier, soit 6 fois moins que la fréquence d'entrée, et a un rappoort cyclique de 50% (signal carré).

Un point important est que la fréquence d'entrée peut provenir de deux sources différentes. En premier lieu, elle peut être présentée sur une broche séparée, appelée l'entrée EFI. En second lieu, elle peut provenir de l’oscillateur à Qaurtz intégré au 8284. Le choix entre les deux se fait avec l'entrée F/C : oscillateur si c'est un 1, entrée EFI si c'est un 0.

L'intérieur du circuit est assez simple : un ''timer'' pour l'OST, un oscilateur à Quartz, un multiplexeur pour choisir la fréquence d'entrée, deux compteurs pour les diviseurs de fréquences.

===Annexe : le bouton Turbo des vieux PC===

[[File:PC-Front IMGP5531 smial wp.jpg|vignette|Exemple de façade de PC avec un bouton Turbo.]]

Si vous êtes assez vieux, vous avez peut-être déjà utilisé un PC qui disposait d'un bouton Turbo à côté du bouton ON/OFF. Vous êtes vous êtes demandé ce à quoi servait ce bouton ? Et surtout : saviez-vous que contre-intuitivement, il ralentissait l'ordinateur ? La raison à cela est partiellement liée à la fréquence du processeur : le bouton Turbo réduisait la fréquence du processeur (sauf exceptions) ! La raison est une question de compatibilité logicielle avec les processeurs 8086 et 8088 d'Intel.

A l'époque, de nombreux jeux ou logiciels interactifs se basaient sur la fréquence du CPU pour timer des actions/évènements. Mais lors du passage au processeurs 286, 396 et 486, la fréquence du CPU a augmenté. Les logiciels allaient alors plus rapidement, les jeux vidéos étaient accélérés au point d'en devenir injouables. L'effet était un peu similaire à la différence entre jeux en 50 et 60 Hz, sauf qu'ici, la fréquence était multipliée par 2, 4, voire 10 ! Le 8088 avait une fréquence de 4,77 MHz et le 8086 allait à 5 MHz. Le 186 allait à 6 MHz, le 286 allait à 10 ou 12.5 MHz selon la version, le 386 allait de 12.5 MHz à 40 MHz selon la version, et le 486 allait de 16 à 100 MHz.

Pour éviter cela, les ordinateurs ont ajouté un bouton Turbo, qui était en réalité un bouton de compatibilité. Lorsqu'on l'appuyait, la vitesse de l'ordinateur était réduite de manière à faire tourner les anciens jeux/logiciels à la bonne vitesse. En clair, le bouton était mal nommé et faisait l'inverse de ce qu'on peut croire intuitivement. Du moins, c'était le principe. Quelques ordinateurs fonctionnaient à vitesse réduite à l'état normal et il fallait appuyer sur le bouton Turbo pour retrouver une vitesse normale.

Et le bouton Turbo agissait sur la fréquence du CPU. Il baissait sa fréquence pour le faire descendre aux 4,77/5 MHz adéquats. Du moins, certaines cartes mères faisaient ainsi. Des rumeurs prétendent que certains carte mères faisaient autrement, en désactivant le cache du processeur, ou en réduisant la fréquence effective du bus (en ajoutant des ''wait state'', des cycles où le bus est inutilisé). Mais dans la majorité des cas, on peut supposer que la réduction de la fréquence était belle et bien utilisée. Et pour cela, il fallait relier le bouton Turbo à des circuits diviseurs de fréquence pour réduire la fréquence du CPU. Qu'un bouton soit relié, même indiretcement aux circuits d'horloge, est tout de même quelque chose d'assez inattendu. Imaginez si les PC actuels avaient un bouton &quot;Power Saving&quot; qui réduisait la fréquence du processeur.

==L'horloge temps réel et la CMOS RAM==

Parmi tous les ''timers'' présents sur la carte mère, l''''horloge temps réel''' se démarque des autres. Dans ce qui suit, nous la noterons RTC, ce qui est l'acronyme du terme anglais ''Real Time Clock''. La RTC est cadencée à fréquence de 1 024 Hz, soit près d'un Kilohertz, ou du moins un circuit capable de l'émuler. La RTC est parfois connectée à l'entrée d'interruption non-masquable, car elle est utilisée pour des fonctions importantes du système d'exploitation, comme la commutation entre les processus, et bien d'autres. Mais son fonction principale est toute autre.

La RTC est utilisée par le système pour compter les secondes, afin que l'ordinateur soit toujours à l'heure. Vous savez déjà que l'ordinateur sait quelle heure il est (vous pouvez regarder le bureau de Windows dans le coin inférieur droit de votre écran pour vous en convaincre) et il peut le faire avec une précision de l'ordre de la seconde.

===La CMOS RAM===

Pour savoir quel jour, heure, minute et seconde il est, l'ordinateur utilise la RTC, ainsi qu'un circuit pour mémoriser la date. La '''CMOS RAM''' mémorise la date exacte à la seconde près. Son nom nous dit qu'elle est fabriquée avec des transistors CMOS, mais aussi qu'il s'agit d'une mémoire RAM. Mais attention, il s'agit d'une mémoire RAM ''non-volatile'', c'est à dire qu'elle ne perd pas ses données quand on éteint l'ordinateur. Nous expliquerons dans la section suivante comment cette RAM fait pour être non-volatile.

La ''CMOS RAM'' est adressable, mais on y accède indirectement, comme si c'était un périphérique, à savoir que la CMOS RAM est mappée en mémoire. On y accède via les adresses 0x0007 0000 et 0x0007 0001 (ces adresses sont écrites en hexadécimal). Elle mémorise, outre la date et l'heure, des informations annexes, comme les paramètres du BIOS (voir plus bas). Oui, vous avez bien lu : la CMOS RAM est utilisée pour stocker les paramètres du BIOS vu plus haut, elle sert de ''non-volatile BIOS memory''. Il s'agit là d'une optimisation : au lieu d'utiliser une ''non-volatile BIOS memory'' et une CMOS RAM séparée, on utilise une seule mémoire non-volatile pour les deux. Mais la manière de stocker les paramètres du BIOS dans la CMOS RAM a beaucoup changé dans le temps.

Les anciens PC avaient un bus ISA, ancêtre du bus PCI. Et le BIOS devait mémoriser la configuration de bus, ainsi que l'ensemble des périphériques installé sur ce bus. Pour cela, ces données de configuration étaient stockées dans la CMOS RAM. Elles suivaient le standard dit d'''Extended System Configuration Data''. Il fournissait un format standard pour stocker les paramètres du bus ISA, l'adresse où placer ces données, et trois fonctions/interruptions du BIOS pour récupérer ces données. Les données de configuration ISA prenaient les 128 octets à la fin de CMOS ROM. Les bus plus récents ne mémorisent plus de données de configuration dans la CMOS RAM, ni même dans le BIOS.

===La source d'alimentation de la RTC et de la CMOS RAM===

[[File:Inside the Real-time clock IC vnutri u nei neonka.jpg|vignette|RTC avec pile au lithium intégrée.]]

L'horloge temps réel, l’oscillateur à Quartz et la CMOS RAM fonctionnent en permanence, même quand l'ordinateur est éteint. Mais cela implique que ces composants doivent être alimenté par une source d'énergie qui fonctionne lorsque l'ordinateur est débranché. Cette source d'énergie est souvent une petite pile au lithium localisée sur la carte mère, plus rarement une petite batterie. Elle alimente les trois composants en même temps, vu que tous les trois doivent fonctionner ordinateur éteint. Elle est facilement visible sur la carte mère, comme n'importe quelle personne qui a déjà ouvert un PC et regardé la carte mère en détail peut en témoigner.

: Au passage : plus haut, nous avions dit que la CMOS RAM est une RAM non-volatile, c'est à dire qu'elle ne s'efface pas quand on éteint l’ordinateur. Et bien si elle l'est, c'est en réalité car elle est alimentée en permanence par une source secondaire de courant.

Sur la plupart des cartes mères, la RTC et la CMOS RAM sont fusionnées en un seul circuit qui s'occupe de la gestion de la date et des durées. Il arrive rarement que la pile au lithium soit intégrée dans ce circuit, mais c'est très rare. La plupart des concepteurs de carte mère préfèrent séparer la pile au lithium de la RTC/CMOS RAM pour une raison simple : on peut changer la pile au lithium en cas de problèmes. Ainsi, si la pile au lithium est vide, on peut la remplacer. Enlever la pile au lithium permet aussi de résoudre certains problèmes, en réinitialisant la CMOS RAM. L'enlever et la remettre réinitialise la ''CMOS RAM'', ce qui remet à zéro la date, mais aussi les paramètres du BIOS.

==Le ''chipset'' de la carte mère==

L'organisation des cartes mères des ordinateurs personnels a évolué au cours du temps pendant que de nombreux bus apparaissaient. Les premiers ordinateurs faisaient avec un simple bus système qui connectait processeur, mémoire et entrée-sortie. Mais avec l'augmentation du nombre de périphériques et de composants systèmes, l'organisation des bus s'est complexifiée.

===La première génération : les bus partagés===

Pour les bus de première génération, un seul et unique bus reliait tous les composants de l'ordinateur. Ce bus s'appelait le '''bus système''' ou ''backplane bus''. Ces bus de première génération avaient le fâcheux désavantage de relier des composants allant à des vitesses très différentes : il arrivait fréquemment qu'un composant rapide doive attendre qu'un composant lent libère le bus. Le processeur était le composant le plus touché par ces temps d'attente. Du fait de l'existence d'un bus unique, les entrées-sorties étaient mappées en mémoire 

[[File:Computer buses.svg|centre|vignette|upright=2|Bus système]]

===L'apparition du ''chipset''===

Les cartes mères récentes, après les années 1980, ne peuvent plus utiliser un bus unique, car il y a trop de composants à connecter dessus. A la place, elles utilisent une architecture à base de répartiteurs. Pour rappel, ce répartiteur est placé en avant du processeur et sert d'interface entre celui-ci, un bus pour la mémoire, et un bus pour les entrées-sorties. Mais il a aussi d'autres capacités qui dépassent de loin son rôle d'interface. Il a intégré des circuits comme le contrôleur mémoire, un contrôleur DMA, un contrôleur d'interruption, etc.

[[File:IO mappées en mémoire avec séparation des bus.png|centre|vignette|upright=2|IO mappées en mémoire avec séparation des bus, usage d'un répartiteur]]

Un exemple est le ''chipset'' utilisé avec le processeur Intel 486, sorti en 1989. Il était connecté au processeur, à la mémoire RAM, aux différents bus, mais aussi à la mémoire cache (qui était séparé du processeur et placé sur la carte mère). Pour ce qui est des bus, il était connecté au bus PCI, au bus IDE pour le disque dur et au bus SMM. Il était indirectement connecté au bus ISA, un bus ancien conservé pour des raisons de rétrocompatibilité, mais qui avait été éclipsé par le PCI.

===La séparation du ''chipset'' en deux===

Un autre problème est que la mémoire et la carte graphique sont devenus de plus en plus rapide avec le temps, au point que les périphériques ne pouvaient plus suivre. Les différents composants de la carte mère sont séparés en deux catégories : les &quot;composants lents&quot; et les &quot;composants rapides&quot;. Les composants rapides regroupent le processeur, la mémoire RAM et la carte graphique, les autres sont regroupés dans les composants lents. Les besoins entre des deux classes de composants étant différents, utiliser un seul bus pour les faire communiquer n'est pas idéal. Les composants rapides demandent des bus rapides, de forte fréquence, avec un gros débit pour communiquer, alors que les composants lents ont besoin de bus moins rapide, de plus faible fréquence.

Entre les années 80 et 2000, la solution retenue par les fabricants de cartes mères utilisait deux répartiteurs séparés : le ''northbridge'' et le ''southbridge''. Le ''northbridge'' sert d'interface entre le processeur, la mémoire et la carte graphique et est connecté à chacun par un bus dédié. Il intègre notamment le controleur mémoire. Le ''southbridge'' est le répartiteur pour les composants lents. Le bus qui relie le processeur au ''northbridge'' est appelé le '''''Front Side Bus''''', abrévié en FSB. Le bus de transmission qui relie le ''northbridge'' au ''southbridge'' est un bus dédié, spécifique au ''chipset'' considéré, sur lequel on ne peut pas dire de généralités.

[[File:Chipset schematic.svg|centre|vignette|upright=1.0|Chipset séparé en northbridge et southbridge.]]

[[File:Motherboard diagram.svg|vignette|Carte mère avec circuit Super IO.]]

Ce qui est mis dans le ''southbridge'' est très variable selon la carte mère. Le ''southbridge'' intègre généralement tout ce qu'il faut pour gérer des périphériques, ce qui inclut des circuits aux noms barbares comme des contrôleurs de périphériques, des contrôleurs d'interruptions, des contrôleurs DMA, etc. Mais les ''chipsets'' modernes ont tellement de transistors qu'on y intègre presque tout et n'importe quoi. Par exemple, les cartes mères des processeurs Intel 5 Series intégraient la ''Real Time Clock''. Il arrive aussi que la CMOS RAM soit intégrée au ''southbridge''. Par contre, sur la plupart des cartes mères, le BIOS est placé en-dehors du ''southbridge''.

Il est arrivé que le ''chipset'' incorpore des cartes sons basiques, voire carrément des cartes graphiques (GPU). Les cartes son des ''chipsets'' étaient au départ assez mauvaises, mais ont rapidement augmenté en qualité, au point où plus personne n'utilise de carte son séparée dans son ordinateur. Quand aux GPU intégrés au ''chipset'' suffisaient largement pour une utilisation bureautique de l'ordinateur. Tant que l'utilisateur ne jouait pas à des jeux vidéos peu gourmands, le GPU du ''chipset'' suffisait. De plus, il consommait peu d'énergie et produisait peu de chaleur, le ''chipset'' avait juste à être refroidit par un simple radiateur. De nos jours, ils sont remplacées par les GPU intégrés aux processeurs, qui ont globalement les mêmes défauts et qualités. 

Sur certaines cartes mères, le ''southbridge'' est complémenté par un circuit de '''''Super IO''''', qui s'occupe des périphériques et bus anciens, comme le bus pour le lecteur de disquette, le port parallèle, le port série, et les ports PS/2 pour le clavier et la souris. De plus, ce circuit peut contenir beaucoup d'autres sous-circuits. Par exemple, il peut contenir des capteurs de température, les circuits qui contrôlent la vitesse des ventilateurs, divers ''timers'', et quelques autres.

===L'intégration du ''northbridge'' au processeur===

[[File:Intel 5 Series architecture.png|vignette|Intel 5 Series architecture]]

Sur les cartes mères qui datent au moins des années 2000, depuis la sortie de l'Athlon64, le contrôleur mémoire a été intégré au processeur, ce qui est équivalent à dire que le ''northbridge'' est intégré au processeur. le ''southbridge'' est encore là, il est toujours connecté au processeur et aux périphériques. Concrètement, le processeur a un bus mémoire séparé, non-connecté au répartiteur de type ''southbridge''.

Les raisons derrière cette intégration ne sont pas très nombreuses. La raison principale est qu'elle permet diverses optimisations quant aux transferts avec la mémoire RAM. De sombres histoires de ''prefetching'', d'optimisation des commandes, et j'en passe. La seconde est surtout que cela simplifie la conception des cartes mères, sans pour autant rendre vraiment plus complexe la fabrication du processeur. Les industriels y trouvent leur compte.

Par la suite, la carte graphique fût aussi connectée directement sur le processeur. Le processeur incorpore pour cela des contrôleurs PCI-Express, et même d'autres circuits contrôleurs de périphériques. Le ''northbridge'' disparu alors complétement. Sur les cartes mères Intel récentes, le ''chipset'' est appelé le ''Platform Controler Hub'', ou PCH. l'organisation des bus sur la carte mère qui résulte de cette connexion du processeur à la carte graphique, est illustrée ci-dessous, avec l'exemple du PCH.

==La gestion thermique : sondes de température et ventilateurs==

[[File:AMD heatsink and fan.jpg|vignette|Section de la carte mère avec dissipateur thermique et ventilateur en aluminium au-dessus du processeur AMD. À côté, on peut voir un dissipateur thermique plus petit, sans ventilateur, au-dessus d'un autre circuit intégré de la carte mère.]]

Une fonctionnalité importante des cartes mères modernes est la gestion de la température, ainsi que le contrôle des ventilateurs. La carte mère surveille en permanence la température du processeur, éventuellement celle du GPU ou du ''chipset'', et réagit en conséquence. Les réactions ne sont pas très variées, la plus simple est de simplement faire tourner les ventilateurs plus ou moins vite. Mais la carte mère peut aussi réduire la fréquence du processeur en cas de température trop importante, si les ventilateurs ne suivent pas, voire déclencher un arrêt d'urgence si le processeur chauffe trop. Tout cela est regroupé sous le terme de '''gestion thermique'''.

La carte mère incorpore un circuit pour la gestion thermique. Concrètement, le circuit varie pas mal selon la carte mère. Il peut faire partie du ''chipset'', précisément dans le ''southbridge''. Mais il se peut aussi qu'il soit séparé des autres, soudé sur la carte mère. Dans ce qui suit, nous partons du principe qu'il s'agit d'un microcontrôleur placé sur la carte mère ou intégré au ''chipset''. Nous l'appellerons le '''microcontrôleur de surveillance hardware'''.

Le microcontrôleur de surveillance lit la température et décide comment commander les ventilateurs. La mesure est généralement directe, par l'intermédiaire d'un bus plus ou moins dédié. Par exemple, sur les anciens processeurs Core 2 Duo d'Intel, le bus était appelé le bus PECI. Il peut aussi lire indirectement la température via le ''chipset'' de la carte mère. Mais il existe une voie alternative, où le processeur ordonne directement d'augmenter la vitesse des ventilateurs, sans lecture des températures. Pour cela, il est connecté au microcontrôleur de surveillance, avec un fil dédié. Si le processeur met à 1 ce fil dédié, le microcontrôleur de surveillance réagit immédiatement en faisant tourner les ventilateurs plus vite.

[[File:Gestion thermique carte mère.png|centre|vignette|upright=2|Gestion thermique carte mère]]

Pour l'anecdote, le microcontrôleur de surveillance des PC était initialement un contrôleur de clavier PS/2, le &quot;Keyboard Controller BIOS&quot;. Et ce contrôleur disposait déjà d'un fil connecté à l'entrée RESET du processeur, ce qui fait qu'il est techniquement possible de redémarrer son ordinateur par l'intermédiaire du contrôleur de clavier... Vu qu'il y avait déjà un microcontrôleur présent sur la carte mère, il a été décidé de le réutiliser pour des tâches autres, comme la gestion thermique, de la gestion des tensions d'alimentation, des régulateurs de tension, le démarrage (normal ou via réseau), la mise en veille, etc. De nos jours encore, le microcontrôleur de surveillance gère le touchpad.

===La mesure de la température : les sondes thermiques===

Le microcontrôleur de surveillance contrôle la vitesse du ventilateur en fonction de la température mesurée. Pour cela, le microcontrôleur de surveillance est relié à une ou plusieurs sondes qui mesurent la température. De nos jours, la sonde est intégrée dans le processeur. La sonde thermique du processeur peut être complétée par des sondes sur la carte mère. Il y a aussi des sondes dans le disque dur, le GPU, parfois dans la mémoire RAM, etc. Mais le gros du travail est réalisé par une sonde intra-processeur. 

Pour mesurer la température, le processeur incorpore un capteur de température, souvent appelé la '''diode thermique'''. Le terme implique qu'il s'agit d'une diode qui est utilisée pour mesurer la température. C'était effectivement le cas auparavant, au tout début de l'informatique. Mais de nos jours, on utilise des senseurs différents, généralement basés sur des transistors configurés de manière à marcher comme une diode. Il faut dire que transistors et diodes sont basés sur des jonctions PN, ce qui fait qu'un transistor peut émuler une diode, mais passons.

L'implémentation originale avec une diode est assez simple à comprendre. La tension aux bornes d'une diode est égale à ceci :

: &lt;math&gt;\text{Tension aux bornes d'une diode} = \text{Tension de base} - K \times \text{Température}&lt;/math&gt;

En clair, plus la température est élevée, plus la tension aux bornes de la diode chute. Dit autrement, une diode laisse d'autant mieux passer le courant. Elle chute assez rapidement, au rythme de 2 milli-volts pour chaque degré de plus. Le coefficient K vaut donc &lt;math&gt;- 2 mV&lt;/math&gt;. Au final, cela donne une différence d'une centaine de millivolts aux hautes températures. Et cela peut se mesurer assez bien. La tension résultante est ensuite convertie soit en tension, soit en un nombre codé en binaire par un convertisseur analogique-numérique.

Le processeur contient au moins une diode thermique, qui est placée à l'endroit le plus susceptible de chauffer. Il y en a généralement une par cœur, afin de gérer individuellement la température de chaque cœur. Généralement, la température mesurée est convertie en digital/numérique et est mémorisée dans un registre, qui est très régulièrement mis à jour. Le registre peut même être consulté par le logiciel, ce qui explique que de nombreux logiciels de surveillance matérielles permettent de connaitre en temps réel les températures du CPU, du GPU, de la mémoire, du SSD, etc.

===Le ''throttling'' du CPU et l'arrêt d'urgence en cas de surchauffe===

Il arrive que le processeur chauffe trop, alors que les ventilateurs tournent à leur vitesse maximale. Dans ce cas, la solution est de réduire la fréquence du processeur et sa tension, afin qu'il consomme moins et donc chauffe moins. On dit que le processeur '''''throttle''''', la technique qui réduit immédiatement la fréquence en cas de surchauffe est souvent appelée le '''''throttling'''''. Le ''throttling'' peut s'implémenter dans le processeur ou dans le microcontrôleur de surveillance, les deux vont souvent de pair. Mais l'implémentation dans le processeur est la plus simple.

L'implémenter est assez simple. On rappelle que le processeur contient un multiplieur de fréquence configurable qui lui permet de régler en direct sa fréquence, de même qu'il contient un régulateur de tension interne lui aussi configurable. Il y a la même chose sur la carte mère. Les circuits de ''throttling'' lisent la mesure provenant de la diode thermique, puis configurent les multiplieurs de fréquence/tension.

Une température trop forte peut endommager le processeur, définitivement. Il y a un seuil de température au-delà duquel le processeur est en danger et peut fondre, prendre feu, ou tout simplement se dégrader. La température que le processeur ne doit en aucun cas dépasser est appelée la '''température de sureté'''. Au-delà de la température de sureté, la température est tellement élevée que le processeur peut être endommagé et doit immédiatement être mis en pause.

Pour éviter cela, le processeur est arrêté de force en cas de température trop forte. Dans ce cas, c'est autant le processeur que le microcontrôleur de surveillance qui sont impliqués. Si la température continue d'augmenter malgré le ''throttling'', ou qu'elle est tout simplement trop forte, le processeur déclenche un arrêt d'urgence et le microcontrôleur de surveillance l'exécute. Le processeur a une sortie PROCHOT qui indique que la température de sureté est dépassée, qui est reliée sur une entrée dédiée du microcontrôleur de surveillance. Lorsque le microcontrôleur de surveillance détecte un 1 sur le fil PROCHOT, il déclenche immédiatement un arrêt d'urgence.

[[File:Gestion thermique CPU.png|centre|vignette|upright=2|Gestion thermique CPU]]

===Le contrôle des ventilateurs===

Le ventilateur principal sur une carte mère est le plus souvent du ventilateur du processeur, placé au-dessus du radiateur. Mais il y a parfois des ventilateurs placés dans le boitier ou sur le ''chipset'', qui sont eux aussi commandés par la carte mère. Ils servent à dissiper la chaleur produite par le fonctionnement de l'ordinateur, qui est d'autant plus forte que le processeur travaille.

Autrefois, les ventilateurs tournaient en permanence, tant que l'ordinateur était allumé. Je parle là d'un temps datant d'avant les années 90, et encore. Mais depuis, les ventilateurs ne sont pas utilisés au maximum en permanence. A la place, la vitesse des ventilateurs s'adapte aux besoins. Précisément, ils s'adaptent à la consommation du processeur : plus le processeur fait de calcul, plus il émet de chaleur, plus les ventilateurs tournent rapidement.

Dans le cas le plus simple, le microcontrôleur de surveillance se contente d'allumer ou d'éteindre le ventilateur. Le résultat est un ventilateur qui tourne à plein pot ou s'arrête totalement. Le ventilateur était allumé au-dessus d'un certain seuil, éteint sous ce seuil. Pour simplifier, nous allons appeler cette technique la '''gestion des ventilateurs à un seuil'''. Elle n'est pas très efficace, mais c'était suffisant sur des processeurs assez anciens, qui pouvaient se contenter du radiateur au repos, mais devaient allumer le ventilateur quand on leur demandait plus de travail. L'inconvénient est que le confort acoustique est perfectible.

Les autres techniques qui vont suivre contrôlent plus finement la vitesse du ventilateur. Plus la température est importante, plus le ventilateur tourne vite, jusqu’à un certain point. Dans le détail, le microcontrôleur utilise une '''gestion des ventilateurs à deux seuils'''. Intuitivement, on sait que la vitesse du ventilateur augmente avec la température, jusqu'à atteindre une vitesse maximale. Mais il est aussi important d'imposer une vitesse minimale au ventilateur, même à de très basses températures. Les raisons à cela sont assez nombreuses, l'une d'entre elle est que cela permet un refroidissement minimal si la sonde de température dysfonctionne. Entre les deux seuils de température précédents, la vitesse augmente avec la température d'une manière relativement proportionnelle, linéaire.

[[File:Controle des ventilateurs.png|centre|vignette|upright=2|Contrôle des ventilateurs]]

[[File:2006 0703molex0002.JPG|vignette|Exemple de connecteur de ventilateur, avec seulement trois pins (VDD, O Volt, Tension de commande).]]

Maintenant, on peut se demander comment commander la vitesse des ventilateurs. Les ventilateurs sont connectés à la carte mère via un connecteur, qui contient un fil pour la tension d'alimentation, un autre pour la masse, et un ou deux fils de contrôle. Le premier envoie au ventilateur une '''tension de commande''' qui indique à quelle vitesse il doit tourner. Le second, le '''fil de ''monitoring''''', indique à la carte mère à quel vitesse le ventilateur tourne. Sur le fil de monitoring, le ventilateur envoie un signal à une certaine fréquence, qui correspond à la fréquence de rotation du ventilateur.

Il y a plusieurs méthodes concernant la tension de commande. Avec la plus simple, la tension de commande est proportionnelle à la vitesse de rotation. Prenons par exemple un ventilateur pouvant tourner de 0 à 1000 RPM (rotations par minute). Si la tension de commande est de 5 volts, alors une tension de 0 volts donnera 0 RPM, la tension maximale de 5V donnera 1000 RPM, une tension de 2 volts donnera 400 RPM, une tension de 3 volts donnera 600 RPM, etc. Le problème est que contrôler finement une tension est quelque peu compliqué, car cela demande d'utiliser des circuits analogiques, qui sont complexes à fabriquer.

Une méthode plus utilisée actuellement est d'utiliser un signal modulé par PWM, un terme barbare dont la signification est pourtant assez simple. Le ventilateur est contrôlé par un signal d'horloge d'une fréquence de 25 KHz. Le moteur du ventilateur est allumé quand le signal d'horloge est à 1, éteint quand il est à 0. Avec l'inertie, le ventilateur continue à tourner quand le signal d'horloge est à 0 et il ralentit assez peu. Le ventilateur accélère quand le signal d'horloge est à 1, mais ralentit quand il est à 0. La vitesse instantanée du ventilateur fluctue donc lors d'une période, mais sa vitesse moyenne est bien définie.

Intuitivement, la signal d'horloge est à 1 la moitié du temps, à 0 l'autre moitié. La vitesse moyenne est donc la moitié de la vitesse maximale. Mais ce n'est pas le cas. L'idée est alors de trifouiller le signal d'horloge, en modulant la durée où il est à 1, mais sans changer la fréquence. En clair, on module le '''rapport cyclique''' (''duty cycle''), le pourcentage d'une période où le signal d'horloge est à 1. Plus le rapport cyclique est grand, plus le ventilateur tourne vite. Pour le dire en une phrase : la tension de commande est un signal d'une fréquence de 25 KHz, dont le rapport cyclique contrôle la vitesse du ventilateur.

[[File:PWM duty cycle with label.gif|centre|vignette|upright=2|Signaux d'horloge asymétriques]]

Typiquement, le rapport cyclique va de 30% à 100%. A 100%, le ventilateur tourne en permanence, le signal d'horloge devient un signal constant, le ventilateur va a sa vitesse maximale. En-dessous de 30%, le comportement dépend fortement de la carte mère et du mécanisme de contrôle du ventilateur. Le ventilateur est généralement éteint, ou alors il ne peut pas tourner à moins de 30% de va vitesse maximale.

==Les circuits de gestion de l'alimentation==

Une partie importante de la carte mère est liée à l'alimentation électrique. Le '''sous-système d'alimentation''' reçoit de l'électricité de la part du connecteur d'alimentation, et génère les tensions demandées par le processeur, la mémoire, etc. Le sous-système d'alimentation est très complexe et comprend un mélange de composants analogiques, numériques, et d'autres purement électriques. Mais il est intéressant d'en parler. Ses fonctions sont très diverses : alimenter les composants avec les tensions adéquates, vérifier la stabilité de l'alimentation, détecter les problèmes de tension, gérer l'allumage et la mise en veille, etc. En cas de problème, il peut déclencher un ''reset hardware''.

===La génération des tensions pour chaque composant===

Le processeur, la mémoire, et les différents circuits sur la carte mère, sont alimentés à travers celle-ci. Mais ils ont chacun besoin d'une tension bien précise, qui varie d'un composant à l'autre. Par exemple, la tension d'alimentation du processeur n'est pas celle de la mémoire RAM, qui n'est pas non plus celle du ''chipset''. Il y a donc des composants qui transforment la tension fournie par l’alimentation en tensions adéquates.

La carte mère est alimentée par une tension de base, qui provient de la batterie sur un ordinateur portable/smartphone, du bloc d'alimentation pour un PC fixe ou serveur. Les PC fixes suivent le format ATX, qui précise que le bloc d'alimentation doit fournir trois tensions de base : une de 3,3V, une autre de 5V et une autre de 12V. Les tensions de base passe alors à travers un ou plusieurs '''régulateurs de tension''', qui fournissent chacun une tension de sortie à la bonne valeur pour soit le processeur, soit la mémoire, soit un autre circuit.

[[File:Voltage Regulator connections-en.svg|centre|vignette|upright=2|Voltage Regulator connections-en]]

[[File:Voltage Regulator.png|vignette|Deux régulateurs de tension.]]

Un régulateur de tension est un circuit qui a au moins trois broches : une entrée pour la tension de base, une sortie pour la tension voulue, et une troisième entrée qui ne nous intéresse pas ici. Il existe des régulateurs qui fournissent une tension de 3,3V, d'autres qui fournissent du 1V, d'autres du 0.5V, d'autres du 2V, etc. Chaque régulateur est conçu pour sortir une tension bien précise. On ne peut pas, en théorie, configurer un régulateur de tension pour choisir sa tension de sortie.

Les ordinateurs modernes utilisent des régulateurs de tension améliorés, appelés des '''modules de régulation de la tension'''. Dans ce qui suit, nous utiliserons l'abréviation VRM, pour ''Voltage Regulator Modules''. Il s'agit de composants très complexes, avec de nombreuses fonctionnalités.

Une fonctionnalité importante des VRM est que l'on peut les activer ou les désactiver. Concrètement, cela permet d'allumer ou couper une tension électrique suivant les besoins. C'est utilisé lors de l'allumage de l'ordinateur, pour l'éteindre, le redémarrer, pour mettre certains composants en veille, etc. L'activation/désactivation d'un VRM se fait via une entrée de commande nommée ''Enable''. Mettez un 1 sur cette entrée pour activer le VRM, un 0 pour le désactiver.

Il existe des '''''smart VRM''''', qui implémentent de nombreuses fonctionnalités. Par exemple, il est possible de configurer la tension de sortie voulue parmi un choix de quelques tensions prédéterminées. Ce qui peut servir pour modifier la tension d'alimentation d'un composant à la volée, chose utile pour mettre un composant en veille. De plus, le VRM surveille en permanence sa température, la tension de sortie, le courant qui le traverse, et d'autres données importantes. Le microcontrôleur de surveillance peut accéder en temps réel à ces données, afin de détecter tout problème. Il peut ainsi détecter une défaillance de la tension de sortie du VRM, ou détecter qu'un VRM surchauffe. Pour résumer, les ''smart VRM'' peuvent être configurés et/ou surveillés.

Pour cela, le ''smart VRM'' communique avec l'extérieur par l'intermédiaire d'un bus dédié. Le bus en question est le bus ''Power Management Bus'', une variante du bus ''System Management Bus'' (SMBus), qui lui-même est une variante du bus i²c. Il s'agit d'un bus très simple, qui demande juste deux fils pour connecter le VRM à l’extérieur. Les ''smart VRM'' sont généralement connectées au microcontroleur de surveillance, parfois aux ''chipset'', parfois les deux.

===La séquence d'allumage des VRM===

Un point important est que chaque composant sur la carte mère utilise souvent plusieurs tensions d'alimentation. Par exemple, le processeur a souvent besoin de plusieurs tensions d'alimentation. Idem pour les cartes graphiques, qui demandent souvent d'avoir à leur disposition d'avoir plusieurs tensions distinctes.

Lors du démarrage, le composant requiert d'activer ces tensions dans un ordre bien précis. Expliquer pourquoi est compliqué, mais disons que sans cela, le composant le fonctionne tout simplement pas. Il y a donc un ordre d'allumage des tensions, décrit par une '''séquence d’amorçage des VRM'''. Et la même chose a lieu lors de la mise en veille : il faut désactiver les VRMs dans le bon ordre, souvent l'ordre inverse du démarrage. La sortie de mise en veille demande de faire comme lors de l’allumage, à quelques détails près.

L'ordre en question est géré via une fonctionnalité importante des VRM : on peut les activer ou les désactiver à la demande. Pour cela, ils disposent d'une entrée de commande qui active ou désactive le régulateur de tension. Si on envoie un 1 sur cette entrée, le VRM s'active. A l'inverse, un 0 sur cette entrée désactive le VRM. L'activation des tensions est le rôle d'un circuit spécialisé relié à chaque VRM, il a une sortie dédiée à chaque VRM, sur laquelle il envoie un 0 ou un 1 pour l'activer au besoin. Nous l’appellerons le '''''sequencing chip'''''. Il s'agit parfois d'un circuit dédié, mais il est souvent intégré directement dans le microcontrôleur de surveillance hardware.

Mais vous vous posez sans doute la question suivante : comment est alimenté le microcontrôleur de surveillance ? La réponse est que le microcontrôleur est relié à une tension de 3,3V qui est toujours active, qui provient du connecteur d'alimentation. Dès que vous branchez votre PC sur secteur, le 3,3 volts va alimenter le microcontrôleur de surveillance. Même si vous laissez votre ordinateur éteint, le microcontrôleur de surveillance est actif tant que le secteur est branché. Par contre, dès que vous appuyez sur le bouton d'alimentation, le microcontrôleur de surveillance démarre la séquence d’amorçage des VRM. D'ailleurs, le microcontrôleur de surveillance est directement connecté au bouton d'alimentation, il lui réserve une entrée dédiée.

[[File:Alimentation du microcontroleur de surveillance et liaison aux VRM.png|centre|vignette|upright=2|Alimentation du microcontroleur de surveillance et liaison aux VRM]]

Il faut noter que le microcontrôleur de surveillance n'est pas le seul alimenté ainsi. En réalité, une partie du ''chipset'' de la carte mère et quelques circuits annexes le sont aussi. Mais nous verrons cela plus tard.

===La stabilité de l'alimentation au démarrage===

Lors d'un démarrage ou d'un redémarrage, le processeur est allumé par un signal RESET. Il y a une petite différence entre l'allumage et le redémarrage, qui tient dans la manière dont la tension d'alimentation et l'horloge sont gérées. Lors d'un ''reset hardware'', le processeur reste alimenté, il n'est pas coupé. Il réinitialise ses registres, remet à zéro pas mal de circuits, mais l'alimentation reste maintenue. Lors du démarrage, ce n'est pas le cas : l'alimentation est allumée, la tension d'alimentation passe de 0 à 12 ou 5 volts. Au passage, si vous débranchez votre ordinateur avant de le rebrancher, ce n'est pas un ''reset hardware'', car vous éteignez l'ordinateur avant de le relancer. L'alimentation est coupée entre-temps.

Lors du démarrage, avant de générer un signal RESET, il faut attendre que la tension d'alimentation se stabilise, de même que le signal d'horloge. Si les tensions d'alimentation ne marchent pas comme prévu, le démarrage n'a pas lieu pour éviter d'endommager le processeur, idem pour le signal d'horloge. Pour cela, la carte mère contient deux circuits séparés. Le '''''Power-on reset''''', temporise en attendant que la tension d'alimentation se stabilise.

Le ''Power-on reset'' vérifie les tensions 12 V, 5 V et 3,3 V, et n'autorise le RESET du processeur que si celles-ci sont stables et à la bonne valeur. Pour cela, il est relié au microcontrôleur de surveillance, sur une entrée de ce dernier. Le microcontrôleur de surveillance ne démarre la séquence d'allumage des VRM que s'il reçoit le signal POR. Ainsi que d'autres signaux, comme celui de l'''oscillator startup timer''.

===Les défaillances de l'alimentation===

Une fois l'ordinateur allumé, le processeur fonctionne. On s'attend à ce que la tension et la fréquence soient stables, mais il est parfaitement possible que la tension soit soudainement déstabilisée, par exemple lorsqu'on débranche la prise, une coupure de courant, un problème matériel avec les régulateurs de tension, des condensateurs de la carte mère qui fondent, etc. 

Un circuit appelé le '''''Low-voltage detect''''' surveille en permanence la tension d'alimentation, pour détecter de telles défaillances et générer un arrêt d'urgence. Il est souvent fusionné avec le ''Power-on reset'' en un seul circuit. Rien d'étonnant à cela : les deux sont reliés à la tension d'alimentation et vérifient sa stabilité. Typiquement, le ''Low-voltage detect'' permet de détecter si la tension d'alimentation descend sous un seuil pendant un certain temps, typiquement sous 2-3 volts pendant quelques centaines de millisecondes.

Le ''Low-voltage detect'' est implémenté différemment entre un PC moderne et les cartes mères hors-PC. Sur PC, c'est rarement un circuit à part, il est intégré dans le microcontrôleur de surveillance. Et c'est encore plus vrai si la carte mère utilise des ''smart VRM''. Il suffit alors de connecter des ''smart VRM'' au microcontrôleur de surveillance, via un bus PMBUS, pour que celui-ci puisse vérifier les tensions de chaque VRM en temps réel. Mais sur les cartes mères hors PC, le ''Low-voltage detect'' est souvent un circuit à part. Il faut dire qu'elles n'incorporent pas forcément de microcontrôleur de surveillance, ni de ''smart VRM'', car leur système d'alimentation est beaucoup plus simple. Aussi, un circuit spécialisé est utilisé à la place.

La gestion d'une défaillance de l'alimentation est aussi gérée différemment entre un PC et un microcontrôleur. La raison est qu'un PC peut fonctionner durant quelques millisecondes, grâce à la présence de condensateurs sur la carte mère. Ils maintiennent la tension d'alimentation pendant quelques millisecondes, ce qui lui laisse le temps de faire quelques sauvegardes mineures et d'éteindre l'ordinateur proprement. Un arrêt d'urgence avec l'entrée NMI est donc acceptable, si les condensateurs sont dimensionnés pour.

Par contre, les microcontrôleurs ne sont pas dans ce cas-là, surtout dans les systèmes alimentés sur batterie. Là, le problème n'est pas tellement une coupure soudaine de l'alimentation, mais une baisse progressive de la tension, au fur et à mesure que la batterie se vide. Typiquement, si la batterie se vide progressivement, il arrive un moment où la tension chute trop bas, et reste basse tant que la batterie n'est pas rechargée. Dans ce cas, le processeur n'est pas éteint, mais maintenu en état de RESET tant que la tension est trop faible. Dès que la tension remonte, le processeur redémarre. On parle alors de '''''brown-out reset'''''.

===Les domaines de puissance et le ''standby domain''===

Le microcontrôleur de surveillance est alimenté par une tension d'alimentation dite de ''standby'', qui est présente dès que l'ordinateur est branché au secteur, même éteint. Et c'est aussi le cas d'une partie du ''chipset'', du contrôleur USB et du contrôleur Ethernet. Ils sont tous partiellement alimentés même ordinateur éteint. C'est grâce à ça qu'un ordinateur peut être allumé via le réseau. L'ensemble des composants alimentés même ordinateur éteint est appelé le '''''Stand By Domain'''''.

[[File:Standby domain.png|centre|vignette|upright=2|Standby domain]]

Le ''Standby Domain'' s'oppose aux circuits qui ne sont allumés qu'une fois qu'on a démarré l'ordinateur. Il est parfois appelé le '''''Wakeup Domain'''''. Mais ce dernier n'est pas uniforme. En réalité, il est lui-même séparé en plusieurs '''domaines de puissance''', chacun relié à un VRM et alimenté par une tension d'alimentation précise. Par exemple, la mémoire RAM n'est pas alimentée par le même VRM que le processeur. Il est ainsi possible d'éteindre le processeur tout en maintenant la RAM allumée. C'est d'ailleurs ce qui est fait lors de la mise en veille normale de l'ordinateur : le CPU est éteint, mais la RAM continue à être alimentée pour ne pas perdre ses données.

[[File:Les différents power domains d'une carte mère.png|centre|vignette|upright=2|Les différents power domains d'une carte mère : CPU, RAM, standby et autres]]

Outre le ''chipset'' et le microcontroleur de surveillance, le ''Standby Domain'' contient des tas de bus spécialisés dans la gestion thermique ou la gestion de l'alimentation. Ils sont reliés au microcontroleur de surveillance, à la ''glue logic'' et au ''chipset'', ainsi qu'aux VRM, aux ventilateurs, aux sondes de température, etc. Nous avons mentionné le bus PECI d'Intel qui permet au microcontrôleur de surveillance et au ''chipset'' de lire la température du processeur. Mais ce n'est pas le seul.

L'un des tout premier bus utilisé dans cet optique était le bus SMBUS, pour '''''System Management Bus''''', dont l'objectif initial était d'interconnecter un grand nombre de composants peu rapides, soudés à la carte mère. Il est assez spécialisé dans la gestion thermique et de l’alimentation, mais est aussi utilisé pour gérer les LEDs RGB et quelques autres fonctionnalités dans le genre. Le PMBUS est utilisé pour commander les ''smart VRM'' est une version améliorée de ce SMBUS.

===Les ''Power States''===

Pour rappel, un ordinateur peut être dans plusieurs états de fonctionnement : en veille, allumé, éteint. Dans chaque état, certains composants sont allumés, d'autres éteints. Dans le détail, ces états de fonctionnement sont appelés des '''''Power State'''''. Sur les processeurs x86, ils sont normalisés par la norme ACPI. Elle définit plusieurs ''Power State'' distincts.
* S0 : ordinateur allumé, en fonctionnement ;
* S0 amélioré, facultatif : forme spécifique de veille ;
* S1, S2, S3 : veille normale ;
* S4 : veille prolongée ;
* S5 Standby : secteur branché, ordinateur éteint ;
* G3 Mechanical OFF : sécteur débranché.

En mode G3, le secteur est débranché, rien n'est alimenté. En mode S5, le ''standby domain'' est alimenté, pas le reste. En mode S0, tout est alimenté, ou presque.

Les modes S1, S2 et S3 sont aussi appelés la veille '''''suspend to RAM''''', le nom est assez transparent. La RAM est alimentée, mais pas le processeur. Le ''standby domain'' est alimenté et c'est pour ça qu'un ordinateur en veille se réveille quand on appuie sur une touche du clavier. Les trois ne sont pas équivalents, mais les différences sont mineures, au point que seul le S3 est réellement utilisé de nos jours.

Le mode S4 veille prolongée est aussi appelé le mode '''''suspend to disk'''''. Avec lui, l'ordinateur est quasiment éteint, même la RAM est désactivée. La RAM de l'ordinateur est recopiée dans un fichier sur le disque dur, pour être restauré en RAM lors de la sortie de mise en veille. Évidemment, la sauvegarde de la RAM sur le disque dur est assez lente, ce qui fait que la mise en veille n'est pas immédiate. Si les premières implémentations utilisaient le BIOS, ce n'est plus le cas. Il peut en théorie être implémenté en logiciel, mais il est géré en partie par le système d'exploitation et le matériel, que ce soit sur Linux et Windows. Tant que le matériel est intégralement compatible avec la norme ACPI, la mise en hibernation est possible.

Les transitions entre ces différents états/''power state'', sont illustrées ci-dessous. Elles sont gérées en coopération par le processeur, le ''chipset'' et le microcontroleur de périphérique. Lors de la mise en veille, le processeur sauvegarde son état de manière à reprendre là où il en était. Puis, il prévient le microcontrôleur de surveillance et le ''chipset'' pour prévenir que l'ordinateur peut être mis en veille. Là, les tensions d'alimentation du CPU sont coupées. Lors de la sortie de veille, les tensions sont rallumées par le microcontrôleur de surveillance, puis un signal RESET est émis.

[[File:Power state x86.png|centre|vignette|upright=2|Power state x86]]

Il faut noter que chaque périphérique peut aussi avoir des ''power state'' similaires. Par exemple, un SSD peut avoir un mode basse consommation, qui est utilisé si le SSD n'est pas utilisé mais que l'ordinateur est allumé. Typiquement, les composants/périphériques disposent de quatre états : un mode éteint, un mode veille, un mode basse consommation et un mode fonctionnement normal. Le composant peut être mis en veille, où il consomme un petit peu mais est plus rapide à réactiver qu'un SSD éteint. Il peut aussi fonctionner en mode basse consommation, où les performances sont un peu diminuées et certaines fonctionnalités ne sont pas disponibles.

===La gestion logicielle des ''Power States'' et de l'économie d'énergie===

Autrefois, la transition entre ces états était gérée par le microcontrôleur de surveillance, qui répondait aux boutons ON/OFF et celui de mise en veille s'il existait. Mais le logiciel ne pouvait pas éteindre l'ordinateur de lui-même, encore moins le mettre en veille. A vrai dire, la mise en veille normale n'existait pas forcément, seule la mise en veille prolongée existait et était gérée purement en logiciel. Il existait des mises en veille basiques, qui se résumaient à éteindre l'écran et le disque dur, mais le CPU fonctionnait normalement, sa fréquence n'était pas stoppée ni réduite. LA gestion des ''power state'' des périphériques n'était pas gérée du tout.

[[File:Win95Build216 Shutdown.png|centre|vignette|upright=2|Windows 95 ne pouvait pas éteindre l’ordinateur, il fallait appuyer sur le bouton ON/OFF.]]

L'apparition du standard APM (''Advanced Power Management'') a permis au logiciel de gérer les ''power state'', mais aussi d'autres fonctionnalités d'économie d'énergie. Le BIOS gérait tout ce qui avait trait à la consommation d'énergie, il était au centre du standard. Il pouvait désactiver des périphériques, les mettre en veille de manière sélective, les mettre en état basse consommation, etc. Le logiciel pouvait envoyer des ordres au BIOS pour cela, en passant par l'intermédiaire d'in pilote de périphérique dédié, appelé ''driver APM''. Le standard définissait comment le BIOS et le logiciel devaient communiquer entre eux. 

[[File:APM-Layers.svg|centre|vignette|upright=2|APM]]

De nos jours, le standard APM a été remplacé par le '''standard ACPI''' (''Advanced Configuration and Power Interface''). Ce standard ne gère pas que l'économie d'énergie, mais aussi des fonctionnalités comme la découverte du matériel (détecter le matériel installé dans le PC au démarrage). Il ne se base plus du tout sur le BIOS, contrairement au format APM, mais laisse le système d'exploitation gérer la consommation énergétique du PC.

Au passage, les temps de mise en veille sont gérés par des ''timers'' dédiés, appelés '''''timers'' d'inactivité'''. Vous savez sans doute qu'il est possible de gérer combien de temps doit d'écouler avant d'éteindre l'écran, de mettre l'ordinateur en veille. Hé bien ces temps sont gérés par des ''timers'' dédiés, faisant partie de la norme ACPI. Dès que Windows détecte un ordinateur inactif, il initialise le ''timer'' avec la durée configurée et laisse le ''timer'' faire son travail. Le ''timer'' est réinitialisé en cas d'activité. Si le ''timer'' déborde, il génère un signal dit d'interruption à destination du processeur, qui réagit immédiatement et met en veille l'ordinateur.

==La ''glue logic'' et les circuits annexes==

Pour résumer, une carte mère intègre de nombreux circuits très différents. Mais avec la loi de Moore, de nombreux circuits distincts ont pu être fusionnés en un seul circuit. Par exemple, le ''chipset'' regroupe de nombreux circuits autrefois distincts, mais nous détaillerons cela dans le chapitre sur les contrôleurs de périphériques. De même, le microcontrôleur de surveillance a beaucoup de fonctions différentes : la gestion de l'alimentation au sens large, la gestion thermique, et bien d'autres que nous n'avons pas encore abordées. Et toutes ces fonctions étaient autrefois le fait de plusieurs circuits séparés.

Une carte mère contient donc deux composants principaux : le microcontroleur de surveillance et le ''chipset''. Et à cela il faut ajouter tous les bus électroniques, qui relient le ''chipset'', le microcontroleur de surveillance, les connecteurs, le processeur, la RAM, le disque dur, les ports PCI-Express, et tout ce qui est sur la carte mère. Mais à tout cela, il faut ajouter un dernier composant : la '''''glue logic'''''.

La ''glue logic'' regroupe tout le reste, à l'exception de composants analogiques/électriques comme des condensateurs de découplage et autres. Il s'agit d'un ensemble de circuits qui n'a pas de fonction précise et dépend fortement de la carte mère. Formellement, son rôle est de servir à coller ensemble des circuits séparés. La carte mère contient un ''chipset'', le µcontroleur de surveillance, le CPU, la RAM, et d'autres composants qui sont fabriqués séparément, et qui doivent être &quot;collés ensemble&quot; pour obtenir la carte mère finale. La ''glue logic'' s'occupe de ce collage, de cet interfaçage.

Elle s'occupe majoritairement de la gestion thermique et des tensions, mais pour des fonctions qui ne sont pas prises en charge par le ''chipset'' ou le µcontroleur. Mais ce n'est pas sa seule fonction. Il est difficile de faire des généralités sur la ''glue logic'', car elle varie énormément d'une carte mère à l'autre. Elle est souvent implémentée avec des FPGA, sur les carte mères actuelles. Mais les anciennes cartes mères utilisaient des composants séparés. La ''glue logic'' prenait donc beaucoup de place, ce qui n'est plus trop le cas maintenant.

==Les chips de sécurité==

Depuis la décennie 2010, les cartes mères incorporent des chips spécialisés dans la sécurité informatique. Vous avez peut-être entendu parler des puces TPM, rendues nécessaires pour passer à Windows 11, de l'Intel Management Engine, ou de son équivalent chez AMD. De telles puces ont une utilité mal compris par le grand public, et souvent décriée pour, paradoxalement, des raisons de sécurité. Quelques-uns les ont accusées de contenir des ''backdoors''.

===Le ''Trusted Platform Module''===

Le ''Trusted Platform Module'', ou TPM, est ce qui s'appelle un '''processeur cryptographique sécurisé'''. Concrètement, il s'agit d'un circuit spécialisé dans tout ce qui est chiffrement. Il a deux rôles principaux : générer et stocker des clés de chiffrement.

Il peut par exemple générer des nombres aléatoires, des clés RSA, etc. En théorie, un processeur cryptographique peut aussi servir d''''accélérateur cryptographique''', à savoir que le processeur CPU lui délègue les calculs cryptographiques. Il peut alors exécuter des fonctions de hachage cryptographiques comme SHA-1, etc. Disons qu'il peut être utilisé dès qu'il faut crypter ou décrypter des données

Il peut aussi mémoriser certaines clés cryptographiques du système, de manière persistante, dans une mémoire EEPROM/FLASH dédiée, intégrée au TPM. Elles ne sont alors accessibles ni par le système d'exploitation, ni par l'utilisateur, ni par qui ou quoi que ce soit d'autres que le TPM.

Outre le stockage des clés à l'intérieur du TPM, le TPM peut protéger une portion de la mémoire RAM afin d'y stocker des clés de cryptage/décryptage importantes. La portion de mémoire est appelée une '''enclave mémoire sécurisée'''. Elle est accessible uniquement par le TPM, mais est inaccessible par l'OS ou l'utilisateur, ou alors seulement partiellement accessible. Cela permet de sécuriser certaines clés cryptographiques pendant qu'elles sont utilisées. 

[[File:TPM 1.2 diagram.svg|centre|vignette|upright=2|TPM 1.2, diagramme.]]

Les utilisations principales sont les trois suivantes le chiffrement des disques durs, la sécurité lors du démarrage et les DRMs. Le TPM sert en premier lieu pour '''encrypter les disques durs''' avec Bitlocker sous Windows ou son équivalent sous Linux/mac. Les clés utilisées pour crypter et décrypter un disque dur encrypté sont stockées dans le TPM et sont aussi utilisées à travers une enclave matérielle. Une utilisation plus controversée est celle des techniques de '''''Secure Boot''''', qui vise à protéger l’ordinateur dès le démarrage, pour stopper net les malwares qui infectent le BIOS ou les secteurs de boot.

Mais le TPM peut aussi être utilisé pour implémenter le ''trusted computing'', un ensemble de techniques qui visent à identifier un ordinateur. Par identifier, on veut dire que le ''trusted computing'' attribue une identité à chaque ordinateur, afin de l'identifier parmi tous les autres. L'intention est d'implémenter des techniques permettant de ne décrypter des données que sur des ordinateurs bien précis et pas ailleurs. Le ''trusted computing'' fournit aussi des procédés afin d'éviter toute usurpation d'identité entre ordinateurs. Le tout se fait par des procédés matériels auxquels qu'aucun logiciel ne peut altérer, pas même le système d'exploitation, et pas même l'utilisateur lui-même (d'où certaines controverses). Elles servent surtout à gérer les DRM, des protections logicielles qui visent à empêcher le piratage de musique, jeux vidéos, films et autres.

Les techniques en question attribuent au matériel une clé de sécurité inconnue de l'OS et de l'utilisateur. A sa création, chaque puce TPM se voit attribuer une clé de sécurité RSA de 2048 bits, qu'il est impossible de changer, et qui est différente d'une puce à l'autre. Avant de poursuivre, rappelons la différence entre clé privée et publique. L'algorithme RSA permet à deux entités de communiquer entre elles en s'échangeant des messages cryptés. Les messages sont encryptés avec une clé publique et décryptés avec une clé privée. La clé dont il est question pour le TPM est une clé privée. Elle permet d'identifier l'ordinateur de manière unique, ce qui sert pour les DRM ou pour authentifier l'ordinateur pour un quelconque login.

Parmi les fonctionnalités du ''trusted computing'', voici quelques exemples. La technique de ''Sealed storage'' permet de lire des données encryptées uniquement sur une machine particulière. Les données sont encryptées par le TPM, qui ajoute des informations sur la configuration dans la clé de cryptage, dont sa clé TPM. La technique est utilisée pour les DRM. La technique de ''Remote attestation'' permet à un autre ordinateur d'être au courant des modifications effectuées sur l'ordinateur considéré.

Le TPM est parfois une puce placée sur la carte mère, mais ce n'est pas le cas sur les PC commerciaux. A la place, le TPM est soit intégré au ''chipset'', soit intégré au processeur. Il en sera de même pour les circuits de sécurité que nous allons voir par la suite, qui font partie du CPU ou du ''chipset''.

===Le ''Management Engine'' d'Intel et l'''AMD Platform Security Processor''===

L''''''Intel Management Engine''''' (ME) et l''''''AMD Platform Security Processor''''' (PSP) sont des microcontrôleurs intégrés au ''chipset'' de la carte mère. Ils ont accès à tout le matériel de l'ordinateur, d'où sa place dans le ''chipset''. Ils sont actifs en permanence, même si l'ordinateur est éteint, ce qui fait qu'ils sont dans le ''standby domain''. Ils ont des fonctions très diverses, mais ils s'occupent de l'initialisation du ''chipset'' et du démarrage de l'ordinateur, de l'initialisation des périphériques, mais aussi de fonctionnalités de sécurité.

En premier lieu, il agit comme un processeur cryptographique sécurisé, à savoir qu'il incorpore des accélérateurs cryptographiques (des circuits de calcul capables de crypter/décrypter des données avec des algorithmes comme AES, RSA, autres). Chez Intel, le tout est appelé l'OCS (''Offload and Cryptography Subsystem''), et est couplé à un système de stockage sécurisé de clés, ainsi qu'un contrôleur DMA (un circuit qui sert pour les échanges entre OCS et mémoire RAM). Le TPM vu précédemment est souvent intégré dans le ME/PSP. Il gère aussi d'autres fonctionnalités, comme des protections lors du démarrage de l’ordinateur, comme le ''secure boot'', ou l'Intel® Boot Guard. Des DRM gérés en hardware sont aussi disponibles.

L'Intel ME était initialement basé sur un processeur ARC core et utilisait le système d'exploitation temps réel ThreadX. De nos jours, depuis la version 11 du ME, il utilise un processeur Intel Quark 32 bits et fait tourner le système d'exploitation MINIX 3. Il est possible pour le processeur principal (CPU) de communiquer avec le ME, via la technologie ''Host Embedded Controller Interface'' (HECI). Mais la communication est surtout utilisée pour la gestion thermique et d'alimentation.

&lt;noinclude&gt;
{{NavChapitre | book=Fonctionnement d'un ordinateur
           | prev=Les techniques de réduction de la consommation électrique d'un processeur
           | prevText=Les techniques de réduction de la consommation électrique d'un processeur
           | next=Les bus et liaisons point à point (généralités)
           | nextText=Les bus et liaisons point à point (généralités)
}}
&lt;/noinclude&gt;</text>
      <sha1>ozqvw0f9fmtljq6dqxzjzqtguhlunya</sha1>
    </revision>
  </page>
  <page>
    <title>Jeu de rôle sur table — Jouer, créer</title>
    <ns>0</ns>
    <id>67338</id>
    <revision>
      <id>744046</id>
      <parentid>741215</parentid>
      <timestamp>2025-06-03T15:21:58Z</timestamp>
      <contributor>
        <username>Cdang</username>
        <id>1202</id>
      </contributor>
      <minor />
      <comment>/* Sommaire */ avancement</comment>
      <origin>744046</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="5658" sha1="ak2lqzn75wfdrtp4i3jmb7wj4jf87u6" xml:space="preserve">{{Page de garde|image=Dadosvariasfaces.jpg|imagedesc=Différents types de dés utilisés dans les jeux de rôle|description=

''Ce wikilivre se trouve sur l'étagère [[Wikilivres:Étagère jeu|Jeu]].''

Ce wikilivre est consacré au '''jeu de rôle sur table''', ou '''jeu de rôle papier'''. Il concerne la manière de jouer, sans s'attacher à un jeu particulier, ainsi que la création en jeu de rôle, et la création de jeu de rôle : création « émergente » en cours de jeu (improvisation), création de scénario et de manière plus générale préparation de partie, création d'un cadre (univers fictionnel), création de règles (règles maison ou système complet).
|avancement=Avancé
|cdu=
* {{CDU item|7|79}}
}}

== Sommaire ==

# [[/Qu'est-ce que le jeu de rôle ?/]] {{100}}
# [[/Ma première partie/]] {{100}}
# [[/Bienveillance et contrat ludique/]] {{100}}
# [[/Préparer une partie/]] {{100}}
# [[/Au cœur du jeu de rôle, la partie/]] {{100}}
# [[/Créer une nouvelle règle/]] {{100}}
# [[/Le hasard dans les jeux de rôle/]] {{100}}
# [[/Probabilités des dés en jeu de rôle/]] {{100}}
# [[/Créer des éléments du monde/]] {{75}}
# [[/Créer un univers/]] {{75}}
# [[/Créer un jeu de rôle/]] {{25}}
; Annexe
# [[/Abréviations/]] {{100}}

== Voir aussi ==

=== Bibliographie ===

* {{ouvrage
 | prénom1 = Pierre | nom1 = Rosenthal | responsabilité1 = rédacteur en chef
 | et al. = oui
 | titre = Manuel pratique du jeu de rôle
 | collection  = Casus Belli | numéro dans collection = HS25
 | mois = mai | année = 1999
 | éditeur = Excelsior publications
 | pages = 98
 | format = A4
 | lire en ligne = https://docs.google.com/file/d/0B-GYyxhvMf-PaUQ4OUVUMkFFQlk/
 | présentation en ligne = http://www.ffjdr.org/manuel-pratique-du-jeu-de-role/
}}
* {{ouvrage
 | langue = fr
 | prénom1 = Coralie | nom1 = David | directeur1 = oui 
 | prénom2 = Jérôme | nom2 = Larré | directeur2 = oui
 | et al. = oui
 | titre = Mener des parties de jeu de rôle
 | éditeur = Lapin Marteau
 | collection = Sortit de l'auberge | numéro dans collection = 1
 | année = 2016
 | isbn = 978-2-9545811-4-9
 | pages = 400
 | format = 16,5 × 24 cm
 | présentation en ligne = http://www.lapinmarteau.com/jeux-et-accessoires-sortir-de-lauberge-01-mener-des-parties-de-jeu-de-role/
}}
* {{ouvrage
 | langue = fr
 | prénom1 = Coralie | nom1 = David | directeur1 = oui 
 | prénom2 = Jérôme | nom2 = Larré | directeur2 = oui
 | et al. = oui
 | titre = Jouer des parties de jeu de rôle
 | éditeur = Lapin Marteau
 | collection = Sortit de l'auberge | numéro dans collection = 2
 | année = 2016
 | isbn = 978-2-9545811-6-3
 | pages = 368
 | format = 16,5 × 24 cm
 | présentation en ligne = http://www.lapinmarteau.com/jeux-et-accessoires-sortir-de-lauberge-02-jouer-des-parties-de-jeu-de-role/
}}

=== Autres wikilivres ===

* [[Guide pour jeux de rôles]]

=== Liens externes ===

* Tartofrez, le blog de [[w:Jérôme Larré|Jérôme « Brand » Larré]] :
** {{lien web | url = http://www.tartofrez.com/category/5-trucs/ | titre = Rubrique « Cinq trucs »}} ;
** {{lien web | url = http://www.tartofrez.com/category/game-design/ | titre = Rubrique « Créer son jeu ''(game design)'' »}} ;
** {{lien web | url = http://www.tartofrez.com/category/theorie/ | titre = Rubrique « Théorie et ''game design'' »}}.
* {{lien web | url = http://awarestudios.blogspot.co.uk/ | titre = Du bruit derrière le paravent}}, le blog de Grégory « Gregopor » Pogorzelski.
* {{lien web | url = http://ptgptb.fr/ | titre = ''Places to go, people to be'' (ptgptb)}}, traduction d'articles sur le jeu de rôle.
** {{lien web | url = https://ptgptb.fr/accueil-ebooks | titre=Ebooks | site=ptgptb |consulté le=2023-03-09}}.
* {{lien web | url = http://www.limbicsystemsjdr.com/ | titre = Limbic System}}, le blog de Frédéric Sintes.
* {{lien web | url = http://www.legrog.org/ | titre = Le Guide du rôliste galactique (GRoG/roliste.com)}}, la plus grande base de données francophone de jeux de rôle.
* {{lien web | url = https://courantsalternatifs.fr/forum/viewtopic.php?f=18&amp;t=1209&amp;p=7979#p7979 | titre = JdR et animation | auteur = Thomas Munier | site = Courants alternatifs | date = 2018-08-21 | consulté le = 2018-08-21}}
* Podcasts :
** {{lien web | url = http://www.cendrones.fr/ | titre = Cendrones, la Voix D'altaride}}.
** {{lien web | url = http://www.lacellule.net/ | titre = La Cellule}}.
* Forums
** {{lien web | url = http://www.subasylum.com/ | titre = Antonio Bay, village rôliste}}
** {{lien web | url = http://www.pandapirate.net/casus/ | titre = Casus non officiel}}
** {{lien web | url = http://forum.opale-roliste.com/ | titre = Opale rôliste}}
** {{lien web | url = http://www.reves-d-ailleurs.eu/ | titre = Rêves d'ailleurs}}
* logiciels et sites d'aide en jeu et tables virtuelles :
** {{lien web | url = https://www.fantasygrounds.com/home/home.php | titre = Fantasy Grounds }}
** {{lien web | url = https://kanka.io/fr | titre = Kanka }}
** {{lien web | url = https://lets-role.com/ | titre = Let's Role }}
** {{lien web | url = https://rolisteam.org/ | titre = Rolisteam }}
** {{lien web | url = https://roll20.net/ | titre = Roll20 }}
* jeux en licence libre :
** {{lien web | url = https://ogc.rpglibrary.org/index.php?title=Main_Page | titre = OGC (RPG Library Open Game Content Repository) consulté le=2025-03-20 }}
** {{lien web | url = https://legrumph.org/Terrier/public/jeux-complets | titre = Jeux de rôle complets |site=Le Terrier du Grümph | consulté le=2025-03-20 }}

{{DEFAULTSORT:Jeu de role sur table Jouer creer}}
[[Catégorie:Jeu de rôle sur table — Jouer, créer (livre)|*]]</text>
      <sha1>ak2lqzn75wfdrtp4i3jmb7wj4jf87u6</sha1>
    </revision>
  </page>
  <page>
    <title>Les cartes graphiques/Les cartes accélératrices 3D</title>
    <ns>0</ns>
    <id>67392</id>
    <revision>
      <id>744096</id>
      <parentid>735604</parentid>
      <timestamp>2025-06-04T00:17:00Z</timestamp>
      <contributor>
        <username>Mewtow</username>
        <id>31375</id>
      </contributor>
      <minor />
      <comment>/* Les unités de texture sont intégrées aux processeurs de shaders */</comment>
      <origin>744096</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="40791" sha1="07oxg8ezjycqq82slljm95jxhtkq71t" xml:space="preserve">Il est intéressant d'étudier le hardware des cartes graphiques en faisant un petit résumé de leur évolution dans le temps. En effet, leur hardware a fortement évolué dans le temps. Et il serait difficile à comprendre le hardware actuel sans parler du hardware d'antan. En effet, une carte graphique moderne est partiellement programmable. Certains circuits sont totalement programmables, d'autres non. Et pour comprendre pourquoi, il faut étudier comment ces circuits ont évolués.

Le hardware des cartes graphiques a fortement évolué dans le temps, ce qui n'est pas une surprise. Les évolutions de la technologie, avec la miniaturisation des transistors et l'augmentation de leurs performances a permit aux cartes graphiques d'incorporer de plus en plus de circuits avec les années. Avant l'invention des cartes graphiques, toutes les étapes du pipeline graphique étaient réalisées par le processeur : il calculait l'image à afficher, et l’envoyait à une carte d'affichage 2D. Au fil du temps, de nombreux circuits furent ajoutés, afin de déporter un maximum de calculs vers la carte vidéo.

Le rendu 3D moderne est basé sur le placage de texture inverse, avec des coordonnées de texture, une correction de perspective, etc. Mais les anciennes consoles et bornes d'arcade utilisaient le placage de texture direct. Et cela a impacté le hardware des consoles/PCs de l'époque. Avec le placage de texture direct, il était primordial de calculer la géométrie, mais la rasterisation était le fait de VDC améliorés. Aussi, les premières bornes d'arcade 3D et les consoles de 5ème génération disposaient processeurs pour calculer la géométrie et de circuits d'application de textures très particuliers. A l'inverse, les PC utilisaient un rendu inverse, totalement différent. Sur les PC, les premières cartes graphiques avaient un circuit de rastérisation et des unités de textures, mais pas de circuits géométriques.

==Les précurseurs : les cartes graphiques des bornes d'arcade==

[[File:Sega ST-V Dynamite Deka PCB 20100324.jpg|vignette|Sega ST-V Dynamite Deka PCB 20100324]]

L'accélération du rendu 3D sur les bornes d'arcade était déjà bien avancé dès les années 90. Les bornes d'arcade ont toujours été un segment haut de gamme de l'industrie du jeu vidéo, aussi ce n'est pas étonnant. Le prix d'une borne d'arcade dépassait facilement les 10 000 dollars pour les plus chères et une bonne partie du prix était celui du matériel informatique. Le matériel était donc très puissant et débordait de mémoire RAM comparé aux consoles de jeu et aux PC.

La plupart des bornes d'arcade utilisaient du matériel standardisé entre plusieurs bornes. A l'intérieur d'une borne d'arcade se trouve une '''carte de borne d'arcade''' qui est une carte mère avec un ou plusieurs processeurs, de la RAM, une carte graphique, un VDC et pas mal d'autres matériels. La carte est reliée aux périphériques de la borne : joysticks, écran, pédales, le dispositif pour insérer les pièces afin de payer, le système sonore, etc. Le jeu utilisé pour la borne est placé dans une cartouche qui est insérée dans un connecteur spécialisé.

Les cartes de bornes d'arcade étaient généralement assez complexes, elles avaient une grande taille et avaient plus de composants que les cartes mères de PC. Chaque carte contenait un grand nombre de chips pour la mémoire RAM et ROM, et il n'était pas rare d'avoir plusieurs processeurs sur une même carte. Et il n'était pas rare d'avoir trois à quatre cartes superposées dans une seule borne. Pour ceux qui veulent en savoir plus, Fabien Sanglard a publié gratuitement un livre sur le fonctionnement des cartes d'arcade CPS System, disponible via ce lien : [https://fabiensanglard.net/b/cpsb.pdf The book of CP System].

Les premières cartes graphiques des bornes d'arcade étaient des cartes graphiques 2D auxquelles on avait ajouté quelques fonctionnalités. Les sprites pouvaient être tournés, agrandit/réduits, ou déformés pour simuler de la perspective et faire de la fausse 3D. Par la suite, le vrai rendu 3D est apparu sur les bornes d'arcade, avec des GPUs totalement programmables.

Dès 1988, la carte d'arcade Namco System 21	et Sega Model 1 géraient les calculs géométriques. Les deux cartes n'utilisaient pas de circuit géométrique fixe, mais l'émulaient avec un processeur programmé avec un programme informatique qui implémentait le T&amp;L en logiciel. Elles utilisaient plusieurs DSP pour ce faire.

Quelques années plus tard, les cartes graphiques se sont mises à supporter un éclairage de Gouraud et du placage de texture. Le Namco System 22 et la Sega model 2 supportaient des textures 2D et comme le filtrage de texture (bilinéaire et trilinéaire), le mip-mapping, et quelques autres. Par la suite, elles ont réutilisé le hardware des PC et autres consoles de jeux.

==La 3D sur les consoles de quatrième génération==

Les consoles avant la quatrième génération de console étaient des consoles purement 2D, sans circuits d'accélération 3D. Leur carte graphique était un simple VDC 2D, plus ou moins performant selon la console. Pourtant, les consoles de quatrième génération ont connus quelques jeux en 3D. Par exemple, les jeux Star Fox sur SNES. Fait important, il s'agissait de vrais jeux en 3D qui tournaient sur des consoles qui ne géraient pas la 3D. La raison à cela est que la 3D était calculée par un GPU placé dans les cartouches du jeu ! 

Par exemple, les cartouches de Starfox et de Super Mario 2 contenait un coprocesseur Super FX, qui gérait des calculs de rendu 2D/3D. Un autre exemple est celui du co-processeur Cx4, cousin du Super FX, qui était spécialisé dans les calculs trigonométriques et diverses opérations utiles pour le rendu 2D/3D. En tout, il y a environ 16 coprocesseurs pour la SNES et on en trouve facilement la liste sur le net.

La console était conçue pour, des pins sur les ports cartouches étaient prévues pour des fonctionnalités de cartouche annexes, dont ces coprocesseurs. Ces pins connectaient le coprocesseur au bus des entrées-sorties. Les coprocesseurs des cartouches de NES avaient souvent de la mémoire rien que pour eux, qui était intégrée dans la cartouche. 

==L'arrivée des consoles de cinquième génération==

Par la suite, les consoles de jeu se sont mises à intégrer des cartes graphiques 3D. Les premières consoles de jeu capables de rendu 3D sont les consoles dites de 5ème génération. Il y a diverses manières de classer les consoles en générations, la plus commune place la 3D à la 5ème génération, mais détailler ces controverses quant à ce classement nous amènerait trop loin. Les cartes graphiques des consoles de jeu utilisaient le rendu inverse, avec quelques exceptions qui utilisaient le rendu inverse.

===La Nintendo 64 : un GPU avancé===

La Nintendo 64 avait le GPU le plus complexe comparé aux autres consoles, et dépassait même les cartes graphiques des PC. Son GPU était très novateur pour une console sortie en 1996. Il incorporait une unité pour les calculs géométriques, un circuit pour la rasterisation, une unité pour les textures et un ROP final pour les calculs de transparence/brouillard/anti-aliasing, ainsi qu'un circuit pour gérer la profondeur des pixels. En somme, tout le pipeline graphique était implémenté dans le GPU de la Nintendo 64, chose très en avance sur son temps, même comparé au PC !

Le GPU est construit autour d'un processeur dédié aux calculs géométriques, le ''Reality Signal Processor'' (RSP), autour duquel on a ajouté des circuits pour le reste du pipeline graphique. L'unité de calcul géométrique est un processeur MIPS R4000, un processeur assez courant à l'époque, mais auquel on avait retiré quelques fonctionnalités inutiles pour le rendu 3D. Il était couplé à 4 KB de mémoire vidéo, ainsi qu'à 4 KB de mémoire ROM. Le reste du GPU était réalisé avec des circuits fixes. La Nintendo 64 utilisait déjà un mélange de circuits programmables et fixes.

Un point intéressant est que le programme exécuté par le RSP pouvait être programmé ! Le RSP gérait déjà des espèces de proto-shaders, qui étaient appelés des ''[https://ultra64.ca/files/documentation/online-manuals/functions_reference_manual_2.0i/ucode/microcode.html micro-codes]'' dans la documentation de l'époque. La ROM associée au RSP mémorise cinq à sept programmes différents, des microcodes de base, aux fonctionnalités différentes. Ils géraient le rendu 3D de manière différente et avec une gestion des ressources différentes. Très peu de studios de jeu vidéo ont développé leur propre microcodes N64, car la documentation était mal faite, que Nintendo ne fournissait pas de support officiel pour cela, que les outils de développement ne permettaient pas de faire cela proprement et efficacement.

===La Playstation 1===

Sur la Playstation 1 le calcul de la géométrie était réalisé par le processeur, la carte graphique gérait tout le reste. Et la carte graphique était un circuit fixe spécialisé dans la rasterisation et le placage de textures. Elle utilisait, comme la Nintendo 64, le placage de texture inverse, qui est apparu ensuite sur les cartes graphiques.

===La 3DO et la Sega Saturn===

La Sega Saturn et la 3DO étaient les deux seules consoles à utiliser le rendu direct. La géométrie était calculée sur le processeur, même si les consoles utilisaient parfois un CPU dédié au calcul de la géométrie. Le reste du pipeline était géré par un VDC 2D qui implémentait le placage de textures.

La Sega Saturn incorpore trois processeurs et deux GPU. Les deux GPUs sont nommés le VDP1 et le VDP2. Le VDP1 s'occupe des textures et des sprites, le VDP2 s'occupe uniquement de l'arrière-plan et incorpore un VDC tout ce qu'il y a de plus simple. Ils ne gèrent pas du tout la géométrie, qui est calculée par les trois processeurs.

Le troisième processeur, la Saturn Control Unit, est un processeur de type DSP, à savoir un processeur spécialisé dans le traitement de signal. Il est utilisé presque exclusivement pour accélérer les calculs géométriques. Il avait sa propre mémoire RAM dédiée, 32 KB de SRAM, soit une mémoire locale très rapide. Les transferts entre cette RAM et le reste de l'ordinateur était géré par un contrôleur DMA intégré dans le DSP. En somme, il s'agit d'une sorte de processeur spécialisé dans la géométrie, une sorte d'unité géométrique programmable. Mais la géométrie n'était pas forcément calculée que sur ce DSP, mais pouvait être prise en charge par les 3 CPU.

==L'historique des cartes graphiques des PC, avant l'arrivée de Direct X et Open Gl==

Sur PC, l'évolution des cartes graphiques a eu du retard par rapport aux consoles. Les PC sont en effet des machines multi-usage, pour lesquelles le jeu vidéo était un cas d'utilisation parmi tant d'autres. Et les consoles étaient la plateforme principale pour jouer à des jeux vidéo, le jeu vidéo PC étant plus marginal. Mais cela ne veut pas dire que le jeu PC n'existait pas, loin de là ! 

Un problème pour les jeux PC était que l'écosystème des PC était aussi fragmenté en plusieurs machines différentes : machines Apple 1 et 2, ordinateurs Commdore et Amiga, IBM PC et dérivés, etc. Aussi, programmer des jeux PC n'était pas mince affaire, car les problèmes de compatibilité étaient légion. C'est seulement quand la plateforme x86 des IBM PC s'est démocratisée que l'informatique grand public s'est standardisée, réduisant fortement les problèmes de compatibilité. Mais cela n'a pas suffit, il a aussi fallu que les API 3D naissent.

Les API 3D comme Direct X et Open GL sont absolument cruciales pour garantir la compatibilité entre plusieurs ordinateurs aux cartes graphiques différentes. Aussi, l'évolution des cartes graphiques pour PC s'est faite main dans la main avec l'évolution des API 3D. Il a fallu que Direct X et Open GL progressent suffisamment pour que les problèmes de compatibilité soient partiellement résolus. Les fonctionnalités des cartes graphiques ont évolué dans le temps, en suivant les évolutions des API 3D. Du moins dans les grandes lignes, car il est arrivé plusieurs fois que des fonctionnalités naissent sur les cartes graphiques, pour que les fabricants forcent la main de Microsoft ou d'Open GL pour les intégrer de force dans les API 3D. Passons.

===L'introduction des premiers jeux 3D : Quake et les drivers miniGL===

L'histoire de la 3D sur PC commence avec la sortie du jeu Quake, d'IdSoftware. Celui-ci pouvait fonctionner en rendu logiciel, mais le programmeur responsable du moteur 3D (le fameux John Carmack) ajouta une version OpenGL du jeu. Le fait que le jeu était programmé sur une station de travail compatible avec OpenGL faisait que ce choix n'était si stupide, même si aucune carte accélératrice de l'époque ne supportait OpenGL. C'était là un choix qui se révéla visionnaire. En théorie, le rendu par OpenGL aurait dû se faire intégralement en logiciel, sauf sur quelques rares stations de travail adaptées. Mais les premières cartes graphiques étaient déjà dans les starting blocks.

La toute première carte 3D pour PC est la Rendition Vérité V1000, sortie en Septembre 1995, soit quelques mois avant l'arrivée de la Nintendo 64. La Rendition Vérité V1000 était purement programmable, contrairement aux autres cartes graphiques de l'époque. Elle contenait un processeur MIPS cadencé à 25 MHz, 4 mébioctets de RAM, une ROM pour le BIOS, et un RAMDAC, rien de plus. C'était un vrai ordinateur complètement programmable de bout en bout. Les programmeurs ne pouvaient cependant pas utiliser cette programmabilité avec des ''shaders'', mais elle permettait à Rendition d'implémenter n'importe quelle API 3D, que ce soit OpenGL, DirectX ou même sa son API propriétaire.

La Rendition Vérité avait de bonnes performances pour ce qui est de la géométrie, mais pas pour le reste. Autant les calculs géométriques sont assez rapides quand on les exécute sur un CPU, autant réaliser la rastérisation et le placage de texture en logiciel n'est pas efficace, pareil pour les opérations de fin de pipeline comme l'antialiasing. Le manque d'unités fixes très rapides pour la rastérisation, le placage de texture ou les opérations de fin de pipeline était clairement un gros défaut. Les autres cartes graphiques avaient implémenté l'exact inverse : de bonnes performances pour le placage de textures et la rastérization, mais les calculs géométriques étaient réalisés par le CPU. Au final, la carte graphique qui s'en sortait le mieux était la Nintendo 64 qui avait un CPU dédié pour les calculs géométriques et des circuits fixes pour le reste...

Les autres cartes graphiques étaient totalement non-programmables et ne contenant que des circuits fixes, regroupe les Voodoo de 3dfx, les Riva TNT de NVIDIA, les Rage/3D d'ATI, la Virge/3D de S3, et la Matrox Mystique. Elles contenaient des circuits pour gérer les textures, mais aussi une étape d'enregistrement des pixels en mémoire. Elle était gérait le ''z-buffer'' en mémoire vidéo, mais aussi quelques effets graphiques comme les effets de brouillard. L'unité d'enregistrement des pixels en mémoire s'appelle le ROP pour ''Raster Operation Pipeline''.

[[File:Architecture de base d'une carte 3D - 2.png|centre|vignette|upright=1.5|Carte 3D sans rasterization matérielle.]]

Les cartes suivantes ajoutèrent une gestion des étapes de ''rasterization'' directement en matériel. Les cartes ATI rage 2, les Invention de chez Rendition, et d'autres cartes graphiques supportaient la rasterisation en hardware.

[[File:Architecture de base d'une carte 3D - 3.png|centre|vignette|upright=1.5|Carte 3D avec gestion de la géométrie.]]

Pour exploiter les unités de texture et le circuit de rastérisation, OpenGL et Direct 3D étaient partiellement implémentées en logiciel, car les cartes graphiques ne supportaient pas toutes les fonctionnalités de l'API. C'était l'époque du miniGL, des implémentations partielles d'OpenGL, fournies par les fabricants de cartes 3D, implémentées dans les pilotes de périphériques de ces dernières. Les fonctionnalités d'OpenGL implémentées dans ces pilotes étaient presque toutes exécutées en matériel, par la carte graphique. Avec l'évolution du matériel, les pilotes de périphériques devinrent de plus en plus complets, au point de devenir des implémentations totales d'OpenGL.

Mais au-delà d'OpenGL, chaque fabricant de carte graphique avait sa propre API propriétaire, qui était gérée par leurs pilotes de périphériques (''drivers''). Par exemple, les premières cartes graphiques de 3dfx interactive, les fameuses voodoo, disposaient de leur propre API graphique, l'API Glide. Elle facilitait la gestion de la géométrie et des textures, ce qui collait bien avec l'architecture de ces cartes 3D. Mais ces API propriétaires tombèrent rapidement en désuétude avec l'évolution de DirectX et d'OpenGL.

Direct X était une API dans l'ombre d'Open GL. La première version de Direct X qui supportait la 3D était DirectX 2.0 (juin 2, 1996), suivie rapidement par DirectX 3.0 (septembre 1996). Elles dataient d'avant le jeu Quake, et elles étaient très éloignées du hardware des premières cartes graphiques. Elles utilisaient un système d'''execute buffer'' pour communiquer avec la carte graphique, Microsoft espérait que le matériel 3D implémenterait ce genre de système. Ce qui ne fu pas le cas.

Direct X 4.0 a été abandonné en cours de développement pour laisser à une version 5.0 assez semblable à la 2.0/3.0. Le mode de rendu laissait de côté les ''execute buffer'' pour coller un peu plus au hardware de l'époque. Mais rien de vraiment probant comparé à Open GL. Même Windows utilisait Open GL au lieu de Direct X maison... C'est avec Direct X 6.0 que Direct X est entré dans la cours des grands. Il gérait la plupart des technologies supportées par les cartes graphiques de l'époque.

===Le ''multi-texturing'' de l'époque Direct X 6.0 : combiner plusieurs textures===

Une technologie très importante standardisée par Dirext X 6 est la technique du '''''multi-texturing'''''. Avec ce qu'on a dit dans le chapitre précédent, vous pensez sans doute qu'il n'y a qu'une seule texture par objet, qui est plaquée sur sa surface. Mais divers effet graphiques demandent d'ajouter des textures par dessus d'autres textures. En général, elles servent pour ajouter des détails, du relief, sur une surface pré-existante.

Un exemple intéressant vient des jeux de tir : ajouter des impacts de balles sur les murs. Pour cela, on plaque une texture d'impact de balle sur le mur, à la position du tir. Il s'agit là d'un exemple de '''''decals''''', des petites textures ajoutées sur les murs ou le sol, afin de simuler de la poussière, des impacts de balle, des craquelures, des fissures, des trous, etc. Les textures en question sont de petite taille et se superposent à une texture existante, plus grande. Rendre des ''decals'' demande de pouvoir superposer deux textures.

Direct X 6.0 supportait l'application de plusieurs textures directement dans le matériel. La carte graphique devait être capable d'accéder à deux textures en même temps, ou du moins faire semblant que. Pour cela, elle doublaient les unités de texture et adaptaient les connexions entre unités de texture et mémoire vidéo. La mémoire vidéo devait être capable de gérer plusieurs accès mémoire en même temps et devait alors avoir un débit binaire élevé.

[[File:Multitexturing.png|centre|vignette|upright=2|Multitexturing]]

La carte graphique devait aussi gérer de quoi combiner deux textures entre elles. Par exemple, pour revenir sur l'exemple d'une texture d'impact de balle, il faut que la texture d'impact recouvre totalement la texture du mur. Dans ce cas, la combinaison est simple : la première texture remplace l'ancienne, là où elle est appliquée. Mais les cartes graphiques ont ajouté d'autres combinaisons possibles, par exemple additionner les deux textures entre elle, faire une moyenne des texels, etc.

Les opérations pour combiner les textures était le fait de circuits appelés des '''''combiners'''''. Concrètement, les ''combiners'' sont de simples unités de calcul. Les ''conbiners'' ont beaucoup évolués dans le temps, mais les premières implémentation se limitaient à quelques opérations simples : addition, multiplication, superposition, interpolation. L'opération effectuer était envoyée au ''conbiner'' sur une entrée dédiée.

[[File:Multitexturing avec combiners.png|centre|vignette|upright=2|Multitexturing avec combiners]]

S'il y avait eu un seul ''conbiner'', le circuit de ''multitexturing'' aurait été simplement configurable. Mais dans la réalité, les premières cartes utilisant du ''multi-texturing'' utilisaient plusieurs ''combiners'' placés les uns à la suite des autres. L'implémentation des ''combiners'' retenue par Open Gl, et par le hardware des cartes graphiques, était la suivante. Les ''combiners'' étaient placés en série, l'un à la suite de l'autre, chacun combinant le résultat de l'étage précédent avec une texture. Le premier ''combiner'' gérait l'éclairage par sommet, afin de conserver un minimum de rétrocompatibilité.

[[File:Texture combiners Open GL.png|centre|vignette|upright=2|Texture combiners Open GL]]

Voici les opérations supportées par les ''combiners'' d'Open GL. Ils prennent en entrée le résultat de l'étage précédent et le combinent avec une texture lue depuis l'unité de texture.

{|class=&quot;wikitable&quot;
|+ Opérations supportées par les ''combiners'' d'Open GL
|-
! Replace
| colspan=&quot;2&quot; | Pixel provenant de l'unité de texture
|-
! Addition
| colspan=&quot;2&quot; | Additionne l'entrée au texel lu.
|-
! Modulate
| colspan=&quot;2&quot; | Multiplie l'entrée avec le texel lu
|-
! Mélange (''blending'')
| Moyenne pondérée des deux entrées, pondérée par la composante de transparence || La couleur de transparence du texel lu et de l'entrée sont multipliées.
|-
! Decals
| Moyenne pondérée des deux entrées, pondérée par la composante de transparence. || La transparence du résultat est celle de l'entrée.
|}

Il faut noter qu'un dernier étage de ''combiners'' s'occupait d'ajouter la couleur spéculaire et les effets de brouillards. Il était à part des autres et n'était pas configurable, c'était un étage fixe, qui était toujours présent, peu importe le nombre de textures utilisé. Il était parfois appelé le '''''combiner'' final''', terme que nous réutiliserons par la suite.

Mine de rien, cela a rendu les cartes graphiques partiellement programmables. Le fait qu'il y ait des opérations enchainées à la suite, opérations qu'on peut choisir librement, suffit à créer une sorte de mini-programme qui décide comment mélanger plusieurs textures. Mais il y avait une limitation de taille : le fait que les données soient transmises d'un étage à l'autre, sans détours possibles. Par exemple, le troisième étage ne pouvait avoir comme seule opérande le résultat du second étage, mais ne pouvait pas utiliser celui du premier étage. Il n'y avait pas de registres pour stocker ce qui sortait de la rastérisation, ni pour mémoriser temporairement les texels lus.

===Le ''Transform &amp; Lighting'' matériel de Direct X 7.0===

[[File:Architecture de base d'une carte 3D - 4.png|vignette|upright=1.5|Carte 3D avec gestion de la géométrie.]]

La première carte graphique pour PC capable de gérer la géométrie en hardware fût la Geforce 256, la toute première Geforce. Son unité de gestion de la géométrie n'est autre que la bien connue '''unité T&amp;L''' (''Transform And Lighting''). Elle implémentait des algorithmes d'éclairage de la scène 3D assez simples, comme un éclairage de Gouraud, qui étaient directement câblés dans ses circuits. Mais contrairement à la Nintendo 64 et aux bornes d'arcade, elle implémentait le tout, non pas avec un processeur classique, mais avec des circuits fixes.

Avec Direct X 7.0 et Open GL 1.0, l'éclairage était en théorie limité à de l'éclairage par sommet, l'éclairage par pixel n'était pas implémentable en hardware. Les cartes graphiques ont tenté d'implémenter l'éclairage par pixel, mais cela n'est pas allé au-delà du support de quelques techniques de ''bump-mapping'' très limitées. Par exemple, Direct X 6.0 implémentait une forme limitée de ''bump-mapping'', guère plus.

Un autre problème est que l'éclairage peut s'implémenter de plusieurs manières différentes, aux résultats visuels différents. Les unités de T&amp;L étaient souvent en retard sur les algorithmes logiciels. Les programmeurs avaient le choix entre programmer les algorithmes d’éclairage qu'ils voulaient et les exécuter en logiciel ou utiliser ceux de l'unité de T&amp;L, et choisissaient souvent la première option. Par exemple, Quake 3 Arena et Unreal Tournament n'utilisaient pas les capacités d'éclairage géométrique et préféraient utiliser leurs calculs d'éclairage logiciel fait maison.

Cependant, le hardware dépassait les capacités des API et avait déjà commencé à ajouter des capacités de programmation liées au ''multi-texturing''. Les cartes graphiques de l'époque, surtout chez NVIDIA, implémentaient un système de '''''register combiners''''', une forme améliorée de ''texture combiners'', qui permettait de faire une forme limitée d'éclairage par pixel, notamment du vrai ''bump-mampping'', voire du ''normal-mapping''. Mais ce n'était pas totalement supporté par les API 3D de l'époque.

Les ''registers combiners'' sont des ''texture combiners'' mais dans lesquels ont aurait retiré la stricte organisation en série. Il y a toujours plusieurs étages à la suite, qui peuvent exécuter chacun une opération, mais tous les étages ont maintenant accès à toutes les textures lues et à tout ce qui sort de la rastérisation, pas seulement au résultat de l'étape précédente. Pour cela, on ajoute des registres pour mémoriser ce qui sort des unités de texture, et pour ce qui sort de la rastérisation. De plus, on ajoute des registres temporaires pour mémoriser les résultats de chaque ''combiner'', de chaque étage.

Il faut cependant signaler qu'il existe un ''combiner'' final, séparé des étages qui effectuent des opérations proprement dits. Il s'agit de l'étage qui applique la couleur spéculaire et les effets de brouillards. Il ne peut être utilisé qu'à la toute fin du traitement, en tant que dernier étage, on ne peut pas mettre d'opérations après lui. Sa sortie est directement connectée aux ROPs, pas à des registres. Il faut donc faire la distinction entre les '''''combiners'' généraux''' qui effectuent une opération et mémorisent le résultat dans des registres, et le ''combiner'' final qui envoie le résultat aux ROPs.

L'implémentation des ''register combiners'' utilisait un processeur spécialisés dans les traitements sur des pixels, une sorte de proto-processeur de ''shader''. Le processeur supportait des opérations assez complexes : multiplication, produit scalaire, additions. Il s'agissait d'un processeur de type VLIW, qui sera décrit dans quelques chapitres. Mais ce processeur avait des programmes très courts. Les premières cartes NVIDIA, comme les cartes TNT pouvaient exécuter deux opérations à la suite, suivie par l'application de la couleurs spéculaire et du brouillard. En somme, elles étaient limitées à un ''shader'' à deux/trois opérations, mais c'était un début. Le nombre d'opérations consécutives est rapidement passé à 8 sur la Geforce 3.

===L'arrivée des ''shaders'' avec Direct X 8.0===

[[File:Architecture de la Geforce 3.png|vignette|upright=1.5|Architecture de la Geforce 3]]

Les ''register combiners'' était un premier pas vers un éclairage programmable. Paradoxalement, l'évolution suivante s'est faite non pas dans l'unité de rastérisation/texture, mais dans l'unité de traitement de la géométrie. La Geforce 3 a remplacé l'unité de T&amp;L par un processeur capable d'exécuter des programmes. Les programmes en question complétaient l'unité de T&amp;L, afin de pouvoir rajouter des techniques d'éclairage plus complexes. Le tout a permis aussi d'ajouter des animations, des effets de fourrures, des ombres par ''shadow volume'', des systèmes de particule évolués, et bien d'autres.

À partir de la Geforce 3 de Nvidia, les cartes graphiques sont devenues capables d'exécuter des programmes appelés '''''shaders'''''. Le terme ''shader'' vient de ''shading'' : ombrage en anglais. Grace aux ''shaders'', l'éclairage est devenu programmable, il n'est plus géré par des unités d'éclairage fixes mais été laissé à la créativité des programmeurs. Les programmeurs ne sont plus vraiment limités par les algorithmes d'éclairage implémentés dans les cartes graphiques, mais peuvent implémenter les algorithmes d'éclairage qu'ils veulent et peuvent le faire exécuter directement sur la carte graphique.

Les ''shaders'' sont classifiés suivant les données qu'ils manipulent : '''''pixel shader''''' pour ceux qui manipulent des pixels, '''''vertex shaders''''' pour ceux qui manipulent des sommets. Les premiers sont utilisés pour implémenter l'éclairage par pixel, les autres pour gérer tout ce qui a trait à la géométrie, pas seulement l'éclairage par sommets.

Direct X 8.0 avait un standard pour les shaders, appelé ''shaders 1.0'', qui correspondait parfaitement à ce dont était capable la Geforce 3. Il standardisait les ''vertex shaders'' de la Geforce 3, mais il a aussi renommé les ''register combiners'' comme étant des ''pixel shaders'' version 1.0. Les ''register combiners'' n'ont pas évolués depuis la Geforce 256, si ce n'est que les programmes sont passés de deux opérations successives à 8, et qu'il y avait possibilité de lire 4 textures en ''multitexturing''. A l'opposé, le processeur de ''vertex shader'' de la Geforce 3 était capable d'exécuter des programmes de 128 opérations consécutives et avait 258 registres différents !

Des ''pixels shaders'' plus évolués sont arrivés avec l'ATI Radeon 8500 et ses dérivés. Elle incorporait la technologie ''SMARTSHADER'' qui remplacait les ''registers combiners'' par un processeur de ''shader'' un peu limité. Un point est que le processeur acceptait de calculer des adresses de texture dans le ''pixel shader''. Avant, les adresses des texels à lire étaient fournis par l'unité de rastérisation et basta. L'avantage est que certains effets graphiques étaient devenus possibles : du ''bump-mapping'' avancé, des textures procédurales, de l'éclairage par pixel anisotrope, du éclairage de Phong réel, etc.

Avec la Radeon 8500, le ''pixel shader'' pouvait calculer des adresses, et lire les texels associés à ces adresses calculées. Les ''pixel shaders'' pouvaient lire 6 textures, faire 8 opérations sur les texels lus, puis lire 6 textures avec les adresses calculées à l'étape précédente, et refaire 8 opérations. Quelque chose de limité, donc, mais déjà plus pratique. Les ''pixel shaders'' de ce type ont été standardisé dans Direct X 8.1, sous le nom de ''pixel shaders 1.4''. Encore une fois, le hardware a forcé l'intégration dans une API 3D.

===Les ''shaders'' de Direct X 9.0 : de vrais ''pixel shaders''===

Avec Direct X 9.0, les ''shaders'' sont devenus de vrais programmes, sans les limitations des ''shaders'' précédents. Les ''pixels shaders'' sont passés à la version 2.0, idem pour les ''vertex shaders''. Concrètement, ils sont maintenant exécutés par un processeur de ''shader'' dédié, aux fonctionnalités bien supérieures à celles des ''registers combiners''. Les ''shaders'' pouvaient exécuter une suite d'opérations arbitraire, dans le sens où elle n'était pas structurée avec tel type d'opération au début, suivie par un accès aux textures, etc. On pouvait mettre n'importe quelle opération dans n'importe quel ordre.

De plus, les ''shaders'' ne sont plus écrit en assembleur comme c'était le cas avant. Ils sont dorénavant écrits dans un langage de haut-niveau, le HLSL pour les shaders Direct X et le GLSL pour les shaders Open Gl. Les ''shaders'' sont ensuite traduit (compilés) en instructions machines compréhensibles par la carte graphique. Au début, ces langages et la carte graphique supportaient uniquement des opérations simples. Mais au fil du temps, les spécifications de ces langages sont devenues de plus en plus riches à chaque version de Direct X ou d'Open Gl, et le matériel en a fait autant.

[[File:Architecture de base d'une carte 3D - 5.png|centre|vignette|upright=1.5|Carte 3D avec pixels et vertex shaders non-unifiés.]]

===L'après Direct X 9.0===

Avant Direct X 10, les processeurs de ''shaders'' ne géraient pas exactement les mêmes opérations pour les processeurs de ''vertex shader'' et de ''pixel shader''. Les processeurs de ''vertex shader'' et de ''pixel shader''étaient séparés. Depuis DirectX 10, ce n'est plus le cas : le jeu d'instructions a été unifié entre les vertex shaders et les pixels shaders, ce qui fait qu'il n'y a plus de distinction entre processeurs de vertex shaders et de pixels shaders, chaque processeur pouvant traiter indifféremment l'un ou l'autre. 

[[File:Architecture de base d'une carte 3D - 6.png|centre|vignette|upright=1.5|Architecture de la GeForce 6800.]]

Avec Direct X 10, de nombreux autres ''shaders'' sont apparus. Les plus liés au rendu 3D sont les '''''geometry shader''''' pour ceux qui manipulent des triangles, de ''hull shaders'' et de ''domain shaders'' pour la tesselation. De plus, les cartes graphiques modernes sont capables d’exécuter des programmes informatiques qui n'ont aucun lien avec le rendu 3D, mais sont exécutés par la carte graphique comme le ferait un processeur d'ordinateur normal. De tels ''shaders'' sans lien avec le rendu 3D sont appelés des ''compute shader''.

==Les cartes graphiques d'aujourd'hui==

Avec l'arrivée des shaders, les circuits d'une carte graphique sont divisés en deux catégories : d'un côté les circuits non-programmables et de l'autre les circuits programmables. Pour exécuter les ''shaders'', la carte graphique incorpore des '''processeurs de ''shaders''''', des processeurs similaires aux processeurs des ordinateurs, aux CPU, mais avec quelques petites différences qu'on expliquera dans le prochain chapitre. A côté des processeurs de ''shaders'', il reste quelques circuits non(programmables appelés des circuits fixes. De nos jours, la gestion de la géométrie et des pixels est programmable, mais la rastérisation, le placage de texture, le ''culling'' et l'enregistrement du ''framebuffer'' ne l'est pas. Il n'en a pas toujours été ainsi.

[[File:3D-Pipeline.svg|centre|vignette|upright=3.0|Pipeline 3D : ce qui est programmable et ce qui ne l'est pas dans une carte graphique moderne.]]

===Les GPU modernes sont un mélange de processeurs et de circuits fixes===

Une carte graphique contient donc un mélange de circuits fixes et de processeurs de ''shaders'', qui peut sembler contradictoire. Pourquoi ne pas tout rendre programmable ? Ou au contraire, utiliser seulement des circuits fixes ? La réponse rapide est qu'il s'agit d'un compromis entre flexibilité et performance qui permet d'avoir le meilleur des deux mondes. Mais ce compromis a fortement évolué dans le temps, comme on va le voir plus bas.

Rendre la gestion de la géométrie ou des pixels programmable permet d'implémenter facilement un grand nombre d'effets graphiques sans avoir à les implémenter en hardware. Avant les ''shaders'', seul le hardware récent gérait les dernières fonctionnalités. Les effets graphiques derniers cri n'étaient disponibles que sur les derniers modèles de carte graphique. Avec des ''vertex/pixel shaders'', ce genre de défaut est passé à la trappe. Si un nouvel algorithme de rendu graphique est inventé, il peut être utilisé dès le lendemain sur toutes les cartes graphiques modernes. De plus, implémenter beaucoup d'algorithmes d'éclairage différents est difficile. Le cout en termes de transistors et de complexité était assez important, utiliser des circuits programmable a un cout en hardware plus limité.

Tout cela est à l'exact opposé de ce qu'on a avec les autres circuits, comme les circuits pour la rastérisation ou le placage de texture. Il n'y a pas 36 façons de rastériser une scène 3D et la flexibilité n'est pas un besoin important pour cette opération, alors que les performances sont cruciales. Même chose pour le placage/filtrage de textures. En conséquences, les unités de transformation, de rastérisation et de placage de texture sont toutes implémentées en matériel. Faire ainsi permet de gagner en performance sans que cela ait le moindre impact pour le programmeur.

===Les unités de texture sont intégrées aux processeurs de shaders===

Les unités de textures sont à part des autres circuits fixes, dans le sens où ce sont les seuls à être implémentés dans les processeurs de shaders. Sur les anciennes cartes 3D, les unités de textures étaient des circuits séparés des autres. Mais avec l'arrivée des processeurs de shaders, elles ont été intégrée dans les processeurs de shaders eux-mêmes. Pour comprendre pourquoi, il faut faire un rappel sur ce qu'il y a dans un processeur. Un processeur contient globalement quatre circuits :
* une unité de calcul qui fait des calculs ;
* des registres pour stocker les opérandes et résultats des calculs ;
* une unité de communication avec la mémoire ;
* et un séquenceur, un circuit de contrôle qui commande les autres.

L'unité de communication avec la mémoire sert à lire ou écrire des données, à les transférer de la RAM vers les registres, ou l'inverse. Lire une donnée demande d'envoyer son adresse à la RAM, qui répond en envoyant la donnée lue. Elle est donc toute indiquée pour lire une texture : lire une texture n'est qu'un cas particulier de lecture de données. Les texels à lire sont à une adresse précise, la RAM répond à la lecture avec le texel demandé. Il est donc possible d'utiliser l'unité de communication avec la mémoire comme si c'était une unité de texture.

Cependant, les textures ne sont pas utilisées comme telles de nos jours. Le rendu 3D moderne utilise des techniques dites de filtrage de texture, qui permettent d'améliorer la qualité du rendu des textures. Sans ce filtrage de texture, les textures appliquées naïvement donnent un résultat assez pixelisé et assez moche, pour des raisons assez techniques. Le filtrage élimine ces artefacts, en utilisant une forme d'''antialiasing'' interne aux textures, le fameux filtrage de texture.

Le filtrage de texture peut être réalisé en logiciel ou en matériel. Techniquement, il est possible de le faire dans un ''shader'' : le ''shader'' calcule les adresses des texels à lire, lit plusieurs texels, et effectue ensuite le filtrage. En soi, rien d'impossible. Mais le filtrage de texture est toujours effectué directement en matériel. Les processeurs de shaders incorporent des circuits de filtrage de texture, dans l'unité de communication avec la mémoire. La raison est que le filtrage de texture est une opération très simple à implémenter en hardware, qui demande assez peu de circuits. Le filtrage bilinéaire ou trilinéaire demande juste des circuits d'interpolation et quelques registres, ce qui est trivial. Et la seconde raison est qu'il n'y a pas 36 façons de filtrer des textures : une carte graphique peut implémenter les algorithmes principaux existants en assez peu de circuits.

: Il faut noter que les ROPs peuvent aussi être intégré dans les processeurs de ''shader'', mais c'est assez rare. Les cartes graphiques pour PC ont des ROPs séparés des processeurs de ''shaders''. Par contre, quelques cartes graphiques destinées les smartphones et autres appareils mobiles font exception. Sur celles-ci, les unités de textures et les ROPs sont intégrés dans les processeurs de ''shaders'', aux côtés de l'unité d'accès mémoire LOAD/STORE. Il s'agit de cartes graphiques en rendu à tuiles.

{{NavChapitre | book=Les cartes graphiques
           | prev=Les cartes graphiques : architecture de base
           | prevText=Les cartes graphiques : architecture de base
           | next=Les processeurs de shaders
           | nextText=Les processeurs de shaders
}}
{{autocat}}</text>
      <sha1>07oxg8ezjycqq82slljm95jxhtkq71t</sha1>
    </revision>
    <revision>
      <id>744097</id>
      <parentid>744096</parentid>
      <timestamp>2025-06-04T00:20:10Z</timestamp>
      <contributor>
        <username>Mewtow</username>
        <id>31375</id>
      </contributor>
      <minor />
      <comment>/* Les unités de texture sont intégrées aux processeurs de shaders */</comment>
      <origin>744097</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="41518" sha1="a17i0s6rz2k3npkd97f0i32coxa71yv" xml:space="preserve">Il est intéressant d'étudier le hardware des cartes graphiques en faisant un petit résumé de leur évolution dans le temps. En effet, leur hardware a fortement évolué dans le temps. Et il serait difficile à comprendre le hardware actuel sans parler du hardware d'antan. En effet, une carte graphique moderne est partiellement programmable. Certains circuits sont totalement programmables, d'autres non. Et pour comprendre pourquoi, il faut étudier comment ces circuits ont évolués.

Le hardware des cartes graphiques a fortement évolué dans le temps, ce qui n'est pas une surprise. Les évolutions de la technologie, avec la miniaturisation des transistors et l'augmentation de leurs performances a permit aux cartes graphiques d'incorporer de plus en plus de circuits avec les années. Avant l'invention des cartes graphiques, toutes les étapes du pipeline graphique étaient réalisées par le processeur : il calculait l'image à afficher, et l’envoyait à une carte d'affichage 2D. Au fil du temps, de nombreux circuits furent ajoutés, afin de déporter un maximum de calculs vers la carte vidéo.

Le rendu 3D moderne est basé sur le placage de texture inverse, avec des coordonnées de texture, une correction de perspective, etc. Mais les anciennes consoles et bornes d'arcade utilisaient le placage de texture direct. Et cela a impacté le hardware des consoles/PCs de l'époque. Avec le placage de texture direct, il était primordial de calculer la géométrie, mais la rasterisation était le fait de VDC améliorés. Aussi, les premières bornes d'arcade 3D et les consoles de 5ème génération disposaient processeurs pour calculer la géométrie et de circuits d'application de textures très particuliers. A l'inverse, les PC utilisaient un rendu inverse, totalement différent. Sur les PC, les premières cartes graphiques avaient un circuit de rastérisation et des unités de textures, mais pas de circuits géométriques.

==Les précurseurs : les cartes graphiques des bornes d'arcade==

[[File:Sega ST-V Dynamite Deka PCB 20100324.jpg|vignette|Sega ST-V Dynamite Deka PCB 20100324]]

L'accélération du rendu 3D sur les bornes d'arcade était déjà bien avancé dès les années 90. Les bornes d'arcade ont toujours été un segment haut de gamme de l'industrie du jeu vidéo, aussi ce n'est pas étonnant. Le prix d'une borne d'arcade dépassait facilement les 10 000 dollars pour les plus chères et une bonne partie du prix était celui du matériel informatique. Le matériel était donc très puissant et débordait de mémoire RAM comparé aux consoles de jeu et aux PC.

La plupart des bornes d'arcade utilisaient du matériel standardisé entre plusieurs bornes. A l'intérieur d'une borne d'arcade se trouve une '''carte de borne d'arcade''' qui est une carte mère avec un ou plusieurs processeurs, de la RAM, une carte graphique, un VDC et pas mal d'autres matériels. La carte est reliée aux périphériques de la borne : joysticks, écran, pédales, le dispositif pour insérer les pièces afin de payer, le système sonore, etc. Le jeu utilisé pour la borne est placé dans une cartouche qui est insérée dans un connecteur spécialisé.

Les cartes de bornes d'arcade étaient généralement assez complexes, elles avaient une grande taille et avaient plus de composants que les cartes mères de PC. Chaque carte contenait un grand nombre de chips pour la mémoire RAM et ROM, et il n'était pas rare d'avoir plusieurs processeurs sur une même carte. Et il n'était pas rare d'avoir trois à quatre cartes superposées dans une seule borne. Pour ceux qui veulent en savoir plus, Fabien Sanglard a publié gratuitement un livre sur le fonctionnement des cartes d'arcade CPS System, disponible via ce lien : [https://fabiensanglard.net/b/cpsb.pdf The book of CP System].

Les premières cartes graphiques des bornes d'arcade étaient des cartes graphiques 2D auxquelles on avait ajouté quelques fonctionnalités. Les sprites pouvaient être tournés, agrandit/réduits, ou déformés pour simuler de la perspective et faire de la fausse 3D. Par la suite, le vrai rendu 3D est apparu sur les bornes d'arcade, avec des GPUs totalement programmables.

Dès 1988, la carte d'arcade Namco System 21	et Sega Model 1 géraient les calculs géométriques. Les deux cartes n'utilisaient pas de circuit géométrique fixe, mais l'émulaient avec un processeur programmé avec un programme informatique qui implémentait le T&amp;L en logiciel. Elles utilisaient plusieurs DSP pour ce faire.

Quelques années plus tard, les cartes graphiques se sont mises à supporter un éclairage de Gouraud et du placage de texture. Le Namco System 22 et la Sega model 2 supportaient des textures 2D et comme le filtrage de texture (bilinéaire et trilinéaire), le mip-mapping, et quelques autres. Par la suite, elles ont réutilisé le hardware des PC et autres consoles de jeux.

==La 3D sur les consoles de quatrième génération==

Les consoles avant la quatrième génération de console étaient des consoles purement 2D, sans circuits d'accélération 3D. Leur carte graphique était un simple VDC 2D, plus ou moins performant selon la console. Pourtant, les consoles de quatrième génération ont connus quelques jeux en 3D. Par exemple, les jeux Star Fox sur SNES. Fait important, il s'agissait de vrais jeux en 3D qui tournaient sur des consoles qui ne géraient pas la 3D. La raison à cela est que la 3D était calculée par un GPU placé dans les cartouches du jeu ! 

Par exemple, les cartouches de Starfox et de Super Mario 2 contenait un coprocesseur Super FX, qui gérait des calculs de rendu 2D/3D. Un autre exemple est celui du co-processeur Cx4, cousin du Super FX, qui était spécialisé dans les calculs trigonométriques et diverses opérations utiles pour le rendu 2D/3D. En tout, il y a environ 16 coprocesseurs pour la SNES et on en trouve facilement la liste sur le net.

La console était conçue pour, des pins sur les ports cartouches étaient prévues pour des fonctionnalités de cartouche annexes, dont ces coprocesseurs. Ces pins connectaient le coprocesseur au bus des entrées-sorties. Les coprocesseurs des cartouches de NES avaient souvent de la mémoire rien que pour eux, qui était intégrée dans la cartouche. 

==L'arrivée des consoles de cinquième génération==

Par la suite, les consoles de jeu se sont mises à intégrer des cartes graphiques 3D. Les premières consoles de jeu capables de rendu 3D sont les consoles dites de 5ème génération. Il y a diverses manières de classer les consoles en générations, la plus commune place la 3D à la 5ème génération, mais détailler ces controverses quant à ce classement nous amènerait trop loin. Les cartes graphiques des consoles de jeu utilisaient le rendu inverse, avec quelques exceptions qui utilisaient le rendu inverse.

===La Nintendo 64 : un GPU avancé===

La Nintendo 64 avait le GPU le plus complexe comparé aux autres consoles, et dépassait même les cartes graphiques des PC. Son GPU était très novateur pour une console sortie en 1996. Il incorporait une unité pour les calculs géométriques, un circuit pour la rasterisation, une unité pour les textures et un ROP final pour les calculs de transparence/brouillard/anti-aliasing, ainsi qu'un circuit pour gérer la profondeur des pixels. En somme, tout le pipeline graphique était implémenté dans le GPU de la Nintendo 64, chose très en avance sur son temps, même comparé au PC !

Le GPU est construit autour d'un processeur dédié aux calculs géométriques, le ''Reality Signal Processor'' (RSP), autour duquel on a ajouté des circuits pour le reste du pipeline graphique. L'unité de calcul géométrique est un processeur MIPS R4000, un processeur assez courant à l'époque, mais auquel on avait retiré quelques fonctionnalités inutiles pour le rendu 3D. Il était couplé à 4 KB de mémoire vidéo, ainsi qu'à 4 KB de mémoire ROM. Le reste du GPU était réalisé avec des circuits fixes. La Nintendo 64 utilisait déjà un mélange de circuits programmables et fixes.

Un point intéressant est que le programme exécuté par le RSP pouvait être programmé ! Le RSP gérait déjà des espèces de proto-shaders, qui étaient appelés des ''[https://ultra64.ca/files/documentation/online-manuals/functions_reference_manual_2.0i/ucode/microcode.html micro-codes]'' dans la documentation de l'époque. La ROM associée au RSP mémorise cinq à sept programmes différents, des microcodes de base, aux fonctionnalités différentes. Ils géraient le rendu 3D de manière différente et avec une gestion des ressources différentes. Très peu de studios de jeu vidéo ont développé leur propre microcodes N64, car la documentation était mal faite, que Nintendo ne fournissait pas de support officiel pour cela, que les outils de développement ne permettaient pas de faire cela proprement et efficacement.

===La Playstation 1===

Sur la Playstation 1 le calcul de la géométrie était réalisé par le processeur, la carte graphique gérait tout le reste. Et la carte graphique était un circuit fixe spécialisé dans la rasterisation et le placage de textures. Elle utilisait, comme la Nintendo 64, le placage de texture inverse, qui est apparu ensuite sur les cartes graphiques.

===La 3DO et la Sega Saturn===

La Sega Saturn et la 3DO étaient les deux seules consoles à utiliser le rendu direct. La géométrie était calculée sur le processeur, même si les consoles utilisaient parfois un CPU dédié au calcul de la géométrie. Le reste du pipeline était géré par un VDC 2D qui implémentait le placage de textures.

La Sega Saturn incorpore trois processeurs et deux GPU. Les deux GPUs sont nommés le VDP1 et le VDP2. Le VDP1 s'occupe des textures et des sprites, le VDP2 s'occupe uniquement de l'arrière-plan et incorpore un VDC tout ce qu'il y a de plus simple. Ils ne gèrent pas du tout la géométrie, qui est calculée par les trois processeurs.

Le troisième processeur, la Saturn Control Unit, est un processeur de type DSP, à savoir un processeur spécialisé dans le traitement de signal. Il est utilisé presque exclusivement pour accélérer les calculs géométriques. Il avait sa propre mémoire RAM dédiée, 32 KB de SRAM, soit une mémoire locale très rapide. Les transferts entre cette RAM et le reste de l'ordinateur était géré par un contrôleur DMA intégré dans le DSP. En somme, il s'agit d'une sorte de processeur spécialisé dans la géométrie, une sorte d'unité géométrique programmable. Mais la géométrie n'était pas forcément calculée que sur ce DSP, mais pouvait être prise en charge par les 3 CPU.

==L'historique des cartes graphiques des PC, avant l'arrivée de Direct X et Open Gl==

Sur PC, l'évolution des cartes graphiques a eu du retard par rapport aux consoles. Les PC sont en effet des machines multi-usage, pour lesquelles le jeu vidéo était un cas d'utilisation parmi tant d'autres. Et les consoles étaient la plateforme principale pour jouer à des jeux vidéo, le jeu vidéo PC étant plus marginal. Mais cela ne veut pas dire que le jeu PC n'existait pas, loin de là ! 

Un problème pour les jeux PC était que l'écosystème des PC était aussi fragmenté en plusieurs machines différentes : machines Apple 1 et 2, ordinateurs Commdore et Amiga, IBM PC et dérivés, etc. Aussi, programmer des jeux PC n'était pas mince affaire, car les problèmes de compatibilité étaient légion. C'est seulement quand la plateforme x86 des IBM PC s'est démocratisée que l'informatique grand public s'est standardisée, réduisant fortement les problèmes de compatibilité. Mais cela n'a pas suffit, il a aussi fallu que les API 3D naissent.

Les API 3D comme Direct X et Open GL sont absolument cruciales pour garantir la compatibilité entre plusieurs ordinateurs aux cartes graphiques différentes. Aussi, l'évolution des cartes graphiques pour PC s'est faite main dans la main avec l'évolution des API 3D. Il a fallu que Direct X et Open GL progressent suffisamment pour que les problèmes de compatibilité soient partiellement résolus. Les fonctionnalités des cartes graphiques ont évolué dans le temps, en suivant les évolutions des API 3D. Du moins dans les grandes lignes, car il est arrivé plusieurs fois que des fonctionnalités naissent sur les cartes graphiques, pour que les fabricants forcent la main de Microsoft ou d'Open GL pour les intégrer de force dans les API 3D. Passons.

===L'introduction des premiers jeux 3D : Quake et les drivers miniGL===

L'histoire de la 3D sur PC commence avec la sortie du jeu Quake, d'IdSoftware. Celui-ci pouvait fonctionner en rendu logiciel, mais le programmeur responsable du moteur 3D (le fameux John Carmack) ajouta une version OpenGL du jeu. Le fait que le jeu était programmé sur une station de travail compatible avec OpenGL faisait que ce choix n'était si stupide, même si aucune carte accélératrice de l'époque ne supportait OpenGL. C'était là un choix qui se révéla visionnaire. En théorie, le rendu par OpenGL aurait dû se faire intégralement en logiciel, sauf sur quelques rares stations de travail adaptées. Mais les premières cartes graphiques étaient déjà dans les starting blocks.

La toute première carte 3D pour PC est la Rendition Vérité V1000, sortie en Septembre 1995, soit quelques mois avant l'arrivée de la Nintendo 64. La Rendition Vérité V1000 était purement programmable, contrairement aux autres cartes graphiques de l'époque. Elle contenait un processeur MIPS cadencé à 25 MHz, 4 mébioctets de RAM, une ROM pour le BIOS, et un RAMDAC, rien de plus. C'était un vrai ordinateur complètement programmable de bout en bout. Les programmeurs ne pouvaient cependant pas utiliser cette programmabilité avec des ''shaders'', mais elle permettait à Rendition d'implémenter n'importe quelle API 3D, que ce soit OpenGL, DirectX ou même sa son API propriétaire.

La Rendition Vérité avait de bonnes performances pour ce qui est de la géométrie, mais pas pour le reste. Autant les calculs géométriques sont assez rapides quand on les exécute sur un CPU, autant réaliser la rastérisation et le placage de texture en logiciel n'est pas efficace, pareil pour les opérations de fin de pipeline comme l'antialiasing. Le manque d'unités fixes très rapides pour la rastérisation, le placage de texture ou les opérations de fin de pipeline était clairement un gros défaut. Les autres cartes graphiques avaient implémenté l'exact inverse : de bonnes performances pour le placage de textures et la rastérization, mais les calculs géométriques étaient réalisés par le CPU. Au final, la carte graphique qui s'en sortait le mieux était la Nintendo 64 qui avait un CPU dédié pour les calculs géométriques et des circuits fixes pour le reste...

Les autres cartes graphiques étaient totalement non-programmables et ne contenant que des circuits fixes, regroupe les Voodoo de 3dfx, les Riva TNT de NVIDIA, les Rage/3D d'ATI, la Virge/3D de S3, et la Matrox Mystique. Elles contenaient des circuits pour gérer les textures, mais aussi une étape d'enregistrement des pixels en mémoire. Elle était gérait le ''z-buffer'' en mémoire vidéo, mais aussi quelques effets graphiques comme les effets de brouillard. L'unité d'enregistrement des pixels en mémoire s'appelle le ROP pour ''Raster Operation Pipeline''.

[[File:Architecture de base d'une carte 3D - 2.png|centre|vignette|upright=1.5|Carte 3D sans rasterization matérielle.]]

Les cartes suivantes ajoutèrent une gestion des étapes de ''rasterization'' directement en matériel. Les cartes ATI rage 2, les Invention de chez Rendition, et d'autres cartes graphiques supportaient la rasterisation en hardware.

[[File:Architecture de base d'une carte 3D - 3.png|centre|vignette|upright=1.5|Carte 3D avec gestion de la géométrie.]]

Pour exploiter les unités de texture et le circuit de rastérisation, OpenGL et Direct 3D étaient partiellement implémentées en logiciel, car les cartes graphiques ne supportaient pas toutes les fonctionnalités de l'API. C'était l'époque du miniGL, des implémentations partielles d'OpenGL, fournies par les fabricants de cartes 3D, implémentées dans les pilotes de périphériques de ces dernières. Les fonctionnalités d'OpenGL implémentées dans ces pilotes étaient presque toutes exécutées en matériel, par la carte graphique. Avec l'évolution du matériel, les pilotes de périphériques devinrent de plus en plus complets, au point de devenir des implémentations totales d'OpenGL.

Mais au-delà d'OpenGL, chaque fabricant de carte graphique avait sa propre API propriétaire, qui était gérée par leurs pilotes de périphériques (''drivers''). Par exemple, les premières cartes graphiques de 3dfx interactive, les fameuses voodoo, disposaient de leur propre API graphique, l'API Glide. Elle facilitait la gestion de la géométrie et des textures, ce qui collait bien avec l'architecture de ces cartes 3D. Mais ces API propriétaires tombèrent rapidement en désuétude avec l'évolution de DirectX et d'OpenGL.

Direct X était une API dans l'ombre d'Open GL. La première version de Direct X qui supportait la 3D était DirectX 2.0 (juin 2, 1996), suivie rapidement par DirectX 3.0 (septembre 1996). Elles dataient d'avant le jeu Quake, et elles étaient très éloignées du hardware des premières cartes graphiques. Elles utilisaient un système d'''execute buffer'' pour communiquer avec la carte graphique, Microsoft espérait que le matériel 3D implémenterait ce genre de système. Ce qui ne fu pas le cas.

Direct X 4.0 a été abandonné en cours de développement pour laisser à une version 5.0 assez semblable à la 2.0/3.0. Le mode de rendu laissait de côté les ''execute buffer'' pour coller un peu plus au hardware de l'époque. Mais rien de vraiment probant comparé à Open GL. Même Windows utilisait Open GL au lieu de Direct X maison... C'est avec Direct X 6.0 que Direct X est entré dans la cours des grands. Il gérait la plupart des technologies supportées par les cartes graphiques de l'époque.

===Le ''multi-texturing'' de l'époque Direct X 6.0 : combiner plusieurs textures===

Une technologie très importante standardisée par Dirext X 6 est la technique du '''''multi-texturing'''''. Avec ce qu'on a dit dans le chapitre précédent, vous pensez sans doute qu'il n'y a qu'une seule texture par objet, qui est plaquée sur sa surface. Mais divers effet graphiques demandent d'ajouter des textures par dessus d'autres textures. En général, elles servent pour ajouter des détails, du relief, sur une surface pré-existante.

Un exemple intéressant vient des jeux de tir : ajouter des impacts de balles sur les murs. Pour cela, on plaque une texture d'impact de balle sur le mur, à la position du tir. Il s'agit là d'un exemple de '''''decals''''', des petites textures ajoutées sur les murs ou le sol, afin de simuler de la poussière, des impacts de balle, des craquelures, des fissures, des trous, etc. Les textures en question sont de petite taille et se superposent à une texture existante, plus grande. Rendre des ''decals'' demande de pouvoir superposer deux textures.

Direct X 6.0 supportait l'application de plusieurs textures directement dans le matériel. La carte graphique devait être capable d'accéder à deux textures en même temps, ou du moins faire semblant que. Pour cela, elle doublaient les unités de texture et adaptaient les connexions entre unités de texture et mémoire vidéo. La mémoire vidéo devait être capable de gérer plusieurs accès mémoire en même temps et devait alors avoir un débit binaire élevé.

[[File:Multitexturing.png|centre|vignette|upright=2|Multitexturing]]

La carte graphique devait aussi gérer de quoi combiner deux textures entre elles. Par exemple, pour revenir sur l'exemple d'une texture d'impact de balle, il faut que la texture d'impact recouvre totalement la texture du mur. Dans ce cas, la combinaison est simple : la première texture remplace l'ancienne, là où elle est appliquée. Mais les cartes graphiques ont ajouté d'autres combinaisons possibles, par exemple additionner les deux textures entre elle, faire une moyenne des texels, etc.

Les opérations pour combiner les textures était le fait de circuits appelés des '''''combiners'''''. Concrètement, les ''combiners'' sont de simples unités de calcul. Les ''conbiners'' ont beaucoup évolués dans le temps, mais les premières implémentation se limitaient à quelques opérations simples : addition, multiplication, superposition, interpolation. L'opération effectuer était envoyée au ''conbiner'' sur une entrée dédiée.

[[File:Multitexturing avec combiners.png|centre|vignette|upright=2|Multitexturing avec combiners]]

S'il y avait eu un seul ''conbiner'', le circuit de ''multitexturing'' aurait été simplement configurable. Mais dans la réalité, les premières cartes utilisant du ''multi-texturing'' utilisaient plusieurs ''combiners'' placés les uns à la suite des autres. L'implémentation des ''combiners'' retenue par Open Gl, et par le hardware des cartes graphiques, était la suivante. Les ''combiners'' étaient placés en série, l'un à la suite de l'autre, chacun combinant le résultat de l'étage précédent avec une texture. Le premier ''combiner'' gérait l'éclairage par sommet, afin de conserver un minimum de rétrocompatibilité.

[[File:Texture combiners Open GL.png|centre|vignette|upright=2|Texture combiners Open GL]]

Voici les opérations supportées par les ''combiners'' d'Open GL. Ils prennent en entrée le résultat de l'étage précédent et le combinent avec une texture lue depuis l'unité de texture.

{|class=&quot;wikitable&quot;
|+ Opérations supportées par les ''combiners'' d'Open GL
|-
! Replace
| colspan=&quot;2&quot; | Pixel provenant de l'unité de texture
|-
! Addition
| colspan=&quot;2&quot; | Additionne l'entrée au texel lu.
|-
! Modulate
| colspan=&quot;2&quot; | Multiplie l'entrée avec le texel lu
|-
! Mélange (''blending'')
| Moyenne pondérée des deux entrées, pondérée par la composante de transparence || La couleur de transparence du texel lu et de l'entrée sont multipliées.
|-
! Decals
| Moyenne pondérée des deux entrées, pondérée par la composante de transparence. || La transparence du résultat est celle de l'entrée.
|}

Il faut noter qu'un dernier étage de ''combiners'' s'occupait d'ajouter la couleur spéculaire et les effets de brouillards. Il était à part des autres et n'était pas configurable, c'était un étage fixe, qui était toujours présent, peu importe le nombre de textures utilisé. Il était parfois appelé le '''''combiner'' final''', terme que nous réutiliserons par la suite.

Mine de rien, cela a rendu les cartes graphiques partiellement programmables. Le fait qu'il y ait des opérations enchainées à la suite, opérations qu'on peut choisir librement, suffit à créer une sorte de mini-programme qui décide comment mélanger plusieurs textures. Mais il y avait une limitation de taille : le fait que les données soient transmises d'un étage à l'autre, sans détours possibles. Par exemple, le troisième étage ne pouvait avoir comme seule opérande le résultat du second étage, mais ne pouvait pas utiliser celui du premier étage. Il n'y avait pas de registres pour stocker ce qui sortait de la rastérisation, ni pour mémoriser temporairement les texels lus.

===Le ''Transform &amp; Lighting'' matériel de Direct X 7.0===

[[File:Architecture de base d'une carte 3D - 4.png|vignette|upright=1.5|Carte 3D avec gestion de la géométrie.]]

La première carte graphique pour PC capable de gérer la géométrie en hardware fût la Geforce 256, la toute première Geforce. Son unité de gestion de la géométrie n'est autre que la bien connue '''unité T&amp;L''' (''Transform And Lighting''). Elle implémentait des algorithmes d'éclairage de la scène 3D assez simples, comme un éclairage de Gouraud, qui étaient directement câblés dans ses circuits. Mais contrairement à la Nintendo 64 et aux bornes d'arcade, elle implémentait le tout, non pas avec un processeur classique, mais avec des circuits fixes.

Avec Direct X 7.0 et Open GL 1.0, l'éclairage était en théorie limité à de l'éclairage par sommet, l'éclairage par pixel n'était pas implémentable en hardware. Les cartes graphiques ont tenté d'implémenter l'éclairage par pixel, mais cela n'est pas allé au-delà du support de quelques techniques de ''bump-mapping'' très limitées. Par exemple, Direct X 6.0 implémentait une forme limitée de ''bump-mapping'', guère plus.

Un autre problème est que l'éclairage peut s'implémenter de plusieurs manières différentes, aux résultats visuels différents. Les unités de T&amp;L étaient souvent en retard sur les algorithmes logiciels. Les programmeurs avaient le choix entre programmer les algorithmes d’éclairage qu'ils voulaient et les exécuter en logiciel ou utiliser ceux de l'unité de T&amp;L, et choisissaient souvent la première option. Par exemple, Quake 3 Arena et Unreal Tournament n'utilisaient pas les capacités d'éclairage géométrique et préféraient utiliser leurs calculs d'éclairage logiciel fait maison.

Cependant, le hardware dépassait les capacités des API et avait déjà commencé à ajouter des capacités de programmation liées au ''multi-texturing''. Les cartes graphiques de l'époque, surtout chez NVIDIA, implémentaient un système de '''''register combiners''''', une forme améliorée de ''texture combiners'', qui permettait de faire une forme limitée d'éclairage par pixel, notamment du vrai ''bump-mampping'', voire du ''normal-mapping''. Mais ce n'était pas totalement supporté par les API 3D de l'époque.

Les ''registers combiners'' sont des ''texture combiners'' mais dans lesquels ont aurait retiré la stricte organisation en série. Il y a toujours plusieurs étages à la suite, qui peuvent exécuter chacun une opération, mais tous les étages ont maintenant accès à toutes les textures lues et à tout ce qui sort de la rastérisation, pas seulement au résultat de l'étape précédente. Pour cela, on ajoute des registres pour mémoriser ce qui sort des unités de texture, et pour ce qui sort de la rastérisation. De plus, on ajoute des registres temporaires pour mémoriser les résultats de chaque ''combiner'', de chaque étage.

Il faut cependant signaler qu'il existe un ''combiner'' final, séparé des étages qui effectuent des opérations proprement dits. Il s'agit de l'étage qui applique la couleur spéculaire et les effets de brouillards. Il ne peut être utilisé qu'à la toute fin du traitement, en tant que dernier étage, on ne peut pas mettre d'opérations après lui. Sa sortie est directement connectée aux ROPs, pas à des registres. Il faut donc faire la distinction entre les '''''combiners'' généraux''' qui effectuent une opération et mémorisent le résultat dans des registres, et le ''combiner'' final qui envoie le résultat aux ROPs.

L'implémentation des ''register combiners'' utilisait un processeur spécialisés dans les traitements sur des pixels, une sorte de proto-processeur de ''shader''. Le processeur supportait des opérations assez complexes : multiplication, produit scalaire, additions. Il s'agissait d'un processeur de type VLIW, qui sera décrit dans quelques chapitres. Mais ce processeur avait des programmes très courts. Les premières cartes NVIDIA, comme les cartes TNT pouvaient exécuter deux opérations à la suite, suivie par l'application de la couleurs spéculaire et du brouillard. En somme, elles étaient limitées à un ''shader'' à deux/trois opérations, mais c'était un début. Le nombre d'opérations consécutives est rapidement passé à 8 sur la Geforce 3.

===L'arrivée des ''shaders'' avec Direct X 8.0===

[[File:Architecture de la Geforce 3.png|vignette|upright=1.5|Architecture de la Geforce 3]]

Les ''register combiners'' était un premier pas vers un éclairage programmable. Paradoxalement, l'évolution suivante s'est faite non pas dans l'unité de rastérisation/texture, mais dans l'unité de traitement de la géométrie. La Geforce 3 a remplacé l'unité de T&amp;L par un processeur capable d'exécuter des programmes. Les programmes en question complétaient l'unité de T&amp;L, afin de pouvoir rajouter des techniques d'éclairage plus complexes. Le tout a permis aussi d'ajouter des animations, des effets de fourrures, des ombres par ''shadow volume'', des systèmes de particule évolués, et bien d'autres.

À partir de la Geforce 3 de Nvidia, les cartes graphiques sont devenues capables d'exécuter des programmes appelés '''''shaders'''''. Le terme ''shader'' vient de ''shading'' : ombrage en anglais. Grace aux ''shaders'', l'éclairage est devenu programmable, il n'est plus géré par des unités d'éclairage fixes mais été laissé à la créativité des programmeurs. Les programmeurs ne sont plus vraiment limités par les algorithmes d'éclairage implémentés dans les cartes graphiques, mais peuvent implémenter les algorithmes d'éclairage qu'ils veulent et peuvent le faire exécuter directement sur la carte graphique.

Les ''shaders'' sont classifiés suivant les données qu'ils manipulent : '''''pixel shader''''' pour ceux qui manipulent des pixels, '''''vertex shaders''''' pour ceux qui manipulent des sommets. Les premiers sont utilisés pour implémenter l'éclairage par pixel, les autres pour gérer tout ce qui a trait à la géométrie, pas seulement l'éclairage par sommets.

Direct X 8.0 avait un standard pour les shaders, appelé ''shaders 1.0'', qui correspondait parfaitement à ce dont était capable la Geforce 3. Il standardisait les ''vertex shaders'' de la Geforce 3, mais il a aussi renommé les ''register combiners'' comme étant des ''pixel shaders'' version 1.0. Les ''register combiners'' n'ont pas évolués depuis la Geforce 256, si ce n'est que les programmes sont passés de deux opérations successives à 8, et qu'il y avait possibilité de lire 4 textures en ''multitexturing''. A l'opposé, le processeur de ''vertex shader'' de la Geforce 3 était capable d'exécuter des programmes de 128 opérations consécutives et avait 258 registres différents !

Des ''pixels shaders'' plus évolués sont arrivés avec l'ATI Radeon 8500 et ses dérivés. Elle incorporait la technologie ''SMARTSHADER'' qui remplacait les ''registers combiners'' par un processeur de ''shader'' un peu limité. Un point est que le processeur acceptait de calculer des adresses de texture dans le ''pixel shader''. Avant, les adresses des texels à lire étaient fournis par l'unité de rastérisation et basta. L'avantage est que certains effets graphiques étaient devenus possibles : du ''bump-mapping'' avancé, des textures procédurales, de l'éclairage par pixel anisotrope, du éclairage de Phong réel, etc.

Avec la Radeon 8500, le ''pixel shader'' pouvait calculer des adresses, et lire les texels associés à ces adresses calculées. Les ''pixel shaders'' pouvaient lire 6 textures, faire 8 opérations sur les texels lus, puis lire 6 textures avec les adresses calculées à l'étape précédente, et refaire 8 opérations. Quelque chose de limité, donc, mais déjà plus pratique. Les ''pixel shaders'' de ce type ont été standardisé dans Direct X 8.1, sous le nom de ''pixel shaders 1.4''. Encore une fois, le hardware a forcé l'intégration dans une API 3D.

===Les ''shaders'' de Direct X 9.0 : de vrais ''pixel shaders''===

Avec Direct X 9.0, les ''shaders'' sont devenus de vrais programmes, sans les limitations des ''shaders'' précédents. Les ''pixels shaders'' sont passés à la version 2.0, idem pour les ''vertex shaders''. Concrètement, ils sont maintenant exécutés par un processeur de ''shader'' dédié, aux fonctionnalités bien supérieures à celles des ''registers combiners''. Les ''shaders'' pouvaient exécuter une suite d'opérations arbitraire, dans le sens où elle n'était pas structurée avec tel type d'opération au début, suivie par un accès aux textures, etc. On pouvait mettre n'importe quelle opération dans n'importe quel ordre.

De plus, les ''shaders'' ne sont plus écrit en assembleur comme c'était le cas avant. Ils sont dorénavant écrits dans un langage de haut-niveau, le HLSL pour les shaders Direct X et le GLSL pour les shaders Open Gl. Les ''shaders'' sont ensuite traduit (compilés) en instructions machines compréhensibles par la carte graphique. Au début, ces langages et la carte graphique supportaient uniquement des opérations simples. Mais au fil du temps, les spécifications de ces langages sont devenues de plus en plus riches à chaque version de Direct X ou d'Open Gl, et le matériel en a fait autant.

[[File:Architecture de base d'une carte 3D - 5.png|centre|vignette|upright=1.5|Carte 3D avec pixels et vertex shaders non-unifiés.]]

===L'après Direct X 9.0===

Avant Direct X 10, les processeurs de ''shaders'' ne géraient pas exactement les mêmes opérations pour les processeurs de ''vertex shader'' et de ''pixel shader''. Les processeurs de ''vertex shader'' et de ''pixel shader''étaient séparés. Depuis DirectX 10, ce n'est plus le cas : le jeu d'instructions a été unifié entre les vertex shaders et les pixels shaders, ce qui fait qu'il n'y a plus de distinction entre processeurs de vertex shaders et de pixels shaders, chaque processeur pouvant traiter indifféremment l'un ou l'autre. 

[[File:Architecture de base d'une carte 3D - 6.png|centre|vignette|upright=1.5|Architecture de la GeForce 6800.]]

Avec Direct X 10, de nombreux autres ''shaders'' sont apparus. Les plus liés au rendu 3D sont les '''''geometry shader''''' pour ceux qui manipulent des triangles, de ''hull shaders'' et de ''domain shaders'' pour la tesselation. De plus, les cartes graphiques modernes sont capables d’exécuter des programmes informatiques qui n'ont aucun lien avec le rendu 3D, mais sont exécutés par la carte graphique comme le ferait un processeur d'ordinateur normal. De tels ''shaders'' sans lien avec le rendu 3D sont appelés des ''compute shader''.

==Les cartes graphiques d'aujourd'hui==

Avec l'arrivée des shaders, les circuits d'une carte graphique sont divisés en deux catégories : d'un côté les circuits non-programmables et de l'autre les circuits programmables. Pour exécuter les ''shaders'', la carte graphique incorpore des '''processeurs de ''shaders''''', des processeurs similaires aux processeurs des ordinateurs, aux CPU, mais avec quelques petites différences qu'on expliquera dans le prochain chapitre. A côté des processeurs de ''shaders'', il reste quelques circuits non(programmables appelés des circuits fixes. De nos jours, la gestion de la géométrie et des pixels est programmable, mais la rastérisation, le placage de texture, le ''culling'' et l'enregistrement du ''framebuffer'' ne l'est pas. Il n'en a pas toujours été ainsi.

[[File:3D-Pipeline.svg|centre|vignette|upright=3.0|Pipeline 3D : ce qui est programmable et ce qui ne l'est pas dans une carte graphique moderne.]]

===Les GPU modernes sont un mélange de processeurs et de circuits fixes===

Une carte graphique contient donc un mélange de circuits fixes et de processeurs de ''shaders'', qui peut sembler contradictoire. Pourquoi ne pas tout rendre programmable ? Ou au contraire, utiliser seulement des circuits fixes ? La réponse rapide est qu'il s'agit d'un compromis entre flexibilité et performance qui permet d'avoir le meilleur des deux mondes. Mais ce compromis a fortement évolué dans le temps, comme on va le voir plus bas.

Rendre la gestion de la géométrie ou des pixels programmable permet d'implémenter facilement un grand nombre d'effets graphiques sans avoir à les implémenter en hardware. Avant les ''shaders'', seul le hardware récent gérait les dernières fonctionnalités. Les effets graphiques derniers cri n'étaient disponibles que sur les derniers modèles de carte graphique. Avec des ''vertex/pixel shaders'', ce genre de défaut est passé à la trappe. Si un nouvel algorithme de rendu graphique est inventé, il peut être utilisé dès le lendemain sur toutes les cartes graphiques modernes. De plus, implémenter beaucoup d'algorithmes d'éclairage différents est difficile. Le cout en termes de transistors et de complexité était assez important, utiliser des circuits programmable a un cout en hardware plus limité.

Tout cela est à l'exact opposé de ce qu'on a avec les autres circuits, comme les circuits pour la rastérisation ou le placage de texture. Il n'y a pas 36 façons de rastériser une scène 3D et la flexibilité n'est pas un besoin important pour cette opération, alors que les performances sont cruciales. Même chose pour le placage/filtrage de textures. En conséquences, les unités de transformation, de rastérisation et de placage de texture sont toutes implémentées en matériel. Faire ainsi permet de gagner en performance sans que cela ait le moindre impact pour le programmeur.

===Les unités de texture sont intégrées aux processeurs de shaders===

Les unités de textures sont à part des autres circuits fixes, dans le sens où ce sont les seuls à être implémentés dans les processeurs de shaders. Sur les anciennes cartes 3D, les unités de textures étaient des circuits séparés des autres. Mais avec l'arrivée des processeurs de shaders, elles ont été intégrée dans les processeurs de shaders eux-mêmes. Pour comprendre pourquoi, il faut faire un rappel sur ce qu'il y a dans un processeur. Un processeur contient globalement quatre circuits :
* une unité de calcul qui fait des calculs ;
* des registres pour stocker les opérandes et résultats des calculs ;
* une unité de communication avec la mémoire ;
* et un séquenceur, un circuit de contrôle qui commande les autres.

L'unité de communication avec la mémoire sert à lire ou écrire des données, à les transférer de la RAM vers les registres, ou l'inverse. Lire une donnée demande d'envoyer son adresse à la RAM, qui répond en envoyant la donnée lue. Elle est donc toute indiquée pour lire une texture : lire une texture n'est qu'un cas particulier de lecture de données. Les texels à lire sont à une adresse précise, la RAM répond à la lecture avec le texel demandé. Il est donc possible d'utiliser l'unité de communication avec la mémoire comme si c'était une unité de texture.

Cependant, les textures ne sont pas utilisées comme telles de nos jours. Le rendu 3D moderne utilise des techniques dites de filtrage de texture, qui permettent d'améliorer la qualité du rendu des textures. Sans ce filtrage de texture, les textures appliquées naïvement donnent un résultat assez pixelisé et assez moche, pour des raisons assez techniques. Le filtrage élimine ces artefacts, en utilisant une forme d'''antialiasing'' interne aux textures, le fameux filtrage de texture.

Le filtrage de texture peut être réalisé en logiciel ou en matériel. Techniquement, il est possible de le faire dans un ''shader'' : le ''shader'' calcule les adresses des texels à lire, lit plusieurs texels, et effectue ensuite le filtrage. En soi, rien d'impossible. Mais le filtrage de texture est toujours effectué directement en matériel. Les processeurs de shaders incorporent des circuits de filtrage de texture, dans l'unité de texture.

Pour simplifier l'implémentation, les processeurs de ''shader'' modernes disposent d'une unité d'accès mémoire séparée de l'unité de texture. L'unité d'accès mémoire normale s'occupe des accès mémoire hors-textures, alors que l'unité mémoire s'occupe de lire les textures. L'unité de texture contient de quoi faire du filtrage de texture, mais aussi faire des calculs d'adresse spécialisées, intrinsèquement liés au format des textures, qu'on détaillera dans le chapitre sur les textures. En comparaison, les unités d'accès mémoire effectuent des calculs d'adresse plus basiques. Un dernier avantage est que l'unité de texture est reliée au cache de texture, alors que l'unité d'accès mémoire est relié au cache L1/L2.

La raison est que le filtrage de texture est une opération très simple à implémenter en hardware, qui demande assez peu de circuits. Le filtrage bilinéaire ou trilinéaire demande juste des circuits d'interpolation et quelques registres, ce qui est trivial. Et la seconde raison est qu'il n'y a pas 36 façons de filtrer des textures : une carte graphique peut implémenter les algorithmes principaux existants en assez peu de circuits.

: Il faut noter que les ROPs peuvent aussi être intégré dans les processeurs de ''shader'', mais c'est assez rare. Les cartes graphiques pour PC ont des ROPs séparés des processeurs de ''shaders''. Par contre, quelques cartes graphiques destinées les smartphones et autres appareils mobiles font exception. Sur celles-ci, les unités de textures et les ROPs sont intégrés dans les processeurs de ''shaders'', aux côtés de l'unité d'accès mémoire LOAD/STORE. Il s'agit de cartes graphiques en rendu à tuiles.

{{NavChapitre | book=Les cartes graphiques
           | prev=Les cartes graphiques : architecture de base
           | prevText=Les cartes graphiques : architecture de base
           | next=Les processeurs de shaders
           | nextText=Les processeurs de shaders
}}
{{autocat}}</text>
      <sha1>a17i0s6rz2k3npkd97f0i32coxa71yv</sha1>
    </revision>
  </page>
  <page>
    <title>Fonctionnement d'un ordinateur/Les mémoires historiques</title>
    <ns>0</ns>
    <id>69063</id>
    <revision>
      <id>744178</id>
      <parentid>729386</parentid>
      <timestamp>2025-06-05T17:40:44Z</timestamp>
      <contributor>
        <username>Mewtow</username>
        <id>31375</id>
      </contributor>
      <minor />
      <comment>/* Les tambours magnétiques */</comment>
      <origin>744178</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="26199" sha1="m7qs12zz8hj8fna3phbjd6z6z7vw8di" xml:space="preserve">Au tout début de l'informatique, les mémoires étaient totalement différentes d'aujourd'hui. Il n'y avait pas de mémoire ROM, de mémoire RAM, ou quoique ce soit d'autres. Les premières mémoires n'étaient pas électroniques, la technologie n'étant pas assez avancée pour cela. On parle d'un temps où les transistors n'existaient pas et où l'informatique était en pleine gestation. Pourtant, les mémoires existaient déjà.

L'électronique analogique avait déjà des supports de stockage : les lecteurs audio utilisaient des cassettes audio à bande magnétiques, les lecteurs vidéo utilisaient des cassettes VHS elles aussi basées sur des bandes magnétiques, et j'en passe. Une partie de ces supports de stockage ont été réutilisés, puis adaptés pour les ordinateurs de l'époque. En conséquence, les premières mémoires informatiques étaient des mémoires magnétiques, bien plus rudimentaires que les disques durs et les disquettes : mémoires à tores de ferrite, bandes magnétiques, et bien d'autres (cassettes audio, notamment). D'autres mémoires historiques étaient des mémoires mécaniques, qui stockaient leurs informations sous la forme de trous dans une carte en plastique, d'ondes sonores, etc.

Ces mémoires, aujourd'hui totalement obsolètes, ont pourtant eu leur heure de gloire, certaines étant plus utilisées que les mémoires magnétiques ou électroniques de leur époque. Ce chapitre se propose de rendre hommage à ces mémoires historiques. Toutes les mémoires que nous allons aborder sont aujourd'hui obsolètes et la plupart ne sont même plus produites du tout. On peut encore en trouver dans des musées, mais leur utilisation réelle est réduite à peau de chagrin.

==Les cartes et rubans perforés==

Les toutes premières mémoires informatiques étaient des mémoires mécaniques. Les mémoires mécaniques les plus connues étaient basées sur du papier : je veux parler des '''cartes et rubans perforés'''. Il s'agit de cartes ou de rubans de papier, parfois de carton ou de plastiques. Les données sont stockées sous la forme de trous dans le ruban ou la carte : un trou code un 1, tandis que l'absence d'un trou code un 0.

[[File:2punchCards.jpg|centre|vignette|Carte perforée.]]

==Les bandes magnétiques==

[[File:Digital pdp8-e.jpg|vignette|Ordinateur Digital PDP-8, avec ses bandes magnétiques visibles.]]

De vieux ordinateurs utilisaient des cassettes à bande magnétique, les mêmes qui étaient utilisées comme cassettes audio il y a de cela quelques décennies. C'était le cas de vieux ordinateurs personnels, comme les Amstrad CPC, les ZX Spectrum, ou les ordinateurs Commodore.

[[File:Amstrad CPC 464 computer at Play Expo 2013.JPG|centre|vignette|Ordinateur personnel Amstrad CPC 464.]]

D'autres ordinateurs de la même époque utilisaient des supports de stockage similaires aux cassettes audio, mais sans le plastique extérieur. Des bandes magnétiques étaient enroulées dans un cylindre plastique, et étaient déroulées par un système de déroulement.

==Les tambours magnétiques==

[[File:ERA Magnetic Drum, US, c. 1951 - Computer History Museum - Mountain View, California.jpg|vignette|ERA Magnetic Drum, US, c. 1951 - Computer History Museum - Mountain View, California]]

Les '''tambours magnétiques''' sont les ancêtres du disque durs, les deux ayant un fonctionnement assez similaire. La différence principale est que les plateaux sont remplacés par un tube cylindrique, dont la surface est couverte d'un matériau magnétique. L'organisation en pistes est toujours présente, chaque piste étant une ligne horizontale sur le tube central. Par contre, il n'y a pas de tête de lecture/écriture qui se déplace de piste en piste. Les têtes de lecture/écriture sont immobiles, mais il y en a une par piste pour compenser. Le temps de latence d'un tel disque dépend donc uniquement de la vitesse de rotation et de la densité surfacique.

Fait surprenant, les tambours magnétiques étaient utilisés comme mémoire primaire, c'est à dire qu'elles avaient la même fonction que la mémoire RAM des PC actuels, malgré leur caractère non-volatile ! De nombreux ordinateurs de l'époque exécutaient des programmes directement depuis le tambour magnétique. Les instructions étaient mémorisées sur le tambour magnétique, étaient copiées dans un registre d'instruction, puis exécutées. Pour garder des performances correctes, la répartition des instructions dans les secteurs devait être optimisée. Les programmeurs ayant travaillé, par exemple sur l'IBM 650, devaient prendre en compte la manière dont les instructions étaient placées dans et entre les secteurs pour éviter des pertes de performance. 

Les tambours magnétiques étaient aussi utilisées comme mémoire de masse, mais c'était une utilisation moins fréquente. Les tambours magnétiques avaient cependant une méthode d'adressage différente selon qu'ils étaient utilisées comme mémoire de masse ou primaire. Les tambours utilisées comme mémoire primaire avaient une adresse par mot mémoire, alors que celles utilisées comme mémoire de masse avaient une adresse par secteur ou par piste. La méthode d'adressage variait suivant le tambour.
* Sur certains tambours, chaque piste avait sa propre adresse mémoire. Les pistes étaient de taille variable suivant la marque du tambour magnétique utilisé, mais chacune avait sa propre adresse.
* Sur d'autres, chaque piste était découpée en secteurs de taille fixe, comme sur les disques durs, et chaque secteur était adressé en précisant le numéro de piste et un numéro de secteur (similaire à l'adressage CHS des disques durs, en enlevant les plateaux).
* Sur d'autres, les secteurs avaient une taille variable, l'adressage se faisait en indiquant le numéro de la piste et la position du secteur dans la piste.
* D'autres mémoires utilisaient des systèmes d'adressages différents.

==Les mémoires à tore de ferrite==

Les premières mémoires de masse sont sans conteste les '''mémoires à tores de ferrites'''. Ce sont des mémoires magnétiques, un peu comme les disques durs, même si les différences sont nombreuses. Elles sont donc naturellement non-volatiles. Elles sont formées d'une matrice de tores fabriqués dans un matériau magnétique (ferromagnétique pour être précis), le plus souvent de la ferrite. Ces tores peuvent être magnétisés dans deux sens différents, ce qui leur permet de coder un bit.

[[File:KL CoreMemory Macro.jpg|centre|vignette|Mémoire à tores de ferrite réelle (avec les fils).]]

===Le fonctionnement d'une mémoire à tore de ferrite===

L'ensemble formait une sorte de tableau où chaque tore a deux positions : une position X et une autre position Y. Deux fils servent pour l'adressage : le fil Y traverse tous les tores d'une ligne, alors que le fil X traverse tous les tores placés sur la même colonne. Quand une tension est envoyée sur un fil Y et un fil X, le tore à l'intersection des deux fils est activé : il peut alors être lu ou écrit. Plus précisément, chaque fil est parcouru par une tension légèrement supérieure à la moitié de la tension nécessaire pour aimanter le tore : ainsi, la somme des deux tensions est supérieure à la tension d'aimantation, mais seulement à l'intersection des deux fils, sur le tore à aimanter. Selon la tension envoyée (plus précisément, son signe), le tore sera mis à 0 ou à 1.

[[File:Coincident-current magnetic core.svg|centre|vignette|Schéma de la matrice de tores (avec les fils).]]

Pour lire ou écrire un bit dans un tore (en changer l'aimantation), il faut que celui-ci soit soumis à un champ magnétique supérieur à une valeur déterminée. pour cela, chaque tore est parcouru par quatre fils : le fil X et Y servent pour l'adressage, comme dit plus haut, un fil S (''Sense'') pour les lectures, et un fil Z pour les écritures. En faisant passer un courant ou une tension dans ces fils, un champ magnétique se forme autour d'eux, ce qui agit sur les tores de ferrites ce qui permet de les aimanter (écriture) ou de lire leur contenu.

[[File:Single coincident-current magnetic core.svg|centre|vignette|Un tore de ferrite.]]

La lecture s'effectue via le fil nommé ''Sense''. Toute lecture est destructrice : le bit stocké dans le tore est effacé après chaque lecture. En effet, chaque lecture commence par mettre à zéro le bit à lire. Cette mise à zéro va ou non, faire changer le champ magnétique dans le fil ''Sense'', entrainant l'apparition d'un courant et d'une tension. Suite à cette mise à zéro, la mémoire regarde ce qui se passe sur ce fil. Si le bit était déjà à zéro avant la lecture, aucun champ magnétique ne sera créé : il ne se passe rien sur le fil ''Sense''. Mais si ce bit était à 1, le tore va changer de polarité, entrainant l'apparition d'une tension sur ce fil, durant un temps très bref (le temps de changement de polarité du tore). La lecture s'effectue donc via le fil ''Sense'', suivant ce qui s'y passe lors d'une mise à zéro d'un bit.

L'écriture s'effectue d'une manière différente, quoique similaire, en utilisant le fil ''Z''. Lors d'une écriture d'un tore, les fils X et Y qui correspondent sont alimentés en tension, de telle manière qu'un 1 soit écrit dans le tore. Pour écrire un 1, cela suffit largement. Mais pour écrire un zéro, il faut que quelque chose annule cette écriture, en compensant le champ magnétique créé par ces deux fils. Pour cela, on fait passer un courant dans le fil ''Inhibit'', afin de créer un champ magnétique contraire dans le tore. Cela annule l'écriture du 1 en inhibant le champ crée par les fils X et Y. La plupart des mémoires de ce type utilisaient deux fils ''Sense'' et ''Inhibit'' séparés. Mais vu que le fil ''Inhibit'' et ''Sense'' ne sont jamais utilisés en même temps, certaines mémoires à tore ont fusionné ces deux fils en un seul.

===Une mémoire très fiable===

Les mémoires à tore de ferrite sont des mémoires non-volatiles très fiables. Elles ne s'effacent pas dans le temps et peuvent supporter des conditions très dures sans perdre de données. Par exemple, elles peuvent résister à des radiations extrêmes , voire à une EMP, sans perdre de données. C'est pour cette raison qu'elles ont beaucoup été utilisées dans des applications aérospatiales, dans l'industrie, voire dans les applications militaires. Elles étaient encore utilisées dans ces applications bien après l'apparition des premières mémoires à semi-conducteurs.

Par contre, ces mémoires étaient très sensibles à la température. Les tensions à envoyer aux tores devaient avoir une valeur bien précise, qui dépend énormément de la température ambiante. Sur les premières mémoires à tore de ferrite, les circuits de contrôle de la mémoire contenaient un senseur de température et ajustaient les tensions appliquées en fonction des mesures. Une autre solution consistait à placer la mémoire dans une petite boite dont la température était maintenue stable. Généralement, la boite était chauffée au-dessus de la température ambiante, car maintenir une température constante est facile quand celle-ci est plus élevée que la normale. Chauffer une petite chambre est plus simple que de la refroidir, surtout pour une petite boite. Autant une simple résistance permet de chauffer la boite, autant utiliser un réfrigérateur pour une mémoire de ce type était clairement une mauvaise solution.

Le défaut principal de ces mémoires est que leur processus de fabrication est difficile à industrialiser. La fabrication de ces mémoires s'est surtout fait de main d'homme, sans machines ou du moins avec peu d'outils. Le fait que ces mémoires ne puisse pas facilement être fabriquées par des machines fait que ces mémoires sont difficiles à miniaturiser : la miniaturisation ne va pas aussi loin que pour les mémoires à semi-conducteurs et on peut tout au plus stocker quelques centaines de bits sur une puce, voire quelques milliers. La capacité de telles mémoire est généralement assez faible. Par contre, leurs performances étaient assez honorables. On estime que les premières mémoires de ce type avaient un temps d'accès mémoire d'environ 6 µs, ce qui fait une fréquence d'environ 166.7 kilohertz. Le temps d'accès est ensuite descendu à 0.6 µs durant les années 70, ce qui faisait une fréquence proche du mégahertz.

[[File:Ferrite core memory.jpg|centre|vignette|upright=1.5|Mémoire à tore Ferrite miniaturisée. La puce fait 10 centimètres de coté et contient 64 mots de 64 bits, soit 4 kikioctets.]]

==Les mémoires à ligne de délai==

Les '''mémoires à ligne de délai''' sont des mémoires volatiles mécaniques, basées sur des ondes sonores ! Celles-ci ont été inventées suite à des technologies liées aux radars, dans les laboratoires militaires. Ces mémoires sont des mémoires séquentielles, qui ont une capacité extrêmement faible (quelques centaines de bits). Il en existe diverses versions, la première étant basée sur des tubes de mercure, les suivantes étant basées sur des tubes de cuivre ou d'autre matériaux magnétiques.

===L'intérieur d'une mémoire à ligne de délai===

Ces mémoires sont basées sur un tube de matière, dans lequel se propage une onde sonore : celui-ci sert de support de mémorisation. Un bit est codé par l'absence ou la présence d'une onde sonore dans le tube de matière. Au bout de ce tube, on trouve un microphone et un haut-parleur. Le haut-parleur génère une onde sonore d'un côté du tube, onde qui est reçue de l'autre côté du tube par le microphone. De plus, le haut-parleur et le microphone sont reliés entre eux : le signal capté sur le microphone est envoyé sur le haut-parleur d'entrée. Ce faisant, l'onde sonore circule en boucle dans le circuit : elle est rafraichie sans cesse, à chaque passage.

[[File:Delay line memory fr.svg|centre|vignette|upright=2.0|Mémoire à ligne de délai.]]

Divers circuits sont présents entre le microphone et le haut-parleur. On trouve notamment des amplificateurs, histoire que les ondes sonores captées ne s'amenuisent pas à force de reparcourir le tube.

[[File:SEACComputer 010.jpg|centre|vignette|upright=2.0|Mémoire à tube de mercure.]]

===La capacité des mémoires à ligne de délai===

Il existe naturellement un petit délai de transmission entre le microphone et le haut-parleur, ainsi qu'un autre délai de propagation dans le tube. Ces délais limitent la capacité de la mémoire, qui dépend du nombre d'ondes sonores qui peuvent parcourir le tube. Chaque bit est codée exactement par une impulsion sonore, qui a une forme et une durée très précise, qui dépend de la qualité du circuit (microphone, haut-parleur, et autres) : notons ce temps &lt;math&gt;\Tau&lt;/math&gt;. La capacité totale est, par définition, égale au nombre d'impulsions qui se trouvent en même temps dans le tube de matière (les unes à la suite des autres). Pour la calculer, on peut diviser le temps que met une impulsion à se propager dans le tube, par la durée d'une impulsion.

===Les différents types de mémoires à lignes de délai===

Les premières mémoires de ce type étaient fabriquées avec des tubes de mercure : ce sont des '''lignes à délai de mercure'''.

[[File:Mercury memory.jpg|centre|vignette|SEAC Computer, avec une mémoire à ligne de Mercure.]]

Mais les inconvénients du mercure (toxicité, notamment) ont mené au remplacement du mercure par des tubes de matériaux conducteurs (des fils électriques, dit autrement) : ce sont des '''lignes de délai à torsion de fil'''.

[[File:Torsion wire delay line.jpg|centre|vignette|Exemple de ligne de délai à torsion de fil.]]

==Les tubes Williams et Selectron==

Les '''tubes ''Williams''''' et '''Selectron''' sont basés sur un écran CRT modifié. Il s'agissait de mémoires de type mémoires vives volatiles qui devaient être rafraichies régulièrement. En clair, ce sont l'ancêtre des mémoires DRAM ! Les ''tubes Williams'' étaient utilisés sur les tout premiers ordinateurs, au tout début de l'histoire de l'informatique, dans les années 50, à une époque où les ordinateurs étaient des monstres qui occupaient une pièce entière et étaient plus proches de petites usines à calcul qu'autre chose. Une technologie alternative basée sur un principe simialire est le ''Tube Selectron''. D'une capacité de 256 bits, il n'a été utilisé que sur un seul ordinateur : le JOHNNIAC de la RAND Corporation. Ils ont tous deux était rapidement remplacé par les mémoires à ligne de délai, plus simples et moins chères.

[[File:Williams-tube.jpg|centre|vignette|upright=2|Williams-tube]]

===Les écrans CRT (''Cathode Ray Tube'')===

Tubes Williams et Selectron se basent sur la même technologie : celle des écrans CRT. Un écran CRT est composé de plusieurs composants, qui marchent de concert : un canon à électron, des bobines de contrôle et la surface de l'écran proprement dite. Le canon à électron émet un faisceau d'électron concentré, qui touche la surface de l'écran. Cette dernière, du moins derrière la vitre transparente, est d'une composition chimique particulière et est notamment riche en phosphore. Elle est souvent appelée ''surface phosphorescente''. Quand elle est touchée par le faisceau d’électron, le phosphore s'illumine pendant quelques millisecondes. Les bobines visent à détourner le faisceau d'électron de manière à ce qu'il balaye tout l'écran de gauche à droite et de haut en bas.

[[File:Cathode ray tube fr.svg|centre|vignette|upright=2|Cathode ray tube.]]

La surface de l'écran est découpée en pixels, et l'intensité du canon varie pour chaque pixel lorsque le faisceau passe sur ce pixelde  l'écran. En commandant l'intensité du canon d'électron, on arrive à afficher des images en noir et blanc ainsi. Un canon intense pendant x millisecondes donnera un point blanc sur l'écran, là où tombe de faisceau. un canon éteint donnera un point noir à l'écran. Il est possible de gérer la couleurs avec des écrans CRT plus complexes, mais ce n'est pas le sujet et nous n'en avons pas besoin pour les explications qui vont suivre.

====La physique de la surface phosphorescente : émission secondaire et puits de potentiels====

Un point important est que la physique de la surface phosphorescente n'est pas intuitive et peu donner lieu à des phénomènes assez importants pour ce qui va suivre. Deux d'entre eu vont nous intéresser.

Le premier est que les électrons émis par le canaux à électrons frappent la surface phosphorescente, l'illuminent, mais qu'il arrive que des électrons soient piégés dans la surface, à l'endroit de l'impact. En conséquence, une petite charge électrique s'accumule progressivement à chaque passage du faisceau, dans chaque pixel. Les électrons ne restent pas en place de manière permanente, ils finissent par s'échapper après un certain temps, ce qui fait que la charge finit par s'atténuer, mais elle peut durer quelques secondes sur les CRT conçus pour exploiter cet effet au mieux.

Le second phénomène est l''''émission secondaire'''. Quand l'énergie du faisceau à électron est trop forte, les électrons naturellement présents dans les atomes du matériau phosphorescent sont dégagés. Les électrons éjectés deviennent alors des électrons libres qui vont allumer les zones alentours, ce qui perturbe l'affichage. Et cela arrive lors que la zone frappée par le faisceau a perdu des électrons et ne s'allume plus. Le résultat est que si une image était affichée sur l'écran auparavant, utiliser un faisceau trop fort l'efface totalement via émission secondaire. Il s'agit là d'un défaut à éviter sur les écrans d'affichage, mais c'est ce phénomène qui est utilisé sur les mémoires à tubes de stockage.

====Les CRT rémanents====

Il existe des écrans CRT conçus pour afficher des images sur une longue durée de temps, et pas seulement pour un 50ème ou 60ème de seconde. Ils sont appelés des '''écrans rémanents''' ou encore '''''storage tubes''''', ou tubes de stockage. Avec eux, l'image affichée s'efface progressivement et lentement, mais reste visible durant quelques secondes. Pour cela, les écran de stockage sont fabriqués en utilisant un matériau phosphorescent spécial, différent de celui des autres CRT, mais le reste du CRT fonctionne de la même manière. La rémanence est liée au premier phénomène mentionné plus haut, à savoir la capture d'électrons par la surface, mais ce phénoméne est maximisé par l'usage du matériau adéquat. Cette rémanence de quelques secondes fait que l'image a besoin d'être rafraichie moins souvent, comparée à un écran CRT normal. Et les mémoires Selectron et de Williams sont basées sur de tels tubes de stockage.

La rémanence de l'image a de nombreuses applications et est utile quand on n'a pas besoin d'une réactivité importante. Elle était utile dans les radars, dans certains oscilloscopes qui demandent de capturer des évènements très brefs, etc. Quelques écrans d'ordinateur ont tenté d'utiliser ce système, notamment les écrans de la marque Textronix. Ils portent le nom de '''''Direct-view bistable storage tube'''''. L'idée est d'utiliser un écran CRT rémanent pour afficher une image pour éviter de rafraichir l'écran souvent. Mais pour quel l'écran soit réactif et éviter des artefacts graphiques liés à la rémanence, on est obligé d'effacer l'écran avant d'afficher une nouvelle image. Et l'effacement se fait grâce à l'émission secondaire. Pour cela, de tels écrans contenaient deu faisceaux : un faisceau normal pour afficher une image, un autre faisceau très puissant qui déclenche une émission secondaire pour effacer l'écran.

===Les tubes Williams===

[[File:SWAC 003.jpg|vignette|Image affichée par un tube Williams en fonctionnement, sur l'ordinateur SWAC.]]

L'idée derrière les tubes tubes Williams et Selectron est de mémoriser les données sous la forme d'images à l'écran. Un bit à 1 correspond à un pixel allumé/lumineux, un bit à 0 à un pixel éteint/noir. Les écrans de l'époque ne géraient pas la couleur, aussi seul le noir et blanc était disponible (avec les niveaux de gris), ce qui est parfait pour un stockage en binaire. L'image affichée par un écran CRT est affichée ligne par ligne, avec un petit temps de pause entre l'affichage de deux lignes pour repositionner le canon à électron sur le début de la ligne suivante. Par simplicité, sur les tubes Williams, chaque ligne correspond à un mot mémoire, une case mémoire. La taille d'un mot mémoire et le nombre d'adresse dépend donc de la résolution utilisée.

Un tube Williams est composé d'un tube CRT rémanent et d'une plaque de métal placée devant l'écran, et de circuits électroniques annexes. La plaque de métal est collée à l'écran, ce qui fait qu'on ne peut pas voir l'écran proprement dit. Elle sert uniquement lors des lectures et pas pour les écritures. Lors d'une lecture, on mesure la tension sur la plaque, qui dépendra du bit stocké au moment de la lecture. La lecture se fait bit par bit, un par un. Elle est reliée à un circuit amplificateur de tension, qui amplifie la tension mesurée par la plaque. On trouve aussi des circuits pour le contrôle de l'écran CRT, à savoir des registres X et Y pour commander les bobines de défléction, de quoi générer un signal d'horloge, et des circuits électroniques pour gérer les lectures/écritures.

[[File:WilliamsTubeFigure1.tiff|centre|vignette|upright=2|WilliamsTubeFigure1]]

L'écriture et l’effacement de l'image est ce qu'il y a de plus facile : écrire une image utilise un faisceau d’électrons normal qu'on allume ou éteint convenablement lors du balayage de l'écran, l'effacer demande de faire la même chose en utilisant un faisceau très puissant. Un faisceau normal allume le phosphore et le charge pendant un certain temps, alors que l'émission secondaire efface ce qui a été enregistré sur le phosphore.

Pour lire un bit, on envoie un faisceau d'électron sur sa position sur l'écran, dont l'intensité est situé juste en-dessous du seuil pour l'émission secondaire. Si le bit stocké est à 0, l'intensité ne sera pas suffisante pour générer une émission secondaire. Mais si cil stocke un 1, la charge électrique stockée sur la surface phosphorescente va s'additionner à l’intensité du faisceau et déclencher une émission secondaire. L’émission secondaire a déclencher une augmentation local de la tension électrique, que la plaque de métal va capter. Un amplifieur amplifie la tension mesurée sur la plaque, pour en faire une tension capable de coder un 0 ou un 1. Vous remarquerez que la lecture est destructrice, ce qui fait que toute lecture de l'écran est suivie par une écriture pour compenser, comme sur les DRAM.

[[File:Williams tube timing.jpg|centre|vignette|upright=2|Williams tube timing]]

Passons maintenant au rafraichissement mémoire. Il faut rafraichir l'écran pour une raison simple : l'image affichée par l'écran s'efface au bout de quelques millisecondes, quelques secondes, tout dépend du type d'écran utilisé. Le rafraichissement se fait en effectuant une lecture suivie d'une écriture : on récupère le contenu de la mémoire/tube, avant de le réécrire.

Autour de la plaque de métal et du tube CRT, on trouve divers circuits qui gèrent les lectures et écritures. Les lectures et écritures se font bit par bit, on peut masquer certains bits lors des écritures, autoriser ou interdire les lectures/écritures durant un temps, etc.

[[File:SEACComputer 004.jpg|centre|vignette|upright=2|Fonctionnement d'un tube Williams, avec les circuits associés]]

&lt;noinclude&gt;
{{NavChapitre | book=Fonctionnement d'un ordinateur
           | prev=Les sections critiques et le modèle mémoire
           | prevText=Les sections critiques et le modèle mémoire
           | next=Le matériel réseau
           | nextText=Le matériel réseau
}}
&lt;/noinclude&gt;</text>
      <sha1>m7qs12zz8hj8fna3phbjd6z6z7vw8di</sha1>
    </revision>
    <revision>
      <id>744180</id>
      <parentid>744178</parentid>
      <timestamp>2025-06-05T17:52:53Z</timestamp>
      <contributor>
        <username>Mewtow</username>
        <id>31375</id>
      </contributor>
      <minor />
      <comment>/* Les tambours magnétiques */</comment>
      <origin>744180</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="27049" sha1="m4cmxboi5vcbwxi5ll0ji9nxw45ejau" xml:space="preserve">Au tout début de l'informatique, les mémoires étaient totalement différentes d'aujourd'hui. Il n'y avait pas de mémoire ROM, de mémoire RAM, ou quoique ce soit d'autres. Les premières mémoires n'étaient pas électroniques, la technologie n'étant pas assez avancée pour cela. On parle d'un temps où les transistors n'existaient pas et où l'informatique était en pleine gestation. Pourtant, les mémoires existaient déjà.

L'électronique analogique avait déjà des supports de stockage : les lecteurs audio utilisaient des cassettes audio à bande magnétiques, les lecteurs vidéo utilisaient des cassettes VHS elles aussi basées sur des bandes magnétiques, et j'en passe. Une partie de ces supports de stockage ont été réutilisés, puis adaptés pour les ordinateurs de l'époque. En conséquence, les premières mémoires informatiques étaient des mémoires magnétiques, bien plus rudimentaires que les disques durs et les disquettes : mémoires à tores de ferrite, bandes magnétiques, et bien d'autres (cassettes audio, notamment). D'autres mémoires historiques étaient des mémoires mécaniques, qui stockaient leurs informations sous la forme de trous dans une carte en plastique, d'ondes sonores, etc.

Ces mémoires, aujourd'hui totalement obsolètes, ont pourtant eu leur heure de gloire, certaines étant plus utilisées que les mémoires magnétiques ou électroniques de leur époque. Ce chapitre se propose de rendre hommage à ces mémoires historiques. Toutes les mémoires que nous allons aborder sont aujourd'hui obsolètes et la plupart ne sont même plus produites du tout. On peut encore en trouver dans des musées, mais leur utilisation réelle est réduite à peau de chagrin.

==Les cartes et rubans perforés==

Les toutes premières mémoires informatiques étaient des mémoires mécaniques. Les mémoires mécaniques les plus connues étaient basées sur du papier : je veux parler des '''cartes et rubans perforés'''. Il s'agit de cartes ou de rubans de papier, parfois de carton ou de plastiques. Les données sont stockées sous la forme de trous dans le ruban ou la carte : un trou code un 1, tandis que l'absence d'un trou code un 0.

[[File:2punchCards.jpg|centre|vignette|Carte perforée.]]

==Les bandes magnétiques==

[[File:Digital pdp8-e.jpg|vignette|Ordinateur Digital PDP-8, avec ses bandes magnétiques visibles.]]

De vieux ordinateurs utilisaient des cassettes à bande magnétique, les mêmes qui étaient utilisées comme cassettes audio il y a de cela quelques décennies. C'était le cas de vieux ordinateurs personnels, comme les Amstrad CPC, les ZX Spectrum, ou les ordinateurs Commodore.

[[File:Amstrad CPC 464 computer at Play Expo 2013.JPG|centre|vignette|Ordinateur personnel Amstrad CPC 464.]]

D'autres ordinateurs de la même époque utilisaient des supports de stockage similaires aux cassettes audio, mais sans le plastique extérieur. Des bandes magnétiques étaient enroulées dans un cylindre plastique, et étaient déroulées par un système de déroulement.

==Les tambours magnétiques==

[[File:ERA Magnetic Drum, US, c. 1951 - Computer History Museum - Mountain View, California.jpg|vignette|ERA Magnetic Drum, US, c. 1951 - Computer History Museum - Mountain View, California]]

Les '''tambours magnétiques''' sont les ancêtres du disque durs, les deux ayant un fonctionnement assez similaire. La différence principale est que les plateaux sont remplacés par un tube cylindrique, dont la surface est couverte d'un matériau magnétique. L'organisation en pistes est toujours présente, chaque piste étant une ligne horizontale sur le tube central. Par contre, il n'y a pas de tête de lecture/écriture qui se déplace de piste en piste. Les têtes de lecture/écriture sont immobiles, mais il y en a une par piste pour compenser. Le temps de latence d'un tel disque dépend donc uniquement de la vitesse de rotation et de la densité surfacique.

===Les tambours magnétiques étaient des mémoires primaires===

Fait surprenant, les tambours magnétiques étaient utilisés comme mémoire primaire, c'est à dire qu'elles avaient la même fonction que la mémoire RAM des PC actuels, malgré leur caractère non-volatile ! Les tambours magnétiques étaient aussi utilisées comme mémoire de masse, mais c'était une utilisation moins fréquente.

De nombreux ordinateurs de l'époque exécutaient des programmes directement depuis le tambour magnétique. Les instructions étaient mémorisées sur le tambour magnétique, étaient copiées dans un registre d'instruction, puis exécutées. Pour garder des performances correctes, la répartition des instructions dans les secteurs devait être optimisée. Les programmeurs ayant travaillé, par exemple sur l'IBM 650, devaient prendre en compte la manière dont les instructions étaient placées dans et entre les secteurs pour éviter des pertes de performance.

L'ordinateur Bull Gamma 3 intégrait une sorte de cache d'instruction pour accélérer l'exécution des programmes depuis le tambour magnétique. Les instructions étaient stockées sur le tambour par groupes de 48 instructions, appelés des séries. Le processeur est relié à mémoires intermédiaires, appelées des ''Circulating Memories'', chacune contenant une série complète. Pour exécuter une instruction, la série complète était recopiée dans une ''Circulating Memories'', si ce n'est pas déjà fait, puis l'instruction était copiée dans le registre d'instruction. Les ''Circulating Memories'' étaient implémentées avec des mémoires magnéto-résistives à ligne de mercure, qu'on détaillera dans la suite de ce chapitre.

===L'adressage sur un tambour magnétique===

Les tambours magnétiques avaient une méthode d'adressage différente selon qu'ils étaient utilisées comme mémoire de masse ou primaire. Les tambours utilisées comme mémoire primaire avaient une adresse par mot mémoire, alors que celles utilisées comme mémoire de masse avaient une adresse par secteur ou par piste. La méthode d'adressage variait suivant le tambour.
* Sur certains tambours, chaque piste avait sa propre adresse mémoire. Les pistes étaient de taille variable suivant la marque du tambour magnétique utilisé, mais chacune avait sa propre adresse.
* Sur d'autres, chaque piste était découpée en secteurs de taille fixe, comme sur les disques durs, et chaque secteur était adressé en précisant le numéro de piste et un numéro de secteur (similaire à l'adressage CHS des disques durs, en enlevant les plateaux).
* Sur d'autres, les secteurs avaient une taille variable, l'adressage se faisait en indiquant le numéro de la piste et la position du secteur dans la piste.
* D'autres mémoires utilisaient des systèmes d'adressages différents.

==Les mémoires à tore de ferrite==

Les premières mémoires de masse sont sans conteste les '''mémoires à tores de ferrites'''. Ce sont des mémoires magnétiques, un peu comme les disques durs, même si les différences sont nombreuses. Elles sont donc naturellement non-volatiles. Elles sont formées d'une matrice de tores fabriqués dans un matériau magnétique (ferromagnétique pour être précis), le plus souvent de la ferrite. Ces tores peuvent être magnétisés dans deux sens différents, ce qui leur permet de coder un bit.

[[File:KL CoreMemory Macro.jpg|centre|vignette|Mémoire à tores de ferrite réelle (avec les fils).]]

===Le fonctionnement d'une mémoire à tore de ferrite===

L'ensemble formait une sorte de tableau où chaque tore a deux positions : une position X et une autre position Y. Deux fils servent pour l'adressage : le fil Y traverse tous les tores d'une ligne, alors que le fil X traverse tous les tores placés sur la même colonne. Quand une tension est envoyée sur un fil Y et un fil X, le tore à l'intersection des deux fils est activé : il peut alors être lu ou écrit. Plus précisément, chaque fil est parcouru par une tension légèrement supérieure à la moitié de la tension nécessaire pour aimanter le tore : ainsi, la somme des deux tensions est supérieure à la tension d'aimantation, mais seulement à l'intersection des deux fils, sur le tore à aimanter. Selon la tension envoyée (plus précisément, son signe), le tore sera mis à 0 ou à 1.

[[File:Coincident-current magnetic core.svg|centre|vignette|Schéma de la matrice de tores (avec les fils).]]

Pour lire ou écrire un bit dans un tore (en changer l'aimantation), il faut que celui-ci soit soumis à un champ magnétique supérieur à une valeur déterminée. pour cela, chaque tore est parcouru par quatre fils : le fil X et Y servent pour l'adressage, comme dit plus haut, un fil S (''Sense'') pour les lectures, et un fil Z pour les écritures. En faisant passer un courant ou une tension dans ces fils, un champ magnétique se forme autour d'eux, ce qui agit sur les tores de ferrites ce qui permet de les aimanter (écriture) ou de lire leur contenu.

[[File:Single coincident-current magnetic core.svg|centre|vignette|Un tore de ferrite.]]

La lecture s'effectue via le fil nommé ''Sense''. Toute lecture est destructrice : le bit stocké dans le tore est effacé après chaque lecture. En effet, chaque lecture commence par mettre à zéro le bit à lire. Cette mise à zéro va ou non, faire changer le champ magnétique dans le fil ''Sense'', entrainant l'apparition d'un courant et d'une tension. Suite à cette mise à zéro, la mémoire regarde ce qui se passe sur ce fil. Si le bit était déjà à zéro avant la lecture, aucun champ magnétique ne sera créé : il ne se passe rien sur le fil ''Sense''. Mais si ce bit était à 1, le tore va changer de polarité, entrainant l'apparition d'une tension sur ce fil, durant un temps très bref (le temps de changement de polarité du tore). La lecture s'effectue donc via le fil ''Sense'', suivant ce qui s'y passe lors d'une mise à zéro d'un bit.

L'écriture s'effectue d'une manière différente, quoique similaire, en utilisant le fil ''Z''. Lors d'une écriture d'un tore, les fils X et Y qui correspondent sont alimentés en tension, de telle manière qu'un 1 soit écrit dans le tore. Pour écrire un 1, cela suffit largement. Mais pour écrire un zéro, il faut que quelque chose annule cette écriture, en compensant le champ magnétique créé par ces deux fils. Pour cela, on fait passer un courant dans le fil ''Inhibit'', afin de créer un champ magnétique contraire dans le tore. Cela annule l'écriture du 1 en inhibant le champ crée par les fils X et Y. La plupart des mémoires de ce type utilisaient deux fils ''Sense'' et ''Inhibit'' séparés. Mais vu que le fil ''Inhibit'' et ''Sense'' ne sont jamais utilisés en même temps, certaines mémoires à tore ont fusionné ces deux fils en un seul.

===Une mémoire très fiable===

Les mémoires à tore de ferrite sont des mémoires non-volatiles très fiables. Elles ne s'effacent pas dans le temps et peuvent supporter des conditions très dures sans perdre de données. Par exemple, elles peuvent résister à des radiations extrêmes , voire à une EMP, sans perdre de données. C'est pour cette raison qu'elles ont beaucoup été utilisées dans des applications aérospatiales, dans l'industrie, voire dans les applications militaires. Elles étaient encore utilisées dans ces applications bien après l'apparition des premières mémoires à semi-conducteurs.

Par contre, ces mémoires étaient très sensibles à la température. Les tensions à envoyer aux tores devaient avoir une valeur bien précise, qui dépend énormément de la température ambiante. Sur les premières mémoires à tore de ferrite, les circuits de contrôle de la mémoire contenaient un senseur de température et ajustaient les tensions appliquées en fonction des mesures. Une autre solution consistait à placer la mémoire dans une petite boite dont la température était maintenue stable. Généralement, la boite était chauffée au-dessus de la température ambiante, car maintenir une température constante est facile quand celle-ci est plus élevée que la normale. Chauffer une petite chambre est plus simple que de la refroidir, surtout pour une petite boite. Autant une simple résistance permet de chauffer la boite, autant utiliser un réfrigérateur pour une mémoire de ce type était clairement une mauvaise solution.

Le défaut principal de ces mémoires est que leur processus de fabrication est difficile à industrialiser. La fabrication de ces mémoires s'est surtout fait de main d'homme, sans machines ou du moins avec peu d'outils. Le fait que ces mémoires ne puisse pas facilement être fabriquées par des machines fait que ces mémoires sont difficiles à miniaturiser : la miniaturisation ne va pas aussi loin que pour les mémoires à semi-conducteurs et on peut tout au plus stocker quelques centaines de bits sur une puce, voire quelques milliers. La capacité de telles mémoire est généralement assez faible. Par contre, leurs performances étaient assez honorables. On estime que les premières mémoires de ce type avaient un temps d'accès mémoire d'environ 6 µs, ce qui fait une fréquence d'environ 166.7 kilohertz. Le temps d'accès est ensuite descendu à 0.6 µs durant les années 70, ce qui faisait une fréquence proche du mégahertz.

[[File:Ferrite core memory.jpg|centre|vignette|upright=1.5|Mémoire à tore Ferrite miniaturisée. La puce fait 10 centimètres de coté et contient 64 mots de 64 bits, soit 4 kikioctets.]]

==Les mémoires à ligne de délai==

Les '''mémoires à ligne de délai''' sont des mémoires volatiles mécaniques, basées sur des ondes sonores ! Celles-ci ont été inventées suite à des technologies liées aux radars, dans les laboratoires militaires. Ces mémoires sont des mémoires séquentielles, qui ont une capacité extrêmement faible (quelques centaines de bits). Il en existe diverses versions, la première étant basée sur des tubes de mercure, les suivantes étant basées sur des tubes de cuivre ou d'autre matériaux magnétiques.

===L'intérieur d'une mémoire à ligne de délai===

Ces mémoires sont basées sur un tube de matière, dans lequel se propage une onde sonore : celui-ci sert de support de mémorisation. Un bit est codé par l'absence ou la présence d'une onde sonore dans le tube de matière. Au bout de ce tube, on trouve un microphone et un haut-parleur. Le haut-parleur génère une onde sonore d'un côté du tube, onde qui est reçue de l'autre côté du tube par le microphone. De plus, le haut-parleur et le microphone sont reliés entre eux : le signal capté sur le microphone est envoyé sur le haut-parleur d'entrée. Ce faisant, l'onde sonore circule en boucle dans le circuit : elle est rafraichie sans cesse, à chaque passage.

[[File:Delay line memory fr.svg|centre|vignette|upright=2.0|Mémoire à ligne de délai.]]

Divers circuits sont présents entre le microphone et le haut-parleur. On trouve notamment des amplificateurs, histoire que les ondes sonores captées ne s'amenuisent pas à force de reparcourir le tube.

[[File:SEACComputer 010.jpg|centre|vignette|upright=2.0|Mémoire à tube de mercure.]]

===La capacité des mémoires à ligne de délai===

Il existe naturellement un petit délai de transmission entre le microphone et le haut-parleur, ainsi qu'un autre délai de propagation dans le tube. Ces délais limitent la capacité de la mémoire, qui dépend du nombre d'ondes sonores qui peuvent parcourir le tube. Chaque bit est codée exactement par une impulsion sonore, qui a une forme et une durée très précise, qui dépend de la qualité du circuit (microphone, haut-parleur, et autres) : notons ce temps &lt;math&gt;\Tau&lt;/math&gt;. La capacité totale est, par définition, égale au nombre d'impulsions qui se trouvent en même temps dans le tube de matière (les unes à la suite des autres). Pour la calculer, on peut diviser le temps que met une impulsion à se propager dans le tube, par la durée d'une impulsion.

===Les différents types de mémoires à lignes de délai===

Les premières mémoires de ce type étaient fabriquées avec des tubes de mercure : ce sont des '''lignes à délai de mercure'''.

[[File:Mercury memory.jpg|centre|vignette|SEAC Computer, avec une mémoire à ligne de Mercure.]]

Mais les inconvénients du mercure (toxicité, notamment) ont mené au remplacement du mercure par des tubes de matériaux conducteurs (des fils électriques, dit autrement) : ce sont des '''lignes de délai à torsion de fil'''.

[[File:Torsion wire delay line.jpg|centre|vignette|Exemple de ligne de délai à torsion de fil.]]

==Les tubes Williams et Selectron==

Les '''tubes ''Williams''''' et '''Selectron''' sont basés sur un écran CRT modifié. Il s'agissait de mémoires de type mémoires vives volatiles qui devaient être rafraichies régulièrement. En clair, ce sont l'ancêtre des mémoires DRAM ! Les ''tubes Williams'' étaient utilisés sur les tout premiers ordinateurs, au tout début de l'histoire de l'informatique, dans les années 50, à une époque où les ordinateurs étaient des monstres qui occupaient une pièce entière et étaient plus proches de petites usines à calcul qu'autre chose. Une technologie alternative basée sur un principe simialire est le ''Tube Selectron''. D'une capacité de 256 bits, il n'a été utilisé que sur un seul ordinateur : le JOHNNIAC de la RAND Corporation. Ils ont tous deux était rapidement remplacé par les mémoires à ligne de délai, plus simples et moins chères.

[[File:Williams-tube.jpg|centre|vignette|upright=2|Williams-tube]]

===Les écrans CRT (''Cathode Ray Tube'')===

Tubes Williams et Selectron se basent sur la même technologie : celle des écrans CRT. Un écran CRT est composé de plusieurs composants, qui marchent de concert : un canon à électron, des bobines de contrôle et la surface de l'écran proprement dite. Le canon à électron émet un faisceau d'électron concentré, qui touche la surface de l'écran. Cette dernière, du moins derrière la vitre transparente, est d'une composition chimique particulière et est notamment riche en phosphore. Elle est souvent appelée ''surface phosphorescente''. Quand elle est touchée par le faisceau d’électron, le phosphore s'illumine pendant quelques millisecondes. Les bobines visent à détourner le faisceau d'électron de manière à ce qu'il balaye tout l'écran de gauche à droite et de haut en bas.

[[File:Cathode ray tube fr.svg|centre|vignette|upright=2|Cathode ray tube.]]

La surface de l'écran est découpée en pixels, et l'intensité du canon varie pour chaque pixel lorsque le faisceau passe sur ce pixelde  l'écran. En commandant l'intensité du canon d'électron, on arrive à afficher des images en noir et blanc ainsi. Un canon intense pendant x millisecondes donnera un point blanc sur l'écran, là où tombe de faisceau. un canon éteint donnera un point noir à l'écran. Il est possible de gérer la couleurs avec des écrans CRT plus complexes, mais ce n'est pas le sujet et nous n'en avons pas besoin pour les explications qui vont suivre.

====La physique de la surface phosphorescente : émission secondaire et puits de potentiels====

Un point important est que la physique de la surface phosphorescente n'est pas intuitive et peu donner lieu à des phénomènes assez importants pour ce qui va suivre. Deux d'entre eu vont nous intéresser.

Le premier est que les électrons émis par le canaux à électrons frappent la surface phosphorescente, l'illuminent, mais qu'il arrive que des électrons soient piégés dans la surface, à l'endroit de l'impact. En conséquence, une petite charge électrique s'accumule progressivement à chaque passage du faisceau, dans chaque pixel. Les électrons ne restent pas en place de manière permanente, ils finissent par s'échapper après un certain temps, ce qui fait que la charge finit par s'atténuer, mais elle peut durer quelques secondes sur les CRT conçus pour exploiter cet effet au mieux.

Le second phénomène est l''''émission secondaire'''. Quand l'énergie du faisceau à électron est trop forte, les électrons naturellement présents dans les atomes du matériau phosphorescent sont dégagés. Les électrons éjectés deviennent alors des électrons libres qui vont allumer les zones alentours, ce qui perturbe l'affichage. Et cela arrive lors que la zone frappée par le faisceau a perdu des électrons et ne s'allume plus. Le résultat est que si une image était affichée sur l'écran auparavant, utiliser un faisceau trop fort l'efface totalement via émission secondaire. Il s'agit là d'un défaut à éviter sur les écrans d'affichage, mais c'est ce phénomène qui est utilisé sur les mémoires à tubes de stockage.

====Les CRT rémanents====

Il existe des écrans CRT conçus pour afficher des images sur une longue durée de temps, et pas seulement pour un 50ème ou 60ème de seconde. Ils sont appelés des '''écrans rémanents''' ou encore '''''storage tubes''''', ou tubes de stockage. Avec eux, l'image affichée s'efface progressivement et lentement, mais reste visible durant quelques secondes. Pour cela, les écran de stockage sont fabriqués en utilisant un matériau phosphorescent spécial, différent de celui des autres CRT, mais le reste du CRT fonctionne de la même manière. La rémanence est liée au premier phénomène mentionné plus haut, à savoir la capture d'électrons par la surface, mais ce phénoméne est maximisé par l'usage du matériau adéquat. Cette rémanence de quelques secondes fait que l'image a besoin d'être rafraichie moins souvent, comparée à un écran CRT normal. Et les mémoires Selectron et de Williams sont basées sur de tels tubes de stockage.

La rémanence de l'image a de nombreuses applications et est utile quand on n'a pas besoin d'une réactivité importante. Elle était utile dans les radars, dans certains oscilloscopes qui demandent de capturer des évènements très brefs, etc. Quelques écrans d'ordinateur ont tenté d'utiliser ce système, notamment les écrans de la marque Textronix. Ils portent le nom de '''''Direct-view bistable storage tube'''''. L'idée est d'utiliser un écran CRT rémanent pour afficher une image pour éviter de rafraichir l'écran souvent. Mais pour quel l'écran soit réactif et éviter des artefacts graphiques liés à la rémanence, on est obligé d'effacer l'écran avant d'afficher une nouvelle image. Et l'effacement se fait grâce à l'émission secondaire. Pour cela, de tels écrans contenaient deu faisceaux : un faisceau normal pour afficher une image, un autre faisceau très puissant qui déclenche une émission secondaire pour effacer l'écran.

===Les tubes Williams===

[[File:SWAC 003.jpg|vignette|Image affichée par un tube Williams en fonctionnement, sur l'ordinateur SWAC.]]

L'idée derrière les tubes tubes Williams et Selectron est de mémoriser les données sous la forme d'images à l'écran. Un bit à 1 correspond à un pixel allumé/lumineux, un bit à 0 à un pixel éteint/noir. Les écrans de l'époque ne géraient pas la couleur, aussi seul le noir et blanc était disponible (avec les niveaux de gris), ce qui est parfait pour un stockage en binaire. L'image affichée par un écran CRT est affichée ligne par ligne, avec un petit temps de pause entre l'affichage de deux lignes pour repositionner le canon à électron sur le début de la ligne suivante. Par simplicité, sur les tubes Williams, chaque ligne correspond à un mot mémoire, une case mémoire. La taille d'un mot mémoire et le nombre d'adresse dépend donc de la résolution utilisée.

Un tube Williams est composé d'un tube CRT rémanent et d'une plaque de métal placée devant l'écran, et de circuits électroniques annexes. La plaque de métal est collée à l'écran, ce qui fait qu'on ne peut pas voir l'écran proprement dit. Elle sert uniquement lors des lectures et pas pour les écritures. Lors d'une lecture, on mesure la tension sur la plaque, qui dépendra du bit stocké au moment de la lecture. La lecture se fait bit par bit, un par un. Elle est reliée à un circuit amplificateur de tension, qui amplifie la tension mesurée par la plaque. On trouve aussi des circuits pour le contrôle de l'écran CRT, à savoir des registres X et Y pour commander les bobines de défléction, de quoi générer un signal d'horloge, et des circuits électroniques pour gérer les lectures/écritures.

[[File:WilliamsTubeFigure1.tiff|centre|vignette|upright=2|WilliamsTubeFigure1]]

L'écriture et l’effacement de l'image est ce qu'il y a de plus facile : écrire une image utilise un faisceau d’électrons normal qu'on allume ou éteint convenablement lors du balayage de l'écran, l'effacer demande de faire la même chose en utilisant un faisceau très puissant. Un faisceau normal allume le phosphore et le charge pendant un certain temps, alors que l'émission secondaire efface ce qui a été enregistré sur le phosphore.

Pour lire un bit, on envoie un faisceau d'électron sur sa position sur l'écran, dont l'intensité est situé juste en-dessous du seuil pour l'émission secondaire. Si le bit stocké est à 0, l'intensité ne sera pas suffisante pour générer une émission secondaire. Mais si cil stocke un 1, la charge électrique stockée sur la surface phosphorescente va s'additionner à l’intensité du faisceau et déclencher une émission secondaire. L’émission secondaire a déclencher une augmentation local de la tension électrique, que la plaque de métal va capter. Un amplifieur amplifie la tension mesurée sur la plaque, pour en faire une tension capable de coder un 0 ou un 1. Vous remarquerez que la lecture est destructrice, ce qui fait que toute lecture de l'écran est suivie par une écriture pour compenser, comme sur les DRAM.

[[File:Williams tube timing.jpg|centre|vignette|upright=2|Williams tube timing]]

Passons maintenant au rafraichissement mémoire. Il faut rafraichir l'écran pour une raison simple : l'image affichée par l'écran s'efface au bout de quelques millisecondes, quelques secondes, tout dépend du type d'écran utilisé. Le rafraichissement se fait en effectuant une lecture suivie d'une écriture : on récupère le contenu de la mémoire/tube, avant de le réécrire.

Autour de la plaque de métal et du tube CRT, on trouve divers circuits qui gèrent les lectures et écritures. Les lectures et écritures se font bit par bit, on peut masquer certains bits lors des écritures, autoriser ou interdire les lectures/écritures durant un temps, etc.

[[File:SEACComputer 004.jpg|centre|vignette|upright=2|Fonctionnement d'un tube Williams, avec les circuits associés]]

&lt;noinclude&gt;
{{NavChapitre | book=Fonctionnement d'un ordinateur
           | prev=Les sections critiques et le modèle mémoire
           | prevText=Les sections critiques et le modèle mémoire
           | next=Le matériel réseau
           | nextText=Le matériel réseau
}}
&lt;/noinclude&gt;</text>
      <sha1>m4cmxboi5vcbwxi5ll0ji9nxw45ejau</sha1>
    </revision>
    <revision>
      <id>744181</id>
      <parentid>744180</parentid>
      <timestamp>2025-06-05T17:57:53Z</timestamp>
      <contributor>
        <username>Mewtow</username>
        <id>31375</id>
      </contributor>
      <minor />
      <comment>/* Les tambours magnétiques étaient des mémoires primaires */</comment>
      <origin>744181</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="27399" sha1="6misyapxuwobescxhwfbgawop7trchb" xml:space="preserve">Au tout début de l'informatique, les mémoires étaient totalement différentes d'aujourd'hui. Il n'y avait pas de mémoire ROM, de mémoire RAM, ou quoique ce soit d'autres. Les premières mémoires n'étaient pas électroniques, la technologie n'étant pas assez avancée pour cela. On parle d'un temps où les transistors n'existaient pas et où l'informatique était en pleine gestation. Pourtant, les mémoires existaient déjà.

L'électronique analogique avait déjà des supports de stockage : les lecteurs audio utilisaient des cassettes audio à bande magnétiques, les lecteurs vidéo utilisaient des cassettes VHS elles aussi basées sur des bandes magnétiques, et j'en passe. Une partie de ces supports de stockage ont été réutilisés, puis adaptés pour les ordinateurs de l'époque. En conséquence, les premières mémoires informatiques étaient des mémoires magnétiques, bien plus rudimentaires que les disques durs et les disquettes : mémoires à tores de ferrite, bandes magnétiques, et bien d'autres (cassettes audio, notamment). D'autres mémoires historiques étaient des mémoires mécaniques, qui stockaient leurs informations sous la forme de trous dans une carte en plastique, d'ondes sonores, etc.

Ces mémoires, aujourd'hui totalement obsolètes, ont pourtant eu leur heure de gloire, certaines étant plus utilisées que les mémoires magnétiques ou électroniques de leur époque. Ce chapitre se propose de rendre hommage à ces mémoires historiques. Toutes les mémoires que nous allons aborder sont aujourd'hui obsolètes et la plupart ne sont même plus produites du tout. On peut encore en trouver dans des musées, mais leur utilisation réelle est réduite à peau de chagrin.

==Les cartes et rubans perforés==

Les toutes premières mémoires informatiques étaient des mémoires mécaniques. Les mémoires mécaniques les plus connues étaient basées sur du papier : je veux parler des '''cartes et rubans perforés'''. Il s'agit de cartes ou de rubans de papier, parfois de carton ou de plastiques. Les données sont stockées sous la forme de trous dans le ruban ou la carte : un trou code un 1, tandis que l'absence d'un trou code un 0.

[[File:2punchCards.jpg|centre|vignette|Carte perforée.]]

==Les bandes magnétiques==

[[File:Digital pdp8-e.jpg|vignette|Ordinateur Digital PDP-8, avec ses bandes magnétiques visibles.]]

De vieux ordinateurs utilisaient des cassettes à bande magnétique, les mêmes qui étaient utilisées comme cassettes audio il y a de cela quelques décennies. C'était le cas de vieux ordinateurs personnels, comme les Amstrad CPC, les ZX Spectrum, ou les ordinateurs Commodore.

[[File:Amstrad CPC 464 computer at Play Expo 2013.JPG|centre|vignette|Ordinateur personnel Amstrad CPC 464.]]

D'autres ordinateurs de la même époque utilisaient des supports de stockage similaires aux cassettes audio, mais sans le plastique extérieur. Des bandes magnétiques étaient enroulées dans un cylindre plastique, et étaient déroulées par un système de déroulement.

==Les tambours magnétiques==

[[File:ERA Magnetic Drum, US, c. 1951 - Computer History Museum - Mountain View, California.jpg|vignette|ERA Magnetic Drum, US, c. 1951 - Computer History Museum - Mountain View, California]]

Les '''tambours magnétiques''' sont les ancêtres du disque durs, les deux ayant un fonctionnement assez similaire. La différence principale est que les plateaux sont remplacés par un tube cylindrique, dont la surface est couverte d'un matériau magnétique. L'organisation en pistes est toujours présente, chaque piste étant une ligne horizontale sur le tube central. Par contre, il n'y a pas de tête de lecture/écriture qui se déplace de piste en piste. Les têtes de lecture/écriture sont immobiles, mais il y en a une par piste pour compenser. Le temps de latence d'un tel disque dépend donc uniquement de la vitesse de rotation et de la densité surfacique.

===Les tambours magnétiques étaient des mémoires primaires===

Fait surprenant, les tambours magnétiques étaient utilisés comme mémoire primaire, c'est à dire qu'elles avaient la même fonction que la mémoire RAM des PC actuels, malgré leur caractère non-volatile ! Les tambours magnétiques étaient aussi utilisées comme mémoire de masse, mais c'était une utilisation moins fréquente.

De nombreux ordinateurs de l'époque exécutaient des programmes directement depuis le tambour magnétique. Les instructions étaient mémorisées sur le tambour magnétique, étaient copiées dans un registre d'instruction, puis exécutées. Pour garder des performances correctes, la répartition des instructions dans les secteurs devait être optimisée. Les programmeurs ayant travaillé, par exemple sur l'IBM 650, devaient prendre en compte la manière dont les instructions étaient placées dans et entre les secteurs pour éviter des pertes de performance.

L'ordinateur Bull Gamma 3 intégrait une sorte de cache d'instruction pour accélérer l'exécution des programmes depuis le tambour magnétique. Pour l'expliquer avec des termes modernes, le processeur intégrait un ''local store'' dédié aux instructions. Les instructions étaient exécutées depuis ce ''local store'', pas depuis le tambour magnétique. Les échanges entre le ''local store'' et le tambour magnétique se faisaient par groupes de 48 instructions. Le ''local store'' était composé de 8 banques, chacune contenant un groupe de 48 instructions complet.

Dans le détail, le Bull Gamma 3 intégrait en réalité 8 ''local store'', appelés des ''Circulating Memories'', chacun pouvant mémoriser un groupe de 48 instructions. Pour exécuter une instruction, le groupe de 48 instructions complet était copié dans une ''Circulating Memory'', puis l'instruction voulue était copiée dans le registre d'instruction. Les ''Circulating Memories'' étaient implémentées avec des mémoires magnéto-résistives à ligne de mercure, qu'on détaillera dans la suite de ce chapitre.

===L'adressage sur un tambour magnétique===

Les tambours magnétiques avaient une méthode d'adressage différente selon qu'ils étaient utilisées comme mémoire de masse ou primaire. Les tambours utilisées comme mémoire primaire avaient une adresse par mot mémoire, alors que celles utilisées comme mémoire de masse avaient une adresse par secteur ou par piste. La méthode d'adressage variait suivant le tambour.
* Sur certains tambours, chaque piste avait sa propre adresse mémoire. Les pistes étaient de taille variable suivant la marque du tambour magnétique utilisé, mais chacune avait sa propre adresse.
* Sur d'autres, chaque piste était découpée en secteurs de taille fixe, comme sur les disques durs, et chaque secteur était adressé en précisant le numéro de piste et un numéro de secteur (similaire à l'adressage CHS des disques durs, en enlevant les plateaux).
* Sur d'autres, les secteurs avaient une taille variable, l'adressage se faisait en indiquant le numéro de la piste et la position du secteur dans la piste.
* D'autres mémoires utilisaient des systèmes d'adressages différents.

==Les mémoires à tore de ferrite==

Les premières mémoires de masse sont sans conteste les '''mémoires à tores de ferrites'''. Ce sont des mémoires magnétiques, un peu comme les disques durs, même si les différences sont nombreuses. Elles sont donc naturellement non-volatiles. Elles sont formées d'une matrice de tores fabriqués dans un matériau magnétique (ferromagnétique pour être précis), le plus souvent de la ferrite. Ces tores peuvent être magnétisés dans deux sens différents, ce qui leur permet de coder un bit.

[[File:KL CoreMemory Macro.jpg|centre|vignette|Mémoire à tores de ferrite réelle (avec les fils).]]

===Le fonctionnement d'une mémoire à tore de ferrite===

L'ensemble formait une sorte de tableau où chaque tore a deux positions : une position X et une autre position Y. Deux fils servent pour l'adressage : le fil Y traverse tous les tores d'une ligne, alors que le fil X traverse tous les tores placés sur la même colonne. Quand une tension est envoyée sur un fil Y et un fil X, le tore à l'intersection des deux fils est activé : il peut alors être lu ou écrit. Plus précisément, chaque fil est parcouru par une tension légèrement supérieure à la moitié de la tension nécessaire pour aimanter le tore : ainsi, la somme des deux tensions est supérieure à la tension d'aimantation, mais seulement à l'intersection des deux fils, sur le tore à aimanter. Selon la tension envoyée (plus précisément, son signe), le tore sera mis à 0 ou à 1.

[[File:Coincident-current magnetic core.svg|centre|vignette|Schéma de la matrice de tores (avec les fils).]]

Pour lire ou écrire un bit dans un tore (en changer l'aimantation), il faut que celui-ci soit soumis à un champ magnétique supérieur à une valeur déterminée. pour cela, chaque tore est parcouru par quatre fils : le fil X et Y servent pour l'adressage, comme dit plus haut, un fil S (''Sense'') pour les lectures, et un fil Z pour les écritures. En faisant passer un courant ou une tension dans ces fils, un champ magnétique se forme autour d'eux, ce qui agit sur les tores de ferrites ce qui permet de les aimanter (écriture) ou de lire leur contenu.

[[File:Single coincident-current magnetic core.svg|centre|vignette|Un tore de ferrite.]]

La lecture s'effectue via le fil nommé ''Sense''. Toute lecture est destructrice : le bit stocké dans le tore est effacé après chaque lecture. En effet, chaque lecture commence par mettre à zéro le bit à lire. Cette mise à zéro va ou non, faire changer le champ magnétique dans le fil ''Sense'', entrainant l'apparition d'un courant et d'une tension. Suite à cette mise à zéro, la mémoire regarde ce qui se passe sur ce fil. Si le bit était déjà à zéro avant la lecture, aucun champ magnétique ne sera créé : il ne se passe rien sur le fil ''Sense''. Mais si ce bit était à 1, le tore va changer de polarité, entrainant l'apparition d'une tension sur ce fil, durant un temps très bref (le temps de changement de polarité du tore). La lecture s'effectue donc via le fil ''Sense'', suivant ce qui s'y passe lors d'une mise à zéro d'un bit.

L'écriture s'effectue d'une manière différente, quoique similaire, en utilisant le fil ''Z''. Lors d'une écriture d'un tore, les fils X et Y qui correspondent sont alimentés en tension, de telle manière qu'un 1 soit écrit dans le tore. Pour écrire un 1, cela suffit largement. Mais pour écrire un zéro, il faut que quelque chose annule cette écriture, en compensant le champ magnétique créé par ces deux fils. Pour cela, on fait passer un courant dans le fil ''Inhibit'', afin de créer un champ magnétique contraire dans le tore. Cela annule l'écriture du 1 en inhibant le champ crée par les fils X et Y. La plupart des mémoires de ce type utilisaient deux fils ''Sense'' et ''Inhibit'' séparés. Mais vu que le fil ''Inhibit'' et ''Sense'' ne sont jamais utilisés en même temps, certaines mémoires à tore ont fusionné ces deux fils en un seul.

===Une mémoire très fiable===

Les mémoires à tore de ferrite sont des mémoires non-volatiles très fiables. Elles ne s'effacent pas dans le temps et peuvent supporter des conditions très dures sans perdre de données. Par exemple, elles peuvent résister à des radiations extrêmes , voire à une EMP, sans perdre de données. C'est pour cette raison qu'elles ont beaucoup été utilisées dans des applications aérospatiales, dans l'industrie, voire dans les applications militaires. Elles étaient encore utilisées dans ces applications bien après l'apparition des premières mémoires à semi-conducteurs.

Par contre, ces mémoires étaient très sensibles à la température. Les tensions à envoyer aux tores devaient avoir une valeur bien précise, qui dépend énormément de la température ambiante. Sur les premières mémoires à tore de ferrite, les circuits de contrôle de la mémoire contenaient un senseur de température et ajustaient les tensions appliquées en fonction des mesures. Une autre solution consistait à placer la mémoire dans une petite boite dont la température était maintenue stable. Généralement, la boite était chauffée au-dessus de la température ambiante, car maintenir une température constante est facile quand celle-ci est plus élevée que la normale. Chauffer une petite chambre est plus simple que de la refroidir, surtout pour une petite boite. Autant une simple résistance permet de chauffer la boite, autant utiliser un réfrigérateur pour une mémoire de ce type était clairement une mauvaise solution.

Le défaut principal de ces mémoires est que leur processus de fabrication est difficile à industrialiser. La fabrication de ces mémoires s'est surtout fait de main d'homme, sans machines ou du moins avec peu d'outils. Le fait que ces mémoires ne puisse pas facilement être fabriquées par des machines fait que ces mémoires sont difficiles à miniaturiser : la miniaturisation ne va pas aussi loin que pour les mémoires à semi-conducteurs et on peut tout au plus stocker quelques centaines de bits sur une puce, voire quelques milliers. La capacité de telles mémoire est généralement assez faible. Par contre, leurs performances étaient assez honorables. On estime que les premières mémoires de ce type avaient un temps d'accès mémoire d'environ 6 µs, ce qui fait une fréquence d'environ 166.7 kilohertz. Le temps d'accès est ensuite descendu à 0.6 µs durant les années 70, ce qui faisait une fréquence proche du mégahertz.

[[File:Ferrite core memory.jpg|centre|vignette|upright=1.5|Mémoire à tore Ferrite miniaturisée. La puce fait 10 centimètres de coté et contient 64 mots de 64 bits, soit 4 kikioctets.]]

==Les mémoires à ligne de délai==

Les '''mémoires à ligne de délai''' sont des mémoires volatiles mécaniques, basées sur des ondes sonores ! Celles-ci ont été inventées suite à des technologies liées aux radars, dans les laboratoires militaires. Ces mémoires sont des mémoires séquentielles, qui ont une capacité extrêmement faible (quelques centaines de bits). Il en existe diverses versions, la première étant basée sur des tubes de mercure, les suivantes étant basées sur des tubes de cuivre ou d'autre matériaux magnétiques.

===L'intérieur d'une mémoire à ligne de délai===

Ces mémoires sont basées sur un tube de matière, dans lequel se propage une onde sonore : celui-ci sert de support de mémorisation. Un bit est codé par l'absence ou la présence d'une onde sonore dans le tube de matière. Au bout de ce tube, on trouve un microphone et un haut-parleur. Le haut-parleur génère une onde sonore d'un côté du tube, onde qui est reçue de l'autre côté du tube par le microphone. De plus, le haut-parleur et le microphone sont reliés entre eux : le signal capté sur le microphone est envoyé sur le haut-parleur d'entrée. Ce faisant, l'onde sonore circule en boucle dans le circuit : elle est rafraichie sans cesse, à chaque passage.

[[File:Delay line memory fr.svg|centre|vignette|upright=2.0|Mémoire à ligne de délai.]]

Divers circuits sont présents entre le microphone et le haut-parleur. On trouve notamment des amplificateurs, histoire que les ondes sonores captées ne s'amenuisent pas à force de reparcourir le tube.

[[File:SEACComputer 010.jpg|centre|vignette|upright=2.0|Mémoire à tube de mercure.]]

===La capacité des mémoires à ligne de délai===

Il existe naturellement un petit délai de transmission entre le microphone et le haut-parleur, ainsi qu'un autre délai de propagation dans le tube. Ces délais limitent la capacité de la mémoire, qui dépend du nombre d'ondes sonores qui peuvent parcourir le tube. Chaque bit est codée exactement par une impulsion sonore, qui a une forme et une durée très précise, qui dépend de la qualité du circuit (microphone, haut-parleur, et autres) : notons ce temps &lt;math&gt;\Tau&lt;/math&gt;. La capacité totale est, par définition, égale au nombre d'impulsions qui se trouvent en même temps dans le tube de matière (les unes à la suite des autres). Pour la calculer, on peut diviser le temps que met une impulsion à se propager dans le tube, par la durée d'une impulsion.

===Les différents types de mémoires à lignes de délai===

Les premières mémoires de ce type étaient fabriquées avec des tubes de mercure : ce sont des '''lignes à délai de mercure'''.

[[File:Mercury memory.jpg|centre|vignette|SEAC Computer, avec une mémoire à ligne de Mercure.]]

Mais les inconvénients du mercure (toxicité, notamment) ont mené au remplacement du mercure par des tubes de matériaux conducteurs (des fils électriques, dit autrement) : ce sont des '''lignes de délai à torsion de fil'''.

[[File:Torsion wire delay line.jpg|centre|vignette|Exemple de ligne de délai à torsion de fil.]]

==Les tubes Williams et Selectron==

Les '''tubes ''Williams''''' et '''Selectron''' sont basés sur un écran CRT modifié. Il s'agissait de mémoires de type mémoires vives volatiles qui devaient être rafraichies régulièrement. En clair, ce sont l'ancêtre des mémoires DRAM ! Les ''tubes Williams'' étaient utilisés sur les tout premiers ordinateurs, au tout début de l'histoire de l'informatique, dans les années 50, à une époque où les ordinateurs étaient des monstres qui occupaient une pièce entière et étaient plus proches de petites usines à calcul qu'autre chose. Une technologie alternative basée sur un principe simialire est le ''Tube Selectron''. D'une capacité de 256 bits, il n'a été utilisé que sur un seul ordinateur : le JOHNNIAC de la RAND Corporation. Ils ont tous deux était rapidement remplacé par les mémoires à ligne de délai, plus simples et moins chères.

[[File:Williams-tube.jpg|centre|vignette|upright=2|Williams-tube]]

===Les écrans CRT (''Cathode Ray Tube'')===

Tubes Williams et Selectron se basent sur la même technologie : celle des écrans CRT. Un écran CRT est composé de plusieurs composants, qui marchent de concert : un canon à électron, des bobines de contrôle et la surface de l'écran proprement dite. Le canon à électron émet un faisceau d'électron concentré, qui touche la surface de l'écran. Cette dernière, du moins derrière la vitre transparente, est d'une composition chimique particulière et est notamment riche en phosphore. Elle est souvent appelée ''surface phosphorescente''. Quand elle est touchée par le faisceau d’électron, le phosphore s'illumine pendant quelques millisecondes. Les bobines visent à détourner le faisceau d'électron de manière à ce qu'il balaye tout l'écran de gauche à droite et de haut en bas.

[[File:Cathode ray tube fr.svg|centre|vignette|upright=2|Cathode ray tube.]]

La surface de l'écran est découpée en pixels, et l'intensité du canon varie pour chaque pixel lorsque le faisceau passe sur ce pixelde  l'écran. En commandant l'intensité du canon d'électron, on arrive à afficher des images en noir et blanc ainsi. Un canon intense pendant x millisecondes donnera un point blanc sur l'écran, là où tombe de faisceau. un canon éteint donnera un point noir à l'écran. Il est possible de gérer la couleurs avec des écrans CRT plus complexes, mais ce n'est pas le sujet et nous n'en avons pas besoin pour les explications qui vont suivre.

====La physique de la surface phosphorescente : émission secondaire et puits de potentiels====

Un point important est que la physique de la surface phosphorescente n'est pas intuitive et peu donner lieu à des phénomènes assez importants pour ce qui va suivre. Deux d'entre eu vont nous intéresser.

Le premier est que les électrons émis par le canaux à électrons frappent la surface phosphorescente, l'illuminent, mais qu'il arrive que des électrons soient piégés dans la surface, à l'endroit de l'impact. En conséquence, une petite charge électrique s'accumule progressivement à chaque passage du faisceau, dans chaque pixel. Les électrons ne restent pas en place de manière permanente, ils finissent par s'échapper après un certain temps, ce qui fait que la charge finit par s'atténuer, mais elle peut durer quelques secondes sur les CRT conçus pour exploiter cet effet au mieux.

Le second phénomène est l''''émission secondaire'''. Quand l'énergie du faisceau à électron est trop forte, les électrons naturellement présents dans les atomes du matériau phosphorescent sont dégagés. Les électrons éjectés deviennent alors des électrons libres qui vont allumer les zones alentours, ce qui perturbe l'affichage. Et cela arrive lors que la zone frappée par le faisceau a perdu des électrons et ne s'allume plus. Le résultat est que si une image était affichée sur l'écran auparavant, utiliser un faisceau trop fort l'efface totalement via émission secondaire. Il s'agit là d'un défaut à éviter sur les écrans d'affichage, mais c'est ce phénomène qui est utilisé sur les mémoires à tubes de stockage.

====Les CRT rémanents====

Il existe des écrans CRT conçus pour afficher des images sur une longue durée de temps, et pas seulement pour un 50ème ou 60ème de seconde. Ils sont appelés des '''écrans rémanents''' ou encore '''''storage tubes''''', ou tubes de stockage. Avec eux, l'image affichée s'efface progressivement et lentement, mais reste visible durant quelques secondes. Pour cela, les écran de stockage sont fabriqués en utilisant un matériau phosphorescent spécial, différent de celui des autres CRT, mais le reste du CRT fonctionne de la même manière. La rémanence est liée au premier phénomène mentionné plus haut, à savoir la capture d'électrons par la surface, mais ce phénoméne est maximisé par l'usage du matériau adéquat. Cette rémanence de quelques secondes fait que l'image a besoin d'être rafraichie moins souvent, comparée à un écran CRT normal. Et les mémoires Selectron et de Williams sont basées sur de tels tubes de stockage.

La rémanence de l'image a de nombreuses applications et est utile quand on n'a pas besoin d'une réactivité importante. Elle était utile dans les radars, dans certains oscilloscopes qui demandent de capturer des évènements très brefs, etc. Quelques écrans d'ordinateur ont tenté d'utiliser ce système, notamment les écrans de la marque Textronix. Ils portent le nom de '''''Direct-view bistable storage tube'''''. L'idée est d'utiliser un écran CRT rémanent pour afficher une image pour éviter de rafraichir l'écran souvent. Mais pour quel l'écran soit réactif et éviter des artefacts graphiques liés à la rémanence, on est obligé d'effacer l'écran avant d'afficher une nouvelle image. Et l'effacement se fait grâce à l'émission secondaire. Pour cela, de tels écrans contenaient deu faisceaux : un faisceau normal pour afficher une image, un autre faisceau très puissant qui déclenche une émission secondaire pour effacer l'écran.

===Les tubes Williams===

[[File:SWAC 003.jpg|vignette|Image affichée par un tube Williams en fonctionnement, sur l'ordinateur SWAC.]]

L'idée derrière les tubes tubes Williams et Selectron est de mémoriser les données sous la forme d'images à l'écran. Un bit à 1 correspond à un pixel allumé/lumineux, un bit à 0 à un pixel éteint/noir. Les écrans de l'époque ne géraient pas la couleur, aussi seul le noir et blanc était disponible (avec les niveaux de gris), ce qui est parfait pour un stockage en binaire. L'image affichée par un écran CRT est affichée ligne par ligne, avec un petit temps de pause entre l'affichage de deux lignes pour repositionner le canon à électron sur le début de la ligne suivante. Par simplicité, sur les tubes Williams, chaque ligne correspond à un mot mémoire, une case mémoire. La taille d'un mot mémoire et le nombre d'adresse dépend donc de la résolution utilisée.

Un tube Williams est composé d'un tube CRT rémanent et d'une plaque de métal placée devant l'écran, et de circuits électroniques annexes. La plaque de métal est collée à l'écran, ce qui fait qu'on ne peut pas voir l'écran proprement dit. Elle sert uniquement lors des lectures et pas pour les écritures. Lors d'une lecture, on mesure la tension sur la plaque, qui dépendra du bit stocké au moment de la lecture. La lecture se fait bit par bit, un par un. Elle est reliée à un circuit amplificateur de tension, qui amplifie la tension mesurée par la plaque. On trouve aussi des circuits pour le contrôle de l'écran CRT, à savoir des registres X et Y pour commander les bobines de défléction, de quoi générer un signal d'horloge, et des circuits électroniques pour gérer les lectures/écritures.

[[File:WilliamsTubeFigure1.tiff|centre|vignette|upright=2|WilliamsTubeFigure1]]

L'écriture et l’effacement de l'image est ce qu'il y a de plus facile : écrire une image utilise un faisceau d’électrons normal qu'on allume ou éteint convenablement lors du balayage de l'écran, l'effacer demande de faire la même chose en utilisant un faisceau très puissant. Un faisceau normal allume le phosphore et le charge pendant un certain temps, alors que l'émission secondaire efface ce qui a été enregistré sur le phosphore.

Pour lire un bit, on envoie un faisceau d'électron sur sa position sur l'écran, dont l'intensité est situé juste en-dessous du seuil pour l'émission secondaire. Si le bit stocké est à 0, l'intensité ne sera pas suffisante pour générer une émission secondaire. Mais si cil stocke un 1, la charge électrique stockée sur la surface phosphorescente va s'additionner à l’intensité du faisceau et déclencher une émission secondaire. L’émission secondaire a déclencher une augmentation local de la tension électrique, que la plaque de métal va capter. Un amplifieur amplifie la tension mesurée sur la plaque, pour en faire une tension capable de coder un 0 ou un 1. Vous remarquerez que la lecture est destructrice, ce qui fait que toute lecture de l'écran est suivie par une écriture pour compenser, comme sur les DRAM.

[[File:Williams tube timing.jpg|centre|vignette|upright=2|Williams tube timing]]

Passons maintenant au rafraichissement mémoire. Il faut rafraichir l'écran pour une raison simple : l'image affichée par l'écran s'efface au bout de quelques millisecondes, quelques secondes, tout dépend du type d'écran utilisé. Le rafraichissement se fait en effectuant une lecture suivie d'une écriture : on récupère le contenu de la mémoire/tube, avant de le réécrire.

Autour de la plaque de métal et du tube CRT, on trouve divers circuits qui gèrent les lectures et écritures. Les lectures et écritures se font bit par bit, on peut masquer certains bits lors des écritures, autoriser ou interdire les lectures/écritures durant un temps, etc.

[[File:SEACComputer 004.jpg|centre|vignette|upright=2|Fonctionnement d'un tube Williams, avec les circuits associés]]

&lt;noinclude&gt;
{{NavChapitre | book=Fonctionnement d'un ordinateur
           | prev=Les sections critiques et le modèle mémoire
           | prevText=Les sections critiques et le modèle mémoire
           | next=Le matériel réseau
           | nextText=Le matériel réseau
}}
&lt;/noinclude&gt;</text>
      <sha1>6misyapxuwobescxhwfbgawop7trchb</sha1>
    </revision>
  </page>
  <page>
    <title>Les cartes graphiques/Le processeur de commandes</title>
    <ns>0</ns>
    <id>69571</id>
    <revision>
      <id>744011</id>
      <parentid>739201</parentid>
      <timestamp>2025-06-02T20:41:16Z</timestamp>
      <contributor>
        <username>Mewtow</username>
        <id>31375</id>
      </contributor>
      <minor />
      <comment>/* Le tampon de commandes */</comment>
      <origin>744011</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="32049" sha1="oprf9vu2e5gm04tmdoaqmum7exib550" xml:space="preserve">Dans ce chapitre, nous allons parler de tous les intermédiaires qui se placent entre une application de rendu 3D et les circuits de rendu 3D proprement dit. En premier lieu, on trouve le pilote de la carte graphique, aux fonctions multiples et variées. En second lieu, nous allons parler d'un circuit de la carte graphique qui fait l'interface entre le logiciel et les circuits de rendu 3D de la carte graphique : le processeur de commandes. Ce processeur de commandes est un circuit qui sert de chef d'orchestre, qui pilote le fonctionnement global de la carte graphique. API 3D, pilote de carte graphique et processeur de commande travaillent de concert pour que l'application communique avec la carte graphique. Nous allons d'abord voir le pilote de la carte graphique, avant de voir le fonctionnement du processeur de commande.

==Le pilote de carte graphique==

Le pilote de la carte graphique est un logiciel qui s'occupe de faire l'interface entre le logiciel et la carte graphique. De manière générale, les pilotes de périphérique sont des intermédiaires entre les applications/APIs et le matériel. En théorie, le système d'exploitation est censé jouer ce rôle, mais il n'est pas programmé pour être compatible avec tous les périphériques vendus sur le marché. À la place, le système d'exploitation ne gère pas directement certains périphériques, mais fournit de quoi ajouter ce qui manque. Le pilote d'un périphérique sert justement à ajouter ce qui manque : ils ajoutent au système d'exploitation de quoi reconnaître le périphérique, de quoi l'utiliser au mieux. Pour une carte graphique, il a diverses fonctions que nous allons voir ci-dessous.

Avant toute chose, précisons que les systèmes d'exploitation usuels (Windows, Linux, MacOsX et autres) sont fournis avec un pilote de carte graphique générique, compatible avec la plupart des cartes graphiques existantes. Rien de magique derrière cela : toutes les cartes graphiques vendues depuis plusieurs décennies respectent des standards, comme le VGA, le VESA, et d'autres. Et le pilote de base fournit avec le système d'exploitation est justement compatible avec ces standards minimaux. Mais le pilote ne peut pas profiter des fonctionnalités qui sont au-delà de ce standard. L'accélération 3D est presque inexistante avec le pilote de base, qui ne sert qu'à faire du rendu 2D (de quoi afficher l’interface de base du système d'exploitation, comme le bureau de Windows). Et même pour du rendu 2D, la plupart des fonctionnalités de la carte graphique ne sont pas disponibles. Par exemple, certaines résolutions ne sont pas disponibles, notamment les grandes résolutions. Ou encore, les performances sont loin d'être excellentes. Si vous avez déjà utilisé un PC sans pilote de carte graphique installé, vous avez certainement remarqué qu'il était particulièrement lent.

===La gestion des interruptions===

Une fonction particulièrement importante du pilote de carte graphique est la réponse aux interruptions lancées par la carte graphique. Pour rappel, les interruptions sont une fonctionnalité qui permet à un périphérique de communiquer avec le processeur, tout en économisant le temps de calcul de ce dernier. Typiquement, lorsqu'un périphérique lance une interruption, le processeur stoppe son travail et exécute automatiquement une routine d'interruption, un petit programme qui s'occupe de gérer le périphérique, de faire ce qu'il faut, ce que l'interruption a demandé.

Il y a plusieurs interruptions possibles, chacune ayant son propre numéro et sa fonction dédiée, chacune ayant sa propre routine d'interruption. Après tout, la routine qui gère un débordement de la mémoire vidéo n'est pas la même que celle qui gère un changement de fréquence du GPU ou la fin du calcul d'une image 3D. Le pilote fournit l'ensemble des routines d'interruptions nécessaires pour gérer la carte graphique.

===La compilation des ''shaders''===

Le pilote de carte graphique est aussi chargé de traduire les ''shaders'' en code machine. En soi, cette étape est assez complexe, et ressemble beaucoup à la compilation d'un programme informatique normal. Les ''shaders'' sont écrits dans un langage de programmation de haut niveau, comme le HLSL ou le GLSL, mais ce n'est pas ce code source qui est compilé par le pilote de carte graphique. À la place, les ''shaders'' sont pré-compilés vers un langage dit intermédiaire, avant d'être compilé par le pilote en code machine. Le langage intermédiaire, comme son nom l'indique, sert d'intermédiaire entre le code source écrit en HLSL/GLSL et le code machine exécuté par la carte graphique. Il ressemble à un langage assembleur, mais reste malgré tout assez générique pour ne pas être un véritable code machine. Par exemple, il y a peu de limitations quant au nombre de processeurs ou de registres. En clair, il y a deux passes de compilation : une passe de traduction du code source en langage intermédiaire, puis une passe de compilation du code intermédiaire vers le code machine. Notons que la première passe est réalisée par le programmeur des ''shaders'', non pas par l'utilisateur. Par exemple, les ''shaders'' d'un jeu vidéo sont fournis déjà pré-compilés : les fichiers du jeu ne contiennent pas le code source GLSL/HLSL, mais du code intermédiaire.

L'avantage de cette méthode est que le travail du pilote est fortement simplifié. Le pilote de périphérique pourrait compiler directement du code HLSL/GLSL, mais le temps de compilation serait très long et cela aurait un impact sur les performances. Avec l'usage du langage intermédiaire, le gros du travail à été fait lors de la première passe de compilation et le pilote graphique ne fait que finir le travail. Les optimisations importantes ont déjà été réalisées lors de la première passe. Il doit bien faire la traduction, ajouter quelques optimisations de bas niveau par-ci par-là, mais rien de bien gourmand en processeur. Autant dire que cela économise plus le processeur que si on devait compiler complètement les ''shaders'' à chaque exécution.

Fait amusant, il faut savoir que le pilote peut parfois remplacer les ''shaders'' d'un jeu vidéo à la volée. Les pilotes récents embarquent en effet des ''shaders'' alternatifs pour les jeux les plus vendus et/ou les plus populaires. Lorsque vous lancez un de ces jeux vidéo et que le ''shader'' originel s'exécute, le pilote le détecte automatiquement et le remplace par la version améliorée, fournie par le pilote. Évidemment, le ''shader'' alternatif du pilote est optimisé pour le matériel adéquat. Cela permet de gagner en performance, voire en qualité d'image, sans pour autant que les concepteurs du jeu n'aient quoique ce soit à faire.

Enfin, certains ''shaders'' sont fournis par le pilote pour d'autres raisons. Par exemple, les cartes graphiques récentes n'ont pas de circuits fixes pour traiter la géométrie. Autant les anciennes cartes graphiques avaient des circuits de T&amp;L qui s'en occupaient, autant tout cela doit être émulé sur les machines récentes. Sans cette émulation, les vieux jeux vidéo conçus pour exploiter le T&amp;L et d'autres technologies du genre ne fonctionneraient plus du tout. Émuler les circuits fixes disparus sur les cartes récentes est justement le fait de ''shaders'', présents dans le pilote de carte graphique.

===Les autres fonctions===

Le pilote a aussi bien d'autres fonctions. Par exemple, il s'occupe d'initialiser la carte graphique, de fixer la résolution, d'allouer la mémoire vidéo, de gérer le curseur de souris matériel, etc.

==Les commandes graphiques/vidéo/autres : des ordres envoyés au GPU==

Tous les traitements que la carte graphique doit effectuer, qu'il s'agisse de rendu 2D, de calculs 2D, du décodage matérielle d'un flux vidéo, ou de calculs généralistes, sont envoyés par le pilote de la carte graphique, sous la forme de '''commandes'''. Ces commandes demandent à la carte graphique d'effectuer une opération 2D, ou une opération 3D, ou encore le rendu d'une vidéo.

Les commandes graphiques en question varient beaucoup selon la carte graphique. Les commandes sont régulièrement revues et chaque nouvelle architecture a quelques changements par rapport aux modèles plus anciens. Des commandes peuvent apparaître, d'autres disparaître, d'autre voient leur fonctionnement légèrement altéré, etc.

Mais dans les grandes lignes, on peut classer ces commandes en quelques grands types. Les commandes les plus importantes s'occupent de l'affichage 3D : afficher une image à partir de paquets de sommets, préparer le passage d'une image à une autre, changer la résolution, etc. Plus rare, d'autres commandes servent à faire du rendu 2D : afficher un polygone, tracer une ligne, coloriser une surface, etc. Sur les cartes graphiques qui peuvent accélérer le rendu des vidéos, il existe des commandes spécialisées pour l’accélération des vidéos.

Pour donner quelques exemples, prenons les commandes 2D de la carte graphique AMD Radeon X1800.

{|class=&quot;wikitable&quot;
|-
! Commandes 2D 
! Fonction
|-
|PAINT 	
|Peindre un rectangle d'une certaine couleur
|-
|PAINT_MULTI 	
|Peindre des rectangles (pas les mêmes paramètres que PAINT)
|-
|BITBLT 	
|Copie d'un bloc de mémoire dans un autre
|-
|BITBLT_MULTI 	
|Plusieurs copies de blocs de mémoire dans d'autres
|-
|TRANS_BITBLT 	
|Copie de blocs de mémoire avec un masque
|-
|NEXTCHAR 	
|Afficher un caractère avec une certaine couleur
|-
|HOSTDATA_BLT 	
|Écrire une chaîne de caractères à l'écran ou copier une série d'image bitmap dans la mémoire vidéo
|-
|POLYLINE 	
|Afficher des lignes reliées entre elles
|-
|POLYSCANLINES
|Afficher des lignes
|-
|PLY_NEXTSCAN 	
|Afficher plusieurs lignes simples
|-
|SET_SCISSORS 	
|Utiliser des coupes (ciseaux)
|-
|LOAD_PALETTE 	
|Charger la palette pour affichage 2D
|}

===Le tampon de commandes===

L'envoi des commandes à la carte graphique ne se fait pas directement. La carte graphique n'est pas toujours libre pour accepter une nouvelle commande, soit parce qu'elle est occupée par une commande précédente, soit parce qu'elle fait autre chose. Il faut alors faire patienter les données tant que la carte graphique est occupée. Les pilotes de la carte graphique vont les mettre en attente dans le '''tampon de commandes'''. 

Le tampon de commandes est ce qu'on appelle une file, une zone de mémoire dans laquelle on stocke des données dans l'ordre d'ajout. Si le tampon de commandes est plein, le driver n'accepte plus de demandes en provenance des applications. Un tampon de commandes plein est généralement mauvais signe : cela signifie que la carte graphique est trop lente pour traiter les demandes qui lui sont faites. Par contre, il arrive que le tampon de commandes soit vide : dans ce cas, c'est simplement que la carte graphique est trop rapide comparé au processeur, qui n'arrive alors pas à donner assez de commandes à la carte graphique pour l'occuper suffisamment.

Le tampon de commande est soit une mémoire FIFO séparée, soit une portion de la mémoire vidéo. Le NV1, la toute première carte graphique NVIDIA, utilisait une mémoire FIFO intégrée à la carte graphique, séparée des autres circuits. Le NV1 contenait dans le détail : un controleur DMA avec une IO-MMU intégrée, la FIFO de commande, le processeur de commande, un pipeline graphique, un pipeline sonore, un contrôleur de manette. L'ensemble était relié par un bus interne à la carte graphique.

: Le fonctionnement de la FIFO du NV1 est décrit dans le brevet ''US5805930A : System for FIFO informing the availability of stages to store commands which include data and virtual address sent directly from application programs''.

===Le processeur de commandes===

Le '''processeur de commande''' est un circuit qui gère les commandes envoyées par le processeur. Il lit la commande la plus ancienne dans le tampon de commande, l’interprète et l’exécute, et recommence ainsi de suite. Le processeur de commande est chargé de piloter les circuits de la carte graphique. Un point important est qu'il répartit le travail entre les différents circuits de la carte graphique et assure que l'ordre du pipeline est respecté. En soi, le processeur de commande est un circuit assez compliqué. Sur les cartes graphiques anciennes, c'était un circuit séquentiel complexe, fabriqué à la main et était la partie la plus complexe du processeur graphique. Sur les cartes graphiques modernes, c'est un véritable microcontrôleur, avec un processeur, de la mémoire RAM, etc.

Le processeur de commandes récupère les commandes dans le tampon de commande, en mémoire RAM, pour les recopier dans la mémoire vidéo et/ou une mémoire interne. Cette copie se fait via la technologie DMA, une technologie de transfert de données entre mémoire RAM et périphérique qui n'utilise pas le processeur principal. Une fois la copie faite, le processeur de commande décode la commande et l’exécute sur la carte graphique. Il garde en mémoire l'état de traitement de chaque commande : est-ce qu'elle est en train de s’exécuter sur le processeur graphique, est-ce qu'elle est mise en pause, est-ce qu'elle attend une donnée en provenance de la mémoire, est-ce qu'elle est terminée, etc.

Une commande utilise divers circuits de la carte 3D, de la mémoire vidéo, et d'autres ressources au sens large : des processeurs de ''shader'', notamment. La fonction principale du processeur de commande est de répartir le travail entre les différents circuits. Le processeur de commande décide à quel processeur ou circuit doit être envoyé une commande. C'est le processeur de commande qui s'occupe de la gestion des ressources et qui attribue telle ressource à telle commande.

A chaque instant, le processeur de commande répartit les ''shaders'' sur les processeurs de ''shaders'', en faisant en sorte qu'ils soient utilisés le plus possible. Dans le cas le plus simple, les unités sont alimentées en vertex/pixels les unes après les autres (principe du round-robin), mais des stratégies plus optimisées sont la règle de nos jours. Cela est très important sur les cartes graphiques : répartir plusieurs commandes sur plusieurs processeurs est une tâche difficile.

Il envoie aussi certaines commandes aux circuits fixes, comme l’''input assembler''. Là encore, il faut en sorte que les circuits fixes soient utilisés le plus possible et évite au maximum les situations où ces circuits n'ont rien à faire. Sa tâche est compliquée par le fait que les cartes graphiques actuelles dupliquent leurs unités pour pouvoir faire beaucoup de calculs en parallèle. Elles ont plusieurs unités de traitement des sommets et des pixels, plusieurs ROP, plusieurs unités de textures, etc. Et c'est en partie le travail du processeur de commande que de répartir les calculs sur ces différentes unités.

[[File:Architecture de base d'une carte 3D - 1.png|centre|vignette|upright=2.5|Architecture de base d'une carte 3D - 1]]

C'est là un problème assez compliqué pour le processeur de commande et ce pour tout un tas de raisons que nous ne ferons que survoler. Les contraintes d'ordonnancement de l'API et les règles de celle-ci sont une partie de la réponse. Mais d'autres raisons sont intrinsèques au rendu 3D ou à la conception des circuits.

===L'ordonnancement et la gestion des ressources===

Le processeur de commande doit souvent mettre en pause certains circuits du pipeline, ainsi que les circuits précédents. Par exemple, si tous les processeurs de ''vertex shader'' sont occupés, l’''input assembler'' ne peut pas charger le paquet suivant car il n'y a aucun processeur de libre pour l’accueillir. Dans ce cas, l'étape d’''input assembly'' est mise en pause en attendant qu'un processeur de ''shader'' soit libre.

La même chose a lieu pour l'étape de rastérisation : si aucun processeur de ''shader'' n'est libre, elle est mise en pause. Sauf que pour la rastérisation, cela a des conséquences sur les circuits précédents la rastérisation. Si un processeur de ''shader'' veut envoyer quelque chose au rastériseur alors qu'il est en pause, il devra lui aussi attendre que le rastériseur soit libre. On a la même chose quand les ROP sont occupés : les ''pixel shader'' ou l'unité de texture doivent parfois être mis en pause, ce qui peut entrainer la mise en pause des étapes précédentes, etc.

En clair : plus un étape est situé vers la fin du pipeline graphique, plus sa mise en pause a de chances de se répercuter sur les étapes précédentes et de les mettre en pause aussi. Le processeur de commande doit gérer ces situations.

===Le pipelining des commandes===

Dans les cartes graphiques les plus rudimentaires, le processeur de commande exécute les commandes dans l'ordre. Il exécute une commande çà la fois et attend qu'une commande soit terminé pour en lancer une autre. Plusieurs commandes sont accumulées dans le tampon de commande, le processeur de commande les traite de la plus ancienne vers la plus récente. Du moins, les anciennes cartes graphiques faisaient comme cela, les cartes graphiques modernes sont un peu plus complexes. Elles n'attendent pas qu'une commande soit totalement terminée avant d'en lancer une nouvelle. Les processeurs de commande actuels sont capables d’exécuter plusieurs commandes en même temps.

L'intérêt est un gain en performance assez important. Pour ceux qui ont déjà eu un cours d'architecture des ordinateurs avancé, lancer plusieurs commandes en même temps permet une forme de pipeline, dont les gains sont substantiels. Par exemple, imaginez qu'une commande de rendu 3D soit bien avancée et n'utilise que les processeurs de ''shaders'' et les ROP, mais laisse les unités géométriques libres. Il est alors possible de démarrer la commande suivante en avance, afin qu'elle remplisse les unités géométriques inutilisées. On a alors deux commandes en cours de traitement : une commande qui utilise la fin du pipeline uniquement, une autre qui utilise seulement le début du pipeline graphique.

Le processeur de commande gère donc plusieurs commandes simultanées, à savoir plusieurs commandes qui en sont à des étapes différentes du pipeline. On peut avoir une commande qui est en cours dans l'étage de gestion de la géométrie, une autre dans le rastériseur, et une autre dans les unités de traitement des pixels. Le fait que les étapes du pipeline graphique sont à effectuer dans un ordre bien précis permet ce genre de chose assez facilement.

Une autre possibilité est de faire des rendus en parallèle. Par exemple, imaginez qu'on ait des circuits séparés pour le rendu 2D et 3D. Prenons l'exemple où le calcul d'une image finale demande de faire un rendu 3D suivi d'un rendu 2D, par exemple un jeu vidéo en 3D qui a un HUD dessiné en 2D. Dans ce cas, on peut démarrer le calcul de l'image suivante dans le pipeline 3D pendant que la précédente est dans les circuits 2D, au lieu de laisser inutilisé le pipeline 3D pendant le rendu 2D.

Mais c'est là un défi compliqué à relever pour le processeur de commande, qui donne lieu à son lot de problèmes. Le problème principal est le partage de ressources entre commandes. Par exemple, on peut prendre le cas où une commande n'utilise pas beaucoup les processeurs de ''shaders''. On pourrait imaginer lancer une seconde commande en parallèle, afin que la seconde commande utiliser les processeurs de ''shaders'' inutilisés. Mais cela n'est possible que si les circuits fixes sont capables d'accepter une seconde commande. Si la première commande sature les circuits fixe, le lancement de la seconde commande sera empêché. Mais si ce n'est pas le cas, les deux commandes pourront être lancées en même temps. Pareil pour le débit mémoire, qui doit alors être partagé entre deux commandes simultanées, ce qui est à prendre en compte.

===La synchronisation de l’exécution des commandes avec le processeur===

Il arrive que le processeur doive savoir où en est le traitement des commandes, ce qui est très utile pour la gestion de la mémoire vidéo. 

Un premier exemple : comment éviter de saturer une carte graphique de commande, alors qu'on ne sait pas si elles traite les commandes rapidement ou non ? L'idéal est de regarder où en est la carte graphique dans l'exécution des commandes. Si elle n'en est qu'au début du tampon de commande et que celui-ci est bien remplit, alors il vaut mieux lever le pied et ne pas envoyer de nouvelles commandes. A l'inverse, si le tampon de commande est presque vide, envoyer des commandes est la meilleure idée possible.

Un autre exemple un peu moins parlant est celui de la gestion de la mémoire vidéo. Rappelons qu'elle est réalisée par le pilote de la carte graphique, sur le processeur principal, qui décide d'allouer et de libérer de la mémoire vidéo. Pour donner un exemple d'utilisation, imaginez que le pilote de la carte graphique doive libérer de la mémoire pour pouvoir ajouter une nouvelle commande. Comment éviter d'enlever une texture tant que les commandes qui l'utilisent ne sont pas terminées ? Ce problème ne se limite pas aux textures, mais vaut pour tout ce qui est placé en mémoire vidéo. 

Il faut donc que la carte graphique trouve un moyen de prévenir le processeur que le traitement de telle commande est terminée, que telle commande en est rendue à tel ou tel point, etc. Pour cela, on a globalement deux grandes solutions. La première est celle des interruptions, abordées dans les chapitres précédents. Mais elles sont assez couteuses et ne sont utilisées que pour des évènements vraiment importants, critiques, qui demandent une réaction rapide du processeur. L'autre solution est celle du ''pooling'', où le processeur monitore la carte graphique à intervalles réguliers. Deux solutions bien connues de ceux qui ont déjà lu un cours d'architecture des ordinateurs digne de ce nom, rien de bien neuf : la carte graphique communique avec le processeur comme tout périphérique.

Pour faciliter l'implémentation du ''pooling'', la carte graphique contient des registres de statut, dans le processeur de commande, qui mémorisent tout ou partie de l'état de la carte graphique. Si un problème survient, certains bits du registre de statut seront mis à 1 pour indiquer que telle erreur bien précise a eu lieu. Il existe aussi un registre de statut qui mémorise le numéro de la commande en cours, ou de la dernière commande terminée, ce qui permet de savoir où en est la carte graphique dans l'exécution des commandes. Et certaines registres de statut sont dédiés à la gestion des commandes. Ils sont totalement programmable, la carte graphique peut écrire dedans sans problème.

Les cartes graphiques récentes incorporent des commandes pour modifier ces registres de statut au besoin. Elles sont appelées des '''commandes de synchronisation''' : les barrières (''fences''). Elles permettent d'écrire une valeur dans un registre de statut quand telle ou telle condition est remplie. Par exemple, si jamais une commande est terminée, on peut écrire la valeur 1 dans tel ou tel registre. La condition en question peut être assez complexe et se résumer à quelque chose du genre : &quot;si jamais toutes les ''shaders'' ont fini de traiter tel ensemble de textures, alors écrit la valeur 1024 dans le registre de statut numéro 9&quot;.

===La synchronisation de l’exécution des commandes intra-GPU===

Lancer plusieurs commandes en parallèle dans le pipeline permet de gagner en performance.Mais cela a un gros défaut : il n'est pas garantit que les commandes se terminent dans l'ordre. Si on démarre une seconde commande après la première, il arrive que la seconde finisse avant. Pire : il n'est pas garantit qu'elles s'exécutent dans l'ordre. Dans la plupart des cas, cela ne pose pas de problèmes. Mais dans d'autres, cela donne des résultats erronés.

Pour donner un exemple, utilisons les commandes de rendu 2D vues plus haut, histoire de simplifier le tout. Imaginez que vous codez un jeu vidéo et que le rendu se fait en 2D, partons sur un jeu de type FPS. Vous avez une série de commandes pour calculer l'image à rendre à l'écran, suivie par une série de commandes finales pour dessiner le HUB. Pour dessiner le HUD, vous utilisez des commandes HOSTDATA_BLT, dont le but est d'écrire une chaîne de caractères à l'écran ou copier une série d'image bitmap dans la mémoire vidéo. Et bien ces commandes HOSTDATA_BLT doivent démarrer une fois que le rendu de l'image est complétement terminé. Imaginez que vous dessiniez le HUD sur une portion de l'image pas encore terminée et que celui-ci est effacé par des écritures ultérieures ! 

Pour éviter tout problème, les GPU incorporent des commandes de synchronisation intra-GPU, destinées au processeur de commande, aussis appelées des '''commandes de sémaphore'''. Elles permettent de mettre en pause le lancement d'une nouvelle commande tant que les précédentes ne sont pas totalement ou partiellement terminées. Les plus simples empêchent le démarrage d'une commande tant que les précédentes ne sont pas terminées. D'autres permettent de démarrer une commande si et seulement si certaines commandes sont terminées. D'autres sont encore plus précises : elles empêchent le démarrage d'une nouvelle commande tant qu'une commande précédente n'a pas atteint un certain stade de son exécution. Là encore, de telles commandes sont des commandes du style &quot;attend que le registre de statut numéro N contienne la valeur adéquate avant de poursuivre l'exécution des commandes&quot;. 

Les commandes en question peuvent être sur le même modèle que précédemment, à savoir des commandes qui lisent les registres de statut. Mais elles peuvent aussi se baser sur le fait que telle ou telle ressource de rendu est libre ou non. Des commandes successives se partagent souvent des données, et que de nombreuses commandes différentes peuvent s'exécuter en même temps. Or, si une commande veut modifier les données utilisées par une autre commande, il faut que l'ordre des commandes soit maintenu : la commande la plus récente ne doit pas modifier les données utilisées par une commande plus ancienne. Avec ce modèle, les sémaphores bloquent une commande tant qu'une ressource (une texture) est utilisée par une autre commande.

{|class=&quot;wikitable&quot;
|-
! Commandes de synchronisation
! Fonction
|-
|NOP 
|Ne rien faire
|-
|WAIT_SEMAPHORE 
|Attendre la synchronisation avec un sémaphore
|-
|WAIT_MEM 
|Attendre que la mémoire vidéo soit disponible et inoccupée par le CPU
|}

==L'arbitrage de l'accès à la carte graphique==

Il n'est pas rare que plusieurs applications souhaitent accéder en même temps à la carte graphique. Imaginons que vous regardez une vidéo en ''streaming'' sur votre navigateur web, avec un programme de ''cloud computing'' de type ''Folding@Home'' qui tourne en arrière-plan, sur Windows. Le décodage de la vidéo est réalisé par la carte graphique, Windows s'occupe de l'affichage du bureau et des fenêtres, le navigateur web doit afficher tout ce qui est autour de la vidéo (la page web), le programme de ''cloud computing'' va lancer ses calculs sur la carte graphique, etc. Des situations de ce genre sont assez courantes et c'est soit le pilote qui s'en charge, soit la carte graphique elle-même.

===L'arbitrage logiciel du GPU===

L'arbitrage logiciel est la méthode la plus simple. Concrètement, c'est le système d'exploitation et/ou le pilote de la carte graphique qui gèrent l'arbitrage du GPU. Dans les deux cas, tout est fait en logiciel. Les commandes sont accumulées dans un tampon de commande, voire plusieurs, et l'OS/pilote décide quelle commande envoyer en priorité.

Sur Windows, avant l'arrivée du modèle de driver dit ''Windows Display Driver Model'', de telles situations étaient gérées simplement. Les applications ajoutaient des commandes dans une file de commande unique. Les commandes étaient exécutées dans l'ordre, en mode premier entrée dans la file premier sorti/exécuté. Il n'y avait pour ainsi dire pas d'arbitrage entre les applications. Et ce n'était pas un problème car, à l'époque, les seules applications qui utilisaient le GPU étaient des jeux vidéos fonctionnant en mode plein écran.

Avec le modèle de driver ''Windows Display Driver Model'' (WDDM), le GPU est maintenant arbitré, à savoir que les applications ont accès à tour de rôle au GPU, certaines ayant droit à plus de temps GPU que d'autres. Chaque programme a accès à la carte graphique durant quelques dizaines ou centaines de millisecondes, à tour de rôle. Si le programme finissait son travail en moins de temps que la durée impartie, il laissait la main au programme suivant. S’il atteignait la durée maximale allouée, il était interrompu pour laisser la place au programme suivant. Et chaque programme avait droit d'accès à la carte graphique chacun à son tour. Un tel algorithme en tourniquet est très simple, mais avait cependant quelques défauts. De nos jours, les algorithmes d'ordonnancement d'accès sont plus élaborés, bien qu'il soit difficile de trouver de la littérature ou des brevets sur le sujet.

Une autre fonctionnalité de WDDM est que les applications utilisant le GPU peuvent se partager la mémoire vidéo sans se marcher dessus. Avant, toutes les applications avaient accès à toute la mémoire vidéo, bien que ce soit par l’intermédiaire de commandes spécifiques. Mais avec WDDM, chaque application dispose de sa propre portion de mémoire vidéo, à laquelle est la seule à avoir accès. Une application ne peut plus lire le contenu réel de la mémoire vidéo, et encore moins lire le contenu des autres applications.

: Il s'agit d'un équivalent à l'isolation des processus pour les programmes Windows, mais appliqué à la mémoire vidéo et non la mémoire système. Et cette isolation est rendue d'autant plus simple que les GPU modernes implémentent un système de mémoire virtuelle à pagination très poussé, avec du swap en mémoire RAM système, une protection mémoire, et bien d'autres fonctionnalités. Nous en reparlerons dans les chapitres sur la mémoire vidéo.

===L'arbitrage accéléré par le GPU===

Depuis 2020, avec l'arrivée de la ''Windows 10 May 2020 update'', Windows est capable de déléguer l'arbitrage du GPU au GPU lui-même. Le  GPU gère lui-même l'arbitrage, du moins en partie. En partie, car l'OS gére les priorité, à savoir quelle application a droit à plus de temps que les autres. Par contre, la gestion du ''quantum'' de temps ou les commutations de contexte (on stoppe une application pour laisser la place à une autre), est du fait du GPU lui-même.

L'avantage est que cela décharge le processeur d'une tâche assez lourde en calcul, pour la déporter sur le GPU. Un autre avantage est que le GPU peut gérer plus finement les ''quantum'' de temps et la commutation de contexte. Le CPU principal gère des durées assez importantes, de l'ordre de la milliseconde. De plus, il doit communiquer avec le GPU par des mécanismes temporellement imprécis, comme des interruptions. Avec l'arbitrage accéléré par le GPU, le GPU n'a plus besoin de communiquer avec le CPU pour l'arbitrage et peut le faire plus précisément, plus immédiatement. Un gain en performance théorique est donc possible.

L'arbitrage accéléré par le GPU est le fait soit du processeur de commandes, soit d'un processeur spécialisé, séparé.

{{NavChapitre | book=Les cartes graphiques
           | prev=La hiérarchie mémoire d'un GPU
           | prevText=La hiérarchie mémoire d'un GPU
           | next=Le pipeline géométrique d'avant DirectX 10
           | netxText=Le pipeline géométrique d'avant DirectX 10
}}{{autocat}}</text>
      <sha1>oprf9vu2e5gm04tmdoaqmum7exib550</sha1>
    </revision>
    <revision>
      <id>744033</id>
      <parentid>744011</parentid>
      <timestamp>2025-06-03T13:43:54Z</timestamp>
      <contributor>
        <username>Mewtow</username>
        <id>31375</id>
      </contributor>
      <minor />
      <comment>/* Le tampon de commandes */</comment>
      <origin>744033</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="32476" sha1="rpjowl8on9mmuplhqtfmb7ghvov9iy6" xml:space="preserve">Dans ce chapitre, nous allons parler de tous les intermédiaires qui se placent entre une application de rendu 3D et les circuits de rendu 3D proprement dit. En premier lieu, on trouve le pilote de la carte graphique, aux fonctions multiples et variées. En second lieu, nous allons parler d'un circuit de la carte graphique qui fait l'interface entre le logiciel et les circuits de rendu 3D de la carte graphique : le processeur de commandes. Ce processeur de commandes est un circuit qui sert de chef d'orchestre, qui pilote le fonctionnement global de la carte graphique. API 3D, pilote de carte graphique et processeur de commande travaillent de concert pour que l'application communique avec la carte graphique. Nous allons d'abord voir le pilote de la carte graphique, avant de voir le fonctionnement du processeur de commande.

==Le pilote de carte graphique==

Le pilote de la carte graphique est un logiciel qui s'occupe de faire l'interface entre le logiciel et la carte graphique. De manière générale, les pilotes de périphérique sont des intermédiaires entre les applications/APIs et le matériel. En théorie, le système d'exploitation est censé jouer ce rôle, mais il n'est pas programmé pour être compatible avec tous les périphériques vendus sur le marché. À la place, le système d'exploitation ne gère pas directement certains périphériques, mais fournit de quoi ajouter ce qui manque. Le pilote d'un périphérique sert justement à ajouter ce qui manque : ils ajoutent au système d'exploitation de quoi reconnaître le périphérique, de quoi l'utiliser au mieux. Pour une carte graphique, il a diverses fonctions que nous allons voir ci-dessous.

Avant toute chose, précisons que les systèmes d'exploitation usuels (Windows, Linux, MacOsX et autres) sont fournis avec un pilote de carte graphique générique, compatible avec la plupart des cartes graphiques existantes. Rien de magique derrière cela : toutes les cartes graphiques vendues depuis plusieurs décennies respectent des standards, comme le VGA, le VESA, et d'autres. Et le pilote de base fournit avec le système d'exploitation est justement compatible avec ces standards minimaux. Mais le pilote ne peut pas profiter des fonctionnalités qui sont au-delà de ce standard. L'accélération 3D est presque inexistante avec le pilote de base, qui ne sert qu'à faire du rendu 2D (de quoi afficher l’interface de base du système d'exploitation, comme le bureau de Windows). Et même pour du rendu 2D, la plupart des fonctionnalités de la carte graphique ne sont pas disponibles. Par exemple, certaines résolutions ne sont pas disponibles, notamment les grandes résolutions. Ou encore, les performances sont loin d'être excellentes. Si vous avez déjà utilisé un PC sans pilote de carte graphique installé, vous avez certainement remarqué qu'il était particulièrement lent.

===La gestion des interruptions===

Une fonction particulièrement importante du pilote de carte graphique est la réponse aux interruptions lancées par la carte graphique. Pour rappel, les interruptions sont une fonctionnalité qui permet à un périphérique de communiquer avec le processeur, tout en économisant le temps de calcul de ce dernier. Typiquement, lorsqu'un périphérique lance une interruption, le processeur stoppe son travail et exécute automatiquement une routine d'interruption, un petit programme qui s'occupe de gérer le périphérique, de faire ce qu'il faut, ce que l'interruption a demandé.

Il y a plusieurs interruptions possibles, chacune ayant son propre numéro et sa fonction dédiée, chacune ayant sa propre routine d'interruption. Après tout, la routine qui gère un débordement de la mémoire vidéo n'est pas la même que celle qui gère un changement de fréquence du GPU ou la fin du calcul d'une image 3D. Le pilote fournit l'ensemble des routines d'interruptions nécessaires pour gérer la carte graphique.

===La compilation des ''shaders''===

Le pilote de carte graphique est aussi chargé de traduire les ''shaders'' en code machine. En soi, cette étape est assez complexe, et ressemble beaucoup à la compilation d'un programme informatique normal. Les ''shaders'' sont écrits dans un langage de programmation de haut niveau, comme le HLSL ou le GLSL, mais ce n'est pas ce code source qui est compilé par le pilote de carte graphique. À la place, les ''shaders'' sont pré-compilés vers un langage dit intermédiaire, avant d'être compilé par le pilote en code machine. Le langage intermédiaire, comme son nom l'indique, sert d'intermédiaire entre le code source écrit en HLSL/GLSL et le code machine exécuté par la carte graphique. Il ressemble à un langage assembleur, mais reste malgré tout assez générique pour ne pas être un véritable code machine. Par exemple, il y a peu de limitations quant au nombre de processeurs ou de registres. En clair, il y a deux passes de compilation : une passe de traduction du code source en langage intermédiaire, puis une passe de compilation du code intermédiaire vers le code machine. Notons que la première passe est réalisée par le programmeur des ''shaders'', non pas par l'utilisateur. Par exemple, les ''shaders'' d'un jeu vidéo sont fournis déjà pré-compilés : les fichiers du jeu ne contiennent pas le code source GLSL/HLSL, mais du code intermédiaire.

L'avantage de cette méthode est que le travail du pilote est fortement simplifié. Le pilote de périphérique pourrait compiler directement du code HLSL/GLSL, mais le temps de compilation serait très long et cela aurait un impact sur les performances. Avec l'usage du langage intermédiaire, le gros du travail à été fait lors de la première passe de compilation et le pilote graphique ne fait que finir le travail. Les optimisations importantes ont déjà été réalisées lors de la première passe. Il doit bien faire la traduction, ajouter quelques optimisations de bas niveau par-ci par-là, mais rien de bien gourmand en processeur. Autant dire que cela économise plus le processeur que si on devait compiler complètement les ''shaders'' à chaque exécution.

Fait amusant, il faut savoir que le pilote peut parfois remplacer les ''shaders'' d'un jeu vidéo à la volée. Les pilotes récents embarquent en effet des ''shaders'' alternatifs pour les jeux les plus vendus et/ou les plus populaires. Lorsque vous lancez un de ces jeux vidéo et que le ''shader'' originel s'exécute, le pilote le détecte automatiquement et le remplace par la version améliorée, fournie par le pilote. Évidemment, le ''shader'' alternatif du pilote est optimisé pour le matériel adéquat. Cela permet de gagner en performance, voire en qualité d'image, sans pour autant que les concepteurs du jeu n'aient quoique ce soit à faire.

Enfin, certains ''shaders'' sont fournis par le pilote pour d'autres raisons. Par exemple, les cartes graphiques récentes n'ont pas de circuits fixes pour traiter la géométrie. Autant les anciennes cartes graphiques avaient des circuits de T&amp;L qui s'en occupaient, autant tout cela doit être émulé sur les machines récentes. Sans cette émulation, les vieux jeux vidéo conçus pour exploiter le T&amp;L et d'autres technologies du genre ne fonctionneraient plus du tout. Émuler les circuits fixes disparus sur les cartes récentes est justement le fait de ''shaders'', présents dans le pilote de carte graphique.

===Les autres fonctions===

Le pilote a aussi bien d'autres fonctions. Par exemple, il s'occupe d'initialiser la carte graphique, de fixer la résolution, d'allouer la mémoire vidéo, de gérer le curseur de souris matériel, etc.

==Les commandes graphiques/vidéo/autres : des ordres envoyés au GPU==

Tous les traitements que la carte graphique doit effectuer, qu'il s'agisse de rendu 2D, de calculs 2D, du décodage matérielle d'un flux vidéo, ou de calculs généralistes, sont envoyés par le pilote de la carte graphique, sous la forme de '''commandes'''. Ces commandes demandent à la carte graphique d'effectuer une opération 2D, ou une opération 3D, ou encore le rendu d'une vidéo.

Les commandes graphiques en question varient beaucoup selon la carte graphique. Les commandes sont régulièrement revues et chaque nouvelle architecture a quelques changements par rapport aux modèles plus anciens. Des commandes peuvent apparaître, d'autres disparaître, d'autre voient leur fonctionnement légèrement altéré, etc.

Mais dans les grandes lignes, on peut classer ces commandes en quelques grands types. Les commandes les plus importantes s'occupent de l'affichage 3D : afficher une image à partir de paquets de sommets, préparer le passage d'une image à une autre, changer la résolution, etc. Plus rare, d'autres commandes servent à faire du rendu 2D : afficher un polygone, tracer une ligne, coloriser une surface, etc. Sur les cartes graphiques qui peuvent accélérer le rendu des vidéos, il existe des commandes spécialisées pour l’accélération des vidéos.

Pour donner quelques exemples, prenons les commandes 2D de la carte graphique AMD Radeon X1800.

{|class=&quot;wikitable&quot;
|-
! Commandes 2D 
! Fonction
|-
|PAINT 	
|Peindre un rectangle d'une certaine couleur
|-
|PAINT_MULTI 	
|Peindre des rectangles (pas les mêmes paramètres que PAINT)
|-
|BITBLT 	
|Copie d'un bloc de mémoire dans un autre
|-
|BITBLT_MULTI 	
|Plusieurs copies de blocs de mémoire dans d'autres
|-
|TRANS_BITBLT 	
|Copie de blocs de mémoire avec un masque
|-
|NEXTCHAR 	
|Afficher un caractère avec une certaine couleur
|-
|HOSTDATA_BLT 	
|Écrire une chaîne de caractères à l'écran ou copier une série d'image bitmap dans la mémoire vidéo
|-
|POLYLINE 	
|Afficher des lignes reliées entre elles
|-
|POLYSCANLINES
|Afficher des lignes
|-
|PLY_NEXTSCAN 	
|Afficher plusieurs lignes simples
|-
|SET_SCISSORS 	
|Utiliser des coupes (ciseaux)
|-
|LOAD_PALETTE 	
|Charger la palette pour affichage 2D
|}

===Le tampon de commandes===

L'envoi des commandes à la carte graphique ne se fait pas directement. La carte graphique n'est pas toujours libre pour accepter une nouvelle commande, soit parce qu'elle est occupée par une commande précédente, soit parce qu'elle fait autre chose. Il faut alors faire patienter les données tant que la carte graphique est occupée. Les pilotes de la carte graphique vont les mettre en attente dans le '''tampon de commandes'''. 

Le tampon de commandes est ce qu'on appelle une file, une zone de mémoire dans laquelle on stocke des données dans l'ordre d'ajout. Si le tampon de commandes est plein, le driver n'accepte plus de demandes en provenance des applications. Un tampon de commandes plein est généralement mauvais signe : cela signifie que la carte graphique est trop lente pour traiter les demandes qui lui sont faites. Par contre, il arrive que le tampon de commandes soit vide : dans ce cas, c'est simplement que la carte graphique est trop rapide comparé au processeur, qui n'arrive alors pas à donner assez de commandes à la carte graphique pour l'occuper suffisamment.

Le tampon de commande est soit une mémoire FIFO séparée, soit une portion de la mémoire vidéo. Le NV1, la toute première carte graphique NVIDIA, utilisait une mémoire FIFO intégrée à la carte graphique, séparée des autres circuits. Le NV1 contenait dans le détail : un controleur DMA avec une IO-MMU intégrée, la FIFO de commande, le processeur de commande, un pipeline graphique, un pipeline sonore, un contrôleur de manette. L'ensemble était relié par un bus interne à la carte graphique. Le processeur envoyait les commandes par rafale au GPU, à savoir qu'il envoyait plusieurs dizaines ou centaines de commandes à la suite, avant de passer à autre chose. Le GPU traitait les commandes une par une, à un rythme bien plus lent. Le processeur pouvait consulter la FIFO pour savoir s'il restait des entrées libres et combien. Le processeur savait ainsi combien d'écritures il pouvait envoyer en une fois au GPU.

: Le fonctionnement de la FIFO du NV1 est décrit dans le brevet ''US5805930A : System for FIFO informing the availability of stages to store commands which include data and virtual address sent directly from application programs''.

===Le processeur de commandes===

Le '''processeur de commande''' est un circuit qui gère les commandes envoyées par le processeur. Il lit la commande la plus ancienne dans le tampon de commande, l’interprète et l’exécute, et recommence ainsi de suite. Le processeur de commande est chargé de piloter les circuits de la carte graphique. Un point important est qu'il répartit le travail entre les différents circuits de la carte graphique et assure que l'ordre du pipeline est respecté. En soi, le processeur de commande est un circuit assez compliqué. Sur les cartes graphiques anciennes, c'était un circuit séquentiel complexe, fabriqué à la main et était la partie la plus complexe du processeur graphique. Sur les cartes graphiques modernes, c'est un véritable microcontrôleur, avec un processeur, de la mémoire RAM, etc.

Le processeur de commandes récupère les commandes dans le tampon de commande, en mémoire RAM, pour les recopier dans la mémoire vidéo et/ou une mémoire interne. Cette copie se fait via la technologie DMA, une technologie de transfert de données entre mémoire RAM et périphérique qui n'utilise pas le processeur principal. Une fois la copie faite, le processeur de commande décode la commande et l’exécute sur la carte graphique. Il garde en mémoire l'état de traitement de chaque commande : est-ce qu'elle est en train de s’exécuter sur le processeur graphique, est-ce qu'elle est mise en pause, est-ce qu'elle attend une donnée en provenance de la mémoire, est-ce qu'elle est terminée, etc.

Une commande utilise divers circuits de la carte 3D, de la mémoire vidéo, et d'autres ressources au sens large : des processeurs de ''shader'', notamment. La fonction principale du processeur de commande est de répartir le travail entre les différents circuits. Le processeur de commande décide à quel processeur ou circuit doit être envoyé une commande. C'est le processeur de commande qui s'occupe de la gestion des ressources et qui attribue telle ressource à telle commande.

A chaque instant, le processeur de commande répartit les ''shaders'' sur les processeurs de ''shaders'', en faisant en sorte qu'ils soient utilisés le plus possible. Dans le cas le plus simple, les unités sont alimentées en vertex/pixels les unes après les autres (principe du round-robin), mais des stratégies plus optimisées sont la règle de nos jours. Cela est très important sur les cartes graphiques : répartir plusieurs commandes sur plusieurs processeurs est une tâche difficile.

Il envoie aussi certaines commandes aux circuits fixes, comme l’''input assembler''. Là encore, il faut en sorte que les circuits fixes soient utilisés le plus possible et évite au maximum les situations où ces circuits n'ont rien à faire. Sa tâche est compliquée par le fait que les cartes graphiques actuelles dupliquent leurs unités pour pouvoir faire beaucoup de calculs en parallèle. Elles ont plusieurs unités de traitement des sommets et des pixels, plusieurs ROP, plusieurs unités de textures, etc. Et c'est en partie le travail du processeur de commande que de répartir les calculs sur ces différentes unités.

[[File:Architecture de base d'une carte 3D - 1.png|centre|vignette|upright=2.5|Architecture de base d'une carte 3D - 1]]

C'est là un problème assez compliqué pour le processeur de commande et ce pour tout un tas de raisons que nous ne ferons que survoler. Les contraintes d'ordonnancement de l'API et les règles de celle-ci sont une partie de la réponse. Mais d'autres raisons sont intrinsèques au rendu 3D ou à la conception des circuits.

===L'ordonnancement et la gestion des ressources===

Le processeur de commande doit souvent mettre en pause certains circuits du pipeline, ainsi que les circuits précédents. Par exemple, si tous les processeurs de ''vertex shader'' sont occupés, l’''input assembler'' ne peut pas charger le paquet suivant car il n'y a aucun processeur de libre pour l’accueillir. Dans ce cas, l'étape d’''input assembly'' est mise en pause en attendant qu'un processeur de ''shader'' soit libre.

La même chose a lieu pour l'étape de rastérisation : si aucun processeur de ''shader'' n'est libre, elle est mise en pause. Sauf que pour la rastérisation, cela a des conséquences sur les circuits précédents la rastérisation. Si un processeur de ''shader'' veut envoyer quelque chose au rastériseur alors qu'il est en pause, il devra lui aussi attendre que le rastériseur soit libre. On a la même chose quand les ROP sont occupés : les ''pixel shader'' ou l'unité de texture doivent parfois être mis en pause, ce qui peut entrainer la mise en pause des étapes précédentes, etc.

En clair : plus un étape est situé vers la fin du pipeline graphique, plus sa mise en pause a de chances de se répercuter sur les étapes précédentes et de les mettre en pause aussi. Le processeur de commande doit gérer ces situations.

===Le pipelining des commandes===

Dans les cartes graphiques les plus rudimentaires, le processeur de commande exécute les commandes dans l'ordre. Il exécute une commande çà la fois et attend qu'une commande soit terminé pour en lancer une autre. Plusieurs commandes sont accumulées dans le tampon de commande, le processeur de commande les traite de la plus ancienne vers la plus récente. Du moins, les anciennes cartes graphiques faisaient comme cela, les cartes graphiques modernes sont un peu plus complexes. Elles n'attendent pas qu'une commande soit totalement terminée avant d'en lancer une nouvelle. Les processeurs de commande actuels sont capables d’exécuter plusieurs commandes en même temps.

L'intérêt est un gain en performance assez important. Pour ceux qui ont déjà eu un cours d'architecture des ordinateurs avancé, lancer plusieurs commandes en même temps permet une forme de pipeline, dont les gains sont substantiels. Par exemple, imaginez qu'une commande de rendu 3D soit bien avancée et n'utilise que les processeurs de ''shaders'' et les ROP, mais laisse les unités géométriques libres. Il est alors possible de démarrer la commande suivante en avance, afin qu'elle remplisse les unités géométriques inutilisées. On a alors deux commandes en cours de traitement : une commande qui utilise la fin du pipeline uniquement, une autre qui utilise seulement le début du pipeline graphique.

Le processeur de commande gère donc plusieurs commandes simultanées, à savoir plusieurs commandes qui en sont à des étapes différentes du pipeline. On peut avoir une commande qui est en cours dans l'étage de gestion de la géométrie, une autre dans le rastériseur, et une autre dans les unités de traitement des pixels. Le fait que les étapes du pipeline graphique sont à effectuer dans un ordre bien précis permet ce genre de chose assez facilement.

Une autre possibilité est de faire des rendus en parallèle. Par exemple, imaginez qu'on ait des circuits séparés pour le rendu 2D et 3D. Prenons l'exemple où le calcul d'une image finale demande de faire un rendu 3D suivi d'un rendu 2D, par exemple un jeu vidéo en 3D qui a un HUD dessiné en 2D. Dans ce cas, on peut démarrer le calcul de l'image suivante dans le pipeline 3D pendant que la précédente est dans les circuits 2D, au lieu de laisser inutilisé le pipeline 3D pendant le rendu 2D.

Mais c'est là un défi compliqué à relever pour le processeur de commande, qui donne lieu à son lot de problèmes. Le problème principal est le partage de ressources entre commandes. Par exemple, on peut prendre le cas où une commande n'utilise pas beaucoup les processeurs de ''shaders''. On pourrait imaginer lancer une seconde commande en parallèle, afin que la seconde commande utiliser les processeurs de ''shaders'' inutilisés. Mais cela n'est possible que si les circuits fixes sont capables d'accepter une seconde commande. Si la première commande sature les circuits fixe, le lancement de la seconde commande sera empêché. Mais si ce n'est pas le cas, les deux commandes pourront être lancées en même temps. Pareil pour le débit mémoire, qui doit alors être partagé entre deux commandes simultanées, ce qui est à prendre en compte.

===La synchronisation de l’exécution des commandes avec le processeur===

Il arrive que le processeur doive savoir où en est le traitement des commandes, ce qui est très utile pour la gestion de la mémoire vidéo. 

Un premier exemple : comment éviter de saturer une carte graphique de commande, alors qu'on ne sait pas si elles traite les commandes rapidement ou non ? L'idéal est de regarder où en est la carte graphique dans l'exécution des commandes. Si elle n'en est qu'au début du tampon de commande et que celui-ci est bien remplit, alors il vaut mieux lever le pied et ne pas envoyer de nouvelles commandes. A l'inverse, si le tampon de commande est presque vide, envoyer des commandes est la meilleure idée possible.

Un autre exemple un peu moins parlant est celui de la gestion de la mémoire vidéo. Rappelons qu'elle est réalisée par le pilote de la carte graphique, sur le processeur principal, qui décide d'allouer et de libérer de la mémoire vidéo. Pour donner un exemple d'utilisation, imaginez que le pilote de la carte graphique doive libérer de la mémoire pour pouvoir ajouter une nouvelle commande. Comment éviter d'enlever une texture tant que les commandes qui l'utilisent ne sont pas terminées ? Ce problème ne se limite pas aux textures, mais vaut pour tout ce qui est placé en mémoire vidéo. 

Il faut donc que la carte graphique trouve un moyen de prévenir le processeur que le traitement de telle commande est terminée, que telle commande en est rendue à tel ou tel point, etc. Pour cela, on a globalement deux grandes solutions. La première est celle des interruptions, abordées dans les chapitres précédents. Mais elles sont assez couteuses et ne sont utilisées que pour des évènements vraiment importants, critiques, qui demandent une réaction rapide du processeur. L'autre solution est celle du ''pooling'', où le processeur monitore la carte graphique à intervalles réguliers. Deux solutions bien connues de ceux qui ont déjà lu un cours d'architecture des ordinateurs digne de ce nom, rien de bien neuf : la carte graphique communique avec le processeur comme tout périphérique.

Pour faciliter l'implémentation du ''pooling'', la carte graphique contient des registres de statut, dans le processeur de commande, qui mémorisent tout ou partie de l'état de la carte graphique. Si un problème survient, certains bits du registre de statut seront mis à 1 pour indiquer que telle erreur bien précise a eu lieu. Il existe aussi un registre de statut qui mémorise le numéro de la commande en cours, ou de la dernière commande terminée, ce qui permet de savoir où en est la carte graphique dans l'exécution des commandes. Et certaines registres de statut sont dédiés à la gestion des commandes. Ils sont totalement programmable, la carte graphique peut écrire dedans sans problème.

Les cartes graphiques récentes incorporent des commandes pour modifier ces registres de statut au besoin. Elles sont appelées des '''commandes de synchronisation''' : les barrières (''fences''). Elles permettent d'écrire une valeur dans un registre de statut quand telle ou telle condition est remplie. Par exemple, si jamais une commande est terminée, on peut écrire la valeur 1 dans tel ou tel registre. La condition en question peut être assez complexe et se résumer à quelque chose du genre : &quot;si jamais toutes les ''shaders'' ont fini de traiter tel ensemble de textures, alors écrit la valeur 1024 dans le registre de statut numéro 9&quot;.

===La synchronisation de l’exécution des commandes intra-GPU===

Lancer plusieurs commandes en parallèle dans le pipeline permet de gagner en performance.Mais cela a un gros défaut : il n'est pas garantit que les commandes se terminent dans l'ordre. Si on démarre une seconde commande après la première, il arrive que la seconde finisse avant. Pire : il n'est pas garantit qu'elles s'exécutent dans l'ordre. Dans la plupart des cas, cela ne pose pas de problèmes. Mais dans d'autres, cela donne des résultats erronés.

Pour donner un exemple, utilisons les commandes de rendu 2D vues plus haut, histoire de simplifier le tout. Imaginez que vous codez un jeu vidéo et que le rendu se fait en 2D, partons sur un jeu de type FPS. Vous avez une série de commandes pour calculer l'image à rendre à l'écran, suivie par une série de commandes finales pour dessiner le HUB. Pour dessiner le HUD, vous utilisez des commandes HOSTDATA_BLT, dont le but est d'écrire une chaîne de caractères à l'écran ou copier une série d'image bitmap dans la mémoire vidéo. Et bien ces commandes HOSTDATA_BLT doivent démarrer une fois que le rendu de l'image est complétement terminé. Imaginez que vous dessiniez le HUD sur une portion de l'image pas encore terminée et que celui-ci est effacé par des écritures ultérieures ! 

Pour éviter tout problème, les GPU incorporent des commandes de synchronisation intra-GPU, destinées au processeur de commande, aussis appelées des '''commandes de sémaphore'''. Elles permettent de mettre en pause le lancement d'une nouvelle commande tant que les précédentes ne sont pas totalement ou partiellement terminées. Les plus simples empêchent le démarrage d'une commande tant que les précédentes ne sont pas terminées. D'autres permettent de démarrer une commande si et seulement si certaines commandes sont terminées. D'autres sont encore plus précises : elles empêchent le démarrage d'une nouvelle commande tant qu'une commande précédente n'a pas atteint un certain stade de son exécution. Là encore, de telles commandes sont des commandes du style &quot;attend que le registre de statut numéro N contienne la valeur adéquate avant de poursuivre l'exécution des commandes&quot;. 

Les commandes en question peuvent être sur le même modèle que précédemment, à savoir des commandes qui lisent les registres de statut. Mais elles peuvent aussi se baser sur le fait que telle ou telle ressource de rendu est libre ou non. Des commandes successives se partagent souvent des données, et que de nombreuses commandes différentes peuvent s'exécuter en même temps. Or, si une commande veut modifier les données utilisées par une autre commande, il faut que l'ordre des commandes soit maintenu : la commande la plus récente ne doit pas modifier les données utilisées par une commande plus ancienne. Avec ce modèle, les sémaphores bloquent une commande tant qu'une ressource (une texture) est utilisée par une autre commande.

{|class=&quot;wikitable&quot;
|-
! Commandes de synchronisation
! Fonction
|-
|NOP 
|Ne rien faire
|-
|WAIT_SEMAPHORE 
|Attendre la synchronisation avec un sémaphore
|-
|WAIT_MEM 
|Attendre que la mémoire vidéo soit disponible et inoccupée par le CPU
|}

==L'arbitrage de l'accès à la carte graphique==

Il n'est pas rare que plusieurs applications souhaitent accéder en même temps à la carte graphique. Imaginons que vous regardez une vidéo en ''streaming'' sur votre navigateur web, avec un programme de ''cloud computing'' de type ''Folding@Home'' qui tourne en arrière-plan, sur Windows. Le décodage de la vidéo est réalisé par la carte graphique, Windows s'occupe de l'affichage du bureau et des fenêtres, le navigateur web doit afficher tout ce qui est autour de la vidéo (la page web), le programme de ''cloud computing'' va lancer ses calculs sur la carte graphique, etc. Des situations de ce genre sont assez courantes et c'est soit le pilote qui s'en charge, soit la carte graphique elle-même.

===L'arbitrage logiciel du GPU===

L'arbitrage logiciel est la méthode la plus simple. Concrètement, c'est le système d'exploitation et/ou le pilote de la carte graphique qui gèrent l'arbitrage du GPU. Dans les deux cas, tout est fait en logiciel. Les commandes sont accumulées dans un tampon de commande, voire plusieurs, et l'OS/pilote décide quelle commande envoyer en priorité.

Sur Windows, avant l'arrivée du modèle de driver dit ''Windows Display Driver Model'', de telles situations étaient gérées simplement. Les applications ajoutaient des commandes dans une file de commande unique. Les commandes étaient exécutées dans l'ordre, en mode premier entrée dans la file premier sorti/exécuté. Il n'y avait pour ainsi dire pas d'arbitrage entre les applications. Et ce n'était pas un problème car, à l'époque, les seules applications qui utilisaient le GPU étaient des jeux vidéos fonctionnant en mode plein écran.

Avec le modèle de driver ''Windows Display Driver Model'' (WDDM), le GPU est maintenant arbitré, à savoir que les applications ont accès à tour de rôle au GPU, certaines ayant droit à plus de temps GPU que d'autres. Chaque programme a accès à la carte graphique durant quelques dizaines ou centaines de millisecondes, à tour de rôle. Si le programme finissait son travail en moins de temps que la durée impartie, il laissait la main au programme suivant. S’il atteignait la durée maximale allouée, il était interrompu pour laisser la place au programme suivant. Et chaque programme avait droit d'accès à la carte graphique chacun à son tour. Un tel algorithme en tourniquet est très simple, mais avait cependant quelques défauts. De nos jours, les algorithmes d'ordonnancement d'accès sont plus élaborés, bien qu'il soit difficile de trouver de la littérature ou des brevets sur le sujet.

Une autre fonctionnalité de WDDM est que les applications utilisant le GPU peuvent se partager la mémoire vidéo sans se marcher dessus. Avant, toutes les applications avaient accès à toute la mémoire vidéo, bien que ce soit par l’intermédiaire de commandes spécifiques. Mais avec WDDM, chaque application dispose de sa propre portion de mémoire vidéo, à laquelle est la seule à avoir accès. Une application ne peut plus lire le contenu réel de la mémoire vidéo, et encore moins lire le contenu des autres applications.

: Il s'agit d'un équivalent à l'isolation des processus pour les programmes Windows, mais appliqué à la mémoire vidéo et non la mémoire système. Et cette isolation est rendue d'autant plus simple que les GPU modernes implémentent un système de mémoire virtuelle à pagination très poussé, avec du swap en mémoire RAM système, une protection mémoire, et bien d'autres fonctionnalités. Nous en reparlerons dans les chapitres sur la mémoire vidéo.

===L'arbitrage accéléré par le GPU===

Depuis 2020, avec l'arrivée de la ''Windows 10 May 2020 update'', Windows est capable de déléguer l'arbitrage du GPU au GPU lui-même. Le  GPU gère lui-même l'arbitrage, du moins en partie. En partie, car l'OS gére les priorité, à savoir quelle application a droit à plus de temps que les autres. Par contre, la gestion du ''quantum'' de temps ou les commutations de contexte (on stoppe une application pour laisser la place à une autre), est du fait du GPU lui-même.

L'avantage est que cela décharge le processeur d'une tâche assez lourde en calcul, pour la déporter sur le GPU. Un autre avantage est que le GPU peut gérer plus finement les ''quantum'' de temps et la commutation de contexte. Le CPU principal gère des durées assez importantes, de l'ordre de la milliseconde. De plus, il doit communiquer avec le GPU par des mécanismes temporellement imprécis, comme des interruptions. Avec l'arbitrage accéléré par le GPU, le GPU n'a plus besoin de communiquer avec le CPU pour l'arbitrage et peut le faire plus précisément, plus immédiatement. Un gain en performance théorique est donc possible.

L'arbitrage accéléré par le GPU est le fait soit du processeur de commandes, soit d'un processeur spécialisé, séparé.

{{NavChapitre | book=Les cartes graphiques
           | prev=La hiérarchie mémoire d'un GPU
           | prevText=La hiérarchie mémoire d'un GPU
           | next=Le pipeline géométrique d'avant DirectX 10
           | netxText=Le pipeline géométrique d'avant DirectX 10
}}{{autocat}}</text>
      <sha1>rpjowl8on9mmuplhqtfmb7ghvov9iy6</sha1>
    </revision>
    <revision>
      <id>744034</id>
      <parentid>744033</parentid>
      <timestamp>2025-06-03T13:51:04Z</timestamp>
      <contributor>
        <username>Mewtow</username>
        <id>31375</id>
      </contributor>
      <minor />
      <comment>/* Le processeur de commandes */</comment>
      <origin>744034</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="32119" sha1="6hblv3izfmnw77b4h0cud01fc7pnx0d" xml:space="preserve">Dans ce chapitre, nous allons parler de tous les intermédiaires qui se placent entre une application de rendu 3D et les circuits de rendu 3D proprement dit. En premier lieu, on trouve le pilote de la carte graphique, aux fonctions multiples et variées. En second lieu, nous allons parler d'un circuit de la carte graphique qui fait l'interface entre le logiciel et les circuits de rendu 3D de la carte graphique : le processeur de commandes. Ce processeur de commandes est un circuit qui sert de chef d'orchestre, qui pilote le fonctionnement global de la carte graphique. API 3D, pilote de carte graphique et processeur de commande travaillent de concert pour que l'application communique avec la carte graphique. Nous allons d'abord voir le pilote de la carte graphique, avant de voir le fonctionnement du processeur de commande.

==Le pilote de carte graphique==

Le pilote de la carte graphique est un logiciel qui s'occupe de faire l'interface entre le logiciel et la carte graphique. De manière générale, les pilotes de périphérique sont des intermédiaires entre les applications/APIs et le matériel. En théorie, le système d'exploitation est censé jouer ce rôle, mais il n'est pas programmé pour être compatible avec tous les périphériques vendus sur le marché. À la place, le système d'exploitation ne gère pas directement certains périphériques, mais fournit de quoi ajouter ce qui manque. Le pilote d'un périphérique sert justement à ajouter ce qui manque : ils ajoutent au système d'exploitation de quoi reconnaître le périphérique, de quoi l'utiliser au mieux. Pour une carte graphique, il a diverses fonctions que nous allons voir ci-dessous.

Avant toute chose, précisons que les systèmes d'exploitation usuels (Windows, Linux, MacOsX et autres) sont fournis avec un pilote de carte graphique générique, compatible avec la plupart des cartes graphiques existantes. Rien de magique derrière cela : toutes les cartes graphiques vendues depuis plusieurs décennies respectent des standards, comme le VGA, le VESA, et d'autres. Et le pilote de base fournit avec le système d'exploitation est justement compatible avec ces standards minimaux. Mais le pilote ne peut pas profiter des fonctionnalités qui sont au-delà de ce standard. L'accélération 3D est presque inexistante avec le pilote de base, qui ne sert qu'à faire du rendu 2D (de quoi afficher l’interface de base du système d'exploitation, comme le bureau de Windows). Et même pour du rendu 2D, la plupart des fonctionnalités de la carte graphique ne sont pas disponibles. Par exemple, certaines résolutions ne sont pas disponibles, notamment les grandes résolutions. Ou encore, les performances sont loin d'être excellentes. Si vous avez déjà utilisé un PC sans pilote de carte graphique installé, vous avez certainement remarqué qu'il était particulièrement lent.

===La gestion des interruptions===

Une fonction particulièrement importante du pilote de carte graphique est la réponse aux interruptions lancées par la carte graphique. Pour rappel, les interruptions sont une fonctionnalité qui permet à un périphérique de communiquer avec le processeur, tout en économisant le temps de calcul de ce dernier. Typiquement, lorsqu'un périphérique lance une interruption, le processeur stoppe son travail et exécute automatiquement une routine d'interruption, un petit programme qui s'occupe de gérer le périphérique, de faire ce qu'il faut, ce que l'interruption a demandé.

Il y a plusieurs interruptions possibles, chacune ayant son propre numéro et sa fonction dédiée, chacune ayant sa propre routine d'interruption. Après tout, la routine qui gère un débordement de la mémoire vidéo n'est pas la même que celle qui gère un changement de fréquence du GPU ou la fin du calcul d'une image 3D. Le pilote fournit l'ensemble des routines d'interruptions nécessaires pour gérer la carte graphique.

===La compilation des ''shaders''===

Le pilote de carte graphique est aussi chargé de traduire les ''shaders'' en code machine. En soi, cette étape est assez complexe, et ressemble beaucoup à la compilation d'un programme informatique normal. Les ''shaders'' sont écrits dans un langage de programmation de haut niveau, comme le HLSL ou le GLSL, mais ce n'est pas ce code source qui est compilé par le pilote de carte graphique. À la place, les ''shaders'' sont pré-compilés vers un langage dit intermédiaire, avant d'être compilé par le pilote en code machine. Le langage intermédiaire, comme son nom l'indique, sert d'intermédiaire entre le code source écrit en HLSL/GLSL et le code machine exécuté par la carte graphique. Il ressemble à un langage assembleur, mais reste malgré tout assez générique pour ne pas être un véritable code machine. Par exemple, il y a peu de limitations quant au nombre de processeurs ou de registres. En clair, il y a deux passes de compilation : une passe de traduction du code source en langage intermédiaire, puis une passe de compilation du code intermédiaire vers le code machine. Notons que la première passe est réalisée par le programmeur des ''shaders'', non pas par l'utilisateur. Par exemple, les ''shaders'' d'un jeu vidéo sont fournis déjà pré-compilés : les fichiers du jeu ne contiennent pas le code source GLSL/HLSL, mais du code intermédiaire.

L'avantage de cette méthode est que le travail du pilote est fortement simplifié. Le pilote de périphérique pourrait compiler directement du code HLSL/GLSL, mais le temps de compilation serait très long et cela aurait un impact sur les performances. Avec l'usage du langage intermédiaire, le gros du travail à été fait lors de la première passe de compilation et le pilote graphique ne fait que finir le travail. Les optimisations importantes ont déjà été réalisées lors de la première passe. Il doit bien faire la traduction, ajouter quelques optimisations de bas niveau par-ci par-là, mais rien de bien gourmand en processeur. Autant dire que cela économise plus le processeur que si on devait compiler complètement les ''shaders'' à chaque exécution.

Fait amusant, il faut savoir que le pilote peut parfois remplacer les ''shaders'' d'un jeu vidéo à la volée. Les pilotes récents embarquent en effet des ''shaders'' alternatifs pour les jeux les plus vendus et/ou les plus populaires. Lorsque vous lancez un de ces jeux vidéo et que le ''shader'' originel s'exécute, le pilote le détecte automatiquement et le remplace par la version améliorée, fournie par le pilote. Évidemment, le ''shader'' alternatif du pilote est optimisé pour le matériel adéquat. Cela permet de gagner en performance, voire en qualité d'image, sans pour autant que les concepteurs du jeu n'aient quoique ce soit à faire.

Enfin, certains ''shaders'' sont fournis par le pilote pour d'autres raisons. Par exemple, les cartes graphiques récentes n'ont pas de circuits fixes pour traiter la géométrie. Autant les anciennes cartes graphiques avaient des circuits de T&amp;L qui s'en occupaient, autant tout cela doit être émulé sur les machines récentes. Sans cette émulation, les vieux jeux vidéo conçus pour exploiter le T&amp;L et d'autres technologies du genre ne fonctionneraient plus du tout. Émuler les circuits fixes disparus sur les cartes récentes est justement le fait de ''shaders'', présents dans le pilote de carte graphique.

===Les autres fonctions===

Le pilote a aussi bien d'autres fonctions. Par exemple, il s'occupe d'initialiser la carte graphique, de fixer la résolution, d'allouer la mémoire vidéo, de gérer le curseur de souris matériel, etc.

==Les commandes graphiques/vidéo/autres : des ordres envoyés au GPU==

Tous les traitements que la carte graphique doit effectuer, qu'il s'agisse de rendu 2D, de calculs 2D, du décodage matérielle d'un flux vidéo, ou de calculs généralistes, sont envoyés par le pilote de la carte graphique, sous la forme de '''commandes'''. Ces commandes demandent à la carte graphique d'effectuer une opération 2D, ou une opération 3D, ou encore le rendu d'une vidéo.

Les commandes graphiques en question varient beaucoup selon la carte graphique. Les commandes sont régulièrement revues et chaque nouvelle architecture a quelques changements par rapport aux modèles plus anciens. Des commandes peuvent apparaître, d'autres disparaître, d'autre voient leur fonctionnement légèrement altéré, etc.

Mais dans les grandes lignes, on peut classer ces commandes en quelques grands types. Les commandes les plus importantes s'occupent de l'affichage 3D : afficher une image à partir de paquets de sommets, préparer le passage d'une image à une autre, changer la résolution, etc. Plus rare, d'autres commandes servent à faire du rendu 2D : afficher un polygone, tracer une ligne, coloriser une surface, etc. Sur les cartes graphiques qui peuvent accélérer le rendu des vidéos, il existe des commandes spécialisées pour l’accélération des vidéos.

Pour donner quelques exemples, prenons les commandes 2D de la carte graphique AMD Radeon X1800.

{|class=&quot;wikitable&quot;
|-
! Commandes 2D 
! Fonction
|-
|PAINT 	
|Peindre un rectangle d'une certaine couleur
|-
|PAINT_MULTI 	
|Peindre des rectangles (pas les mêmes paramètres que PAINT)
|-
|BITBLT 	
|Copie d'un bloc de mémoire dans un autre
|-
|BITBLT_MULTI 	
|Plusieurs copies de blocs de mémoire dans d'autres
|-
|TRANS_BITBLT 	
|Copie de blocs de mémoire avec un masque
|-
|NEXTCHAR 	
|Afficher un caractère avec une certaine couleur
|-
|HOSTDATA_BLT 	
|Écrire une chaîne de caractères à l'écran ou copier une série d'image bitmap dans la mémoire vidéo
|-
|POLYLINE 	
|Afficher des lignes reliées entre elles
|-
|POLYSCANLINES
|Afficher des lignes
|-
|PLY_NEXTSCAN 	
|Afficher plusieurs lignes simples
|-
|SET_SCISSORS 	
|Utiliser des coupes (ciseaux)
|-
|LOAD_PALETTE 	
|Charger la palette pour affichage 2D
|}

===Le tampon de commandes===

L'envoi des commandes à la carte graphique ne se fait pas directement. La carte graphique n'est pas toujours libre pour accepter une nouvelle commande, soit parce qu'elle est occupée par une commande précédente, soit parce qu'elle fait autre chose. Il faut alors faire patienter les données tant que la carte graphique est occupée. Les pilotes de la carte graphique vont les mettre en attente dans le '''tampon de commandes'''. 

Le tampon de commandes est ce qu'on appelle une file, une zone de mémoire dans laquelle on stocke des données dans l'ordre d'ajout. Si le tampon de commandes est plein, le driver n'accepte plus de demandes en provenance des applications. Un tampon de commandes plein est généralement mauvais signe : cela signifie que la carte graphique est trop lente pour traiter les demandes qui lui sont faites. Par contre, il arrive que le tampon de commandes soit vide : dans ce cas, c'est simplement que la carte graphique est trop rapide comparé au processeur, qui n'arrive alors pas à donner assez de commandes à la carte graphique pour l'occuper suffisamment.

Le tampon de commande est soit une mémoire FIFO séparée, soit une portion de la mémoire vidéo. Le NV1, la toute première carte graphique NVIDIA, utilisait une mémoire FIFO intégrée à la carte graphique, séparée des autres circuits. Le NV1 contenait dans le détail : un controleur DMA avec une IO-MMU intégrée, la FIFO de commande, le processeur de commande, un pipeline graphique, un pipeline sonore, un contrôleur de manette. L'ensemble était relié par un bus interne à la carte graphique. Le processeur envoyait les commandes par rafale au GPU, à savoir qu'il envoyait plusieurs dizaines ou centaines de commandes à la suite, avant de passer à autre chose. Le GPU traitait les commandes une par une, à un rythme bien plus lent. Le processeur pouvait consulter la FIFO pour savoir s'il restait des entrées libres et combien. Le processeur savait ainsi combien d'écritures il pouvait envoyer en une fois au GPU.

: Le fonctionnement de la FIFO du NV1 est décrit dans le brevet ''US5805930A : System for FIFO informing the availability of stages to store commands which include data and virtual address sent directly from application programs''.

===Le processeur de commandes===

Le '''processeur de commande''' est un circuit qui gère les commandes envoyées par le processeur. Il lit la commande la plus ancienne dans le tampon de commande, l’interprète et l’exécute, puis passe à la suivante. Le processeur de commande est un circuit assez compliqué. Sur les cartes graphiques anciennes, c'était un circuit séquentiel complexe, fabriqué à la main et était la partie la plus complexe du processeur graphique. Sur les cartes graphiques modernes, c'est un véritable microcontrôleur, avec un processeur, de la mémoire RAM, etc.

Le processeur de commandes lit une commande dans le tampon de commande, décode la commande et l’exécute sur la carte graphique. Il garde en mémoire l'état de traitement de chaque commande : est-ce qu'elle est en train de s’exécuter sur le processeur graphique, est-ce qu'elle est mise en pause, est-ce qu'elle attend une donnée en provenance de la mémoire, est-ce qu'elle est terminée, etc.

Une commande utilise divers circuits de la carte 3D, de la mémoire vidéo, et d'autres ressources au sens large (des processeurs de ''shader'', notamment). Aussi, le processeur de commande pilote les circuits de la carte graphique, il répartit le travail entre les différents circuits de la carte graphique et assure que l'ordre du pipeline est respecté. La fonction principale du processeur de commande est de répartir le travail entre les différents circuits. Le processeur de commande décide à quel processeur ou circuit doit être envoyé une commande. C'est le processeur de commande qui s'occupe de la gestion des ressources et qui attribue telle ressource à telle commande.

A chaque instant, le processeur de commande répartit les ''shaders'' sur les processeurs de ''shaders'', en faisant en sorte qu'ils soient utilisés le plus possible. Dans le cas le plus simple, les unités sont alimentées en vertex/pixels les unes après les autres (principe du round-robin), mais des stratégies plus optimisées sont la règle de nos jours. Cela est très important sur les cartes graphiques : répartir plusieurs commandes sur plusieurs processeurs est une tâche difficile.

Il envoie aussi certaines commandes aux circuits fixes, comme l’''input assembler''. Là encore, il faut en sorte que les circuits fixes soient utilisés le plus possible et évite au maximum les situations où ces circuits n'ont rien à faire. Sa tâche est compliquée par le fait que les cartes graphiques actuelles dupliquent leurs unités pour pouvoir faire beaucoup de calculs en parallèle. Elles ont plusieurs unités de traitement des sommets et des pixels, plusieurs ROP, plusieurs unités de textures, etc. Et c'est en partie le travail du processeur de commande que de répartir les calculs sur ces différentes unités.

[[File:Architecture de base d'une carte 3D - 1.png|centre|vignette|upright=2.5|Architecture de base d'une carte 3D - 1]]

C'est là un problème assez compliqué pour le processeur de commande et ce pour tout un tas de raisons que nous ne ferons que survoler. Les contraintes d'ordonnancement de l'API et les règles de celle-ci sont une partie de la réponse. Mais d'autres raisons sont intrinsèques au rendu 3D ou à la conception des circuits.

===L'ordonnancement et la gestion des ressources===

Le processeur de commande doit souvent mettre en pause certains circuits du pipeline, ainsi que les circuits précédents. Par exemple, si tous les processeurs de ''vertex shader'' sont occupés, l’''input assembler'' ne peut pas charger le paquet suivant car il n'y a aucun processeur de libre pour l’accueillir. Dans ce cas, l'étape d’''input assembly'' est mise en pause en attendant qu'un processeur de ''shader'' soit libre.

La même chose a lieu pour l'étape de rastérisation : si aucun processeur de ''shader'' n'est libre, elle est mise en pause. Sauf que pour la rastérisation, cela a des conséquences sur les circuits précédents la rastérisation. Si un processeur de ''shader'' veut envoyer quelque chose au rastériseur alors qu'il est en pause, il devra lui aussi attendre que le rastériseur soit libre. On a la même chose quand les ROP sont occupés : les ''pixel shader'' ou l'unité de texture doivent parfois être mis en pause, ce qui peut entrainer la mise en pause des étapes précédentes, etc.

En clair : plus un étape est situé vers la fin du pipeline graphique, plus sa mise en pause a de chances de se répercuter sur les étapes précédentes et de les mettre en pause aussi. Le processeur de commande doit gérer ces situations.

===Le pipelining des commandes===

Dans les cartes graphiques les plus rudimentaires, le processeur de commande exécute les commandes dans l'ordre. Il exécute une commande çà la fois et attend qu'une commande soit terminé pour en lancer une autre. Plusieurs commandes sont accumulées dans le tampon de commande, le processeur de commande les traite de la plus ancienne vers la plus récente. Du moins, les anciennes cartes graphiques faisaient comme cela, les cartes graphiques modernes sont un peu plus complexes. Elles n'attendent pas qu'une commande soit totalement terminée avant d'en lancer une nouvelle. Les processeurs de commande actuels sont capables d’exécuter plusieurs commandes en même temps.

L'intérêt est un gain en performance assez important. Pour ceux qui ont déjà eu un cours d'architecture des ordinateurs avancé, lancer plusieurs commandes en même temps permet une forme de pipeline, dont les gains sont substantiels. Par exemple, imaginez qu'une commande de rendu 3D soit bien avancée et n'utilise que les processeurs de ''shaders'' et les ROP, mais laisse les unités géométriques libres. Il est alors possible de démarrer la commande suivante en avance, afin qu'elle remplisse les unités géométriques inutilisées. On a alors deux commandes en cours de traitement : une commande qui utilise la fin du pipeline uniquement, une autre qui utilise seulement le début du pipeline graphique.

Le processeur de commande gère donc plusieurs commandes simultanées, à savoir plusieurs commandes qui en sont à des étapes différentes du pipeline. On peut avoir une commande qui est en cours dans l'étage de gestion de la géométrie, une autre dans le rastériseur, et une autre dans les unités de traitement des pixels. Le fait que les étapes du pipeline graphique sont à effectuer dans un ordre bien précis permet ce genre de chose assez facilement.

Une autre possibilité est de faire des rendus en parallèle. Par exemple, imaginez qu'on ait des circuits séparés pour le rendu 2D et 3D. Prenons l'exemple où le calcul d'une image finale demande de faire un rendu 3D suivi d'un rendu 2D, par exemple un jeu vidéo en 3D qui a un HUD dessiné en 2D. Dans ce cas, on peut démarrer le calcul de l'image suivante dans le pipeline 3D pendant que la précédente est dans les circuits 2D, au lieu de laisser inutilisé le pipeline 3D pendant le rendu 2D.

Mais c'est là un défi compliqué à relever pour le processeur de commande, qui donne lieu à son lot de problèmes. Le problème principal est le partage de ressources entre commandes. Par exemple, on peut prendre le cas où une commande n'utilise pas beaucoup les processeurs de ''shaders''. On pourrait imaginer lancer une seconde commande en parallèle, afin que la seconde commande utiliser les processeurs de ''shaders'' inutilisés. Mais cela n'est possible que si les circuits fixes sont capables d'accepter une seconde commande. Si la première commande sature les circuits fixe, le lancement de la seconde commande sera empêché. Mais si ce n'est pas le cas, les deux commandes pourront être lancées en même temps. Pareil pour le débit mémoire, qui doit alors être partagé entre deux commandes simultanées, ce qui est à prendre en compte.

===La synchronisation de l’exécution des commandes avec le processeur===

Il arrive que le processeur doive savoir où en est le traitement des commandes, ce qui est très utile pour la gestion de la mémoire vidéo. 

Un premier exemple : comment éviter de saturer une carte graphique de commande, alors qu'on ne sait pas si elles traite les commandes rapidement ou non ? L'idéal est de regarder où en est la carte graphique dans l'exécution des commandes. Si elle n'en est qu'au début du tampon de commande et que celui-ci est bien remplit, alors il vaut mieux lever le pied et ne pas envoyer de nouvelles commandes. A l'inverse, si le tampon de commande est presque vide, envoyer des commandes est la meilleure idée possible.

Un autre exemple un peu moins parlant est celui de la gestion de la mémoire vidéo. Rappelons qu'elle est réalisée par le pilote de la carte graphique, sur le processeur principal, qui décide d'allouer et de libérer de la mémoire vidéo. Pour donner un exemple d'utilisation, imaginez que le pilote de la carte graphique doive libérer de la mémoire pour pouvoir ajouter une nouvelle commande. Comment éviter d'enlever une texture tant que les commandes qui l'utilisent ne sont pas terminées ? Ce problème ne se limite pas aux textures, mais vaut pour tout ce qui est placé en mémoire vidéo. 

Il faut donc que la carte graphique trouve un moyen de prévenir le processeur que le traitement de telle commande est terminée, que telle commande en est rendue à tel ou tel point, etc. Pour cela, on a globalement deux grandes solutions. La première est celle des interruptions, abordées dans les chapitres précédents. Mais elles sont assez couteuses et ne sont utilisées que pour des évènements vraiment importants, critiques, qui demandent une réaction rapide du processeur. L'autre solution est celle du ''pooling'', où le processeur monitore la carte graphique à intervalles réguliers. Deux solutions bien connues de ceux qui ont déjà lu un cours d'architecture des ordinateurs digne de ce nom, rien de bien neuf : la carte graphique communique avec le processeur comme tout périphérique.

Pour faciliter l'implémentation du ''pooling'', la carte graphique contient des registres de statut, dans le processeur de commande, qui mémorisent tout ou partie de l'état de la carte graphique. Si un problème survient, certains bits du registre de statut seront mis à 1 pour indiquer que telle erreur bien précise a eu lieu. Il existe aussi un registre de statut qui mémorise le numéro de la commande en cours, ou de la dernière commande terminée, ce qui permet de savoir où en est la carte graphique dans l'exécution des commandes. Et certaines registres de statut sont dédiés à la gestion des commandes. Ils sont totalement programmable, la carte graphique peut écrire dedans sans problème.

Les cartes graphiques récentes incorporent des commandes pour modifier ces registres de statut au besoin. Elles sont appelées des '''commandes de synchronisation''' : les barrières (''fences''). Elles permettent d'écrire une valeur dans un registre de statut quand telle ou telle condition est remplie. Par exemple, si jamais une commande est terminée, on peut écrire la valeur 1 dans tel ou tel registre. La condition en question peut être assez complexe et se résumer à quelque chose du genre : &quot;si jamais toutes les ''shaders'' ont fini de traiter tel ensemble de textures, alors écrit la valeur 1024 dans le registre de statut numéro 9&quot;.

===La synchronisation de l’exécution des commandes intra-GPU===

Lancer plusieurs commandes en parallèle dans le pipeline permet de gagner en performance.Mais cela a un gros défaut : il n'est pas garantit que les commandes se terminent dans l'ordre. Si on démarre une seconde commande après la première, il arrive que la seconde finisse avant. Pire : il n'est pas garantit qu'elles s'exécutent dans l'ordre. Dans la plupart des cas, cela ne pose pas de problèmes. Mais dans d'autres, cela donne des résultats erronés.

Pour donner un exemple, utilisons les commandes de rendu 2D vues plus haut, histoire de simplifier le tout. Imaginez que vous codez un jeu vidéo et que le rendu se fait en 2D, partons sur un jeu de type FPS. Vous avez une série de commandes pour calculer l'image à rendre à l'écran, suivie par une série de commandes finales pour dessiner le HUB. Pour dessiner le HUD, vous utilisez des commandes HOSTDATA_BLT, dont le but est d'écrire une chaîne de caractères à l'écran ou copier une série d'image bitmap dans la mémoire vidéo. Et bien ces commandes HOSTDATA_BLT doivent démarrer une fois que le rendu de l'image est complétement terminé. Imaginez que vous dessiniez le HUD sur une portion de l'image pas encore terminée et que celui-ci est effacé par des écritures ultérieures ! 

Pour éviter tout problème, les GPU incorporent des commandes de synchronisation intra-GPU, destinées au processeur de commande, aussis appelées des '''commandes de sémaphore'''. Elles permettent de mettre en pause le lancement d'une nouvelle commande tant que les précédentes ne sont pas totalement ou partiellement terminées. Les plus simples empêchent le démarrage d'une commande tant que les précédentes ne sont pas terminées. D'autres permettent de démarrer une commande si et seulement si certaines commandes sont terminées. D'autres sont encore plus précises : elles empêchent le démarrage d'une nouvelle commande tant qu'une commande précédente n'a pas atteint un certain stade de son exécution. Là encore, de telles commandes sont des commandes du style &quot;attend que le registre de statut numéro N contienne la valeur adéquate avant de poursuivre l'exécution des commandes&quot;. 

Les commandes en question peuvent être sur le même modèle que précédemment, à savoir des commandes qui lisent les registres de statut. Mais elles peuvent aussi se baser sur le fait que telle ou telle ressource de rendu est libre ou non. Des commandes successives se partagent souvent des données, et que de nombreuses commandes différentes peuvent s'exécuter en même temps. Or, si une commande veut modifier les données utilisées par une autre commande, il faut que l'ordre des commandes soit maintenu : la commande la plus récente ne doit pas modifier les données utilisées par une commande plus ancienne. Avec ce modèle, les sémaphores bloquent une commande tant qu'une ressource (une texture) est utilisée par une autre commande.

{|class=&quot;wikitable&quot;
|-
! Commandes de synchronisation
! Fonction
|-
|NOP 
|Ne rien faire
|-
|WAIT_SEMAPHORE 
|Attendre la synchronisation avec un sémaphore
|-
|WAIT_MEM 
|Attendre que la mémoire vidéo soit disponible et inoccupée par le CPU
|}

==L'arbitrage de l'accès à la carte graphique==

Il n'est pas rare que plusieurs applications souhaitent accéder en même temps à la carte graphique. Imaginons que vous regardez une vidéo en ''streaming'' sur votre navigateur web, avec un programme de ''cloud computing'' de type ''Folding@Home'' qui tourne en arrière-plan, sur Windows. Le décodage de la vidéo est réalisé par la carte graphique, Windows s'occupe de l'affichage du bureau et des fenêtres, le navigateur web doit afficher tout ce qui est autour de la vidéo (la page web), le programme de ''cloud computing'' va lancer ses calculs sur la carte graphique, etc. Des situations de ce genre sont assez courantes et c'est soit le pilote qui s'en charge, soit la carte graphique elle-même.

===L'arbitrage logiciel du GPU===

L'arbitrage logiciel est la méthode la plus simple. Concrètement, c'est le système d'exploitation et/ou le pilote de la carte graphique qui gèrent l'arbitrage du GPU. Dans les deux cas, tout est fait en logiciel. Les commandes sont accumulées dans un tampon de commande, voire plusieurs, et l'OS/pilote décide quelle commande envoyer en priorité.

Sur Windows, avant l'arrivée du modèle de driver dit ''Windows Display Driver Model'', de telles situations étaient gérées simplement. Les applications ajoutaient des commandes dans une file de commande unique. Les commandes étaient exécutées dans l'ordre, en mode premier entrée dans la file premier sorti/exécuté. Il n'y avait pour ainsi dire pas d'arbitrage entre les applications. Et ce n'était pas un problème car, à l'époque, les seules applications qui utilisaient le GPU étaient des jeux vidéos fonctionnant en mode plein écran.

Avec le modèle de driver ''Windows Display Driver Model'' (WDDM), le GPU est maintenant arbitré, à savoir que les applications ont accès à tour de rôle au GPU, certaines ayant droit à plus de temps GPU que d'autres. Chaque programme a accès à la carte graphique durant quelques dizaines ou centaines de millisecondes, à tour de rôle. Si le programme finissait son travail en moins de temps que la durée impartie, il laissait la main au programme suivant. S’il atteignait la durée maximale allouée, il était interrompu pour laisser la place au programme suivant. Et chaque programme avait droit d'accès à la carte graphique chacun à son tour. Un tel algorithme en tourniquet est très simple, mais avait cependant quelques défauts. De nos jours, les algorithmes d'ordonnancement d'accès sont plus élaborés, bien qu'il soit difficile de trouver de la littérature ou des brevets sur le sujet.

Une autre fonctionnalité de WDDM est que les applications utilisant le GPU peuvent se partager la mémoire vidéo sans se marcher dessus. Avant, toutes les applications avaient accès à toute la mémoire vidéo, bien que ce soit par l’intermédiaire de commandes spécifiques. Mais avec WDDM, chaque application dispose de sa propre portion de mémoire vidéo, à laquelle est la seule à avoir accès. Une application ne peut plus lire le contenu réel de la mémoire vidéo, et encore moins lire le contenu des autres applications.

: Il s'agit d'un équivalent à l'isolation des processus pour les programmes Windows, mais appliqué à la mémoire vidéo et non la mémoire système. Et cette isolation est rendue d'autant plus simple que les GPU modernes implémentent un système de mémoire virtuelle à pagination très poussé, avec du swap en mémoire RAM système, une protection mémoire, et bien d'autres fonctionnalités. Nous en reparlerons dans les chapitres sur la mémoire vidéo.

===L'arbitrage accéléré par le GPU===

Depuis 2020, avec l'arrivée de la ''Windows 10 May 2020 update'', Windows est capable de déléguer l'arbitrage du GPU au GPU lui-même. Le  GPU gère lui-même l'arbitrage, du moins en partie. En partie, car l'OS gére les priorité, à savoir quelle application a droit à plus de temps que les autres. Par contre, la gestion du ''quantum'' de temps ou les commutations de contexte (on stoppe une application pour laisser la place à une autre), est du fait du GPU lui-même.

L'avantage est que cela décharge le processeur d'une tâche assez lourde en calcul, pour la déporter sur le GPU. Un autre avantage est que le GPU peut gérer plus finement les ''quantum'' de temps et la commutation de contexte. Le CPU principal gère des durées assez importantes, de l'ordre de la milliseconde. De plus, il doit communiquer avec le GPU par des mécanismes temporellement imprécis, comme des interruptions. Avec l'arbitrage accéléré par le GPU, le GPU n'a plus besoin de communiquer avec le CPU pour l'arbitrage et peut le faire plus précisément, plus immédiatement. Un gain en performance théorique est donc possible.

L'arbitrage accéléré par le GPU est le fait soit du processeur de commandes, soit d'un processeur spécialisé, séparé.

{{NavChapitre | book=Les cartes graphiques
           | prev=La hiérarchie mémoire d'un GPU
           | prevText=La hiérarchie mémoire d'un GPU
           | next=Le pipeline géométrique d'avant DirectX 10
           | netxText=Le pipeline géométrique d'avant DirectX 10
}}{{autocat}}</text>
      <sha1>6hblv3izfmnw77b4h0cud01fc7pnx0d</sha1>
    </revision>
    <revision>
      <id>744035</id>
      <parentid>744034</parentid>
      <timestamp>2025-06-03T13:53:37Z</timestamp>
      <contributor>
        <username>Mewtow</username>
        <id>31375</id>
      </contributor>
      <minor />
      <comment>/* Le processeur de commandes */</comment>
      <origin>744035</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="32459" sha1="d36a6dam6qp7nmj2mdks0wbyxdxeo8v" xml:space="preserve">Dans ce chapitre, nous allons parler de tous les intermédiaires qui se placent entre une application de rendu 3D et les circuits de rendu 3D proprement dit. En premier lieu, on trouve le pilote de la carte graphique, aux fonctions multiples et variées. En second lieu, nous allons parler d'un circuit de la carte graphique qui fait l'interface entre le logiciel et les circuits de rendu 3D de la carte graphique : le processeur de commandes. Ce processeur de commandes est un circuit qui sert de chef d'orchestre, qui pilote le fonctionnement global de la carte graphique. API 3D, pilote de carte graphique et processeur de commande travaillent de concert pour que l'application communique avec la carte graphique. Nous allons d'abord voir le pilote de la carte graphique, avant de voir le fonctionnement du processeur de commande.

==Le pilote de carte graphique==

Le pilote de la carte graphique est un logiciel qui s'occupe de faire l'interface entre le logiciel et la carte graphique. De manière générale, les pilotes de périphérique sont des intermédiaires entre les applications/APIs et le matériel. En théorie, le système d'exploitation est censé jouer ce rôle, mais il n'est pas programmé pour être compatible avec tous les périphériques vendus sur le marché. À la place, le système d'exploitation ne gère pas directement certains périphériques, mais fournit de quoi ajouter ce qui manque. Le pilote d'un périphérique sert justement à ajouter ce qui manque : ils ajoutent au système d'exploitation de quoi reconnaître le périphérique, de quoi l'utiliser au mieux. Pour une carte graphique, il a diverses fonctions que nous allons voir ci-dessous.

Avant toute chose, précisons que les systèmes d'exploitation usuels (Windows, Linux, MacOsX et autres) sont fournis avec un pilote de carte graphique générique, compatible avec la plupart des cartes graphiques existantes. Rien de magique derrière cela : toutes les cartes graphiques vendues depuis plusieurs décennies respectent des standards, comme le VGA, le VESA, et d'autres. Et le pilote de base fournit avec le système d'exploitation est justement compatible avec ces standards minimaux. Mais le pilote ne peut pas profiter des fonctionnalités qui sont au-delà de ce standard. L'accélération 3D est presque inexistante avec le pilote de base, qui ne sert qu'à faire du rendu 2D (de quoi afficher l’interface de base du système d'exploitation, comme le bureau de Windows). Et même pour du rendu 2D, la plupart des fonctionnalités de la carte graphique ne sont pas disponibles. Par exemple, certaines résolutions ne sont pas disponibles, notamment les grandes résolutions. Ou encore, les performances sont loin d'être excellentes. Si vous avez déjà utilisé un PC sans pilote de carte graphique installé, vous avez certainement remarqué qu'il était particulièrement lent.

===La gestion des interruptions===

Une fonction particulièrement importante du pilote de carte graphique est la réponse aux interruptions lancées par la carte graphique. Pour rappel, les interruptions sont une fonctionnalité qui permet à un périphérique de communiquer avec le processeur, tout en économisant le temps de calcul de ce dernier. Typiquement, lorsqu'un périphérique lance une interruption, le processeur stoppe son travail et exécute automatiquement une routine d'interruption, un petit programme qui s'occupe de gérer le périphérique, de faire ce qu'il faut, ce que l'interruption a demandé.

Il y a plusieurs interruptions possibles, chacune ayant son propre numéro et sa fonction dédiée, chacune ayant sa propre routine d'interruption. Après tout, la routine qui gère un débordement de la mémoire vidéo n'est pas la même que celle qui gère un changement de fréquence du GPU ou la fin du calcul d'une image 3D. Le pilote fournit l'ensemble des routines d'interruptions nécessaires pour gérer la carte graphique.

===La compilation des ''shaders''===

Le pilote de carte graphique est aussi chargé de traduire les ''shaders'' en code machine. En soi, cette étape est assez complexe, et ressemble beaucoup à la compilation d'un programme informatique normal. Les ''shaders'' sont écrits dans un langage de programmation de haut niveau, comme le HLSL ou le GLSL, mais ce n'est pas ce code source qui est compilé par le pilote de carte graphique. À la place, les ''shaders'' sont pré-compilés vers un langage dit intermédiaire, avant d'être compilé par le pilote en code machine. Le langage intermédiaire, comme son nom l'indique, sert d'intermédiaire entre le code source écrit en HLSL/GLSL et le code machine exécuté par la carte graphique. Il ressemble à un langage assembleur, mais reste malgré tout assez générique pour ne pas être un véritable code machine. Par exemple, il y a peu de limitations quant au nombre de processeurs ou de registres. En clair, il y a deux passes de compilation : une passe de traduction du code source en langage intermédiaire, puis une passe de compilation du code intermédiaire vers le code machine. Notons que la première passe est réalisée par le programmeur des ''shaders'', non pas par l'utilisateur. Par exemple, les ''shaders'' d'un jeu vidéo sont fournis déjà pré-compilés : les fichiers du jeu ne contiennent pas le code source GLSL/HLSL, mais du code intermédiaire.

L'avantage de cette méthode est que le travail du pilote est fortement simplifié. Le pilote de périphérique pourrait compiler directement du code HLSL/GLSL, mais le temps de compilation serait très long et cela aurait un impact sur les performances. Avec l'usage du langage intermédiaire, le gros du travail à été fait lors de la première passe de compilation et le pilote graphique ne fait que finir le travail. Les optimisations importantes ont déjà été réalisées lors de la première passe. Il doit bien faire la traduction, ajouter quelques optimisations de bas niveau par-ci par-là, mais rien de bien gourmand en processeur. Autant dire que cela économise plus le processeur que si on devait compiler complètement les ''shaders'' à chaque exécution.

Fait amusant, il faut savoir que le pilote peut parfois remplacer les ''shaders'' d'un jeu vidéo à la volée. Les pilotes récents embarquent en effet des ''shaders'' alternatifs pour les jeux les plus vendus et/ou les plus populaires. Lorsque vous lancez un de ces jeux vidéo et que le ''shader'' originel s'exécute, le pilote le détecte automatiquement et le remplace par la version améliorée, fournie par le pilote. Évidemment, le ''shader'' alternatif du pilote est optimisé pour le matériel adéquat. Cela permet de gagner en performance, voire en qualité d'image, sans pour autant que les concepteurs du jeu n'aient quoique ce soit à faire.

Enfin, certains ''shaders'' sont fournis par le pilote pour d'autres raisons. Par exemple, les cartes graphiques récentes n'ont pas de circuits fixes pour traiter la géométrie. Autant les anciennes cartes graphiques avaient des circuits de T&amp;L qui s'en occupaient, autant tout cela doit être émulé sur les machines récentes. Sans cette émulation, les vieux jeux vidéo conçus pour exploiter le T&amp;L et d'autres technologies du genre ne fonctionneraient plus du tout. Émuler les circuits fixes disparus sur les cartes récentes est justement le fait de ''shaders'', présents dans le pilote de carte graphique.

===Les autres fonctions===

Le pilote a aussi bien d'autres fonctions. Par exemple, il s'occupe d'initialiser la carte graphique, de fixer la résolution, d'allouer la mémoire vidéo, de gérer le curseur de souris matériel, etc.

==Les commandes graphiques/vidéo/autres : des ordres envoyés au GPU==

Tous les traitements que la carte graphique doit effectuer, qu'il s'agisse de rendu 2D, de calculs 2D, du décodage matérielle d'un flux vidéo, ou de calculs généralistes, sont envoyés par le pilote de la carte graphique, sous la forme de '''commandes'''. Ces commandes demandent à la carte graphique d'effectuer une opération 2D, ou une opération 3D, ou encore le rendu d'une vidéo.

Les commandes graphiques en question varient beaucoup selon la carte graphique. Les commandes sont régulièrement revues et chaque nouvelle architecture a quelques changements par rapport aux modèles plus anciens. Des commandes peuvent apparaître, d'autres disparaître, d'autre voient leur fonctionnement légèrement altéré, etc.

Mais dans les grandes lignes, on peut classer ces commandes en quelques grands types. Les commandes les plus importantes s'occupent de l'affichage 3D : afficher une image à partir de paquets de sommets, préparer le passage d'une image à une autre, changer la résolution, etc. Plus rare, d'autres commandes servent à faire du rendu 2D : afficher un polygone, tracer une ligne, coloriser une surface, etc. Sur les cartes graphiques qui peuvent accélérer le rendu des vidéos, il existe des commandes spécialisées pour l’accélération des vidéos.

Pour donner quelques exemples, prenons les commandes 2D de la carte graphique AMD Radeon X1800.

{|class=&quot;wikitable&quot;
|-
! Commandes 2D 
! Fonction
|-
|PAINT 	
|Peindre un rectangle d'une certaine couleur
|-
|PAINT_MULTI 	
|Peindre des rectangles (pas les mêmes paramètres que PAINT)
|-
|BITBLT 	
|Copie d'un bloc de mémoire dans un autre
|-
|BITBLT_MULTI 	
|Plusieurs copies de blocs de mémoire dans d'autres
|-
|TRANS_BITBLT 	
|Copie de blocs de mémoire avec un masque
|-
|NEXTCHAR 	
|Afficher un caractère avec une certaine couleur
|-
|HOSTDATA_BLT 	
|Écrire une chaîne de caractères à l'écran ou copier une série d'image bitmap dans la mémoire vidéo
|-
|POLYLINE 	
|Afficher des lignes reliées entre elles
|-
|POLYSCANLINES
|Afficher des lignes
|-
|PLY_NEXTSCAN 	
|Afficher plusieurs lignes simples
|-
|SET_SCISSORS 	
|Utiliser des coupes (ciseaux)
|-
|LOAD_PALETTE 	
|Charger la palette pour affichage 2D
|}

===Le tampon de commandes===

L'envoi des commandes à la carte graphique ne se fait pas directement. La carte graphique n'est pas toujours libre pour accepter une nouvelle commande, soit parce qu'elle est occupée par une commande précédente, soit parce qu'elle fait autre chose. Il faut alors faire patienter les données tant que la carte graphique est occupée. Les pilotes de la carte graphique vont les mettre en attente dans le '''tampon de commandes'''. 

Le tampon de commandes est ce qu'on appelle une file, une zone de mémoire dans laquelle on stocke des données dans l'ordre d'ajout. Si le tampon de commandes est plein, le driver n'accepte plus de demandes en provenance des applications. Un tampon de commandes plein est généralement mauvais signe : cela signifie que la carte graphique est trop lente pour traiter les demandes qui lui sont faites. Par contre, il arrive que le tampon de commandes soit vide : dans ce cas, c'est simplement que la carte graphique est trop rapide comparé au processeur, qui n'arrive alors pas à donner assez de commandes à la carte graphique pour l'occuper suffisamment.

Le tampon de commande est soit une mémoire FIFO séparée, soit une portion de la mémoire vidéo. Le NV1, la toute première carte graphique NVIDIA, utilisait une mémoire FIFO intégrée à la carte graphique, séparée des autres circuits. Le NV1 contenait dans le détail : un controleur DMA avec une IO-MMU intégrée, la FIFO de commande, le processeur de commande, un pipeline graphique, un pipeline sonore, un contrôleur de manette. L'ensemble était relié par un bus interne à la carte graphique. Le processeur envoyait les commandes par rafale au GPU, à savoir qu'il envoyait plusieurs dizaines ou centaines de commandes à la suite, avant de passer à autre chose. Le GPU traitait les commandes une par une, à un rythme bien plus lent. Le processeur pouvait consulter la FIFO pour savoir s'il restait des entrées libres et combien. Le processeur savait ainsi combien d'écritures il pouvait envoyer en une fois au GPU.

: Le fonctionnement de la FIFO du NV1 est décrit dans le brevet ''US5805930A : System for FIFO informing the availability of stages to store commands which include data and virtual address sent directly from application programs''.

===Le processeur de commandes===

Le '''processeur de commande''' est un circuit qui gère les commandes envoyées par le processeur. Il lit la commande la plus ancienne dans le tampon de commande, l’interprète et l’exécute, puis passe à la suivante. Le processeur de commande est un circuit assez compliqué. Sur les cartes graphiques anciennes, c'était un circuit séquentiel complexe, fabriqué à la main et était la partie la plus complexe du processeur graphique. Sur les cartes graphiques modernes, c'est un véritable microcontrôleur, avec un processeur, de la mémoire RAM, etc.

Le processeur de commandes lit une commande dans le tampon de commande, décode la commande et l’exécute sur la carte graphique. Il garde en mémoire l'état de traitement de chaque commande : est-ce qu'elle est en train de s’exécuter sur le processeur graphique, est-ce qu'elle est mise en pause, est-ce qu'elle attend une donnée en provenance de la mémoire, est-ce qu'elle est terminée, etc.

Une commande utilise divers circuits de la carte 3D, de la mémoire vidéo, et d'autres ressources au sens large (des processeurs de ''shader'', notamment). Aussi, le processeur de commande pilote les circuits de la carte graphique, il répartit le travail entre les différents circuits de la carte graphique et assure que l'ordre du pipeline est respecté. La fonction principale du processeur de commande est de répartir le travail entre les différents circuits. Le processeur de commande décide à quel processeur ou circuit doit être envoyé une commande. C'est le processeur de commande qui s'occupe de la gestion des ressources et qui attribue telle ressource à telle commande.

A chaque instant, le processeur de commande répartit les ''shaders'' sur les processeurs de ''shaders'', en faisant en sorte qu'ils soient utilisés le plus possible. Dans le cas le plus simple, les unités sont alimentées en vertex/pixels les unes après les autres (principe du round-robin), mais des stratégies plus optimisées sont la règle de nos jours. Cela est très important sur les cartes graphiques : répartir plusieurs commandes sur plusieurs processeurs est une tâche difficile. Un chapitre entier sera d'ailleurs dédié à ce sujet.

Il envoie aussi certaines commandes aux circuits fixes, comme l’''input assembler''. Là encore, il faut en sorte que les circuits fixes soient utilisés le mieux possible. Sa tâche est compliquée par le fait que les GPU récents ont plusieurs unités de traitement des sommets et des pixels, plusieurs ROP, plusieurs unités de textures, etc. Et c'est en partie le travail du processeur de commande que de répartir les calculs sur ces différentes unités. C'est là un problème assez compliqué pour le processeur de commande et ce pour tout un tas de raisons que nous ne ferons que survoler. Les contraintes d'ordonnancement de l'API et les règles de celle-ci sont une partie de la réponse. Mais d'autres raisons sont intrinsèques au rendu 3D ou à la conception des circuits.

[[File:Architecture de base d'une carte 3D - 1.png|centre|vignette|upright=2.5|Architecture de base d'une carte 3D - 1]]

==Le fonctionnement du processeur de commandes==

Le processeur de commande lit, décode et exécute des commandes. Intuitivement, on se dit qu'il procède une commande à la fois. Mais les GPU modernes sont plus intelligents et peuvent exécuter plusieurs commandes en même temps, dans des circuits séparés. De nombreuses optimisations de ce type sont utilisées pour gagner en performance. Voyons comment un processeur de commande moderne fonctionne.

===L'ordonnancement et la gestion des ressources===

Le processeur de commande doit souvent mettre en pause certains circuits du pipeline, ainsi que les circuits précédents. Par exemple, si tous les processeurs de ''vertex shader'' sont occupés, l’''input assembler'' ne peut pas charger le paquet suivant car il n'y a aucun processeur de libre pour l’accueillir. Dans ce cas, l'étape d’''input assembly'' est mise en pause en attendant qu'un processeur de ''shader'' soit libre.

La même chose a lieu pour l'étape de rastérisation : si aucun processeur de ''shader'' n'est libre, elle est mise en pause. Sauf que pour la rastérisation, cela a des conséquences sur les circuits précédents la rastérisation. Si un processeur de ''shader'' veut envoyer quelque chose au rastériseur alors qu'il est en pause, il devra lui aussi attendre que le rastériseur soit libre. On a la même chose quand les ROP sont occupés : les ''pixel shader'' ou l'unité de texture doivent parfois être mis en pause, ce qui peut entrainer la mise en pause des étapes précédentes, etc.

En clair : plus un étape est situé vers la fin du pipeline graphique, plus sa mise en pause a de chances de se répercuter sur les étapes précédentes et de les mettre en pause aussi. Le processeur de commande doit gérer ces situations.

===Le pipelining des commandes===

Dans les cartes graphiques les plus rudimentaires, le processeur de commande exécute les commandes dans l'ordre. Il exécute une commande çà la fois et attend qu'une commande soit terminé pour en lancer une autre. Plusieurs commandes sont accumulées dans le tampon de commande, le processeur de commande les traite de la plus ancienne vers la plus récente. Du moins, les anciennes cartes graphiques faisaient comme cela, les cartes graphiques modernes sont un peu plus complexes. Elles n'attendent pas qu'une commande soit totalement terminée avant d'en lancer une nouvelle. Les processeurs de commande actuels sont capables d’exécuter plusieurs commandes en même temps.

L'intérêt est un gain en performance assez important. Pour ceux qui ont déjà eu un cours d'architecture des ordinateurs avancé, lancer plusieurs commandes en même temps permet une forme de pipeline, dont les gains sont substantiels. Par exemple, imaginez qu'une commande de rendu 3D soit bien avancée et n'utilise que les processeurs de ''shaders'' et les ROP, mais laisse les unités géométriques libres. Il est alors possible de démarrer la commande suivante en avance, afin qu'elle remplisse les unités géométriques inutilisées. On a alors deux commandes en cours de traitement : une commande qui utilise la fin du pipeline uniquement, une autre qui utilise seulement le début du pipeline graphique.

Le processeur de commande gère donc plusieurs commandes simultanées, à savoir plusieurs commandes qui en sont à des étapes différentes du pipeline. On peut avoir une commande qui est en cours dans l'étage de gestion de la géométrie, une autre dans le rastériseur, et une autre dans les unités de traitement des pixels. Le fait que les étapes du pipeline graphique sont à effectuer dans un ordre bien précis permet ce genre de chose assez facilement.

Une autre possibilité est de faire des rendus en parallèle. Par exemple, imaginez qu'on ait des circuits séparés pour le rendu 2D et 3D. Prenons l'exemple où le calcul d'une image finale demande de faire un rendu 3D suivi d'un rendu 2D, par exemple un jeu vidéo en 3D qui a un HUD dessiné en 2D. Dans ce cas, on peut démarrer le calcul de l'image suivante dans le pipeline 3D pendant que la précédente est dans les circuits 2D, au lieu de laisser inutilisé le pipeline 3D pendant le rendu 2D.

Mais c'est là un défi compliqué à relever pour le processeur de commande, qui donne lieu à son lot de problèmes. Le problème principal est le partage de ressources entre commandes. Par exemple, on peut prendre le cas où une commande n'utilise pas beaucoup les processeurs de ''shaders''. On pourrait imaginer lancer une seconde commande en parallèle, afin que la seconde commande utiliser les processeurs de ''shaders'' inutilisés. Mais cela n'est possible que si les circuits fixes sont capables d'accepter une seconde commande. Si la première commande sature les circuits fixe, le lancement de la seconde commande sera empêché. Mais si ce n'est pas le cas, les deux commandes pourront être lancées en même temps. Pareil pour le débit mémoire, qui doit alors être partagé entre deux commandes simultanées, ce qui est à prendre en compte.

===La synchronisation de l’exécution des commandes avec le processeur===

Il arrive que le processeur doive savoir où en est le traitement des commandes, ce qui est très utile pour la gestion de la mémoire vidéo. 

Un premier exemple : comment éviter de saturer une carte graphique de commande, alors qu'on ne sait pas si elles traite les commandes rapidement ou non ? L'idéal est de regarder où en est la carte graphique dans l'exécution des commandes. Si elle n'en est qu'au début du tampon de commande et que celui-ci est bien remplit, alors il vaut mieux lever le pied et ne pas envoyer de nouvelles commandes. A l'inverse, si le tampon de commande est presque vide, envoyer des commandes est la meilleure idée possible.

Un autre exemple un peu moins parlant est celui de la gestion de la mémoire vidéo. Rappelons qu'elle est réalisée par le pilote de la carte graphique, sur le processeur principal, qui décide d'allouer et de libérer de la mémoire vidéo. Pour donner un exemple d'utilisation, imaginez que le pilote de la carte graphique doive libérer de la mémoire pour pouvoir ajouter une nouvelle commande. Comment éviter d'enlever une texture tant que les commandes qui l'utilisent ne sont pas terminées ? Ce problème ne se limite pas aux textures, mais vaut pour tout ce qui est placé en mémoire vidéo. 

Il faut donc que la carte graphique trouve un moyen de prévenir le processeur que le traitement de telle commande est terminée, que telle commande en est rendue à tel ou tel point, etc. Pour cela, on a globalement deux grandes solutions. La première est celle des interruptions, abordées dans les chapitres précédents. Mais elles sont assez couteuses et ne sont utilisées que pour des évènements vraiment importants, critiques, qui demandent une réaction rapide du processeur. L'autre solution est celle du ''pooling'', où le processeur monitore la carte graphique à intervalles réguliers. Deux solutions bien connues de ceux qui ont déjà lu un cours d'architecture des ordinateurs digne de ce nom, rien de bien neuf : la carte graphique communique avec le processeur comme tout périphérique.

Pour faciliter l'implémentation du ''pooling'', la carte graphique contient des registres de statut, dans le processeur de commande, qui mémorisent tout ou partie de l'état de la carte graphique. Si un problème survient, certains bits du registre de statut seront mis à 1 pour indiquer que telle erreur bien précise a eu lieu. Il existe aussi un registre de statut qui mémorise le numéro de la commande en cours, ou de la dernière commande terminée, ce qui permet de savoir où en est la carte graphique dans l'exécution des commandes. Et certaines registres de statut sont dédiés à la gestion des commandes. Ils sont totalement programmable, la carte graphique peut écrire dedans sans problème.

Les cartes graphiques récentes incorporent des commandes pour modifier ces registres de statut au besoin. Elles sont appelées des '''commandes de synchronisation''' : les barrières (''fences''). Elles permettent d'écrire une valeur dans un registre de statut quand telle ou telle condition est remplie. Par exemple, si jamais une commande est terminée, on peut écrire la valeur 1 dans tel ou tel registre. La condition en question peut être assez complexe et se résumer à quelque chose du genre : &quot;si jamais toutes les ''shaders'' ont fini de traiter tel ensemble de textures, alors écrit la valeur 1024 dans le registre de statut numéro 9&quot;.

===La synchronisation de l’exécution des commandes intra-GPU===

Lancer plusieurs commandes en parallèle dans le pipeline permet de gagner en performance.Mais cela a un gros défaut : il n'est pas garantit que les commandes se terminent dans l'ordre. Si on démarre une seconde commande après la première, il arrive que la seconde finisse avant. Pire : il n'est pas garantit qu'elles s'exécutent dans l'ordre. Dans la plupart des cas, cela ne pose pas de problèmes. Mais dans d'autres, cela donne des résultats erronés.

Pour donner un exemple, utilisons les commandes de rendu 2D vues plus haut, histoire de simplifier le tout. Imaginez que vous codez un jeu vidéo et que le rendu se fait en 2D, partons sur un jeu de type FPS. Vous avez une série de commandes pour calculer l'image à rendre à l'écran, suivie par une série de commandes finales pour dessiner le HUB. Pour dessiner le HUD, vous utilisez des commandes HOSTDATA_BLT, dont le but est d'écrire une chaîne de caractères à l'écran ou copier une série d'image bitmap dans la mémoire vidéo. Et bien ces commandes HOSTDATA_BLT doivent démarrer une fois que le rendu de l'image est complétement terminé. Imaginez que vous dessiniez le HUD sur une portion de l'image pas encore terminée et que celui-ci est effacé par des écritures ultérieures ! 

Pour éviter tout problème, les GPU incorporent des commandes de synchronisation intra-GPU, destinées au processeur de commande, aussis appelées des '''commandes de sémaphore'''. Elles permettent de mettre en pause le lancement d'une nouvelle commande tant que les précédentes ne sont pas totalement ou partiellement terminées. Les plus simples empêchent le démarrage d'une commande tant que les précédentes ne sont pas terminées. D'autres permettent de démarrer une commande si et seulement si certaines commandes sont terminées. D'autres sont encore plus précises : elles empêchent le démarrage d'une nouvelle commande tant qu'une commande précédente n'a pas atteint un certain stade de son exécution. Là encore, de telles commandes sont des commandes du style &quot;attend que le registre de statut numéro N contienne la valeur adéquate avant de poursuivre l'exécution des commandes&quot;. 

Les commandes en question peuvent être sur le même modèle que précédemment, à savoir des commandes qui lisent les registres de statut. Mais elles peuvent aussi se baser sur le fait que telle ou telle ressource de rendu est libre ou non. Des commandes successives se partagent souvent des données, et que de nombreuses commandes différentes peuvent s'exécuter en même temps. Or, si une commande veut modifier les données utilisées par une autre commande, il faut que l'ordre des commandes soit maintenu : la commande la plus récente ne doit pas modifier les données utilisées par une commande plus ancienne. Avec ce modèle, les sémaphores bloquent une commande tant qu'une ressource (une texture) est utilisée par une autre commande.

{|class=&quot;wikitable&quot;
|-
! Commandes de synchronisation
! Fonction
|-
|NOP 
|Ne rien faire
|-
|WAIT_SEMAPHORE 
|Attendre la synchronisation avec un sémaphore
|-
|WAIT_MEM 
|Attendre que la mémoire vidéo soit disponible et inoccupée par le CPU
|}

==L'arbitrage de l'accès à la carte graphique==

Il n'est pas rare que plusieurs applications souhaitent accéder en même temps à la carte graphique. Imaginons que vous regardez une vidéo en ''streaming'' sur votre navigateur web, avec un programme de ''cloud computing'' de type ''Folding@Home'' qui tourne en arrière-plan, sur Windows. Le décodage de la vidéo est réalisé par la carte graphique, Windows s'occupe de l'affichage du bureau et des fenêtres, le navigateur web doit afficher tout ce qui est autour de la vidéo (la page web), le programme de ''cloud computing'' va lancer ses calculs sur la carte graphique, etc. Des situations de ce genre sont assez courantes et c'est soit le pilote qui s'en charge, soit la carte graphique elle-même.

===L'arbitrage logiciel du GPU===

L'arbitrage logiciel est la méthode la plus simple. Concrètement, c'est le système d'exploitation et/ou le pilote de la carte graphique qui gèrent l'arbitrage du GPU. Dans les deux cas, tout est fait en logiciel. Les commandes sont accumulées dans un tampon de commande, voire plusieurs, et l'OS/pilote décide quelle commande envoyer en priorité.

Sur Windows, avant l'arrivée du modèle de driver dit ''Windows Display Driver Model'', de telles situations étaient gérées simplement. Les applications ajoutaient des commandes dans une file de commande unique. Les commandes étaient exécutées dans l'ordre, en mode premier entrée dans la file premier sorti/exécuté. Il n'y avait pour ainsi dire pas d'arbitrage entre les applications. Et ce n'était pas un problème car, à l'époque, les seules applications qui utilisaient le GPU étaient des jeux vidéos fonctionnant en mode plein écran.

Avec le modèle de driver ''Windows Display Driver Model'' (WDDM), le GPU est maintenant arbitré, à savoir que les applications ont accès à tour de rôle au GPU, certaines ayant droit à plus de temps GPU que d'autres. Chaque programme a accès à la carte graphique durant quelques dizaines ou centaines de millisecondes, à tour de rôle. Si le programme finissait son travail en moins de temps que la durée impartie, il laissait la main au programme suivant. S’il atteignait la durée maximale allouée, il était interrompu pour laisser la place au programme suivant. Et chaque programme avait droit d'accès à la carte graphique chacun à son tour. Un tel algorithme en tourniquet est très simple, mais avait cependant quelques défauts. De nos jours, les algorithmes d'ordonnancement d'accès sont plus élaborés, bien qu'il soit difficile de trouver de la littérature ou des brevets sur le sujet.

Une autre fonctionnalité de WDDM est que les applications utilisant le GPU peuvent se partager la mémoire vidéo sans se marcher dessus. Avant, toutes les applications avaient accès à toute la mémoire vidéo, bien que ce soit par l’intermédiaire de commandes spécifiques. Mais avec WDDM, chaque application dispose de sa propre portion de mémoire vidéo, à laquelle est la seule à avoir accès. Une application ne peut plus lire le contenu réel de la mémoire vidéo, et encore moins lire le contenu des autres applications.

: Il s'agit d'un équivalent à l'isolation des processus pour les programmes Windows, mais appliqué à la mémoire vidéo et non la mémoire système. Et cette isolation est rendue d'autant plus simple que les GPU modernes implémentent un système de mémoire virtuelle à pagination très poussé, avec du swap en mémoire RAM système, une protection mémoire, et bien d'autres fonctionnalités. Nous en reparlerons dans les chapitres sur la mémoire vidéo.

===L'arbitrage accéléré par le GPU===

Depuis 2020, avec l'arrivée de la ''Windows 10 May 2020 update'', Windows est capable de déléguer l'arbitrage du GPU au GPU lui-même. Le  GPU gère lui-même l'arbitrage, du moins en partie. En partie, car l'OS gére les priorité, à savoir quelle application a droit à plus de temps que les autres. Par contre, la gestion du ''quantum'' de temps ou les commutations de contexte (on stoppe une application pour laisser la place à une autre), est du fait du GPU lui-même.

L'avantage est que cela décharge le processeur d'une tâche assez lourde en calcul, pour la déporter sur le GPU. Un autre avantage est que le GPU peut gérer plus finement les ''quantum'' de temps et la commutation de contexte. Le CPU principal gère des durées assez importantes, de l'ordre de la milliseconde. De plus, il doit communiquer avec le GPU par des mécanismes temporellement imprécis, comme des interruptions. Avec l'arbitrage accéléré par le GPU, le GPU n'a plus besoin de communiquer avec le CPU pour l'arbitrage et peut le faire plus précisément, plus immédiatement. Un gain en performance théorique est donc possible.

L'arbitrage accéléré par le GPU est le fait soit du processeur de commandes, soit d'un processeur spécialisé, séparé.

{{NavChapitre | book=Les cartes graphiques
           | prev=La hiérarchie mémoire d'un GPU
           | prevText=La hiérarchie mémoire d'un GPU
           | next=Le pipeline géométrique d'avant DirectX 10
           | netxText=Le pipeline géométrique d'avant DirectX 10
}}{{autocat}}</text>
      <sha1>d36a6dam6qp7nmj2mdks0wbyxdxeo8v</sha1>
    </revision>
    <revision>
      <id>744036</id>
      <parentid>744035</parentid>
      <timestamp>2025-06-03T13:54:49Z</timestamp>
      <contributor>
        <username>Mewtow</username>
        <id>31375</id>
      </contributor>
      <minor />
      <comment>/* Le tampon de commandes */</comment>
      <origin>744036</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="32193" sha1="3xsa0467zoahvmttmmiqfi81t4iprd9" xml:space="preserve">Dans ce chapitre, nous allons parler de tous les intermédiaires qui se placent entre une application de rendu 3D et les circuits de rendu 3D proprement dit. En premier lieu, on trouve le pilote de la carte graphique, aux fonctions multiples et variées. En second lieu, nous allons parler d'un circuit de la carte graphique qui fait l'interface entre le logiciel et les circuits de rendu 3D de la carte graphique : le processeur de commandes. Ce processeur de commandes est un circuit qui sert de chef d'orchestre, qui pilote le fonctionnement global de la carte graphique. API 3D, pilote de carte graphique et processeur de commande travaillent de concert pour que l'application communique avec la carte graphique. Nous allons d'abord voir le pilote de la carte graphique, avant de voir le fonctionnement du processeur de commande.

==Le pilote de carte graphique==

Le pilote de la carte graphique est un logiciel qui s'occupe de faire l'interface entre le logiciel et la carte graphique. De manière générale, les pilotes de périphérique sont des intermédiaires entre les applications/APIs et le matériel. En théorie, le système d'exploitation est censé jouer ce rôle, mais il n'est pas programmé pour être compatible avec tous les périphériques vendus sur le marché. À la place, le système d'exploitation ne gère pas directement certains périphériques, mais fournit de quoi ajouter ce qui manque. Le pilote d'un périphérique sert justement à ajouter ce qui manque : ils ajoutent au système d'exploitation de quoi reconnaître le périphérique, de quoi l'utiliser au mieux. Pour une carte graphique, il a diverses fonctions que nous allons voir ci-dessous.

Avant toute chose, précisons que les systèmes d'exploitation usuels (Windows, Linux, MacOsX et autres) sont fournis avec un pilote de carte graphique générique, compatible avec la plupart des cartes graphiques existantes. Rien de magique derrière cela : toutes les cartes graphiques vendues depuis plusieurs décennies respectent des standards, comme le VGA, le VESA, et d'autres. Et le pilote de base fournit avec le système d'exploitation est justement compatible avec ces standards minimaux. Mais le pilote ne peut pas profiter des fonctionnalités qui sont au-delà de ce standard. L'accélération 3D est presque inexistante avec le pilote de base, qui ne sert qu'à faire du rendu 2D (de quoi afficher l’interface de base du système d'exploitation, comme le bureau de Windows). Et même pour du rendu 2D, la plupart des fonctionnalités de la carte graphique ne sont pas disponibles. Par exemple, certaines résolutions ne sont pas disponibles, notamment les grandes résolutions. Ou encore, les performances sont loin d'être excellentes. Si vous avez déjà utilisé un PC sans pilote de carte graphique installé, vous avez certainement remarqué qu'il était particulièrement lent.

===La gestion des interruptions===

Une fonction particulièrement importante du pilote de carte graphique est la réponse aux interruptions lancées par la carte graphique. Pour rappel, les interruptions sont une fonctionnalité qui permet à un périphérique de communiquer avec le processeur, tout en économisant le temps de calcul de ce dernier. Typiquement, lorsqu'un périphérique lance une interruption, le processeur stoppe son travail et exécute automatiquement une routine d'interruption, un petit programme qui s'occupe de gérer le périphérique, de faire ce qu'il faut, ce que l'interruption a demandé.

Il y a plusieurs interruptions possibles, chacune ayant son propre numéro et sa fonction dédiée, chacune ayant sa propre routine d'interruption. Après tout, la routine qui gère un débordement de la mémoire vidéo n'est pas la même que celle qui gère un changement de fréquence du GPU ou la fin du calcul d'une image 3D. Le pilote fournit l'ensemble des routines d'interruptions nécessaires pour gérer la carte graphique.

===La compilation des ''shaders''===

Le pilote de carte graphique est aussi chargé de traduire les ''shaders'' en code machine. En soi, cette étape est assez complexe, et ressemble beaucoup à la compilation d'un programme informatique normal. Les ''shaders'' sont écrits dans un langage de programmation de haut niveau, comme le HLSL ou le GLSL, mais ce n'est pas ce code source qui est compilé par le pilote de carte graphique. À la place, les ''shaders'' sont pré-compilés vers un langage dit intermédiaire, avant d'être compilé par le pilote en code machine. Le langage intermédiaire, comme son nom l'indique, sert d'intermédiaire entre le code source écrit en HLSL/GLSL et le code machine exécuté par la carte graphique. Il ressemble à un langage assembleur, mais reste malgré tout assez générique pour ne pas être un véritable code machine. Par exemple, il y a peu de limitations quant au nombre de processeurs ou de registres. En clair, il y a deux passes de compilation : une passe de traduction du code source en langage intermédiaire, puis une passe de compilation du code intermédiaire vers le code machine. Notons que la première passe est réalisée par le programmeur des ''shaders'', non pas par l'utilisateur. Par exemple, les ''shaders'' d'un jeu vidéo sont fournis déjà pré-compilés : les fichiers du jeu ne contiennent pas le code source GLSL/HLSL, mais du code intermédiaire.

L'avantage de cette méthode est que le travail du pilote est fortement simplifié. Le pilote de périphérique pourrait compiler directement du code HLSL/GLSL, mais le temps de compilation serait très long et cela aurait un impact sur les performances. Avec l'usage du langage intermédiaire, le gros du travail à été fait lors de la première passe de compilation et le pilote graphique ne fait que finir le travail. Les optimisations importantes ont déjà été réalisées lors de la première passe. Il doit bien faire la traduction, ajouter quelques optimisations de bas niveau par-ci par-là, mais rien de bien gourmand en processeur. Autant dire que cela économise plus le processeur que si on devait compiler complètement les ''shaders'' à chaque exécution.

Fait amusant, il faut savoir que le pilote peut parfois remplacer les ''shaders'' d'un jeu vidéo à la volée. Les pilotes récents embarquent en effet des ''shaders'' alternatifs pour les jeux les plus vendus et/ou les plus populaires. Lorsque vous lancez un de ces jeux vidéo et que le ''shader'' originel s'exécute, le pilote le détecte automatiquement et le remplace par la version améliorée, fournie par le pilote. Évidemment, le ''shader'' alternatif du pilote est optimisé pour le matériel adéquat. Cela permet de gagner en performance, voire en qualité d'image, sans pour autant que les concepteurs du jeu n'aient quoique ce soit à faire.

Enfin, certains ''shaders'' sont fournis par le pilote pour d'autres raisons. Par exemple, les cartes graphiques récentes n'ont pas de circuits fixes pour traiter la géométrie. Autant les anciennes cartes graphiques avaient des circuits de T&amp;L qui s'en occupaient, autant tout cela doit être émulé sur les machines récentes. Sans cette émulation, les vieux jeux vidéo conçus pour exploiter le T&amp;L et d'autres technologies du genre ne fonctionneraient plus du tout. Émuler les circuits fixes disparus sur les cartes récentes est justement le fait de ''shaders'', présents dans le pilote de carte graphique.

===Les autres fonctions===

Le pilote a aussi bien d'autres fonctions. Par exemple, il s'occupe d'initialiser la carte graphique, de fixer la résolution, d'allouer la mémoire vidéo, de gérer le curseur de souris matériel, etc.

==Les commandes graphiques/vidéo/autres : des ordres envoyés au GPU==

Tous les traitements que la carte graphique doit effectuer, qu'il s'agisse de rendu 2D, de calculs 2D, du décodage matérielle d'un flux vidéo, ou de calculs généralistes, sont envoyés par le pilote de la carte graphique, sous la forme de '''commandes'''. Ces commandes demandent à la carte graphique d'effectuer une opération 2D, ou une opération 3D, ou encore le rendu d'une vidéo.

Les commandes graphiques en question varient beaucoup selon la carte graphique. Les commandes sont régulièrement revues et chaque nouvelle architecture a quelques changements par rapport aux modèles plus anciens. Des commandes peuvent apparaître, d'autres disparaître, d'autre voient leur fonctionnement légèrement altéré, etc.

Mais dans les grandes lignes, on peut classer ces commandes en quelques grands types. Les commandes les plus importantes s'occupent de l'affichage 3D : afficher une image à partir de paquets de sommets, préparer le passage d'une image à une autre, changer la résolution, etc. Plus rare, d'autres commandes servent à faire du rendu 2D : afficher un polygone, tracer une ligne, coloriser une surface, etc. Sur les cartes graphiques qui peuvent accélérer le rendu des vidéos, il existe des commandes spécialisées pour l’accélération des vidéos.

Pour donner quelques exemples, prenons les commandes 2D de la carte graphique AMD Radeon X1800.

{|class=&quot;wikitable&quot;
|-
! Commandes 2D 
! Fonction
|-
|PAINT 	
|Peindre un rectangle d'une certaine couleur
|-
|PAINT_MULTI 	
|Peindre des rectangles (pas les mêmes paramètres que PAINT)
|-
|BITBLT 	
|Copie d'un bloc de mémoire dans un autre
|-
|BITBLT_MULTI 	
|Plusieurs copies de blocs de mémoire dans d'autres
|-
|TRANS_BITBLT 	
|Copie de blocs de mémoire avec un masque
|-
|NEXTCHAR 	
|Afficher un caractère avec une certaine couleur
|-
|HOSTDATA_BLT 	
|Écrire une chaîne de caractères à l'écran ou copier une série d'image bitmap dans la mémoire vidéo
|-
|POLYLINE 	
|Afficher des lignes reliées entre elles
|-
|POLYSCANLINES
|Afficher des lignes
|-
|PLY_NEXTSCAN 	
|Afficher plusieurs lignes simples
|-
|SET_SCISSORS 	
|Utiliser des coupes (ciseaux)
|-
|LOAD_PALETTE 	
|Charger la palette pour affichage 2D
|}

===Le tampon de commandes===

L'envoi des commandes à la carte graphique ne se fait pas directement. La carte graphique n'est pas toujours libre pour accepter une nouvelle commande, soit parce qu'elle est occupée par une commande précédente, soit parce qu'elle fait autre chose. Il faut alors faire patienter les données tant que la carte graphique est occupée. Les pilotes de la carte graphique vont les mettre en attente dans le '''tampon de commandes'''. 

Le tampon de commandes est ce qu'on appelle une file, une zone de mémoire dans laquelle on stocke des données dans l'ordre d'ajout. Si le tampon de commandes est plein, le driver n'accepte plus de demandes en provenance des applications. Un tampon de commandes plein est généralement mauvais signe : cela signifie que la carte graphique est trop lente pour traiter les demandes qui lui sont faites. Par contre, il arrive que le tampon de commandes soit vide : dans ce cas, c'est simplement que la carte graphique est trop rapide comparé au processeur, qui n'arrive alors pas à donner assez de commandes à la carte graphique pour l'occuper suffisamment.

Le tampon de commande est soit une mémoire FIFO séparée, soit une portion de la mémoire vidéo. Le NV1, la toute première carte graphique NVIDIA, utilisait une mémoire FIFO intégrée à la carte graphique, séparée des autres circuits. Le processeur envoyait les commandes par rafale au GPU, à savoir qu'il envoyait plusieurs dizaines ou centaines de commandes à la suite, avant de passer à autre chose. Le GPU traitait les commandes une par une, à un rythme bien plus lent. Le processeur pouvait consulter la FIFO pour savoir s'il restait des entrées libres et combien. Le processeur savait ainsi combien d'écritures il pouvait envoyer en une fois au GPU.

: Le fonctionnement de la FIFO du NV1 est décrit dans le brevet ''US5805930A : System for FIFO informing the availability of stages to store commands which include data and virtual address sent directly from application programs''.

===Le processeur de commandes===

Le '''processeur de commande''' est un circuit qui gère les commandes envoyées par le processeur. Il lit la commande la plus ancienne dans le tampon de commande, l’interprète et l’exécute, puis passe à la suivante. Le processeur de commande est un circuit assez compliqué. Sur les cartes graphiques anciennes, c'était un circuit séquentiel complexe, fabriqué à la main et était la partie la plus complexe du processeur graphique. Sur les cartes graphiques modernes, c'est un véritable microcontrôleur, avec un processeur, de la mémoire RAM, etc.

Le processeur de commandes lit une commande dans le tampon de commande, décode la commande et l’exécute sur la carte graphique. Il garde en mémoire l'état de traitement de chaque commande : est-ce qu'elle est en train de s’exécuter sur le processeur graphique, est-ce qu'elle est mise en pause, est-ce qu'elle attend une donnée en provenance de la mémoire, est-ce qu'elle est terminée, etc.

Une commande utilise divers circuits de la carte 3D, de la mémoire vidéo, et d'autres ressources au sens large (des processeurs de ''shader'', notamment). Aussi, le processeur de commande pilote les circuits de la carte graphique, il répartit le travail entre les différents circuits de la carte graphique et assure que l'ordre du pipeline est respecté. La fonction principale du processeur de commande est de répartir le travail entre les différents circuits. Le processeur de commande décide à quel processeur ou circuit doit être envoyé une commande. C'est le processeur de commande qui s'occupe de la gestion des ressources et qui attribue telle ressource à telle commande.

A chaque instant, le processeur de commande répartit les ''shaders'' sur les processeurs de ''shaders'', en faisant en sorte qu'ils soient utilisés le plus possible. Dans le cas le plus simple, les unités sont alimentées en vertex/pixels les unes après les autres (principe du round-robin), mais des stratégies plus optimisées sont la règle de nos jours. Cela est très important sur les cartes graphiques : répartir plusieurs commandes sur plusieurs processeurs est une tâche difficile. Un chapitre entier sera d'ailleurs dédié à ce sujet.

Il envoie aussi certaines commandes aux circuits fixes, comme l’''input assembler''. Là encore, il faut en sorte que les circuits fixes soient utilisés le mieux possible. Sa tâche est compliquée par le fait que les GPU récents ont plusieurs unités de traitement des sommets et des pixels, plusieurs ROP, plusieurs unités de textures, etc. Et c'est en partie le travail du processeur de commande que de répartir les calculs sur ces différentes unités. C'est là un problème assez compliqué pour le processeur de commande et ce pour tout un tas de raisons que nous ne ferons que survoler. Les contraintes d'ordonnancement de l'API et les règles de celle-ci sont une partie de la réponse. Mais d'autres raisons sont intrinsèques au rendu 3D ou à la conception des circuits.

[[File:Architecture de base d'une carte 3D - 1.png|centre|vignette|upright=2.5|Architecture de base d'une carte 3D - 1]]

==Le fonctionnement du processeur de commandes==

Le processeur de commande lit, décode et exécute des commandes. Intuitivement, on se dit qu'il procède une commande à la fois. Mais les GPU modernes sont plus intelligents et peuvent exécuter plusieurs commandes en même temps, dans des circuits séparés. De nombreuses optimisations de ce type sont utilisées pour gagner en performance. Voyons comment un processeur de commande moderne fonctionne.

===L'ordonnancement et la gestion des ressources===

Le processeur de commande doit souvent mettre en pause certains circuits du pipeline, ainsi que les circuits précédents. Par exemple, si tous les processeurs de ''vertex shader'' sont occupés, l’''input assembler'' ne peut pas charger le paquet suivant car il n'y a aucun processeur de libre pour l’accueillir. Dans ce cas, l'étape d’''input assembly'' est mise en pause en attendant qu'un processeur de ''shader'' soit libre.

La même chose a lieu pour l'étape de rastérisation : si aucun processeur de ''shader'' n'est libre, elle est mise en pause. Sauf que pour la rastérisation, cela a des conséquences sur les circuits précédents la rastérisation. Si un processeur de ''shader'' veut envoyer quelque chose au rastériseur alors qu'il est en pause, il devra lui aussi attendre que le rastériseur soit libre. On a la même chose quand les ROP sont occupés : les ''pixel shader'' ou l'unité de texture doivent parfois être mis en pause, ce qui peut entrainer la mise en pause des étapes précédentes, etc.

En clair : plus un étape est situé vers la fin du pipeline graphique, plus sa mise en pause a de chances de se répercuter sur les étapes précédentes et de les mettre en pause aussi. Le processeur de commande doit gérer ces situations.

===Le pipelining des commandes===

Dans les cartes graphiques les plus rudimentaires, le processeur de commande exécute les commandes dans l'ordre. Il exécute une commande çà la fois et attend qu'une commande soit terminé pour en lancer une autre. Plusieurs commandes sont accumulées dans le tampon de commande, le processeur de commande les traite de la plus ancienne vers la plus récente. Du moins, les anciennes cartes graphiques faisaient comme cela, les cartes graphiques modernes sont un peu plus complexes. Elles n'attendent pas qu'une commande soit totalement terminée avant d'en lancer une nouvelle. Les processeurs de commande actuels sont capables d’exécuter plusieurs commandes en même temps.

L'intérêt est un gain en performance assez important. Pour ceux qui ont déjà eu un cours d'architecture des ordinateurs avancé, lancer plusieurs commandes en même temps permet une forme de pipeline, dont les gains sont substantiels. Par exemple, imaginez qu'une commande de rendu 3D soit bien avancée et n'utilise que les processeurs de ''shaders'' et les ROP, mais laisse les unités géométriques libres. Il est alors possible de démarrer la commande suivante en avance, afin qu'elle remplisse les unités géométriques inutilisées. On a alors deux commandes en cours de traitement : une commande qui utilise la fin du pipeline uniquement, une autre qui utilise seulement le début du pipeline graphique.

Le processeur de commande gère donc plusieurs commandes simultanées, à savoir plusieurs commandes qui en sont à des étapes différentes du pipeline. On peut avoir une commande qui est en cours dans l'étage de gestion de la géométrie, une autre dans le rastériseur, et une autre dans les unités de traitement des pixels. Le fait que les étapes du pipeline graphique sont à effectuer dans un ordre bien précis permet ce genre de chose assez facilement.

Une autre possibilité est de faire des rendus en parallèle. Par exemple, imaginez qu'on ait des circuits séparés pour le rendu 2D et 3D. Prenons l'exemple où le calcul d'une image finale demande de faire un rendu 3D suivi d'un rendu 2D, par exemple un jeu vidéo en 3D qui a un HUD dessiné en 2D. Dans ce cas, on peut démarrer le calcul de l'image suivante dans le pipeline 3D pendant que la précédente est dans les circuits 2D, au lieu de laisser inutilisé le pipeline 3D pendant le rendu 2D.

Mais c'est là un défi compliqué à relever pour le processeur de commande, qui donne lieu à son lot de problèmes. Le problème principal est le partage de ressources entre commandes. Par exemple, on peut prendre le cas où une commande n'utilise pas beaucoup les processeurs de ''shaders''. On pourrait imaginer lancer une seconde commande en parallèle, afin que la seconde commande utiliser les processeurs de ''shaders'' inutilisés. Mais cela n'est possible que si les circuits fixes sont capables d'accepter une seconde commande. Si la première commande sature les circuits fixe, le lancement de la seconde commande sera empêché. Mais si ce n'est pas le cas, les deux commandes pourront être lancées en même temps. Pareil pour le débit mémoire, qui doit alors être partagé entre deux commandes simultanées, ce qui est à prendre en compte.

===La synchronisation de l’exécution des commandes avec le processeur===

Il arrive que le processeur doive savoir où en est le traitement des commandes, ce qui est très utile pour la gestion de la mémoire vidéo. 

Un premier exemple : comment éviter de saturer une carte graphique de commande, alors qu'on ne sait pas si elles traite les commandes rapidement ou non ? L'idéal est de regarder où en est la carte graphique dans l'exécution des commandes. Si elle n'en est qu'au début du tampon de commande et que celui-ci est bien remplit, alors il vaut mieux lever le pied et ne pas envoyer de nouvelles commandes. A l'inverse, si le tampon de commande est presque vide, envoyer des commandes est la meilleure idée possible.

Un autre exemple un peu moins parlant est celui de la gestion de la mémoire vidéo. Rappelons qu'elle est réalisée par le pilote de la carte graphique, sur le processeur principal, qui décide d'allouer et de libérer de la mémoire vidéo. Pour donner un exemple d'utilisation, imaginez que le pilote de la carte graphique doive libérer de la mémoire pour pouvoir ajouter une nouvelle commande. Comment éviter d'enlever une texture tant que les commandes qui l'utilisent ne sont pas terminées ? Ce problème ne se limite pas aux textures, mais vaut pour tout ce qui est placé en mémoire vidéo. 

Il faut donc que la carte graphique trouve un moyen de prévenir le processeur que le traitement de telle commande est terminée, que telle commande en est rendue à tel ou tel point, etc. Pour cela, on a globalement deux grandes solutions. La première est celle des interruptions, abordées dans les chapitres précédents. Mais elles sont assez couteuses et ne sont utilisées que pour des évènements vraiment importants, critiques, qui demandent une réaction rapide du processeur. L'autre solution est celle du ''pooling'', où le processeur monitore la carte graphique à intervalles réguliers. Deux solutions bien connues de ceux qui ont déjà lu un cours d'architecture des ordinateurs digne de ce nom, rien de bien neuf : la carte graphique communique avec le processeur comme tout périphérique.

Pour faciliter l'implémentation du ''pooling'', la carte graphique contient des registres de statut, dans le processeur de commande, qui mémorisent tout ou partie de l'état de la carte graphique. Si un problème survient, certains bits du registre de statut seront mis à 1 pour indiquer que telle erreur bien précise a eu lieu. Il existe aussi un registre de statut qui mémorise le numéro de la commande en cours, ou de la dernière commande terminée, ce qui permet de savoir où en est la carte graphique dans l'exécution des commandes. Et certaines registres de statut sont dédiés à la gestion des commandes. Ils sont totalement programmable, la carte graphique peut écrire dedans sans problème.

Les cartes graphiques récentes incorporent des commandes pour modifier ces registres de statut au besoin. Elles sont appelées des '''commandes de synchronisation''' : les barrières (''fences''). Elles permettent d'écrire une valeur dans un registre de statut quand telle ou telle condition est remplie. Par exemple, si jamais une commande est terminée, on peut écrire la valeur 1 dans tel ou tel registre. La condition en question peut être assez complexe et se résumer à quelque chose du genre : &quot;si jamais toutes les ''shaders'' ont fini de traiter tel ensemble de textures, alors écrit la valeur 1024 dans le registre de statut numéro 9&quot;.

===La synchronisation de l’exécution des commandes intra-GPU===

Lancer plusieurs commandes en parallèle dans le pipeline permet de gagner en performance.Mais cela a un gros défaut : il n'est pas garantit que les commandes se terminent dans l'ordre. Si on démarre une seconde commande après la première, il arrive que la seconde finisse avant. Pire : il n'est pas garantit qu'elles s'exécutent dans l'ordre. Dans la plupart des cas, cela ne pose pas de problèmes. Mais dans d'autres, cela donne des résultats erronés.

Pour donner un exemple, utilisons les commandes de rendu 2D vues plus haut, histoire de simplifier le tout. Imaginez que vous codez un jeu vidéo et que le rendu se fait en 2D, partons sur un jeu de type FPS. Vous avez une série de commandes pour calculer l'image à rendre à l'écran, suivie par une série de commandes finales pour dessiner le HUB. Pour dessiner le HUD, vous utilisez des commandes HOSTDATA_BLT, dont le but est d'écrire une chaîne de caractères à l'écran ou copier une série d'image bitmap dans la mémoire vidéo. Et bien ces commandes HOSTDATA_BLT doivent démarrer une fois que le rendu de l'image est complétement terminé. Imaginez que vous dessiniez le HUD sur une portion de l'image pas encore terminée et que celui-ci est effacé par des écritures ultérieures ! 

Pour éviter tout problème, les GPU incorporent des commandes de synchronisation intra-GPU, destinées au processeur de commande, aussis appelées des '''commandes de sémaphore'''. Elles permettent de mettre en pause le lancement d'une nouvelle commande tant que les précédentes ne sont pas totalement ou partiellement terminées. Les plus simples empêchent le démarrage d'une commande tant que les précédentes ne sont pas terminées. D'autres permettent de démarrer une commande si et seulement si certaines commandes sont terminées. D'autres sont encore plus précises : elles empêchent le démarrage d'une nouvelle commande tant qu'une commande précédente n'a pas atteint un certain stade de son exécution. Là encore, de telles commandes sont des commandes du style &quot;attend que le registre de statut numéro N contienne la valeur adéquate avant de poursuivre l'exécution des commandes&quot;. 

Les commandes en question peuvent être sur le même modèle que précédemment, à savoir des commandes qui lisent les registres de statut. Mais elles peuvent aussi se baser sur le fait que telle ou telle ressource de rendu est libre ou non. Des commandes successives se partagent souvent des données, et que de nombreuses commandes différentes peuvent s'exécuter en même temps. Or, si une commande veut modifier les données utilisées par une autre commande, il faut que l'ordre des commandes soit maintenu : la commande la plus récente ne doit pas modifier les données utilisées par une commande plus ancienne. Avec ce modèle, les sémaphores bloquent une commande tant qu'une ressource (une texture) est utilisée par une autre commande.

{|class=&quot;wikitable&quot;
|-
! Commandes de synchronisation
! Fonction
|-
|NOP 
|Ne rien faire
|-
|WAIT_SEMAPHORE 
|Attendre la synchronisation avec un sémaphore
|-
|WAIT_MEM 
|Attendre que la mémoire vidéo soit disponible et inoccupée par le CPU
|}

==L'arbitrage de l'accès à la carte graphique==

Il n'est pas rare que plusieurs applications souhaitent accéder en même temps à la carte graphique. Imaginons que vous regardez une vidéo en ''streaming'' sur votre navigateur web, avec un programme de ''cloud computing'' de type ''Folding@Home'' qui tourne en arrière-plan, sur Windows. Le décodage de la vidéo est réalisé par la carte graphique, Windows s'occupe de l'affichage du bureau et des fenêtres, le navigateur web doit afficher tout ce qui est autour de la vidéo (la page web), le programme de ''cloud computing'' va lancer ses calculs sur la carte graphique, etc. Des situations de ce genre sont assez courantes et c'est soit le pilote qui s'en charge, soit la carte graphique elle-même.

===L'arbitrage logiciel du GPU===

L'arbitrage logiciel est la méthode la plus simple. Concrètement, c'est le système d'exploitation et/ou le pilote de la carte graphique qui gèrent l'arbitrage du GPU. Dans les deux cas, tout est fait en logiciel. Les commandes sont accumulées dans un tampon de commande, voire plusieurs, et l'OS/pilote décide quelle commande envoyer en priorité.

Sur Windows, avant l'arrivée du modèle de driver dit ''Windows Display Driver Model'', de telles situations étaient gérées simplement. Les applications ajoutaient des commandes dans une file de commande unique. Les commandes étaient exécutées dans l'ordre, en mode premier entrée dans la file premier sorti/exécuté. Il n'y avait pour ainsi dire pas d'arbitrage entre les applications. Et ce n'était pas un problème car, à l'époque, les seules applications qui utilisaient le GPU étaient des jeux vidéos fonctionnant en mode plein écran.

Avec le modèle de driver ''Windows Display Driver Model'' (WDDM), le GPU est maintenant arbitré, à savoir que les applications ont accès à tour de rôle au GPU, certaines ayant droit à plus de temps GPU que d'autres. Chaque programme a accès à la carte graphique durant quelques dizaines ou centaines de millisecondes, à tour de rôle. Si le programme finissait son travail en moins de temps que la durée impartie, il laissait la main au programme suivant. S’il atteignait la durée maximale allouée, il était interrompu pour laisser la place au programme suivant. Et chaque programme avait droit d'accès à la carte graphique chacun à son tour. Un tel algorithme en tourniquet est très simple, mais avait cependant quelques défauts. De nos jours, les algorithmes d'ordonnancement d'accès sont plus élaborés, bien qu'il soit difficile de trouver de la littérature ou des brevets sur le sujet.

Une autre fonctionnalité de WDDM est que les applications utilisant le GPU peuvent se partager la mémoire vidéo sans se marcher dessus. Avant, toutes les applications avaient accès à toute la mémoire vidéo, bien que ce soit par l’intermédiaire de commandes spécifiques. Mais avec WDDM, chaque application dispose de sa propre portion de mémoire vidéo, à laquelle est la seule à avoir accès. Une application ne peut plus lire le contenu réel de la mémoire vidéo, et encore moins lire le contenu des autres applications.

: Il s'agit d'un équivalent à l'isolation des processus pour les programmes Windows, mais appliqué à la mémoire vidéo et non la mémoire système. Et cette isolation est rendue d'autant plus simple que les GPU modernes implémentent un système de mémoire virtuelle à pagination très poussé, avec du swap en mémoire RAM système, une protection mémoire, et bien d'autres fonctionnalités. Nous en reparlerons dans les chapitres sur la mémoire vidéo.

===L'arbitrage accéléré par le GPU===

Depuis 2020, avec l'arrivée de la ''Windows 10 May 2020 update'', Windows est capable de déléguer l'arbitrage du GPU au GPU lui-même. Le  GPU gère lui-même l'arbitrage, du moins en partie. En partie, car l'OS gére les priorité, à savoir quelle application a droit à plus de temps que les autres. Par contre, la gestion du ''quantum'' de temps ou les commutations de contexte (on stoppe une application pour laisser la place à une autre), est du fait du GPU lui-même.

L'avantage est que cela décharge le processeur d'une tâche assez lourde en calcul, pour la déporter sur le GPU. Un autre avantage est que le GPU peut gérer plus finement les ''quantum'' de temps et la commutation de contexte. Le CPU principal gère des durées assez importantes, de l'ordre de la milliseconde. De plus, il doit communiquer avec le GPU par des mécanismes temporellement imprécis, comme des interruptions. Avec l'arbitrage accéléré par le GPU, le GPU n'a plus besoin de communiquer avec le CPU pour l'arbitrage et peut le faire plus précisément, plus immédiatement. Un gain en performance théorique est donc possible.

L'arbitrage accéléré par le GPU est le fait soit du processeur de commandes, soit d'un processeur spécialisé, séparé.

{{NavChapitre | book=Les cartes graphiques
           | prev=La hiérarchie mémoire d'un GPU
           | prevText=La hiérarchie mémoire d'un GPU
           | next=Le pipeline géométrique d'avant DirectX 10
           | netxText=Le pipeline géométrique d'avant DirectX 10
}}{{autocat}}</text>
      <sha1>3xsa0467zoahvmttmmiqfi81t4iprd9</sha1>
    </revision>
    <revision>
      <id>744037</id>
      <parentid>744036</parentid>
      <timestamp>2025-06-03T13:55:37Z</timestamp>
      <contributor>
        <username>Mewtow</username>
        <id>31375</id>
      </contributor>
      <minor />
      <comment>/* Le processeur de commandes */</comment>
      <origin>744037</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="32579" sha1="qynv97pw0ullmt1d9g2iftk48kg4pdk" xml:space="preserve">Dans ce chapitre, nous allons parler de tous les intermédiaires qui se placent entre une application de rendu 3D et les circuits de rendu 3D proprement dit. En premier lieu, on trouve le pilote de la carte graphique, aux fonctions multiples et variées. En second lieu, nous allons parler d'un circuit de la carte graphique qui fait l'interface entre le logiciel et les circuits de rendu 3D de la carte graphique : le processeur de commandes. Ce processeur de commandes est un circuit qui sert de chef d'orchestre, qui pilote le fonctionnement global de la carte graphique. API 3D, pilote de carte graphique et processeur de commande travaillent de concert pour que l'application communique avec la carte graphique. Nous allons d'abord voir le pilote de la carte graphique, avant de voir le fonctionnement du processeur de commande.

==Le pilote de carte graphique==

Le pilote de la carte graphique est un logiciel qui s'occupe de faire l'interface entre le logiciel et la carte graphique. De manière générale, les pilotes de périphérique sont des intermédiaires entre les applications/APIs et le matériel. En théorie, le système d'exploitation est censé jouer ce rôle, mais il n'est pas programmé pour être compatible avec tous les périphériques vendus sur le marché. À la place, le système d'exploitation ne gère pas directement certains périphériques, mais fournit de quoi ajouter ce qui manque. Le pilote d'un périphérique sert justement à ajouter ce qui manque : ils ajoutent au système d'exploitation de quoi reconnaître le périphérique, de quoi l'utiliser au mieux. Pour une carte graphique, il a diverses fonctions que nous allons voir ci-dessous.

Avant toute chose, précisons que les systèmes d'exploitation usuels (Windows, Linux, MacOsX et autres) sont fournis avec un pilote de carte graphique générique, compatible avec la plupart des cartes graphiques existantes. Rien de magique derrière cela : toutes les cartes graphiques vendues depuis plusieurs décennies respectent des standards, comme le VGA, le VESA, et d'autres. Et le pilote de base fournit avec le système d'exploitation est justement compatible avec ces standards minimaux. Mais le pilote ne peut pas profiter des fonctionnalités qui sont au-delà de ce standard. L'accélération 3D est presque inexistante avec le pilote de base, qui ne sert qu'à faire du rendu 2D (de quoi afficher l’interface de base du système d'exploitation, comme le bureau de Windows). Et même pour du rendu 2D, la plupart des fonctionnalités de la carte graphique ne sont pas disponibles. Par exemple, certaines résolutions ne sont pas disponibles, notamment les grandes résolutions. Ou encore, les performances sont loin d'être excellentes. Si vous avez déjà utilisé un PC sans pilote de carte graphique installé, vous avez certainement remarqué qu'il était particulièrement lent.

===La gestion des interruptions===

Une fonction particulièrement importante du pilote de carte graphique est la réponse aux interruptions lancées par la carte graphique. Pour rappel, les interruptions sont une fonctionnalité qui permet à un périphérique de communiquer avec le processeur, tout en économisant le temps de calcul de ce dernier. Typiquement, lorsqu'un périphérique lance une interruption, le processeur stoppe son travail et exécute automatiquement une routine d'interruption, un petit programme qui s'occupe de gérer le périphérique, de faire ce qu'il faut, ce que l'interruption a demandé.

Il y a plusieurs interruptions possibles, chacune ayant son propre numéro et sa fonction dédiée, chacune ayant sa propre routine d'interruption. Après tout, la routine qui gère un débordement de la mémoire vidéo n'est pas la même que celle qui gère un changement de fréquence du GPU ou la fin du calcul d'une image 3D. Le pilote fournit l'ensemble des routines d'interruptions nécessaires pour gérer la carte graphique.

===La compilation des ''shaders''===

Le pilote de carte graphique est aussi chargé de traduire les ''shaders'' en code machine. En soi, cette étape est assez complexe, et ressemble beaucoup à la compilation d'un programme informatique normal. Les ''shaders'' sont écrits dans un langage de programmation de haut niveau, comme le HLSL ou le GLSL, mais ce n'est pas ce code source qui est compilé par le pilote de carte graphique. À la place, les ''shaders'' sont pré-compilés vers un langage dit intermédiaire, avant d'être compilé par le pilote en code machine. Le langage intermédiaire, comme son nom l'indique, sert d'intermédiaire entre le code source écrit en HLSL/GLSL et le code machine exécuté par la carte graphique. Il ressemble à un langage assembleur, mais reste malgré tout assez générique pour ne pas être un véritable code machine. Par exemple, il y a peu de limitations quant au nombre de processeurs ou de registres. En clair, il y a deux passes de compilation : une passe de traduction du code source en langage intermédiaire, puis une passe de compilation du code intermédiaire vers le code machine. Notons que la première passe est réalisée par le programmeur des ''shaders'', non pas par l'utilisateur. Par exemple, les ''shaders'' d'un jeu vidéo sont fournis déjà pré-compilés : les fichiers du jeu ne contiennent pas le code source GLSL/HLSL, mais du code intermédiaire.

L'avantage de cette méthode est que le travail du pilote est fortement simplifié. Le pilote de périphérique pourrait compiler directement du code HLSL/GLSL, mais le temps de compilation serait très long et cela aurait un impact sur les performances. Avec l'usage du langage intermédiaire, le gros du travail à été fait lors de la première passe de compilation et le pilote graphique ne fait que finir le travail. Les optimisations importantes ont déjà été réalisées lors de la première passe. Il doit bien faire la traduction, ajouter quelques optimisations de bas niveau par-ci par-là, mais rien de bien gourmand en processeur. Autant dire que cela économise plus le processeur que si on devait compiler complètement les ''shaders'' à chaque exécution.

Fait amusant, il faut savoir que le pilote peut parfois remplacer les ''shaders'' d'un jeu vidéo à la volée. Les pilotes récents embarquent en effet des ''shaders'' alternatifs pour les jeux les plus vendus et/ou les plus populaires. Lorsque vous lancez un de ces jeux vidéo et que le ''shader'' originel s'exécute, le pilote le détecte automatiquement et le remplace par la version améliorée, fournie par le pilote. Évidemment, le ''shader'' alternatif du pilote est optimisé pour le matériel adéquat. Cela permet de gagner en performance, voire en qualité d'image, sans pour autant que les concepteurs du jeu n'aient quoique ce soit à faire.

Enfin, certains ''shaders'' sont fournis par le pilote pour d'autres raisons. Par exemple, les cartes graphiques récentes n'ont pas de circuits fixes pour traiter la géométrie. Autant les anciennes cartes graphiques avaient des circuits de T&amp;L qui s'en occupaient, autant tout cela doit être émulé sur les machines récentes. Sans cette émulation, les vieux jeux vidéo conçus pour exploiter le T&amp;L et d'autres technologies du genre ne fonctionneraient plus du tout. Émuler les circuits fixes disparus sur les cartes récentes est justement le fait de ''shaders'', présents dans le pilote de carte graphique.

===Les autres fonctions===

Le pilote a aussi bien d'autres fonctions. Par exemple, il s'occupe d'initialiser la carte graphique, de fixer la résolution, d'allouer la mémoire vidéo, de gérer le curseur de souris matériel, etc.

==Les commandes graphiques/vidéo/autres : des ordres envoyés au GPU==

Tous les traitements que la carte graphique doit effectuer, qu'il s'agisse de rendu 2D, de calculs 2D, du décodage matérielle d'un flux vidéo, ou de calculs généralistes, sont envoyés par le pilote de la carte graphique, sous la forme de '''commandes'''. Ces commandes demandent à la carte graphique d'effectuer une opération 2D, ou une opération 3D, ou encore le rendu d'une vidéo.

Les commandes graphiques en question varient beaucoup selon la carte graphique. Les commandes sont régulièrement revues et chaque nouvelle architecture a quelques changements par rapport aux modèles plus anciens. Des commandes peuvent apparaître, d'autres disparaître, d'autre voient leur fonctionnement légèrement altéré, etc.

Mais dans les grandes lignes, on peut classer ces commandes en quelques grands types. Les commandes les plus importantes s'occupent de l'affichage 3D : afficher une image à partir de paquets de sommets, préparer le passage d'une image à une autre, changer la résolution, etc. Plus rare, d'autres commandes servent à faire du rendu 2D : afficher un polygone, tracer une ligne, coloriser une surface, etc. Sur les cartes graphiques qui peuvent accélérer le rendu des vidéos, il existe des commandes spécialisées pour l’accélération des vidéos.

Pour donner quelques exemples, prenons les commandes 2D de la carte graphique AMD Radeon X1800.

{|class=&quot;wikitable&quot;
|-
! Commandes 2D 
! Fonction
|-
|PAINT 	
|Peindre un rectangle d'une certaine couleur
|-
|PAINT_MULTI 	
|Peindre des rectangles (pas les mêmes paramètres que PAINT)
|-
|BITBLT 	
|Copie d'un bloc de mémoire dans un autre
|-
|BITBLT_MULTI 	
|Plusieurs copies de blocs de mémoire dans d'autres
|-
|TRANS_BITBLT 	
|Copie de blocs de mémoire avec un masque
|-
|NEXTCHAR 	
|Afficher un caractère avec une certaine couleur
|-
|HOSTDATA_BLT 	
|Écrire une chaîne de caractères à l'écran ou copier une série d'image bitmap dans la mémoire vidéo
|-
|POLYLINE 	
|Afficher des lignes reliées entre elles
|-
|POLYSCANLINES
|Afficher des lignes
|-
|PLY_NEXTSCAN 	
|Afficher plusieurs lignes simples
|-
|SET_SCISSORS 	
|Utiliser des coupes (ciseaux)
|-
|LOAD_PALETTE 	
|Charger la palette pour affichage 2D
|}

===Le tampon de commandes===

L'envoi des commandes à la carte graphique ne se fait pas directement. La carte graphique n'est pas toujours libre pour accepter une nouvelle commande, soit parce qu'elle est occupée par une commande précédente, soit parce qu'elle fait autre chose. Il faut alors faire patienter les données tant que la carte graphique est occupée. Les pilotes de la carte graphique vont les mettre en attente dans le '''tampon de commandes'''. 

Le tampon de commandes est ce qu'on appelle une file, une zone de mémoire dans laquelle on stocke des données dans l'ordre d'ajout. Si le tampon de commandes est plein, le driver n'accepte plus de demandes en provenance des applications. Un tampon de commandes plein est généralement mauvais signe : cela signifie que la carte graphique est trop lente pour traiter les demandes qui lui sont faites. Par contre, il arrive que le tampon de commandes soit vide : dans ce cas, c'est simplement que la carte graphique est trop rapide comparé au processeur, qui n'arrive alors pas à donner assez de commandes à la carte graphique pour l'occuper suffisamment.

Le tampon de commande est soit une mémoire FIFO séparée, soit une portion de la mémoire vidéo. Le NV1, la toute première carte graphique NVIDIA, utilisait une mémoire FIFO intégrée à la carte graphique, séparée des autres circuits. Le processeur envoyait les commandes par rafale au GPU, à savoir qu'il envoyait plusieurs dizaines ou centaines de commandes à la suite, avant de passer à autre chose. Le GPU traitait les commandes une par une, à un rythme bien plus lent. Le processeur pouvait consulter la FIFO pour savoir s'il restait des entrées libres et combien. Le processeur savait ainsi combien d'écritures il pouvait envoyer en une fois au GPU.

: Le fonctionnement de la FIFO du NV1 est décrit dans le brevet ''US5805930A : System for FIFO informing the availability of stages to store commands which include data and virtual address sent directly from application programs''.

===Le processeur de commandes===

Le '''processeur de commande''' est un circuit qui gère les commandes envoyées par le processeur. Il lit la commande la plus ancienne dans le tampon de commande, l’interprète et l’exécute, puis passe à la suivante. Le processeur de commande est un circuit assez compliqué. Sur les cartes graphiques anciennes, c'était un circuit séquentiel complexe, fabriqué à la main et était la partie la plus complexe du processeur graphique. Sur les cartes graphiques modernes, c'est un véritable microcontrôleur, avec un processeur, de la mémoire RAM, etc.

Le processeur de commandes lit une commande dans le tampon de commande, décode la commande et l’exécute sur la carte graphique. Il garde en mémoire l'état de traitement de chaque commande : est-ce qu'elle est en train de s’exécuter sur le processeur graphique, est-ce qu'elle est mise en pause, est-ce qu'elle attend une donnée en provenance de la mémoire, est-ce qu'elle est terminée, etc.

Une commande utilise divers circuits de la carte 3D, de la mémoire vidéo, et d'autres ressources au sens large (des processeurs de ''shader'', notamment). Pour donner un exemple, la première carte graphique de NVIDIA, le NV1, contenait dans le détail : un controleur DMA avec une IO-MMU intégrée, la FIFO de commande, le processeur de commande, un pipeline graphique, un pipeline sonore, un contrôleur de manette. L'ensemble était relié par un bus interne à la carte graphique. Le processeur de commande servait de gestionnaire principal.

Le processeur de commande pilote les circuits de la carte graphique, il répartit le travail entre les différents circuits de la carte graphique et assure que l'ordre du pipeline est respecté. La fonction principale du processeur de commande est de répartir le travail entre les différents circuits. Le processeur de commande décide à quel processeur ou circuit doit être envoyé une commande. C'est le processeur de commande qui s'occupe de la gestion des ressources et qui attribue telle ressource à telle commande.

A chaque instant, le processeur de commande répartit les ''shaders'' sur les processeurs de ''shaders'', en faisant en sorte qu'ils soient utilisés le plus possible. Dans le cas le plus simple, les unités sont alimentées en vertex/pixels les unes après les autres (principe du round-robin), mais des stratégies plus optimisées sont la règle de nos jours. Cela est très important sur les cartes graphiques : répartir plusieurs commandes sur plusieurs processeurs est une tâche difficile. Un chapitre entier sera d'ailleurs dédié à ce sujet.

Il envoie aussi certaines commandes aux circuits fixes, comme l’''input assembler''. Là encore, il faut en sorte que les circuits fixes soient utilisés le mieux possible. Sa tâche est compliquée par le fait que les GPU récents ont plusieurs unités de traitement des sommets et des pixels, plusieurs ROP, plusieurs unités de textures, etc. Et c'est en partie le travail du processeur de commande que de répartir les calculs sur ces différentes unités. C'est là un problème assez compliqué pour le processeur de commande et ce pour tout un tas de raisons que nous ne ferons que survoler. Les contraintes d'ordonnancement de l'API et les règles de celle-ci sont une partie de la réponse. Mais d'autres raisons sont intrinsèques au rendu 3D ou à la conception des circuits.

[[File:Architecture de base d'une carte 3D - 1.png|centre|vignette|upright=2.5|Architecture de base d'une carte 3D - 1]]

==Le fonctionnement du processeur de commandes==

Le processeur de commande lit, décode et exécute des commandes. Intuitivement, on se dit qu'il procède une commande à la fois. Mais les GPU modernes sont plus intelligents et peuvent exécuter plusieurs commandes en même temps, dans des circuits séparés. De nombreuses optimisations de ce type sont utilisées pour gagner en performance. Voyons comment un processeur de commande moderne fonctionne.

===L'ordonnancement et la gestion des ressources===

Le processeur de commande doit souvent mettre en pause certains circuits du pipeline, ainsi que les circuits précédents. Par exemple, si tous les processeurs de ''vertex shader'' sont occupés, l’''input assembler'' ne peut pas charger le paquet suivant car il n'y a aucun processeur de libre pour l’accueillir. Dans ce cas, l'étape d’''input assembly'' est mise en pause en attendant qu'un processeur de ''shader'' soit libre.

La même chose a lieu pour l'étape de rastérisation : si aucun processeur de ''shader'' n'est libre, elle est mise en pause. Sauf que pour la rastérisation, cela a des conséquences sur les circuits précédents la rastérisation. Si un processeur de ''shader'' veut envoyer quelque chose au rastériseur alors qu'il est en pause, il devra lui aussi attendre que le rastériseur soit libre. On a la même chose quand les ROP sont occupés : les ''pixel shader'' ou l'unité de texture doivent parfois être mis en pause, ce qui peut entrainer la mise en pause des étapes précédentes, etc.

En clair : plus un étape est situé vers la fin du pipeline graphique, plus sa mise en pause a de chances de se répercuter sur les étapes précédentes et de les mettre en pause aussi. Le processeur de commande doit gérer ces situations.

===Le pipelining des commandes===

Dans les cartes graphiques les plus rudimentaires, le processeur de commande exécute les commandes dans l'ordre. Il exécute une commande çà la fois et attend qu'une commande soit terminé pour en lancer une autre. Plusieurs commandes sont accumulées dans le tampon de commande, le processeur de commande les traite de la plus ancienne vers la plus récente. Du moins, les anciennes cartes graphiques faisaient comme cela, les cartes graphiques modernes sont un peu plus complexes. Elles n'attendent pas qu'une commande soit totalement terminée avant d'en lancer une nouvelle. Les processeurs de commande actuels sont capables d’exécuter plusieurs commandes en même temps.

L'intérêt est un gain en performance assez important. Pour ceux qui ont déjà eu un cours d'architecture des ordinateurs avancé, lancer plusieurs commandes en même temps permet une forme de pipeline, dont les gains sont substantiels. Par exemple, imaginez qu'une commande de rendu 3D soit bien avancée et n'utilise que les processeurs de ''shaders'' et les ROP, mais laisse les unités géométriques libres. Il est alors possible de démarrer la commande suivante en avance, afin qu'elle remplisse les unités géométriques inutilisées. On a alors deux commandes en cours de traitement : une commande qui utilise la fin du pipeline uniquement, une autre qui utilise seulement le début du pipeline graphique.

Le processeur de commande gère donc plusieurs commandes simultanées, à savoir plusieurs commandes qui en sont à des étapes différentes du pipeline. On peut avoir une commande qui est en cours dans l'étage de gestion de la géométrie, une autre dans le rastériseur, et une autre dans les unités de traitement des pixels. Le fait que les étapes du pipeline graphique sont à effectuer dans un ordre bien précis permet ce genre de chose assez facilement.

Une autre possibilité est de faire des rendus en parallèle. Par exemple, imaginez qu'on ait des circuits séparés pour le rendu 2D et 3D. Prenons l'exemple où le calcul d'une image finale demande de faire un rendu 3D suivi d'un rendu 2D, par exemple un jeu vidéo en 3D qui a un HUD dessiné en 2D. Dans ce cas, on peut démarrer le calcul de l'image suivante dans le pipeline 3D pendant que la précédente est dans les circuits 2D, au lieu de laisser inutilisé le pipeline 3D pendant le rendu 2D.

Mais c'est là un défi compliqué à relever pour le processeur de commande, qui donne lieu à son lot de problèmes. Le problème principal est le partage de ressources entre commandes. Par exemple, on peut prendre le cas où une commande n'utilise pas beaucoup les processeurs de ''shaders''. On pourrait imaginer lancer une seconde commande en parallèle, afin que la seconde commande utiliser les processeurs de ''shaders'' inutilisés. Mais cela n'est possible que si les circuits fixes sont capables d'accepter une seconde commande. Si la première commande sature les circuits fixe, le lancement de la seconde commande sera empêché. Mais si ce n'est pas le cas, les deux commandes pourront être lancées en même temps. Pareil pour le débit mémoire, qui doit alors être partagé entre deux commandes simultanées, ce qui est à prendre en compte.

===La synchronisation de l’exécution des commandes avec le processeur===

Il arrive que le processeur doive savoir où en est le traitement des commandes, ce qui est très utile pour la gestion de la mémoire vidéo. 

Un premier exemple : comment éviter de saturer une carte graphique de commande, alors qu'on ne sait pas si elles traite les commandes rapidement ou non ? L'idéal est de regarder où en est la carte graphique dans l'exécution des commandes. Si elle n'en est qu'au début du tampon de commande et que celui-ci est bien remplit, alors il vaut mieux lever le pied et ne pas envoyer de nouvelles commandes. A l'inverse, si le tampon de commande est presque vide, envoyer des commandes est la meilleure idée possible.

Un autre exemple un peu moins parlant est celui de la gestion de la mémoire vidéo. Rappelons qu'elle est réalisée par le pilote de la carte graphique, sur le processeur principal, qui décide d'allouer et de libérer de la mémoire vidéo. Pour donner un exemple d'utilisation, imaginez que le pilote de la carte graphique doive libérer de la mémoire pour pouvoir ajouter une nouvelle commande. Comment éviter d'enlever une texture tant que les commandes qui l'utilisent ne sont pas terminées ? Ce problème ne se limite pas aux textures, mais vaut pour tout ce qui est placé en mémoire vidéo. 

Il faut donc que la carte graphique trouve un moyen de prévenir le processeur que le traitement de telle commande est terminée, que telle commande en est rendue à tel ou tel point, etc. Pour cela, on a globalement deux grandes solutions. La première est celle des interruptions, abordées dans les chapitres précédents. Mais elles sont assez couteuses et ne sont utilisées que pour des évènements vraiment importants, critiques, qui demandent une réaction rapide du processeur. L'autre solution est celle du ''pooling'', où le processeur monitore la carte graphique à intervalles réguliers. Deux solutions bien connues de ceux qui ont déjà lu un cours d'architecture des ordinateurs digne de ce nom, rien de bien neuf : la carte graphique communique avec le processeur comme tout périphérique.

Pour faciliter l'implémentation du ''pooling'', la carte graphique contient des registres de statut, dans le processeur de commande, qui mémorisent tout ou partie de l'état de la carte graphique. Si un problème survient, certains bits du registre de statut seront mis à 1 pour indiquer que telle erreur bien précise a eu lieu. Il existe aussi un registre de statut qui mémorise le numéro de la commande en cours, ou de la dernière commande terminée, ce qui permet de savoir où en est la carte graphique dans l'exécution des commandes. Et certaines registres de statut sont dédiés à la gestion des commandes. Ils sont totalement programmable, la carte graphique peut écrire dedans sans problème.

Les cartes graphiques récentes incorporent des commandes pour modifier ces registres de statut au besoin. Elles sont appelées des '''commandes de synchronisation''' : les barrières (''fences''). Elles permettent d'écrire une valeur dans un registre de statut quand telle ou telle condition est remplie. Par exemple, si jamais une commande est terminée, on peut écrire la valeur 1 dans tel ou tel registre. La condition en question peut être assez complexe et se résumer à quelque chose du genre : &quot;si jamais toutes les ''shaders'' ont fini de traiter tel ensemble de textures, alors écrit la valeur 1024 dans le registre de statut numéro 9&quot;.

===La synchronisation de l’exécution des commandes intra-GPU===

Lancer plusieurs commandes en parallèle dans le pipeline permet de gagner en performance.Mais cela a un gros défaut : il n'est pas garantit que les commandes se terminent dans l'ordre. Si on démarre une seconde commande après la première, il arrive que la seconde finisse avant. Pire : il n'est pas garantit qu'elles s'exécutent dans l'ordre. Dans la plupart des cas, cela ne pose pas de problèmes. Mais dans d'autres, cela donne des résultats erronés.

Pour donner un exemple, utilisons les commandes de rendu 2D vues plus haut, histoire de simplifier le tout. Imaginez que vous codez un jeu vidéo et que le rendu se fait en 2D, partons sur un jeu de type FPS. Vous avez une série de commandes pour calculer l'image à rendre à l'écran, suivie par une série de commandes finales pour dessiner le HUB. Pour dessiner le HUD, vous utilisez des commandes HOSTDATA_BLT, dont le but est d'écrire une chaîne de caractères à l'écran ou copier une série d'image bitmap dans la mémoire vidéo. Et bien ces commandes HOSTDATA_BLT doivent démarrer une fois que le rendu de l'image est complétement terminé. Imaginez que vous dessiniez le HUD sur une portion de l'image pas encore terminée et que celui-ci est effacé par des écritures ultérieures ! 

Pour éviter tout problème, les GPU incorporent des commandes de synchronisation intra-GPU, destinées au processeur de commande, aussis appelées des '''commandes de sémaphore'''. Elles permettent de mettre en pause le lancement d'une nouvelle commande tant que les précédentes ne sont pas totalement ou partiellement terminées. Les plus simples empêchent le démarrage d'une commande tant que les précédentes ne sont pas terminées. D'autres permettent de démarrer une commande si et seulement si certaines commandes sont terminées. D'autres sont encore plus précises : elles empêchent le démarrage d'une nouvelle commande tant qu'une commande précédente n'a pas atteint un certain stade de son exécution. Là encore, de telles commandes sont des commandes du style &quot;attend que le registre de statut numéro N contienne la valeur adéquate avant de poursuivre l'exécution des commandes&quot;. 

Les commandes en question peuvent être sur le même modèle que précédemment, à savoir des commandes qui lisent les registres de statut. Mais elles peuvent aussi se baser sur le fait que telle ou telle ressource de rendu est libre ou non. Des commandes successives se partagent souvent des données, et que de nombreuses commandes différentes peuvent s'exécuter en même temps. Or, si une commande veut modifier les données utilisées par une autre commande, il faut que l'ordre des commandes soit maintenu : la commande la plus récente ne doit pas modifier les données utilisées par une commande plus ancienne. Avec ce modèle, les sémaphores bloquent une commande tant qu'une ressource (une texture) est utilisée par une autre commande.

{|class=&quot;wikitable&quot;
|-
! Commandes de synchronisation
! Fonction
|-
|NOP 
|Ne rien faire
|-
|WAIT_SEMAPHORE 
|Attendre la synchronisation avec un sémaphore
|-
|WAIT_MEM 
|Attendre que la mémoire vidéo soit disponible et inoccupée par le CPU
|}

==L'arbitrage de l'accès à la carte graphique==

Il n'est pas rare que plusieurs applications souhaitent accéder en même temps à la carte graphique. Imaginons que vous regardez une vidéo en ''streaming'' sur votre navigateur web, avec un programme de ''cloud computing'' de type ''Folding@Home'' qui tourne en arrière-plan, sur Windows. Le décodage de la vidéo est réalisé par la carte graphique, Windows s'occupe de l'affichage du bureau et des fenêtres, le navigateur web doit afficher tout ce qui est autour de la vidéo (la page web), le programme de ''cloud computing'' va lancer ses calculs sur la carte graphique, etc. Des situations de ce genre sont assez courantes et c'est soit le pilote qui s'en charge, soit la carte graphique elle-même.

===L'arbitrage logiciel du GPU===

L'arbitrage logiciel est la méthode la plus simple. Concrètement, c'est le système d'exploitation et/ou le pilote de la carte graphique qui gèrent l'arbitrage du GPU. Dans les deux cas, tout est fait en logiciel. Les commandes sont accumulées dans un tampon de commande, voire plusieurs, et l'OS/pilote décide quelle commande envoyer en priorité.

Sur Windows, avant l'arrivée du modèle de driver dit ''Windows Display Driver Model'', de telles situations étaient gérées simplement. Les applications ajoutaient des commandes dans une file de commande unique. Les commandes étaient exécutées dans l'ordre, en mode premier entrée dans la file premier sorti/exécuté. Il n'y avait pour ainsi dire pas d'arbitrage entre les applications. Et ce n'était pas un problème car, à l'époque, les seules applications qui utilisaient le GPU étaient des jeux vidéos fonctionnant en mode plein écran.

Avec le modèle de driver ''Windows Display Driver Model'' (WDDM), le GPU est maintenant arbitré, à savoir que les applications ont accès à tour de rôle au GPU, certaines ayant droit à plus de temps GPU que d'autres. Chaque programme a accès à la carte graphique durant quelques dizaines ou centaines de millisecondes, à tour de rôle. Si le programme finissait son travail en moins de temps que la durée impartie, il laissait la main au programme suivant. S’il atteignait la durée maximale allouée, il était interrompu pour laisser la place au programme suivant. Et chaque programme avait droit d'accès à la carte graphique chacun à son tour. Un tel algorithme en tourniquet est très simple, mais avait cependant quelques défauts. De nos jours, les algorithmes d'ordonnancement d'accès sont plus élaborés, bien qu'il soit difficile de trouver de la littérature ou des brevets sur le sujet.

Une autre fonctionnalité de WDDM est que les applications utilisant le GPU peuvent se partager la mémoire vidéo sans se marcher dessus. Avant, toutes les applications avaient accès à toute la mémoire vidéo, bien que ce soit par l’intermédiaire de commandes spécifiques. Mais avec WDDM, chaque application dispose de sa propre portion de mémoire vidéo, à laquelle est la seule à avoir accès. Une application ne peut plus lire le contenu réel de la mémoire vidéo, et encore moins lire le contenu des autres applications.

: Il s'agit d'un équivalent à l'isolation des processus pour les programmes Windows, mais appliqué à la mémoire vidéo et non la mémoire système. Et cette isolation est rendue d'autant plus simple que les GPU modernes implémentent un système de mémoire virtuelle à pagination très poussé, avec du swap en mémoire RAM système, une protection mémoire, et bien d'autres fonctionnalités. Nous en reparlerons dans les chapitres sur la mémoire vidéo.

===L'arbitrage accéléré par le GPU===

Depuis 2020, avec l'arrivée de la ''Windows 10 May 2020 update'', Windows est capable de déléguer l'arbitrage du GPU au GPU lui-même. Le  GPU gère lui-même l'arbitrage, du moins en partie. En partie, car l'OS gére les priorité, à savoir quelle application a droit à plus de temps que les autres. Par contre, la gestion du ''quantum'' de temps ou les commutations de contexte (on stoppe une application pour laisser la place à une autre), est du fait du GPU lui-même.

L'avantage est que cela décharge le processeur d'une tâche assez lourde en calcul, pour la déporter sur le GPU. Un autre avantage est que le GPU peut gérer plus finement les ''quantum'' de temps et la commutation de contexte. Le CPU principal gère des durées assez importantes, de l'ordre de la milliseconde. De plus, il doit communiquer avec le GPU par des mécanismes temporellement imprécis, comme des interruptions. Avec l'arbitrage accéléré par le GPU, le GPU n'a plus besoin de communiquer avec le CPU pour l'arbitrage et peut le faire plus précisément, plus immédiatement. Un gain en performance théorique est donc possible.

L'arbitrage accéléré par le GPU est le fait soit du processeur de commandes, soit d'un processeur spécialisé, séparé.

{{NavChapitre | book=Les cartes graphiques
           | prev=La hiérarchie mémoire d'un GPU
           | prevText=La hiérarchie mémoire d'un GPU
           | next=Le pipeline géométrique d'avant DirectX 10
           | netxText=Le pipeline géométrique d'avant DirectX 10
}}{{autocat}}</text>
      <sha1>qynv97pw0ullmt1d9g2iftk48kg4pdk</sha1>
    </revision>
    <revision>
      <id>744038</id>
      <parentid>744037</parentid>
      <timestamp>2025-06-03T14:07:13Z</timestamp>
      <contributor>
        <username>Mewtow</username>
        <id>31375</id>
      </contributor>
      <minor />
      <comment>/* Le processeur de commandes */</comment>
      <origin>744038</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="32697" sha1="aaxj8lvkma159v81rxhge6n2t7atbph" xml:space="preserve">Dans ce chapitre, nous allons parler de tous les intermédiaires qui se placent entre une application de rendu 3D et les circuits de rendu 3D proprement dit. En premier lieu, on trouve le pilote de la carte graphique, aux fonctions multiples et variées. En second lieu, nous allons parler d'un circuit de la carte graphique qui fait l'interface entre le logiciel et les circuits de rendu 3D de la carte graphique : le processeur de commandes. Ce processeur de commandes est un circuit qui sert de chef d'orchestre, qui pilote le fonctionnement global de la carte graphique. API 3D, pilote de carte graphique et processeur de commande travaillent de concert pour que l'application communique avec la carte graphique. Nous allons d'abord voir le pilote de la carte graphique, avant de voir le fonctionnement du processeur de commande.

==Le pilote de carte graphique==

Le pilote de la carte graphique est un logiciel qui s'occupe de faire l'interface entre le logiciel et la carte graphique. De manière générale, les pilotes de périphérique sont des intermédiaires entre les applications/APIs et le matériel. En théorie, le système d'exploitation est censé jouer ce rôle, mais il n'est pas programmé pour être compatible avec tous les périphériques vendus sur le marché. À la place, le système d'exploitation ne gère pas directement certains périphériques, mais fournit de quoi ajouter ce qui manque. Le pilote d'un périphérique sert justement à ajouter ce qui manque : ils ajoutent au système d'exploitation de quoi reconnaître le périphérique, de quoi l'utiliser au mieux. Pour une carte graphique, il a diverses fonctions que nous allons voir ci-dessous.

Avant toute chose, précisons que les systèmes d'exploitation usuels (Windows, Linux, MacOsX et autres) sont fournis avec un pilote de carte graphique générique, compatible avec la plupart des cartes graphiques existantes. Rien de magique derrière cela : toutes les cartes graphiques vendues depuis plusieurs décennies respectent des standards, comme le VGA, le VESA, et d'autres. Et le pilote de base fournit avec le système d'exploitation est justement compatible avec ces standards minimaux. Mais le pilote ne peut pas profiter des fonctionnalités qui sont au-delà de ce standard. L'accélération 3D est presque inexistante avec le pilote de base, qui ne sert qu'à faire du rendu 2D (de quoi afficher l’interface de base du système d'exploitation, comme le bureau de Windows). Et même pour du rendu 2D, la plupart des fonctionnalités de la carte graphique ne sont pas disponibles. Par exemple, certaines résolutions ne sont pas disponibles, notamment les grandes résolutions. Ou encore, les performances sont loin d'être excellentes. Si vous avez déjà utilisé un PC sans pilote de carte graphique installé, vous avez certainement remarqué qu'il était particulièrement lent.

===La gestion des interruptions===

Une fonction particulièrement importante du pilote de carte graphique est la réponse aux interruptions lancées par la carte graphique. Pour rappel, les interruptions sont une fonctionnalité qui permet à un périphérique de communiquer avec le processeur, tout en économisant le temps de calcul de ce dernier. Typiquement, lorsqu'un périphérique lance une interruption, le processeur stoppe son travail et exécute automatiquement une routine d'interruption, un petit programme qui s'occupe de gérer le périphérique, de faire ce qu'il faut, ce que l'interruption a demandé.

Il y a plusieurs interruptions possibles, chacune ayant son propre numéro et sa fonction dédiée, chacune ayant sa propre routine d'interruption. Après tout, la routine qui gère un débordement de la mémoire vidéo n'est pas la même que celle qui gère un changement de fréquence du GPU ou la fin du calcul d'une image 3D. Le pilote fournit l'ensemble des routines d'interruptions nécessaires pour gérer la carte graphique.

===La compilation des ''shaders''===

Le pilote de carte graphique est aussi chargé de traduire les ''shaders'' en code machine. En soi, cette étape est assez complexe, et ressemble beaucoup à la compilation d'un programme informatique normal. Les ''shaders'' sont écrits dans un langage de programmation de haut niveau, comme le HLSL ou le GLSL, mais ce n'est pas ce code source qui est compilé par le pilote de carte graphique. À la place, les ''shaders'' sont pré-compilés vers un langage dit intermédiaire, avant d'être compilé par le pilote en code machine. Le langage intermédiaire, comme son nom l'indique, sert d'intermédiaire entre le code source écrit en HLSL/GLSL et le code machine exécuté par la carte graphique. Il ressemble à un langage assembleur, mais reste malgré tout assez générique pour ne pas être un véritable code machine. Par exemple, il y a peu de limitations quant au nombre de processeurs ou de registres. En clair, il y a deux passes de compilation : une passe de traduction du code source en langage intermédiaire, puis une passe de compilation du code intermédiaire vers le code machine. Notons que la première passe est réalisée par le programmeur des ''shaders'', non pas par l'utilisateur. Par exemple, les ''shaders'' d'un jeu vidéo sont fournis déjà pré-compilés : les fichiers du jeu ne contiennent pas le code source GLSL/HLSL, mais du code intermédiaire.

L'avantage de cette méthode est que le travail du pilote est fortement simplifié. Le pilote de périphérique pourrait compiler directement du code HLSL/GLSL, mais le temps de compilation serait très long et cela aurait un impact sur les performances. Avec l'usage du langage intermédiaire, le gros du travail à été fait lors de la première passe de compilation et le pilote graphique ne fait que finir le travail. Les optimisations importantes ont déjà été réalisées lors de la première passe. Il doit bien faire la traduction, ajouter quelques optimisations de bas niveau par-ci par-là, mais rien de bien gourmand en processeur. Autant dire que cela économise plus le processeur que si on devait compiler complètement les ''shaders'' à chaque exécution.

Fait amusant, il faut savoir que le pilote peut parfois remplacer les ''shaders'' d'un jeu vidéo à la volée. Les pilotes récents embarquent en effet des ''shaders'' alternatifs pour les jeux les plus vendus et/ou les plus populaires. Lorsque vous lancez un de ces jeux vidéo et que le ''shader'' originel s'exécute, le pilote le détecte automatiquement et le remplace par la version améliorée, fournie par le pilote. Évidemment, le ''shader'' alternatif du pilote est optimisé pour le matériel adéquat. Cela permet de gagner en performance, voire en qualité d'image, sans pour autant que les concepteurs du jeu n'aient quoique ce soit à faire.

Enfin, certains ''shaders'' sont fournis par le pilote pour d'autres raisons. Par exemple, les cartes graphiques récentes n'ont pas de circuits fixes pour traiter la géométrie. Autant les anciennes cartes graphiques avaient des circuits de T&amp;L qui s'en occupaient, autant tout cela doit être émulé sur les machines récentes. Sans cette émulation, les vieux jeux vidéo conçus pour exploiter le T&amp;L et d'autres technologies du genre ne fonctionneraient plus du tout. Émuler les circuits fixes disparus sur les cartes récentes est justement le fait de ''shaders'', présents dans le pilote de carte graphique.

===Les autres fonctions===

Le pilote a aussi bien d'autres fonctions. Par exemple, il s'occupe d'initialiser la carte graphique, de fixer la résolution, d'allouer la mémoire vidéo, de gérer le curseur de souris matériel, etc.

==Les commandes graphiques/vidéo/autres : des ordres envoyés au GPU==

Tous les traitements que la carte graphique doit effectuer, qu'il s'agisse de rendu 2D, de calculs 2D, du décodage matérielle d'un flux vidéo, ou de calculs généralistes, sont envoyés par le pilote de la carte graphique, sous la forme de '''commandes'''. Ces commandes demandent à la carte graphique d'effectuer une opération 2D, ou une opération 3D, ou encore le rendu d'une vidéo.

Les commandes graphiques en question varient beaucoup selon la carte graphique. Les commandes sont régulièrement revues et chaque nouvelle architecture a quelques changements par rapport aux modèles plus anciens. Des commandes peuvent apparaître, d'autres disparaître, d'autre voient leur fonctionnement légèrement altéré, etc.

Mais dans les grandes lignes, on peut classer ces commandes en quelques grands types. Les commandes les plus importantes s'occupent de l'affichage 3D : afficher une image à partir de paquets de sommets, préparer le passage d'une image à une autre, changer la résolution, etc. Plus rare, d'autres commandes servent à faire du rendu 2D : afficher un polygone, tracer une ligne, coloriser une surface, etc. Sur les cartes graphiques qui peuvent accélérer le rendu des vidéos, il existe des commandes spécialisées pour l’accélération des vidéos.

Pour donner quelques exemples, prenons les commandes 2D de la carte graphique AMD Radeon X1800.

{|class=&quot;wikitable&quot;
|-
! Commandes 2D 
! Fonction
|-
|PAINT 	
|Peindre un rectangle d'une certaine couleur
|-
|PAINT_MULTI 	
|Peindre des rectangles (pas les mêmes paramètres que PAINT)
|-
|BITBLT 	
|Copie d'un bloc de mémoire dans un autre
|-
|BITBLT_MULTI 	
|Plusieurs copies de blocs de mémoire dans d'autres
|-
|TRANS_BITBLT 	
|Copie de blocs de mémoire avec un masque
|-
|NEXTCHAR 	
|Afficher un caractère avec une certaine couleur
|-
|HOSTDATA_BLT 	
|Écrire une chaîne de caractères à l'écran ou copier une série d'image bitmap dans la mémoire vidéo
|-
|POLYLINE 	
|Afficher des lignes reliées entre elles
|-
|POLYSCANLINES
|Afficher des lignes
|-
|PLY_NEXTSCAN 	
|Afficher plusieurs lignes simples
|-
|SET_SCISSORS 	
|Utiliser des coupes (ciseaux)
|-
|LOAD_PALETTE 	
|Charger la palette pour affichage 2D
|}

===Le tampon de commandes===

L'envoi des commandes à la carte graphique ne se fait pas directement. La carte graphique n'est pas toujours libre pour accepter une nouvelle commande, soit parce qu'elle est occupée par une commande précédente, soit parce qu'elle fait autre chose. Il faut alors faire patienter les données tant que la carte graphique est occupée. Les pilotes de la carte graphique vont les mettre en attente dans le '''tampon de commandes'''. 

Le tampon de commandes est ce qu'on appelle une file, une zone de mémoire dans laquelle on stocke des données dans l'ordre d'ajout. Si le tampon de commandes est plein, le driver n'accepte plus de demandes en provenance des applications. Un tampon de commandes plein est généralement mauvais signe : cela signifie que la carte graphique est trop lente pour traiter les demandes qui lui sont faites. Par contre, il arrive que le tampon de commandes soit vide : dans ce cas, c'est simplement que la carte graphique est trop rapide comparé au processeur, qui n'arrive alors pas à donner assez de commandes à la carte graphique pour l'occuper suffisamment.

Le tampon de commande est soit une mémoire FIFO séparée, soit une portion de la mémoire vidéo. Le NV1, la toute première carte graphique NVIDIA, utilisait une mémoire FIFO intégrée à la carte graphique, séparée des autres circuits. Le processeur envoyait les commandes par rafale au GPU, à savoir qu'il envoyait plusieurs dizaines ou centaines de commandes à la suite, avant de passer à autre chose. Le GPU traitait les commandes une par une, à un rythme bien plus lent. Le processeur pouvait consulter la FIFO pour savoir s'il restait des entrées libres et combien. Le processeur savait ainsi combien d'écritures il pouvait envoyer en une fois au GPU.

: Le fonctionnement de la FIFO du NV1 est décrit dans le brevet ''US5805930A : System for FIFO informing the availability of stages to store commands which include data and virtual address sent directly from application programs''.

===Le processeur de commandes===

Le '''processeur de commande''' est un circuit qui gère les commandes envoyées par le processeur. Il lit la commande la plus ancienne dans le tampon de commande, l’interprète et l’exécute, puis passe à la suivante. Le processeur de commande est un circuit assez compliqué. Sur les cartes graphiques anciennes, c'était un circuit séquentiel complexe, fabriqué à la main et était la partie la plus complexe du processeur graphique. Sur les cartes graphiques modernes, c'est un véritable microcontrôleur, avec un processeur, de la mémoire RAM, etc.

Le processeur de commandes lit une commande dans le tampon de commande, décode la commande et l’exécute sur la carte graphique. Il garde en mémoire l'état de traitement de chaque commande : est-ce qu'elle est en train de s’exécuter sur le processeur graphique, est-ce qu'elle est mise en pause, est-ce qu'elle attend une donnée en provenance de la mémoire, est-ce qu'elle est terminée, etc.

Une commande utilise divers circuits de la carte 3D, de la mémoire vidéo, et d'autres ressources au sens large (des processeurs de ''shader'', notamment). Pour donner un exemple, la première carte graphique de NVIDIA, le NV1, contenait dans le détail : un controleur DMA avec une IO-MMU intégrée, la FIFO de commande, le processeur de commande, un pipeline graphique, un pipeline sonore, un contrôleur de manette. L'ensemble était relié par un bus interne à la carte graphique. Le processeur de commande servait de gestionnaire principal.

[[File:Microarchitecture du GPU NV1 de NVIDIA.png|centre|vignette|upright=2|Microarchitecture du GPU NV1 de NVIDIA]]

Le processeur de commande pilote les circuits de la carte graphique, il répartit le travail entre les différents circuits de la carte graphique et assure que l'ordre du pipeline est respecté. La fonction principale du processeur de commande est de répartir le travail entre les différents circuits. Le processeur de commande décide à quel processeur ou circuit doit être envoyé une commande. C'est le processeur de commande qui s'occupe de la gestion des ressources et qui attribue telle ressource à telle commande.

A chaque instant, le processeur de commande répartit les ''shaders'' sur les processeurs de ''shaders'', en faisant en sorte qu'ils soient utilisés le plus possible. Dans le cas le plus simple, les unités sont alimentées en vertex/pixels les unes après les autres (principe du round-robin), mais des stratégies plus optimisées sont la règle de nos jours. Cela est très important sur les cartes graphiques : répartir plusieurs commandes sur plusieurs processeurs est une tâche difficile. Un chapitre entier sera d'ailleurs dédié à ce sujet.

Il envoie aussi certaines commandes aux circuits fixes, comme l’''input assembler''. Là encore, il faut en sorte que les circuits fixes soient utilisés le mieux possible. Sa tâche est compliquée par le fait que les GPU récents ont plusieurs unités de traitement des sommets et des pixels, plusieurs ROP, plusieurs unités de textures, etc. Et c'est en partie le travail du processeur de commande que de répartir les calculs sur ces différentes unités. C'est là un problème assez compliqué pour le processeur de commande et ce pour tout un tas de raisons que nous ne ferons que survoler. Les contraintes d'ordonnancement de l'API et les règles de celle-ci sont une partie de la réponse. Mais d'autres raisons sont intrinsèques au rendu 3D ou à la conception des circuits.

[[File:Architecture de base d'une carte 3D - 1.png|centre|vignette|upright=2.5|Architecture de base d'une carte 3D - 1]]

==Le fonctionnement du processeur de commandes==

Le processeur de commande lit, décode et exécute des commandes. Intuitivement, on se dit qu'il procède une commande à la fois. Mais les GPU modernes sont plus intelligents et peuvent exécuter plusieurs commandes en même temps, dans des circuits séparés. De nombreuses optimisations de ce type sont utilisées pour gagner en performance. Voyons comment un processeur de commande moderne fonctionne.

===L'ordonnancement et la gestion des ressources===

Le processeur de commande doit souvent mettre en pause certains circuits du pipeline, ainsi que les circuits précédents. Par exemple, si tous les processeurs de ''vertex shader'' sont occupés, l’''input assembler'' ne peut pas charger le paquet suivant car il n'y a aucun processeur de libre pour l’accueillir. Dans ce cas, l'étape d’''input assembly'' est mise en pause en attendant qu'un processeur de ''shader'' soit libre.

La même chose a lieu pour l'étape de rastérisation : si aucun processeur de ''shader'' n'est libre, elle est mise en pause. Sauf que pour la rastérisation, cela a des conséquences sur les circuits précédents la rastérisation. Si un processeur de ''shader'' veut envoyer quelque chose au rastériseur alors qu'il est en pause, il devra lui aussi attendre que le rastériseur soit libre. On a la même chose quand les ROP sont occupés : les ''pixel shader'' ou l'unité de texture doivent parfois être mis en pause, ce qui peut entrainer la mise en pause des étapes précédentes, etc.

En clair : plus un étape est situé vers la fin du pipeline graphique, plus sa mise en pause a de chances de se répercuter sur les étapes précédentes et de les mettre en pause aussi. Le processeur de commande doit gérer ces situations.

===Le pipelining des commandes===

Dans les cartes graphiques les plus rudimentaires, le processeur de commande exécute les commandes dans l'ordre. Il exécute une commande çà la fois et attend qu'une commande soit terminé pour en lancer une autre. Plusieurs commandes sont accumulées dans le tampon de commande, le processeur de commande les traite de la plus ancienne vers la plus récente. Du moins, les anciennes cartes graphiques faisaient comme cela, les cartes graphiques modernes sont un peu plus complexes. Elles n'attendent pas qu'une commande soit totalement terminée avant d'en lancer une nouvelle. Les processeurs de commande actuels sont capables d’exécuter plusieurs commandes en même temps.

L'intérêt est un gain en performance assez important. Pour ceux qui ont déjà eu un cours d'architecture des ordinateurs avancé, lancer plusieurs commandes en même temps permet une forme de pipeline, dont les gains sont substantiels. Par exemple, imaginez qu'une commande de rendu 3D soit bien avancée et n'utilise que les processeurs de ''shaders'' et les ROP, mais laisse les unités géométriques libres. Il est alors possible de démarrer la commande suivante en avance, afin qu'elle remplisse les unités géométriques inutilisées. On a alors deux commandes en cours de traitement : une commande qui utilise la fin du pipeline uniquement, une autre qui utilise seulement le début du pipeline graphique.

Le processeur de commande gère donc plusieurs commandes simultanées, à savoir plusieurs commandes qui en sont à des étapes différentes du pipeline. On peut avoir une commande qui est en cours dans l'étage de gestion de la géométrie, une autre dans le rastériseur, et une autre dans les unités de traitement des pixels. Le fait que les étapes du pipeline graphique sont à effectuer dans un ordre bien précis permet ce genre de chose assez facilement.

Une autre possibilité est de faire des rendus en parallèle. Par exemple, imaginez qu'on ait des circuits séparés pour le rendu 2D et 3D. Prenons l'exemple où le calcul d'une image finale demande de faire un rendu 3D suivi d'un rendu 2D, par exemple un jeu vidéo en 3D qui a un HUD dessiné en 2D. Dans ce cas, on peut démarrer le calcul de l'image suivante dans le pipeline 3D pendant que la précédente est dans les circuits 2D, au lieu de laisser inutilisé le pipeline 3D pendant le rendu 2D.

Mais c'est là un défi compliqué à relever pour le processeur de commande, qui donne lieu à son lot de problèmes. Le problème principal est le partage de ressources entre commandes. Par exemple, on peut prendre le cas où une commande n'utilise pas beaucoup les processeurs de ''shaders''. On pourrait imaginer lancer une seconde commande en parallèle, afin que la seconde commande utiliser les processeurs de ''shaders'' inutilisés. Mais cela n'est possible que si les circuits fixes sont capables d'accepter une seconde commande. Si la première commande sature les circuits fixe, le lancement de la seconde commande sera empêché. Mais si ce n'est pas le cas, les deux commandes pourront être lancées en même temps. Pareil pour le débit mémoire, qui doit alors être partagé entre deux commandes simultanées, ce qui est à prendre en compte.

===La synchronisation de l’exécution des commandes avec le processeur===

Il arrive que le processeur doive savoir où en est le traitement des commandes, ce qui est très utile pour la gestion de la mémoire vidéo. 

Un premier exemple : comment éviter de saturer une carte graphique de commande, alors qu'on ne sait pas si elles traite les commandes rapidement ou non ? L'idéal est de regarder où en est la carte graphique dans l'exécution des commandes. Si elle n'en est qu'au début du tampon de commande et que celui-ci est bien remplit, alors il vaut mieux lever le pied et ne pas envoyer de nouvelles commandes. A l'inverse, si le tampon de commande est presque vide, envoyer des commandes est la meilleure idée possible.

Un autre exemple un peu moins parlant est celui de la gestion de la mémoire vidéo. Rappelons qu'elle est réalisée par le pilote de la carte graphique, sur le processeur principal, qui décide d'allouer et de libérer de la mémoire vidéo. Pour donner un exemple d'utilisation, imaginez que le pilote de la carte graphique doive libérer de la mémoire pour pouvoir ajouter une nouvelle commande. Comment éviter d'enlever une texture tant que les commandes qui l'utilisent ne sont pas terminées ? Ce problème ne se limite pas aux textures, mais vaut pour tout ce qui est placé en mémoire vidéo. 

Il faut donc que la carte graphique trouve un moyen de prévenir le processeur que le traitement de telle commande est terminée, que telle commande en est rendue à tel ou tel point, etc. Pour cela, on a globalement deux grandes solutions. La première est celle des interruptions, abordées dans les chapitres précédents. Mais elles sont assez couteuses et ne sont utilisées que pour des évènements vraiment importants, critiques, qui demandent une réaction rapide du processeur. L'autre solution est celle du ''pooling'', où le processeur monitore la carte graphique à intervalles réguliers. Deux solutions bien connues de ceux qui ont déjà lu un cours d'architecture des ordinateurs digne de ce nom, rien de bien neuf : la carte graphique communique avec le processeur comme tout périphérique.

Pour faciliter l'implémentation du ''pooling'', la carte graphique contient des registres de statut, dans le processeur de commande, qui mémorisent tout ou partie de l'état de la carte graphique. Si un problème survient, certains bits du registre de statut seront mis à 1 pour indiquer que telle erreur bien précise a eu lieu. Il existe aussi un registre de statut qui mémorise le numéro de la commande en cours, ou de la dernière commande terminée, ce qui permet de savoir où en est la carte graphique dans l'exécution des commandes. Et certaines registres de statut sont dédiés à la gestion des commandes. Ils sont totalement programmable, la carte graphique peut écrire dedans sans problème.

Les cartes graphiques récentes incorporent des commandes pour modifier ces registres de statut au besoin. Elles sont appelées des '''commandes de synchronisation''' : les barrières (''fences''). Elles permettent d'écrire une valeur dans un registre de statut quand telle ou telle condition est remplie. Par exemple, si jamais une commande est terminée, on peut écrire la valeur 1 dans tel ou tel registre. La condition en question peut être assez complexe et se résumer à quelque chose du genre : &quot;si jamais toutes les ''shaders'' ont fini de traiter tel ensemble de textures, alors écrit la valeur 1024 dans le registre de statut numéro 9&quot;.

===La synchronisation de l’exécution des commandes intra-GPU===

Lancer plusieurs commandes en parallèle dans le pipeline permet de gagner en performance.Mais cela a un gros défaut : il n'est pas garantit que les commandes se terminent dans l'ordre. Si on démarre une seconde commande après la première, il arrive que la seconde finisse avant. Pire : il n'est pas garantit qu'elles s'exécutent dans l'ordre. Dans la plupart des cas, cela ne pose pas de problèmes. Mais dans d'autres, cela donne des résultats erronés.

Pour donner un exemple, utilisons les commandes de rendu 2D vues plus haut, histoire de simplifier le tout. Imaginez que vous codez un jeu vidéo et que le rendu se fait en 2D, partons sur un jeu de type FPS. Vous avez une série de commandes pour calculer l'image à rendre à l'écran, suivie par une série de commandes finales pour dessiner le HUB. Pour dessiner le HUD, vous utilisez des commandes HOSTDATA_BLT, dont le but est d'écrire une chaîne de caractères à l'écran ou copier une série d'image bitmap dans la mémoire vidéo. Et bien ces commandes HOSTDATA_BLT doivent démarrer une fois que le rendu de l'image est complétement terminé. Imaginez que vous dessiniez le HUD sur une portion de l'image pas encore terminée et que celui-ci est effacé par des écritures ultérieures ! 

Pour éviter tout problème, les GPU incorporent des commandes de synchronisation intra-GPU, destinées au processeur de commande, aussis appelées des '''commandes de sémaphore'''. Elles permettent de mettre en pause le lancement d'une nouvelle commande tant que les précédentes ne sont pas totalement ou partiellement terminées. Les plus simples empêchent le démarrage d'une commande tant que les précédentes ne sont pas terminées. D'autres permettent de démarrer une commande si et seulement si certaines commandes sont terminées. D'autres sont encore plus précises : elles empêchent le démarrage d'une nouvelle commande tant qu'une commande précédente n'a pas atteint un certain stade de son exécution. Là encore, de telles commandes sont des commandes du style &quot;attend que le registre de statut numéro N contienne la valeur adéquate avant de poursuivre l'exécution des commandes&quot;. 

Les commandes en question peuvent être sur le même modèle que précédemment, à savoir des commandes qui lisent les registres de statut. Mais elles peuvent aussi se baser sur le fait que telle ou telle ressource de rendu est libre ou non. Des commandes successives se partagent souvent des données, et que de nombreuses commandes différentes peuvent s'exécuter en même temps. Or, si une commande veut modifier les données utilisées par une autre commande, il faut que l'ordre des commandes soit maintenu : la commande la plus récente ne doit pas modifier les données utilisées par une commande plus ancienne. Avec ce modèle, les sémaphores bloquent une commande tant qu'une ressource (une texture) est utilisée par une autre commande.

{|class=&quot;wikitable&quot;
|-
! Commandes de synchronisation
! Fonction
|-
|NOP 
|Ne rien faire
|-
|WAIT_SEMAPHORE 
|Attendre la synchronisation avec un sémaphore
|-
|WAIT_MEM 
|Attendre que la mémoire vidéo soit disponible et inoccupée par le CPU
|}

==L'arbitrage de l'accès à la carte graphique==

Il n'est pas rare que plusieurs applications souhaitent accéder en même temps à la carte graphique. Imaginons que vous regardez une vidéo en ''streaming'' sur votre navigateur web, avec un programme de ''cloud computing'' de type ''Folding@Home'' qui tourne en arrière-plan, sur Windows. Le décodage de la vidéo est réalisé par la carte graphique, Windows s'occupe de l'affichage du bureau et des fenêtres, le navigateur web doit afficher tout ce qui est autour de la vidéo (la page web), le programme de ''cloud computing'' va lancer ses calculs sur la carte graphique, etc. Des situations de ce genre sont assez courantes et c'est soit le pilote qui s'en charge, soit la carte graphique elle-même.

===L'arbitrage logiciel du GPU===

L'arbitrage logiciel est la méthode la plus simple. Concrètement, c'est le système d'exploitation et/ou le pilote de la carte graphique qui gèrent l'arbitrage du GPU. Dans les deux cas, tout est fait en logiciel. Les commandes sont accumulées dans un tampon de commande, voire plusieurs, et l'OS/pilote décide quelle commande envoyer en priorité.

Sur Windows, avant l'arrivée du modèle de driver dit ''Windows Display Driver Model'', de telles situations étaient gérées simplement. Les applications ajoutaient des commandes dans une file de commande unique. Les commandes étaient exécutées dans l'ordre, en mode premier entrée dans la file premier sorti/exécuté. Il n'y avait pour ainsi dire pas d'arbitrage entre les applications. Et ce n'était pas un problème car, à l'époque, les seules applications qui utilisaient le GPU étaient des jeux vidéos fonctionnant en mode plein écran.

Avec le modèle de driver ''Windows Display Driver Model'' (WDDM), le GPU est maintenant arbitré, à savoir que les applications ont accès à tour de rôle au GPU, certaines ayant droit à plus de temps GPU que d'autres. Chaque programme a accès à la carte graphique durant quelques dizaines ou centaines de millisecondes, à tour de rôle. Si le programme finissait son travail en moins de temps que la durée impartie, il laissait la main au programme suivant. S’il atteignait la durée maximale allouée, il était interrompu pour laisser la place au programme suivant. Et chaque programme avait droit d'accès à la carte graphique chacun à son tour. Un tel algorithme en tourniquet est très simple, mais avait cependant quelques défauts. De nos jours, les algorithmes d'ordonnancement d'accès sont plus élaborés, bien qu'il soit difficile de trouver de la littérature ou des brevets sur le sujet.

Une autre fonctionnalité de WDDM est que les applications utilisant le GPU peuvent se partager la mémoire vidéo sans se marcher dessus. Avant, toutes les applications avaient accès à toute la mémoire vidéo, bien que ce soit par l’intermédiaire de commandes spécifiques. Mais avec WDDM, chaque application dispose de sa propre portion de mémoire vidéo, à laquelle est la seule à avoir accès. Une application ne peut plus lire le contenu réel de la mémoire vidéo, et encore moins lire le contenu des autres applications.

: Il s'agit d'un équivalent à l'isolation des processus pour les programmes Windows, mais appliqué à la mémoire vidéo et non la mémoire système. Et cette isolation est rendue d'autant plus simple que les GPU modernes implémentent un système de mémoire virtuelle à pagination très poussé, avec du swap en mémoire RAM système, une protection mémoire, et bien d'autres fonctionnalités. Nous en reparlerons dans les chapitres sur la mémoire vidéo.

===L'arbitrage accéléré par le GPU===

Depuis 2020, avec l'arrivée de la ''Windows 10 May 2020 update'', Windows est capable de déléguer l'arbitrage du GPU au GPU lui-même. Le  GPU gère lui-même l'arbitrage, du moins en partie. En partie, car l'OS gére les priorité, à savoir quelle application a droit à plus de temps que les autres. Par contre, la gestion du ''quantum'' de temps ou les commutations de contexte (on stoppe une application pour laisser la place à une autre), est du fait du GPU lui-même.

L'avantage est que cela décharge le processeur d'une tâche assez lourde en calcul, pour la déporter sur le GPU. Un autre avantage est que le GPU peut gérer plus finement les ''quantum'' de temps et la commutation de contexte. Le CPU principal gère des durées assez importantes, de l'ordre de la milliseconde. De plus, il doit communiquer avec le GPU par des mécanismes temporellement imprécis, comme des interruptions. Avec l'arbitrage accéléré par le GPU, le GPU n'a plus besoin de communiquer avec le CPU pour l'arbitrage et peut le faire plus précisément, plus immédiatement. Un gain en performance théorique est donc possible.

L'arbitrage accéléré par le GPU est le fait soit du processeur de commandes, soit d'un processeur spécialisé, séparé.

{{NavChapitre | book=Les cartes graphiques
           | prev=La hiérarchie mémoire d'un GPU
           | prevText=La hiérarchie mémoire d'un GPU
           | next=Le pipeline géométrique d'avant DirectX 10
           | netxText=Le pipeline géométrique d'avant DirectX 10
}}{{autocat}}</text>
      <sha1>aaxj8lvkma159v81rxhge6n2t7atbph</sha1>
    </revision>
    <revision>
      <id>744039</id>
      <parentid>744038</parentid>
      <timestamp>2025-06-03T14:17:38Z</timestamp>
      <contributor>
        <username>Mewtow</username>
        <id>31375</id>
      </contributor>
      <minor />
      <comment>/* Le processeur de commandes */</comment>
      <origin>744039</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="33323" sha1="l28htpqczxe3lslqksy9ny04mi7k0fr" xml:space="preserve">Dans ce chapitre, nous allons parler de tous les intermédiaires qui se placent entre une application de rendu 3D et les circuits de rendu 3D proprement dit. En premier lieu, on trouve le pilote de la carte graphique, aux fonctions multiples et variées. En second lieu, nous allons parler d'un circuit de la carte graphique qui fait l'interface entre le logiciel et les circuits de rendu 3D de la carte graphique : le processeur de commandes. Ce processeur de commandes est un circuit qui sert de chef d'orchestre, qui pilote le fonctionnement global de la carte graphique. API 3D, pilote de carte graphique et processeur de commande travaillent de concert pour que l'application communique avec la carte graphique. Nous allons d'abord voir le pilote de la carte graphique, avant de voir le fonctionnement du processeur de commande.

==Le pilote de carte graphique==

Le pilote de la carte graphique est un logiciel qui s'occupe de faire l'interface entre le logiciel et la carte graphique. De manière générale, les pilotes de périphérique sont des intermédiaires entre les applications/APIs et le matériel. En théorie, le système d'exploitation est censé jouer ce rôle, mais il n'est pas programmé pour être compatible avec tous les périphériques vendus sur le marché. À la place, le système d'exploitation ne gère pas directement certains périphériques, mais fournit de quoi ajouter ce qui manque. Le pilote d'un périphérique sert justement à ajouter ce qui manque : ils ajoutent au système d'exploitation de quoi reconnaître le périphérique, de quoi l'utiliser au mieux. Pour une carte graphique, il a diverses fonctions que nous allons voir ci-dessous.

Avant toute chose, précisons que les systèmes d'exploitation usuels (Windows, Linux, MacOsX et autres) sont fournis avec un pilote de carte graphique générique, compatible avec la plupart des cartes graphiques existantes. Rien de magique derrière cela : toutes les cartes graphiques vendues depuis plusieurs décennies respectent des standards, comme le VGA, le VESA, et d'autres. Et le pilote de base fournit avec le système d'exploitation est justement compatible avec ces standards minimaux. Mais le pilote ne peut pas profiter des fonctionnalités qui sont au-delà de ce standard. L'accélération 3D est presque inexistante avec le pilote de base, qui ne sert qu'à faire du rendu 2D (de quoi afficher l’interface de base du système d'exploitation, comme le bureau de Windows). Et même pour du rendu 2D, la plupart des fonctionnalités de la carte graphique ne sont pas disponibles. Par exemple, certaines résolutions ne sont pas disponibles, notamment les grandes résolutions. Ou encore, les performances sont loin d'être excellentes. Si vous avez déjà utilisé un PC sans pilote de carte graphique installé, vous avez certainement remarqué qu'il était particulièrement lent.

===La gestion des interruptions===

Une fonction particulièrement importante du pilote de carte graphique est la réponse aux interruptions lancées par la carte graphique. Pour rappel, les interruptions sont une fonctionnalité qui permet à un périphérique de communiquer avec le processeur, tout en économisant le temps de calcul de ce dernier. Typiquement, lorsqu'un périphérique lance une interruption, le processeur stoppe son travail et exécute automatiquement une routine d'interruption, un petit programme qui s'occupe de gérer le périphérique, de faire ce qu'il faut, ce que l'interruption a demandé.

Il y a plusieurs interruptions possibles, chacune ayant son propre numéro et sa fonction dédiée, chacune ayant sa propre routine d'interruption. Après tout, la routine qui gère un débordement de la mémoire vidéo n'est pas la même que celle qui gère un changement de fréquence du GPU ou la fin du calcul d'une image 3D. Le pilote fournit l'ensemble des routines d'interruptions nécessaires pour gérer la carte graphique.

===La compilation des ''shaders''===

Le pilote de carte graphique est aussi chargé de traduire les ''shaders'' en code machine. En soi, cette étape est assez complexe, et ressemble beaucoup à la compilation d'un programme informatique normal. Les ''shaders'' sont écrits dans un langage de programmation de haut niveau, comme le HLSL ou le GLSL, mais ce n'est pas ce code source qui est compilé par le pilote de carte graphique. À la place, les ''shaders'' sont pré-compilés vers un langage dit intermédiaire, avant d'être compilé par le pilote en code machine. Le langage intermédiaire, comme son nom l'indique, sert d'intermédiaire entre le code source écrit en HLSL/GLSL et le code machine exécuté par la carte graphique. Il ressemble à un langage assembleur, mais reste malgré tout assez générique pour ne pas être un véritable code machine. Par exemple, il y a peu de limitations quant au nombre de processeurs ou de registres. En clair, il y a deux passes de compilation : une passe de traduction du code source en langage intermédiaire, puis une passe de compilation du code intermédiaire vers le code machine. Notons que la première passe est réalisée par le programmeur des ''shaders'', non pas par l'utilisateur. Par exemple, les ''shaders'' d'un jeu vidéo sont fournis déjà pré-compilés : les fichiers du jeu ne contiennent pas le code source GLSL/HLSL, mais du code intermédiaire.

L'avantage de cette méthode est que le travail du pilote est fortement simplifié. Le pilote de périphérique pourrait compiler directement du code HLSL/GLSL, mais le temps de compilation serait très long et cela aurait un impact sur les performances. Avec l'usage du langage intermédiaire, le gros du travail à été fait lors de la première passe de compilation et le pilote graphique ne fait que finir le travail. Les optimisations importantes ont déjà été réalisées lors de la première passe. Il doit bien faire la traduction, ajouter quelques optimisations de bas niveau par-ci par-là, mais rien de bien gourmand en processeur. Autant dire que cela économise plus le processeur que si on devait compiler complètement les ''shaders'' à chaque exécution.

Fait amusant, il faut savoir que le pilote peut parfois remplacer les ''shaders'' d'un jeu vidéo à la volée. Les pilotes récents embarquent en effet des ''shaders'' alternatifs pour les jeux les plus vendus et/ou les plus populaires. Lorsque vous lancez un de ces jeux vidéo et que le ''shader'' originel s'exécute, le pilote le détecte automatiquement et le remplace par la version améliorée, fournie par le pilote. Évidemment, le ''shader'' alternatif du pilote est optimisé pour le matériel adéquat. Cela permet de gagner en performance, voire en qualité d'image, sans pour autant que les concepteurs du jeu n'aient quoique ce soit à faire.

Enfin, certains ''shaders'' sont fournis par le pilote pour d'autres raisons. Par exemple, les cartes graphiques récentes n'ont pas de circuits fixes pour traiter la géométrie. Autant les anciennes cartes graphiques avaient des circuits de T&amp;L qui s'en occupaient, autant tout cela doit être émulé sur les machines récentes. Sans cette émulation, les vieux jeux vidéo conçus pour exploiter le T&amp;L et d'autres technologies du genre ne fonctionneraient plus du tout. Émuler les circuits fixes disparus sur les cartes récentes est justement le fait de ''shaders'', présents dans le pilote de carte graphique.

===Les autres fonctions===

Le pilote a aussi bien d'autres fonctions. Par exemple, il s'occupe d'initialiser la carte graphique, de fixer la résolution, d'allouer la mémoire vidéo, de gérer le curseur de souris matériel, etc.

==Les commandes graphiques/vidéo/autres : des ordres envoyés au GPU==

Tous les traitements que la carte graphique doit effectuer, qu'il s'agisse de rendu 2D, de calculs 2D, du décodage matérielle d'un flux vidéo, ou de calculs généralistes, sont envoyés par le pilote de la carte graphique, sous la forme de '''commandes'''. Ces commandes demandent à la carte graphique d'effectuer une opération 2D, ou une opération 3D, ou encore le rendu d'une vidéo.

Les commandes graphiques en question varient beaucoup selon la carte graphique. Les commandes sont régulièrement revues et chaque nouvelle architecture a quelques changements par rapport aux modèles plus anciens. Des commandes peuvent apparaître, d'autres disparaître, d'autre voient leur fonctionnement légèrement altéré, etc.

Mais dans les grandes lignes, on peut classer ces commandes en quelques grands types. Les commandes les plus importantes s'occupent de l'affichage 3D : afficher une image à partir de paquets de sommets, préparer le passage d'une image à une autre, changer la résolution, etc. Plus rare, d'autres commandes servent à faire du rendu 2D : afficher un polygone, tracer une ligne, coloriser une surface, etc. Sur les cartes graphiques qui peuvent accélérer le rendu des vidéos, il existe des commandes spécialisées pour l’accélération des vidéos.

Pour donner quelques exemples, prenons les commandes 2D de la carte graphique AMD Radeon X1800.

{|class=&quot;wikitable&quot;
|-
! Commandes 2D 
! Fonction
|-
|PAINT 	
|Peindre un rectangle d'une certaine couleur
|-
|PAINT_MULTI 	
|Peindre des rectangles (pas les mêmes paramètres que PAINT)
|-
|BITBLT 	
|Copie d'un bloc de mémoire dans un autre
|-
|BITBLT_MULTI 	
|Plusieurs copies de blocs de mémoire dans d'autres
|-
|TRANS_BITBLT 	
|Copie de blocs de mémoire avec un masque
|-
|NEXTCHAR 	
|Afficher un caractère avec une certaine couleur
|-
|HOSTDATA_BLT 	
|Écrire une chaîne de caractères à l'écran ou copier une série d'image bitmap dans la mémoire vidéo
|-
|POLYLINE 	
|Afficher des lignes reliées entre elles
|-
|POLYSCANLINES
|Afficher des lignes
|-
|PLY_NEXTSCAN 	
|Afficher plusieurs lignes simples
|-
|SET_SCISSORS 	
|Utiliser des coupes (ciseaux)
|-
|LOAD_PALETTE 	
|Charger la palette pour affichage 2D
|}

===Le tampon de commandes===

L'envoi des commandes à la carte graphique ne se fait pas directement. La carte graphique n'est pas toujours libre pour accepter une nouvelle commande, soit parce qu'elle est occupée par une commande précédente, soit parce qu'elle fait autre chose. Il faut alors faire patienter les données tant que la carte graphique est occupée. Les pilotes de la carte graphique vont les mettre en attente dans le '''tampon de commandes'''. 

Le tampon de commandes est ce qu'on appelle une file, une zone de mémoire dans laquelle on stocke des données dans l'ordre d'ajout. Si le tampon de commandes est plein, le driver n'accepte plus de demandes en provenance des applications. Un tampon de commandes plein est généralement mauvais signe : cela signifie que la carte graphique est trop lente pour traiter les demandes qui lui sont faites. Par contre, il arrive que le tampon de commandes soit vide : dans ce cas, c'est simplement que la carte graphique est trop rapide comparé au processeur, qui n'arrive alors pas à donner assez de commandes à la carte graphique pour l'occuper suffisamment.

Le tampon de commande est soit une mémoire FIFO séparée, soit une portion de la mémoire vidéo. Le NV1, la toute première carte graphique NVIDIA, utilisait une mémoire FIFO intégrée à la carte graphique, séparée des autres circuits. Le processeur envoyait les commandes par rafale au GPU, à savoir qu'il envoyait plusieurs dizaines ou centaines de commandes à la suite, avant de passer à autre chose. Le GPU traitait les commandes une par une, à un rythme bien plus lent. Le processeur pouvait consulter la FIFO pour savoir s'il restait des entrées libres et combien. Le processeur savait ainsi combien d'écritures il pouvait envoyer en une fois au GPU.

: Le fonctionnement de la FIFO du NV1 est décrit dans le brevet ''US5805930A : System for FIFO informing the availability of stages to store commands which include data and virtual address sent directly from application programs''.

===Le processeur de commandes===

Le '''processeur de commande''' est un circuit qui gère les commandes envoyées par le processeur. Il lit la commande la plus ancienne dans le tampon de commande, l’interprète et l’exécute, puis passe à la suivante. Le processeur de commande est un circuit assez compliqué. Sur les cartes graphiques anciennes, c'était un circuit séquentiel complexe, fabriqué à la main et était la partie la plus complexe du processeur graphique. Sur les cartes graphiques modernes, c'est un véritable microcontrôleur, avec un processeur, de la mémoire RAM, etc.

Une commande utilise divers circuits de la carte 3D, de la mémoire vidéo, et d'autres ressources au sens large (des processeurs de ''shader'', notamment). Pour donner un exemple, prenons la première carte graphique de NVIDIA, le NV1. Il s'agissait d'une carte multimédia qui incorporait non seulement une carte 2D/3D, mais aussi une carte son un contrôleur de disque et de quoi communiquer avec des manettes. De plus, il incorporait un contrôleur DMA pour échanger des données entre RAM système et les autres circuits. Et à tout cela, il fallait ajouter la FIFO de commandes et le processeur de commande. L'ensemble était relié par un bus interne à la carte graphique.

Le processeur de commande servait de gestionnaire principal. Il envoyait des ordres interne aux circuits de rendu 3D, à sa carte son, au contrôleur DMA. Par exemple, lorsque le processeur voulait copier des données en mémoire vidéo, il envoyait une commande de copie, qui était stockée dans le tampon de commande, puis était exécutée par le processeur de commande. Le processeur de commande envoyait alors les ordres adéquats au contrôleur DMA, qui faisait la copie des données.

[[File:Microarchitecture du GPU NV1 de NVIDIA.png|centre|vignette|upright=2|Microarchitecture du GPU NV1 de NVIDIA]]

Le processeur de commandes lit une commande dans le tampon de commande, décode la commande et l’exécute sur la carte graphique. Il garde en mémoire l'état de traitement de chaque commande : est-ce qu'elle est en train de s’exécuter sur le processeur graphique, est-ce qu'elle est mise en pause, est-ce qu'elle attend une donnée en provenance de la mémoire, est-ce qu'elle est terminée, etc.

Le processeur de commande pilote les circuits de la carte graphique, il répartit le travail entre les différents circuits de la carte graphique et assure que l'ordre du pipeline est respecté. La fonction principale du processeur de commande est de répartir le travail entre les différents circuits. Le processeur de commande décide à quel processeur ou circuit doit être envoyé une commande. C'est le processeur de commande qui s'occupe de la gestion des ressources et qui attribue telle ressource à telle commande.

A chaque instant, le processeur de commande répartit les ''shaders'' sur les processeurs de ''shaders'', en faisant en sorte qu'ils soient utilisés le plus possible. Dans le cas le plus simple, les unités sont alimentées en vertex/pixels les unes après les autres (principe du round-robin), mais des stratégies plus optimisées sont la règle de nos jours. Cela est très important sur les cartes graphiques : répartir plusieurs commandes sur plusieurs processeurs est une tâche difficile. Un chapitre entier sera d'ailleurs dédié à ce sujet.

Il envoie aussi certaines commandes aux circuits fixes, comme l’''input assembler''. Là encore, il faut en sorte que les circuits fixes soient utilisés le mieux possible. Sa tâche est compliquée par le fait que les GPU récents ont plusieurs unités de traitement des sommets et des pixels, plusieurs ROP, plusieurs unités de textures, etc. Et c'est en partie le travail du processeur de commande que de répartir les calculs sur ces différentes unités. C'est là un problème assez compliqué pour le processeur de commande et ce pour tout un tas de raisons que nous ne ferons que survoler. Les contraintes d'ordonnancement de l'API et les règles de celle-ci sont une partie de la réponse. Mais d'autres raisons sont intrinsèques au rendu 3D ou à la conception des circuits.

[[File:Architecture de base d'une carte 3D - 1.png|centre|vignette|upright=2.5|Architecture de base d'une carte 3D - 1]]

==Le fonctionnement du processeur de commandes==

Le processeur de commande lit, décode et exécute des commandes. Intuitivement, on se dit qu'il procède une commande à la fois. Mais les GPU modernes sont plus intelligents et peuvent exécuter plusieurs commandes en même temps, dans des circuits séparés. De nombreuses optimisations de ce type sont utilisées pour gagner en performance. Voyons comment un processeur de commande moderne fonctionne.

===L'ordonnancement et la gestion des ressources===

Le processeur de commande doit souvent mettre en pause certains circuits du pipeline, ainsi que les circuits précédents. Par exemple, si tous les processeurs de ''vertex shader'' sont occupés, l’''input assembler'' ne peut pas charger le paquet suivant car il n'y a aucun processeur de libre pour l’accueillir. Dans ce cas, l'étape d’''input assembly'' est mise en pause en attendant qu'un processeur de ''shader'' soit libre.

La même chose a lieu pour l'étape de rastérisation : si aucun processeur de ''shader'' n'est libre, elle est mise en pause. Sauf que pour la rastérisation, cela a des conséquences sur les circuits précédents la rastérisation. Si un processeur de ''shader'' veut envoyer quelque chose au rastériseur alors qu'il est en pause, il devra lui aussi attendre que le rastériseur soit libre. On a la même chose quand les ROP sont occupés : les ''pixel shader'' ou l'unité de texture doivent parfois être mis en pause, ce qui peut entrainer la mise en pause des étapes précédentes, etc.

En clair : plus un étape est situé vers la fin du pipeline graphique, plus sa mise en pause a de chances de se répercuter sur les étapes précédentes et de les mettre en pause aussi. Le processeur de commande doit gérer ces situations.

===Le pipelining des commandes===

Dans les cartes graphiques les plus rudimentaires, le processeur de commande exécute les commandes dans l'ordre. Il exécute une commande çà la fois et attend qu'une commande soit terminé pour en lancer une autre. Plusieurs commandes sont accumulées dans le tampon de commande, le processeur de commande les traite de la plus ancienne vers la plus récente. Du moins, les anciennes cartes graphiques faisaient comme cela, les cartes graphiques modernes sont un peu plus complexes. Elles n'attendent pas qu'une commande soit totalement terminée avant d'en lancer une nouvelle. Les processeurs de commande actuels sont capables d’exécuter plusieurs commandes en même temps.

L'intérêt est un gain en performance assez important. Pour ceux qui ont déjà eu un cours d'architecture des ordinateurs avancé, lancer plusieurs commandes en même temps permet une forme de pipeline, dont les gains sont substantiels. Par exemple, imaginez qu'une commande de rendu 3D soit bien avancée et n'utilise que les processeurs de ''shaders'' et les ROP, mais laisse les unités géométriques libres. Il est alors possible de démarrer la commande suivante en avance, afin qu'elle remplisse les unités géométriques inutilisées. On a alors deux commandes en cours de traitement : une commande qui utilise la fin du pipeline uniquement, une autre qui utilise seulement le début du pipeline graphique.

Le processeur de commande gère donc plusieurs commandes simultanées, à savoir plusieurs commandes qui en sont à des étapes différentes du pipeline. On peut avoir une commande qui est en cours dans l'étage de gestion de la géométrie, une autre dans le rastériseur, et une autre dans les unités de traitement des pixels. Le fait que les étapes du pipeline graphique sont à effectuer dans un ordre bien précis permet ce genre de chose assez facilement.

Une autre possibilité est de faire des rendus en parallèle. Par exemple, imaginez qu'on ait des circuits séparés pour le rendu 2D et 3D. Prenons l'exemple où le calcul d'une image finale demande de faire un rendu 3D suivi d'un rendu 2D, par exemple un jeu vidéo en 3D qui a un HUD dessiné en 2D. Dans ce cas, on peut démarrer le calcul de l'image suivante dans le pipeline 3D pendant que la précédente est dans les circuits 2D, au lieu de laisser inutilisé le pipeline 3D pendant le rendu 2D.

Mais c'est là un défi compliqué à relever pour le processeur de commande, qui donne lieu à son lot de problèmes. Le problème principal est le partage de ressources entre commandes. Par exemple, on peut prendre le cas où une commande n'utilise pas beaucoup les processeurs de ''shaders''. On pourrait imaginer lancer une seconde commande en parallèle, afin que la seconde commande utiliser les processeurs de ''shaders'' inutilisés. Mais cela n'est possible que si les circuits fixes sont capables d'accepter une seconde commande. Si la première commande sature les circuits fixe, le lancement de la seconde commande sera empêché. Mais si ce n'est pas le cas, les deux commandes pourront être lancées en même temps. Pareil pour le débit mémoire, qui doit alors être partagé entre deux commandes simultanées, ce qui est à prendre en compte.

===La synchronisation de l’exécution des commandes avec le processeur===

Il arrive que le processeur doive savoir où en est le traitement des commandes, ce qui est très utile pour la gestion de la mémoire vidéo. 

Un premier exemple : comment éviter de saturer une carte graphique de commande, alors qu'on ne sait pas si elles traite les commandes rapidement ou non ? L'idéal est de regarder où en est la carte graphique dans l'exécution des commandes. Si elle n'en est qu'au début du tampon de commande et que celui-ci est bien remplit, alors il vaut mieux lever le pied et ne pas envoyer de nouvelles commandes. A l'inverse, si le tampon de commande est presque vide, envoyer des commandes est la meilleure idée possible.

Un autre exemple un peu moins parlant est celui de la gestion de la mémoire vidéo. Rappelons qu'elle est réalisée par le pilote de la carte graphique, sur le processeur principal, qui décide d'allouer et de libérer de la mémoire vidéo. Pour donner un exemple d'utilisation, imaginez que le pilote de la carte graphique doive libérer de la mémoire pour pouvoir ajouter une nouvelle commande. Comment éviter d'enlever une texture tant que les commandes qui l'utilisent ne sont pas terminées ? Ce problème ne se limite pas aux textures, mais vaut pour tout ce qui est placé en mémoire vidéo. 

Il faut donc que la carte graphique trouve un moyen de prévenir le processeur que le traitement de telle commande est terminée, que telle commande en est rendue à tel ou tel point, etc. Pour cela, on a globalement deux grandes solutions. La première est celle des interruptions, abordées dans les chapitres précédents. Mais elles sont assez couteuses et ne sont utilisées que pour des évènements vraiment importants, critiques, qui demandent une réaction rapide du processeur. L'autre solution est celle du ''pooling'', où le processeur monitore la carte graphique à intervalles réguliers. Deux solutions bien connues de ceux qui ont déjà lu un cours d'architecture des ordinateurs digne de ce nom, rien de bien neuf : la carte graphique communique avec le processeur comme tout périphérique.

Pour faciliter l'implémentation du ''pooling'', la carte graphique contient des registres de statut, dans le processeur de commande, qui mémorisent tout ou partie de l'état de la carte graphique. Si un problème survient, certains bits du registre de statut seront mis à 1 pour indiquer que telle erreur bien précise a eu lieu. Il existe aussi un registre de statut qui mémorise le numéro de la commande en cours, ou de la dernière commande terminée, ce qui permet de savoir où en est la carte graphique dans l'exécution des commandes. Et certaines registres de statut sont dédiés à la gestion des commandes. Ils sont totalement programmable, la carte graphique peut écrire dedans sans problème.

Les cartes graphiques récentes incorporent des commandes pour modifier ces registres de statut au besoin. Elles sont appelées des '''commandes de synchronisation''' : les barrières (''fences''). Elles permettent d'écrire une valeur dans un registre de statut quand telle ou telle condition est remplie. Par exemple, si jamais une commande est terminée, on peut écrire la valeur 1 dans tel ou tel registre. La condition en question peut être assez complexe et se résumer à quelque chose du genre : &quot;si jamais toutes les ''shaders'' ont fini de traiter tel ensemble de textures, alors écrit la valeur 1024 dans le registre de statut numéro 9&quot;.

===La synchronisation de l’exécution des commandes intra-GPU===

Lancer plusieurs commandes en parallèle dans le pipeline permet de gagner en performance.Mais cela a un gros défaut : il n'est pas garantit que les commandes se terminent dans l'ordre. Si on démarre une seconde commande après la première, il arrive que la seconde finisse avant. Pire : il n'est pas garantit qu'elles s'exécutent dans l'ordre. Dans la plupart des cas, cela ne pose pas de problèmes. Mais dans d'autres, cela donne des résultats erronés.

Pour donner un exemple, utilisons les commandes de rendu 2D vues plus haut, histoire de simplifier le tout. Imaginez que vous codez un jeu vidéo et que le rendu se fait en 2D, partons sur un jeu de type FPS. Vous avez une série de commandes pour calculer l'image à rendre à l'écran, suivie par une série de commandes finales pour dessiner le HUB. Pour dessiner le HUD, vous utilisez des commandes HOSTDATA_BLT, dont le but est d'écrire une chaîne de caractères à l'écran ou copier une série d'image bitmap dans la mémoire vidéo. Et bien ces commandes HOSTDATA_BLT doivent démarrer une fois que le rendu de l'image est complétement terminé. Imaginez que vous dessiniez le HUD sur une portion de l'image pas encore terminée et que celui-ci est effacé par des écritures ultérieures ! 

Pour éviter tout problème, les GPU incorporent des commandes de synchronisation intra-GPU, destinées au processeur de commande, aussis appelées des '''commandes de sémaphore'''. Elles permettent de mettre en pause le lancement d'une nouvelle commande tant que les précédentes ne sont pas totalement ou partiellement terminées. Les plus simples empêchent le démarrage d'une commande tant que les précédentes ne sont pas terminées. D'autres permettent de démarrer une commande si et seulement si certaines commandes sont terminées. D'autres sont encore plus précises : elles empêchent le démarrage d'une nouvelle commande tant qu'une commande précédente n'a pas atteint un certain stade de son exécution. Là encore, de telles commandes sont des commandes du style &quot;attend que le registre de statut numéro N contienne la valeur adéquate avant de poursuivre l'exécution des commandes&quot;. 

Les commandes en question peuvent être sur le même modèle que précédemment, à savoir des commandes qui lisent les registres de statut. Mais elles peuvent aussi se baser sur le fait que telle ou telle ressource de rendu est libre ou non. Des commandes successives se partagent souvent des données, et que de nombreuses commandes différentes peuvent s'exécuter en même temps. Or, si une commande veut modifier les données utilisées par une autre commande, il faut que l'ordre des commandes soit maintenu : la commande la plus récente ne doit pas modifier les données utilisées par une commande plus ancienne. Avec ce modèle, les sémaphores bloquent une commande tant qu'une ressource (une texture) est utilisée par une autre commande.

{|class=&quot;wikitable&quot;
|-
! Commandes de synchronisation
! Fonction
|-
|NOP 
|Ne rien faire
|-
|WAIT_SEMAPHORE 
|Attendre la synchronisation avec un sémaphore
|-
|WAIT_MEM 
|Attendre que la mémoire vidéo soit disponible et inoccupée par le CPU
|}

==L'arbitrage de l'accès à la carte graphique==

Il n'est pas rare que plusieurs applications souhaitent accéder en même temps à la carte graphique. Imaginons que vous regardez une vidéo en ''streaming'' sur votre navigateur web, avec un programme de ''cloud computing'' de type ''Folding@Home'' qui tourne en arrière-plan, sur Windows. Le décodage de la vidéo est réalisé par la carte graphique, Windows s'occupe de l'affichage du bureau et des fenêtres, le navigateur web doit afficher tout ce qui est autour de la vidéo (la page web), le programme de ''cloud computing'' va lancer ses calculs sur la carte graphique, etc. Des situations de ce genre sont assez courantes et c'est soit le pilote qui s'en charge, soit la carte graphique elle-même.

===L'arbitrage logiciel du GPU===

L'arbitrage logiciel est la méthode la plus simple. Concrètement, c'est le système d'exploitation et/ou le pilote de la carte graphique qui gèrent l'arbitrage du GPU. Dans les deux cas, tout est fait en logiciel. Les commandes sont accumulées dans un tampon de commande, voire plusieurs, et l'OS/pilote décide quelle commande envoyer en priorité.

Sur Windows, avant l'arrivée du modèle de driver dit ''Windows Display Driver Model'', de telles situations étaient gérées simplement. Les applications ajoutaient des commandes dans une file de commande unique. Les commandes étaient exécutées dans l'ordre, en mode premier entrée dans la file premier sorti/exécuté. Il n'y avait pour ainsi dire pas d'arbitrage entre les applications. Et ce n'était pas un problème car, à l'époque, les seules applications qui utilisaient le GPU étaient des jeux vidéos fonctionnant en mode plein écran.

Avec le modèle de driver ''Windows Display Driver Model'' (WDDM), le GPU est maintenant arbitré, à savoir que les applications ont accès à tour de rôle au GPU, certaines ayant droit à plus de temps GPU que d'autres. Chaque programme a accès à la carte graphique durant quelques dizaines ou centaines de millisecondes, à tour de rôle. Si le programme finissait son travail en moins de temps que la durée impartie, il laissait la main au programme suivant. S’il atteignait la durée maximale allouée, il était interrompu pour laisser la place au programme suivant. Et chaque programme avait droit d'accès à la carte graphique chacun à son tour. Un tel algorithme en tourniquet est très simple, mais avait cependant quelques défauts. De nos jours, les algorithmes d'ordonnancement d'accès sont plus élaborés, bien qu'il soit difficile de trouver de la littérature ou des brevets sur le sujet.

Une autre fonctionnalité de WDDM est que les applications utilisant le GPU peuvent se partager la mémoire vidéo sans se marcher dessus. Avant, toutes les applications avaient accès à toute la mémoire vidéo, bien que ce soit par l’intermédiaire de commandes spécifiques. Mais avec WDDM, chaque application dispose de sa propre portion de mémoire vidéo, à laquelle est la seule à avoir accès. Une application ne peut plus lire le contenu réel de la mémoire vidéo, et encore moins lire le contenu des autres applications.

: Il s'agit d'un équivalent à l'isolation des processus pour les programmes Windows, mais appliqué à la mémoire vidéo et non la mémoire système. Et cette isolation est rendue d'autant plus simple que les GPU modernes implémentent un système de mémoire virtuelle à pagination très poussé, avec du swap en mémoire RAM système, une protection mémoire, et bien d'autres fonctionnalités. Nous en reparlerons dans les chapitres sur la mémoire vidéo.

===L'arbitrage accéléré par le GPU===

Depuis 2020, avec l'arrivée de la ''Windows 10 May 2020 update'', Windows est capable de déléguer l'arbitrage du GPU au GPU lui-même. Le  GPU gère lui-même l'arbitrage, du moins en partie. En partie, car l'OS gére les priorité, à savoir quelle application a droit à plus de temps que les autres. Par contre, la gestion du ''quantum'' de temps ou les commutations de contexte (on stoppe une application pour laisser la place à une autre), est du fait du GPU lui-même.

L'avantage est que cela décharge le processeur d'une tâche assez lourde en calcul, pour la déporter sur le GPU. Un autre avantage est que le GPU peut gérer plus finement les ''quantum'' de temps et la commutation de contexte. Le CPU principal gère des durées assez importantes, de l'ordre de la milliseconde. De plus, il doit communiquer avec le GPU par des mécanismes temporellement imprécis, comme des interruptions. Avec l'arbitrage accéléré par le GPU, le GPU n'a plus besoin de communiquer avec le CPU pour l'arbitrage et peut le faire plus précisément, plus immédiatement. Un gain en performance théorique est donc possible.

L'arbitrage accéléré par le GPU est le fait soit du processeur de commandes, soit d'un processeur spécialisé, séparé.

{{NavChapitre | book=Les cartes graphiques
           | prev=La hiérarchie mémoire d'un GPU
           | prevText=La hiérarchie mémoire d'un GPU
           | next=Le pipeline géométrique d'avant DirectX 10
           | netxText=Le pipeline géométrique d'avant DirectX 10
}}{{autocat}}</text>
      <sha1>l28htpqczxe3lslqksy9ny04mi7k0fr</sha1>
    </revision>
    <revision>
      <id>744040</id>
      <parentid>744039</parentid>
      <timestamp>2025-06-03T14:20:32Z</timestamp>
      <contributor>
        <username>Mewtow</username>
        <id>31375</id>
      </contributor>
      <minor />
      <comment>/* Le processeur de commandes */</comment>
      <origin>744040</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="33018" sha1="5p3cvjkutz493a9ow3kmvdkp17bbpis" xml:space="preserve">Dans ce chapitre, nous allons parler de tous les intermédiaires qui se placent entre une application de rendu 3D et les circuits de rendu 3D proprement dit. En premier lieu, on trouve le pilote de la carte graphique, aux fonctions multiples et variées. En second lieu, nous allons parler d'un circuit de la carte graphique qui fait l'interface entre le logiciel et les circuits de rendu 3D de la carte graphique : le processeur de commandes. Ce processeur de commandes est un circuit qui sert de chef d'orchestre, qui pilote le fonctionnement global de la carte graphique. API 3D, pilote de carte graphique et processeur de commande travaillent de concert pour que l'application communique avec la carte graphique. Nous allons d'abord voir le pilote de la carte graphique, avant de voir le fonctionnement du processeur de commande.

==Le pilote de carte graphique==

Le pilote de la carte graphique est un logiciel qui s'occupe de faire l'interface entre le logiciel et la carte graphique. De manière générale, les pilotes de périphérique sont des intermédiaires entre les applications/APIs et le matériel. En théorie, le système d'exploitation est censé jouer ce rôle, mais il n'est pas programmé pour être compatible avec tous les périphériques vendus sur le marché. À la place, le système d'exploitation ne gère pas directement certains périphériques, mais fournit de quoi ajouter ce qui manque. Le pilote d'un périphérique sert justement à ajouter ce qui manque : ils ajoutent au système d'exploitation de quoi reconnaître le périphérique, de quoi l'utiliser au mieux. Pour une carte graphique, il a diverses fonctions que nous allons voir ci-dessous.

Avant toute chose, précisons que les systèmes d'exploitation usuels (Windows, Linux, MacOsX et autres) sont fournis avec un pilote de carte graphique générique, compatible avec la plupart des cartes graphiques existantes. Rien de magique derrière cela : toutes les cartes graphiques vendues depuis plusieurs décennies respectent des standards, comme le VGA, le VESA, et d'autres. Et le pilote de base fournit avec le système d'exploitation est justement compatible avec ces standards minimaux. Mais le pilote ne peut pas profiter des fonctionnalités qui sont au-delà de ce standard. L'accélération 3D est presque inexistante avec le pilote de base, qui ne sert qu'à faire du rendu 2D (de quoi afficher l’interface de base du système d'exploitation, comme le bureau de Windows). Et même pour du rendu 2D, la plupart des fonctionnalités de la carte graphique ne sont pas disponibles. Par exemple, certaines résolutions ne sont pas disponibles, notamment les grandes résolutions. Ou encore, les performances sont loin d'être excellentes. Si vous avez déjà utilisé un PC sans pilote de carte graphique installé, vous avez certainement remarqué qu'il était particulièrement lent.

===La gestion des interruptions===

Une fonction particulièrement importante du pilote de carte graphique est la réponse aux interruptions lancées par la carte graphique. Pour rappel, les interruptions sont une fonctionnalité qui permet à un périphérique de communiquer avec le processeur, tout en économisant le temps de calcul de ce dernier. Typiquement, lorsqu'un périphérique lance une interruption, le processeur stoppe son travail et exécute automatiquement une routine d'interruption, un petit programme qui s'occupe de gérer le périphérique, de faire ce qu'il faut, ce que l'interruption a demandé.

Il y a plusieurs interruptions possibles, chacune ayant son propre numéro et sa fonction dédiée, chacune ayant sa propre routine d'interruption. Après tout, la routine qui gère un débordement de la mémoire vidéo n'est pas la même que celle qui gère un changement de fréquence du GPU ou la fin du calcul d'une image 3D. Le pilote fournit l'ensemble des routines d'interruptions nécessaires pour gérer la carte graphique.

===La compilation des ''shaders''===

Le pilote de carte graphique est aussi chargé de traduire les ''shaders'' en code machine. En soi, cette étape est assez complexe, et ressemble beaucoup à la compilation d'un programme informatique normal. Les ''shaders'' sont écrits dans un langage de programmation de haut niveau, comme le HLSL ou le GLSL, mais ce n'est pas ce code source qui est compilé par le pilote de carte graphique. À la place, les ''shaders'' sont pré-compilés vers un langage dit intermédiaire, avant d'être compilé par le pilote en code machine. Le langage intermédiaire, comme son nom l'indique, sert d'intermédiaire entre le code source écrit en HLSL/GLSL et le code machine exécuté par la carte graphique. Il ressemble à un langage assembleur, mais reste malgré tout assez générique pour ne pas être un véritable code machine. Par exemple, il y a peu de limitations quant au nombre de processeurs ou de registres. En clair, il y a deux passes de compilation : une passe de traduction du code source en langage intermédiaire, puis une passe de compilation du code intermédiaire vers le code machine. Notons que la première passe est réalisée par le programmeur des ''shaders'', non pas par l'utilisateur. Par exemple, les ''shaders'' d'un jeu vidéo sont fournis déjà pré-compilés : les fichiers du jeu ne contiennent pas le code source GLSL/HLSL, mais du code intermédiaire.

L'avantage de cette méthode est que le travail du pilote est fortement simplifié. Le pilote de périphérique pourrait compiler directement du code HLSL/GLSL, mais le temps de compilation serait très long et cela aurait un impact sur les performances. Avec l'usage du langage intermédiaire, le gros du travail à été fait lors de la première passe de compilation et le pilote graphique ne fait que finir le travail. Les optimisations importantes ont déjà été réalisées lors de la première passe. Il doit bien faire la traduction, ajouter quelques optimisations de bas niveau par-ci par-là, mais rien de bien gourmand en processeur. Autant dire que cela économise plus le processeur que si on devait compiler complètement les ''shaders'' à chaque exécution.

Fait amusant, il faut savoir que le pilote peut parfois remplacer les ''shaders'' d'un jeu vidéo à la volée. Les pilotes récents embarquent en effet des ''shaders'' alternatifs pour les jeux les plus vendus et/ou les plus populaires. Lorsque vous lancez un de ces jeux vidéo et que le ''shader'' originel s'exécute, le pilote le détecte automatiquement et le remplace par la version améliorée, fournie par le pilote. Évidemment, le ''shader'' alternatif du pilote est optimisé pour le matériel adéquat. Cela permet de gagner en performance, voire en qualité d'image, sans pour autant que les concepteurs du jeu n'aient quoique ce soit à faire.

Enfin, certains ''shaders'' sont fournis par le pilote pour d'autres raisons. Par exemple, les cartes graphiques récentes n'ont pas de circuits fixes pour traiter la géométrie. Autant les anciennes cartes graphiques avaient des circuits de T&amp;L qui s'en occupaient, autant tout cela doit être émulé sur les machines récentes. Sans cette émulation, les vieux jeux vidéo conçus pour exploiter le T&amp;L et d'autres technologies du genre ne fonctionneraient plus du tout. Émuler les circuits fixes disparus sur les cartes récentes est justement le fait de ''shaders'', présents dans le pilote de carte graphique.

===Les autres fonctions===

Le pilote a aussi bien d'autres fonctions. Par exemple, il s'occupe d'initialiser la carte graphique, de fixer la résolution, d'allouer la mémoire vidéo, de gérer le curseur de souris matériel, etc.

==Les commandes graphiques/vidéo/autres : des ordres envoyés au GPU==

Tous les traitements que la carte graphique doit effectuer, qu'il s'agisse de rendu 2D, de calculs 2D, du décodage matérielle d'un flux vidéo, ou de calculs généralistes, sont envoyés par le pilote de la carte graphique, sous la forme de '''commandes'''. Ces commandes demandent à la carte graphique d'effectuer une opération 2D, ou une opération 3D, ou encore le rendu d'une vidéo.

Les commandes graphiques en question varient beaucoup selon la carte graphique. Les commandes sont régulièrement revues et chaque nouvelle architecture a quelques changements par rapport aux modèles plus anciens. Des commandes peuvent apparaître, d'autres disparaître, d'autre voient leur fonctionnement légèrement altéré, etc.

Mais dans les grandes lignes, on peut classer ces commandes en quelques grands types. Les commandes les plus importantes s'occupent de l'affichage 3D : afficher une image à partir de paquets de sommets, préparer le passage d'une image à une autre, changer la résolution, etc. Plus rare, d'autres commandes servent à faire du rendu 2D : afficher un polygone, tracer une ligne, coloriser une surface, etc. Sur les cartes graphiques qui peuvent accélérer le rendu des vidéos, il existe des commandes spécialisées pour l’accélération des vidéos.

Pour donner quelques exemples, prenons les commandes 2D de la carte graphique AMD Radeon X1800.

{|class=&quot;wikitable&quot;
|-
! Commandes 2D 
! Fonction
|-
|PAINT 	
|Peindre un rectangle d'une certaine couleur
|-
|PAINT_MULTI 	
|Peindre des rectangles (pas les mêmes paramètres que PAINT)
|-
|BITBLT 	
|Copie d'un bloc de mémoire dans un autre
|-
|BITBLT_MULTI 	
|Plusieurs copies de blocs de mémoire dans d'autres
|-
|TRANS_BITBLT 	
|Copie de blocs de mémoire avec un masque
|-
|NEXTCHAR 	
|Afficher un caractère avec une certaine couleur
|-
|HOSTDATA_BLT 	
|Écrire une chaîne de caractères à l'écran ou copier une série d'image bitmap dans la mémoire vidéo
|-
|POLYLINE 	
|Afficher des lignes reliées entre elles
|-
|POLYSCANLINES
|Afficher des lignes
|-
|PLY_NEXTSCAN 	
|Afficher plusieurs lignes simples
|-
|SET_SCISSORS 	
|Utiliser des coupes (ciseaux)
|-
|LOAD_PALETTE 	
|Charger la palette pour affichage 2D
|}

===Le tampon de commandes===

L'envoi des commandes à la carte graphique ne se fait pas directement. La carte graphique n'est pas toujours libre pour accepter une nouvelle commande, soit parce qu'elle est occupée par une commande précédente, soit parce qu'elle fait autre chose. Il faut alors faire patienter les données tant que la carte graphique est occupée. Les pilotes de la carte graphique vont les mettre en attente dans le '''tampon de commandes'''. 

Le tampon de commandes est ce qu'on appelle une file, une zone de mémoire dans laquelle on stocke des données dans l'ordre d'ajout. Si le tampon de commandes est plein, le driver n'accepte plus de demandes en provenance des applications. Un tampon de commandes plein est généralement mauvais signe : cela signifie que la carte graphique est trop lente pour traiter les demandes qui lui sont faites. Par contre, il arrive que le tampon de commandes soit vide : dans ce cas, c'est simplement que la carte graphique est trop rapide comparé au processeur, qui n'arrive alors pas à donner assez de commandes à la carte graphique pour l'occuper suffisamment.

Le tampon de commande est soit une mémoire FIFO séparée, soit une portion de la mémoire vidéo. Le NV1, la toute première carte graphique NVIDIA, utilisait une mémoire FIFO intégrée à la carte graphique, séparée des autres circuits. Le processeur envoyait les commandes par rafale au GPU, à savoir qu'il envoyait plusieurs dizaines ou centaines de commandes à la suite, avant de passer à autre chose. Le GPU traitait les commandes une par une, à un rythme bien plus lent. Le processeur pouvait consulter la FIFO pour savoir s'il restait des entrées libres et combien. Le processeur savait ainsi combien d'écritures il pouvait envoyer en une fois au GPU.

: Le fonctionnement de la FIFO du NV1 est décrit dans le brevet ''US5805930A : System for FIFO informing the availability of stages to store commands which include data and virtual address sent directly from application programs''.

===Le processeur de commandes===

Le '''processeur de commande''' est un circuit qui gère les commandes envoyées par le processeur. Il lit la commande la plus ancienne dans le tampon de commande, l’interprète, l’exécute, puis passe à la suivante. Le processeur de commande est un circuit assez compliqué. Sur les cartes graphiques anciennes, c'était un circuit séquentiel complexe, fabriqué à la main et était la partie la plus complexe du processeur graphique. Sur les cartes graphiques modernes, c'est un véritable microcontrôleur, avec un processeur, de la mémoire RAM, etc.

Lors de l'exécution d'une commande, le processeur de commande pilote les circuits de la carte graphique. Précisément, il répartit le travail entre les différents circuits de la carte graphique et assure que l'ordre du pipeline est respecté. Le processeur de commande décide à quel processeur ou circuit doit être envoyé une commande.

Pour donner un exemple, prenons la première carte graphique de NVIDIA, le NV1. Il s'agissait d'une carte multimédia qui incorporait non seulement une carte 2D/3D, mais aussi une carte son un contrôleur de disque et de quoi communiquer avec des manettes. De plus, il incorporait un contrôleur DMA pour échanger des données entre RAM système et les autres circuits. Et à tout cela, il fallait ajouter la FIFO de commandes et le processeur de commande. L'ensemble était relié par un bus interne à la carte graphique.

Le processeur de commande servait de gestionnaire principal. Il envoyait des ordres interne aux circuits de rendu 3D, à sa carte son, au contrôleur DMA. Par exemple, lorsque le processeur voulait copier des données en mémoire vidéo, il envoyait une commande de copie, qui était stockée dans le tampon de commande, puis était exécutée par le processeur de commande. Le processeur de commande envoyait alors les ordres adéquats au contrôleur DMA, qui faisait la copie des données. Lors d'un rendu 3D, une commande de rendu 3D est envoyée au NV1, le processeur de commande la traite et l'envoi dans les circuits de rendu 3D.

[[File:Microarchitecture du GPU NV1 de NVIDIA.png|centre|vignette|upright=2|Microarchitecture du GPU NV1 de NVIDIA]]

Le processeur de commandes garde en mémoire l'état de traitement de chaque commande : est-ce qu'elle est en train de s’exécuter sur le processeur graphique, est-ce qu'elle est mise en pause, est-ce qu'elle attend une donnée en provenance de la mémoire, est-ce qu'elle est terminée, etc.

A chaque instant, le processeur de commande répartit les ''shaders'' sur les processeurs de ''shaders'', en faisant en sorte qu'ils soient utilisés le plus possible. Dans le cas le plus simple, les unités sont alimentées en vertex/pixels les unes après les autres (principe du round-robin), mais des stratégies plus optimisées sont la règle de nos jours. Cela est très important sur les cartes graphiques : répartir plusieurs commandes sur plusieurs processeurs est une tâche difficile. Un chapitre entier sera d'ailleurs dédié à ce sujet.

Il envoie aussi certaines commandes aux circuits fixes, comme l’''input assembler''. Là encore, il faut en sorte que les circuits fixes soient utilisés le mieux possible. Sa tâche est compliquée par le fait que les GPU récents ont plusieurs unités de traitement des sommets et des pixels, plusieurs ROP, plusieurs unités de textures, etc. Et c'est en partie le travail du processeur de commande que de répartir les calculs sur ces différentes unités. C'est là un problème assez compliqué pour le processeur de commande et ce pour tout un tas de raisons que nous ne ferons que survoler. Les contraintes d'ordonnancement de l'API et les règles de celle-ci sont une partie de la réponse. Mais d'autres raisons sont intrinsèques au rendu 3D ou à la conception des circuits.

[[File:Architecture de base d'une carte 3D - 1.png|centre|vignette|upright=2.5|Architecture de base d'une carte 3D - 1]]

==Le fonctionnement du processeur de commandes==

Le processeur de commande lit, décode et exécute des commandes. Intuitivement, on se dit qu'il procède une commande à la fois. Mais les GPU modernes sont plus intelligents et peuvent exécuter plusieurs commandes en même temps, dans des circuits séparés. De nombreuses optimisations de ce type sont utilisées pour gagner en performance. Voyons comment un processeur de commande moderne fonctionne.

===L'ordonnancement et la gestion des ressources===

Le processeur de commande doit souvent mettre en pause certains circuits du pipeline, ainsi que les circuits précédents. Par exemple, si tous les processeurs de ''vertex shader'' sont occupés, l’''input assembler'' ne peut pas charger le paquet suivant car il n'y a aucun processeur de libre pour l’accueillir. Dans ce cas, l'étape d’''input assembly'' est mise en pause en attendant qu'un processeur de ''shader'' soit libre.

La même chose a lieu pour l'étape de rastérisation : si aucun processeur de ''shader'' n'est libre, elle est mise en pause. Sauf que pour la rastérisation, cela a des conséquences sur les circuits précédents la rastérisation. Si un processeur de ''shader'' veut envoyer quelque chose au rastériseur alors qu'il est en pause, il devra lui aussi attendre que le rastériseur soit libre. On a la même chose quand les ROP sont occupés : les ''pixel shader'' ou l'unité de texture doivent parfois être mis en pause, ce qui peut entrainer la mise en pause des étapes précédentes, etc.

En clair : plus un étape est situé vers la fin du pipeline graphique, plus sa mise en pause a de chances de se répercuter sur les étapes précédentes et de les mettre en pause aussi. Le processeur de commande doit gérer ces situations.

===Le pipelining des commandes===

Dans les cartes graphiques les plus rudimentaires, le processeur de commande exécute les commandes dans l'ordre. Il exécute une commande çà la fois et attend qu'une commande soit terminé pour en lancer une autre. Plusieurs commandes sont accumulées dans le tampon de commande, le processeur de commande les traite de la plus ancienne vers la plus récente. Du moins, les anciennes cartes graphiques faisaient comme cela, les cartes graphiques modernes sont un peu plus complexes. Elles n'attendent pas qu'une commande soit totalement terminée avant d'en lancer une nouvelle. Les processeurs de commande actuels sont capables d’exécuter plusieurs commandes en même temps.

L'intérêt est un gain en performance assez important. Pour ceux qui ont déjà eu un cours d'architecture des ordinateurs avancé, lancer plusieurs commandes en même temps permet une forme de pipeline, dont les gains sont substantiels. Par exemple, imaginez qu'une commande de rendu 3D soit bien avancée et n'utilise que les processeurs de ''shaders'' et les ROP, mais laisse les unités géométriques libres. Il est alors possible de démarrer la commande suivante en avance, afin qu'elle remplisse les unités géométriques inutilisées. On a alors deux commandes en cours de traitement : une commande qui utilise la fin du pipeline uniquement, une autre qui utilise seulement le début du pipeline graphique.

Le processeur de commande gère donc plusieurs commandes simultanées, à savoir plusieurs commandes qui en sont à des étapes différentes du pipeline. On peut avoir une commande qui est en cours dans l'étage de gestion de la géométrie, une autre dans le rastériseur, et une autre dans les unités de traitement des pixels. Le fait que les étapes du pipeline graphique sont à effectuer dans un ordre bien précis permet ce genre de chose assez facilement.

Une autre possibilité est de faire des rendus en parallèle. Par exemple, imaginez qu'on ait des circuits séparés pour le rendu 2D et 3D. Prenons l'exemple où le calcul d'une image finale demande de faire un rendu 3D suivi d'un rendu 2D, par exemple un jeu vidéo en 3D qui a un HUD dessiné en 2D. Dans ce cas, on peut démarrer le calcul de l'image suivante dans le pipeline 3D pendant que la précédente est dans les circuits 2D, au lieu de laisser inutilisé le pipeline 3D pendant le rendu 2D.

Mais c'est là un défi compliqué à relever pour le processeur de commande, qui donne lieu à son lot de problèmes. Le problème principal est le partage de ressources entre commandes. Par exemple, on peut prendre le cas où une commande n'utilise pas beaucoup les processeurs de ''shaders''. On pourrait imaginer lancer une seconde commande en parallèle, afin que la seconde commande utiliser les processeurs de ''shaders'' inutilisés. Mais cela n'est possible que si les circuits fixes sont capables d'accepter une seconde commande. Si la première commande sature les circuits fixe, le lancement de la seconde commande sera empêché. Mais si ce n'est pas le cas, les deux commandes pourront être lancées en même temps. Pareil pour le débit mémoire, qui doit alors être partagé entre deux commandes simultanées, ce qui est à prendre en compte.

===La synchronisation de l’exécution des commandes avec le processeur===

Il arrive que le processeur doive savoir où en est le traitement des commandes, ce qui est très utile pour la gestion de la mémoire vidéo. 

Un premier exemple : comment éviter de saturer une carte graphique de commande, alors qu'on ne sait pas si elles traite les commandes rapidement ou non ? L'idéal est de regarder où en est la carte graphique dans l'exécution des commandes. Si elle n'en est qu'au début du tampon de commande et que celui-ci est bien remplit, alors il vaut mieux lever le pied et ne pas envoyer de nouvelles commandes. A l'inverse, si le tampon de commande est presque vide, envoyer des commandes est la meilleure idée possible.

Un autre exemple un peu moins parlant est celui de la gestion de la mémoire vidéo. Rappelons qu'elle est réalisée par le pilote de la carte graphique, sur le processeur principal, qui décide d'allouer et de libérer de la mémoire vidéo. Pour donner un exemple d'utilisation, imaginez que le pilote de la carte graphique doive libérer de la mémoire pour pouvoir ajouter une nouvelle commande. Comment éviter d'enlever une texture tant que les commandes qui l'utilisent ne sont pas terminées ? Ce problème ne se limite pas aux textures, mais vaut pour tout ce qui est placé en mémoire vidéo. 

Il faut donc que la carte graphique trouve un moyen de prévenir le processeur que le traitement de telle commande est terminée, que telle commande en est rendue à tel ou tel point, etc. Pour cela, on a globalement deux grandes solutions. La première est celle des interruptions, abordées dans les chapitres précédents. Mais elles sont assez couteuses et ne sont utilisées que pour des évènements vraiment importants, critiques, qui demandent une réaction rapide du processeur. L'autre solution est celle du ''pooling'', où le processeur monitore la carte graphique à intervalles réguliers. Deux solutions bien connues de ceux qui ont déjà lu un cours d'architecture des ordinateurs digne de ce nom, rien de bien neuf : la carte graphique communique avec le processeur comme tout périphérique.

Pour faciliter l'implémentation du ''pooling'', la carte graphique contient des registres de statut, dans le processeur de commande, qui mémorisent tout ou partie de l'état de la carte graphique. Si un problème survient, certains bits du registre de statut seront mis à 1 pour indiquer que telle erreur bien précise a eu lieu. Il existe aussi un registre de statut qui mémorise le numéro de la commande en cours, ou de la dernière commande terminée, ce qui permet de savoir où en est la carte graphique dans l'exécution des commandes. Et certaines registres de statut sont dédiés à la gestion des commandes. Ils sont totalement programmable, la carte graphique peut écrire dedans sans problème.

Les cartes graphiques récentes incorporent des commandes pour modifier ces registres de statut au besoin. Elles sont appelées des '''commandes de synchronisation''' : les barrières (''fences''). Elles permettent d'écrire une valeur dans un registre de statut quand telle ou telle condition est remplie. Par exemple, si jamais une commande est terminée, on peut écrire la valeur 1 dans tel ou tel registre. La condition en question peut être assez complexe et se résumer à quelque chose du genre : &quot;si jamais toutes les ''shaders'' ont fini de traiter tel ensemble de textures, alors écrit la valeur 1024 dans le registre de statut numéro 9&quot;.

===La synchronisation de l’exécution des commandes intra-GPU===

Lancer plusieurs commandes en parallèle dans le pipeline permet de gagner en performance.Mais cela a un gros défaut : il n'est pas garantit que les commandes se terminent dans l'ordre. Si on démarre une seconde commande après la première, il arrive que la seconde finisse avant. Pire : il n'est pas garantit qu'elles s'exécutent dans l'ordre. Dans la plupart des cas, cela ne pose pas de problèmes. Mais dans d'autres, cela donne des résultats erronés.

Pour donner un exemple, utilisons les commandes de rendu 2D vues plus haut, histoire de simplifier le tout. Imaginez que vous codez un jeu vidéo et que le rendu se fait en 2D, partons sur un jeu de type FPS. Vous avez une série de commandes pour calculer l'image à rendre à l'écran, suivie par une série de commandes finales pour dessiner le HUB. Pour dessiner le HUD, vous utilisez des commandes HOSTDATA_BLT, dont le but est d'écrire une chaîne de caractères à l'écran ou copier une série d'image bitmap dans la mémoire vidéo. Et bien ces commandes HOSTDATA_BLT doivent démarrer une fois que le rendu de l'image est complétement terminé. Imaginez que vous dessiniez le HUD sur une portion de l'image pas encore terminée et que celui-ci est effacé par des écritures ultérieures ! 

Pour éviter tout problème, les GPU incorporent des commandes de synchronisation intra-GPU, destinées au processeur de commande, aussis appelées des '''commandes de sémaphore'''. Elles permettent de mettre en pause le lancement d'une nouvelle commande tant que les précédentes ne sont pas totalement ou partiellement terminées. Les plus simples empêchent le démarrage d'une commande tant que les précédentes ne sont pas terminées. D'autres permettent de démarrer une commande si et seulement si certaines commandes sont terminées. D'autres sont encore plus précises : elles empêchent le démarrage d'une nouvelle commande tant qu'une commande précédente n'a pas atteint un certain stade de son exécution. Là encore, de telles commandes sont des commandes du style &quot;attend que le registre de statut numéro N contienne la valeur adéquate avant de poursuivre l'exécution des commandes&quot;. 

Les commandes en question peuvent être sur le même modèle que précédemment, à savoir des commandes qui lisent les registres de statut. Mais elles peuvent aussi se baser sur le fait que telle ou telle ressource de rendu est libre ou non. Des commandes successives se partagent souvent des données, et que de nombreuses commandes différentes peuvent s'exécuter en même temps. Or, si une commande veut modifier les données utilisées par une autre commande, il faut que l'ordre des commandes soit maintenu : la commande la plus récente ne doit pas modifier les données utilisées par une commande plus ancienne. Avec ce modèle, les sémaphores bloquent une commande tant qu'une ressource (une texture) est utilisée par une autre commande.

{|class=&quot;wikitable&quot;
|-
! Commandes de synchronisation
! Fonction
|-
|NOP 
|Ne rien faire
|-
|WAIT_SEMAPHORE 
|Attendre la synchronisation avec un sémaphore
|-
|WAIT_MEM 
|Attendre que la mémoire vidéo soit disponible et inoccupée par le CPU
|}

==L'arbitrage de l'accès à la carte graphique==

Il n'est pas rare que plusieurs applications souhaitent accéder en même temps à la carte graphique. Imaginons que vous regardez une vidéo en ''streaming'' sur votre navigateur web, avec un programme de ''cloud computing'' de type ''Folding@Home'' qui tourne en arrière-plan, sur Windows. Le décodage de la vidéo est réalisé par la carte graphique, Windows s'occupe de l'affichage du bureau et des fenêtres, le navigateur web doit afficher tout ce qui est autour de la vidéo (la page web), le programme de ''cloud computing'' va lancer ses calculs sur la carte graphique, etc. Des situations de ce genre sont assez courantes et c'est soit le pilote qui s'en charge, soit la carte graphique elle-même.

===L'arbitrage logiciel du GPU===

L'arbitrage logiciel est la méthode la plus simple. Concrètement, c'est le système d'exploitation et/ou le pilote de la carte graphique qui gèrent l'arbitrage du GPU. Dans les deux cas, tout est fait en logiciel. Les commandes sont accumulées dans un tampon de commande, voire plusieurs, et l'OS/pilote décide quelle commande envoyer en priorité.

Sur Windows, avant l'arrivée du modèle de driver dit ''Windows Display Driver Model'', de telles situations étaient gérées simplement. Les applications ajoutaient des commandes dans une file de commande unique. Les commandes étaient exécutées dans l'ordre, en mode premier entrée dans la file premier sorti/exécuté. Il n'y avait pour ainsi dire pas d'arbitrage entre les applications. Et ce n'était pas un problème car, à l'époque, les seules applications qui utilisaient le GPU étaient des jeux vidéos fonctionnant en mode plein écran.

Avec le modèle de driver ''Windows Display Driver Model'' (WDDM), le GPU est maintenant arbitré, à savoir que les applications ont accès à tour de rôle au GPU, certaines ayant droit à plus de temps GPU que d'autres. Chaque programme a accès à la carte graphique durant quelques dizaines ou centaines de millisecondes, à tour de rôle. Si le programme finissait son travail en moins de temps que la durée impartie, il laissait la main au programme suivant. S’il atteignait la durée maximale allouée, il était interrompu pour laisser la place au programme suivant. Et chaque programme avait droit d'accès à la carte graphique chacun à son tour. Un tel algorithme en tourniquet est très simple, mais avait cependant quelques défauts. De nos jours, les algorithmes d'ordonnancement d'accès sont plus élaborés, bien qu'il soit difficile de trouver de la littérature ou des brevets sur le sujet.

Une autre fonctionnalité de WDDM est que les applications utilisant le GPU peuvent se partager la mémoire vidéo sans se marcher dessus. Avant, toutes les applications avaient accès à toute la mémoire vidéo, bien que ce soit par l’intermédiaire de commandes spécifiques. Mais avec WDDM, chaque application dispose de sa propre portion de mémoire vidéo, à laquelle est la seule à avoir accès. Une application ne peut plus lire le contenu réel de la mémoire vidéo, et encore moins lire le contenu des autres applications.

: Il s'agit d'un équivalent à l'isolation des processus pour les programmes Windows, mais appliqué à la mémoire vidéo et non la mémoire système. Et cette isolation est rendue d'autant plus simple que les GPU modernes implémentent un système de mémoire virtuelle à pagination très poussé, avec du swap en mémoire RAM système, une protection mémoire, et bien d'autres fonctionnalités. Nous en reparlerons dans les chapitres sur la mémoire vidéo.

===L'arbitrage accéléré par le GPU===

Depuis 2020, avec l'arrivée de la ''Windows 10 May 2020 update'', Windows est capable de déléguer l'arbitrage du GPU au GPU lui-même. Le  GPU gère lui-même l'arbitrage, du moins en partie. En partie, car l'OS gére les priorité, à savoir quelle application a droit à plus de temps que les autres. Par contre, la gestion du ''quantum'' de temps ou les commutations de contexte (on stoppe une application pour laisser la place à une autre), est du fait du GPU lui-même.

L'avantage est que cela décharge le processeur d'une tâche assez lourde en calcul, pour la déporter sur le GPU. Un autre avantage est que le GPU peut gérer plus finement les ''quantum'' de temps et la commutation de contexte. Le CPU principal gère des durées assez importantes, de l'ordre de la milliseconde. De plus, il doit communiquer avec le GPU par des mécanismes temporellement imprécis, comme des interruptions. Avec l'arbitrage accéléré par le GPU, le GPU n'a plus besoin de communiquer avec le CPU pour l'arbitrage et peut le faire plus précisément, plus immédiatement. Un gain en performance théorique est donc possible.

L'arbitrage accéléré par le GPU est le fait soit du processeur de commandes, soit d'un processeur spécialisé, séparé.

{{NavChapitre | book=Les cartes graphiques
           | prev=La hiérarchie mémoire d'un GPU
           | prevText=La hiérarchie mémoire d'un GPU
           | next=Le pipeline géométrique d'avant DirectX 10
           | netxText=Le pipeline géométrique d'avant DirectX 10
}}{{autocat}}</text>
      <sha1>5p3cvjkutz493a9ow3kmvdkp17bbpis</sha1>
    </revision>
    <revision>
      <id>744041</id>
      <parentid>744040</parentid>
      <timestamp>2025-06-03T14:24:34Z</timestamp>
      <contributor>
        <username>Mewtow</username>
        <id>31375</id>
      </contributor>
      <minor />
      <comment>/* Le processeur de commandes */</comment>
      <origin>744041</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="33531" sha1="74kzthjlkdrlrx920c4mcbxr7bxzwz0" xml:space="preserve">Dans ce chapitre, nous allons parler de tous les intermédiaires qui se placent entre une application de rendu 3D et les circuits de rendu 3D proprement dit. En premier lieu, on trouve le pilote de la carte graphique, aux fonctions multiples et variées. En second lieu, nous allons parler d'un circuit de la carte graphique qui fait l'interface entre le logiciel et les circuits de rendu 3D de la carte graphique : le processeur de commandes. Ce processeur de commandes est un circuit qui sert de chef d'orchestre, qui pilote le fonctionnement global de la carte graphique. API 3D, pilote de carte graphique et processeur de commande travaillent de concert pour que l'application communique avec la carte graphique. Nous allons d'abord voir le pilote de la carte graphique, avant de voir le fonctionnement du processeur de commande.

==Le pilote de carte graphique==

Le pilote de la carte graphique est un logiciel qui s'occupe de faire l'interface entre le logiciel et la carte graphique. De manière générale, les pilotes de périphérique sont des intermédiaires entre les applications/APIs et le matériel. En théorie, le système d'exploitation est censé jouer ce rôle, mais il n'est pas programmé pour être compatible avec tous les périphériques vendus sur le marché. À la place, le système d'exploitation ne gère pas directement certains périphériques, mais fournit de quoi ajouter ce qui manque. Le pilote d'un périphérique sert justement à ajouter ce qui manque : ils ajoutent au système d'exploitation de quoi reconnaître le périphérique, de quoi l'utiliser au mieux. Pour une carte graphique, il a diverses fonctions que nous allons voir ci-dessous.

Avant toute chose, précisons que les systèmes d'exploitation usuels (Windows, Linux, MacOsX et autres) sont fournis avec un pilote de carte graphique générique, compatible avec la plupart des cartes graphiques existantes. Rien de magique derrière cela : toutes les cartes graphiques vendues depuis plusieurs décennies respectent des standards, comme le VGA, le VESA, et d'autres. Et le pilote de base fournit avec le système d'exploitation est justement compatible avec ces standards minimaux. Mais le pilote ne peut pas profiter des fonctionnalités qui sont au-delà de ce standard. L'accélération 3D est presque inexistante avec le pilote de base, qui ne sert qu'à faire du rendu 2D (de quoi afficher l’interface de base du système d'exploitation, comme le bureau de Windows). Et même pour du rendu 2D, la plupart des fonctionnalités de la carte graphique ne sont pas disponibles. Par exemple, certaines résolutions ne sont pas disponibles, notamment les grandes résolutions. Ou encore, les performances sont loin d'être excellentes. Si vous avez déjà utilisé un PC sans pilote de carte graphique installé, vous avez certainement remarqué qu'il était particulièrement lent.

===La gestion des interruptions===

Une fonction particulièrement importante du pilote de carte graphique est la réponse aux interruptions lancées par la carte graphique. Pour rappel, les interruptions sont une fonctionnalité qui permet à un périphérique de communiquer avec le processeur, tout en économisant le temps de calcul de ce dernier. Typiquement, lorsqu'un périphérique lance une interruption, le processeur stoppe son travail et exécute automatiquement une routine d'interruption, un petit programme qui s'occupe de gérer le périphérique, de faire ce qu'il faut, ce que l'interruption a demandé.

Il y a plusieurs interruptions possibles, chacune ayant son propre numéro et sa fonction dédiée, chacune ayant sa propre routine d'interruption. Après tout, la routine qui gère un débordement de la mémoire vidéo n'est pas la même que celle qui gère un changement de fréquence du GPU ou la fin du calcul d'une image 3D. Le pilote fournit l'ensemble des routines d'interruptions nécessaires pour gérer la carte graphique.

===La compilation des ''shaders''===

Le pilote de carte graphique est aussi chargé de traduire les ''shaders'' en code machine. En soi, cette étape est assez complexe, et ressemble beaucoup à la compilation d'un programme informatique normal. Les ''shaders'' sont écrits dans un langage de programmation de haut niveau, comme le HLSL ou le GLSL, mais ce n'est pas ce code source qui est compilé par le pilote de carte graphique. À la place, les ''shaders'' sont pré-compilés vers un langage dit intermédiaire, avant d'être compilé par le pilote en code machine. Le langage intermédiaire, comme son nom l'indique, sert d'intermédiaire entre le code source écrit en HLSL/GLSL et le code machine exécuté par la carte graphique. Il ressemble à un langage assembleur, mais reste malgré tout assez générique pour ne pas être un véritable code machine. Par exemple, il y a peu de limitations quant au nombre de processeurs ou de registres. En clair, il y a deux passes de compilation : une passe de traduction du code source en langage intermédiaire, puis une passe de compilation du code intermédiaire vers le code machine. Notons que la première passe est réalisée par le programmeur des ''shaders'', non pas par l'utilisateur. Par exemple, les ''shaders'' d'un jeu vidéo sont fournis déjà pré-compilés : les fichiers du jeu ne contiennent pas le code source GLSL/HLSL, mais du code intermédiaire.

L'avantage de cette méthode est que le travail du pilote est fortement simplifié. Le pilote de périphérique pourrait compiler directement du code HLSL/GLSL, mais le temps de compilation serait très long et cela aurait un impact sur les performances. Avec l'usage du langage intermédiaire, le gros du travail à été fait lors de la première passe de compilation et le pilote graphique ne fait que finir le travail. Les optimisations importantes ont déjà été réalisées lors de la première passe. Il doit bien faire la traduction, ajouter quelques optimisations de bas niveau par-ci par-là, mais rien de bien gourmand en processeur. Autant dire que cela économise plus le processeur que si on devait compiler complètement les ''shaders'' à chaque exécution.

Fait amusant, il faut savoir que le pilote peut parfois remplacer les ''shaders'' d'un jeu vidéo à la volée. Les pilotes récents embarquent en effet des ''shaders'' alternatifs pour les jeux les plus vendus et/ou les plus populaires. Lorsque vous lancez un de ces jeux vidéo et que le ''shader'' originel s'exécute, le pilote le détecte automatiquement et le remplace par la version améliorée, fournie par le pilote. Évidemment, le ''shader'' alternatif du pilote est optimisé pour le matériel adéquat. Cela permet de gagner en performance, voire en qualité d'image, sans pour autant que les concepteurs du jeu n'aient quoique ce soit à faire.

Enfin, certains ''shaders'' sont fournis par le pilote pour d'autres raisons. Par exemple, les cartes graphiques récentes n'ont pas de circuits fixes pour traiter la géométrie. Autant les anciennes cartes graphiques avaient des circuits de T&amp;L qui s'en occupaient, autant tout cela doit être émulé sur les machines récentes. Sans cette émulation, les vieux jeux vidéo conçus pour exploiter le T&amp;L et d'autres technologies du genre ne fonctionneraient plus du tout. Émuler les circuits fixes disparus sur les cartes récentes est justement le fait de ''shaders'', présents dans le pilote de carte graphique.

===Les autres fonctions===

Le pilote a aussi bien d'autres fonctions. Par exemple, il s'occupe d'initialiser la carte graphique, de fixer la résolution, d'allouer la mémoire vidéo, de gérer le curseur de souris matériel, etc.

==Les commandes graphiques/vidéo/autres : des ordres envoyés au GPU==

Tous les traitements que la carte graphique doit effectuer, qu'il s'agisse de rendu 2D, de calculs 2D, du décodage matérielle d'un flux vidéo, ou de calculs généralistes, sont envoyés par le pilote de la carte graphique, sous la forme de '''commandes'''. Ces commandes demandent à la carte graphique d'effectuer une opération 2D, ou une opération 3D, ou encore le rendu d'une vidéo.

Les commandes graphiques en question varient beaucoup selon la carte graphique. Les commandes sont régulièrement revues et chaque nouvelle architecture a quelques changements par rapport aux modèles plus anciens. Des commandes peuvent apparaître, d'autres disparaître, d'autre voient leur fonctionnement légèrement altéré, etc.

Mais dans les grandes lignes, on peut classer ces commandes en quelques grands types. Les commandes les plus importantes s'occupent de l'affichage 3D : afficher une image à partir de paquets de sommets, préparer le passage d'une image à une autre, changer la résolution, etc. Plus rare, d'autres commandes servent à faire du rendu 2D : afficher un polygone, tracer une ligne, coloriser une surface, etc. Sur les cartes graphiques qui peuvent accélérer le rendu des vidéos, il existe des commandes spécialisées pour l’accélération des vidéos.

Pour donner quelques exemples, prenons les commandes 2D de la carte graphique AMD Radeon X1800.

{|class=&quot;wikitable&quot;
|-
! Commandes 2D 
! Fonction
|-
|PAINT 	
|Peindre un rectangle d'une certaine couleur
|-
|PAINT_MULTI 	
|Peindre des rectangles (pas les mêmes paramètres que PAINT)
|-
|BITBLT 	
|Copie d'un bloc de mémoire dans un autre
|-
|BITBLT_MULTI 	
|Plusieurs copies de blocs de mémoire dans d'autres
|-
|TRANS_BITBLT 	
|Copie de blocs de mémoire avec un masque
|-
|NEXTCHAR 	
|Afficher un caractère avec une certaine couleur
|-
|HOSTDATA_BLT 	
|Écrire une chaîne de caractères à l'écran ou copier une série d'image bitmap dans la mémoire vidéo
|-
|POLYLINE 	
|Afficher des lignes reliées entre elles
|-
|POLYSCANLINES
|Afficher des lignes
|-
|PLY_NEXTSCAN 	
|Afficher plusieurs lignes simples
|-
|SET_SCISSORS 	
|Utiliser des coupes (ciseaux)
|-
|LOAD_PALETTE 	
|Charger la palette pour affichage 2D
|}

===Le tampon de commandes===

L'envoi des commandes à la carte graphique ne se fait pas directement. La carte graphique n'est pas toujours libre pour accepter une nouvelle commande, soit parce qu'elle est occupée par une commande précédente, soit parce qu'elle fait autre chose. Il faut alors faire patienter les données tant que la carte graphique est occupée. Les pilotes de la carte graphique vont les mettre en attente dans le '''tampon de commandes'''. 

Le tampon de commandes est ce qu'on appelle une file, une zone de mémoire dans laquelle on stocke des données dans l'ordre d'ajout. Si le tampon de commandes est plein, le driver n'accepte plus de demandes en provenance des applications. Un tampon de commandes plein est généralement mauvais signe : cela signifie que la carte graphique est trop lente pour traiter les demandes qui lui sont faites. Par contre, il arrive que le tampon de commandes soit vide : dans ce cas, c'est simplement que la carte graphique est trop rapide comparé au processeur, qui n'arrive alors pas à donner assez de commandes à la carte graphique pour l'occuper suffisamment.

Le tampon de commande est soit une mémoire FIFO séparée, soit une portion de la mémoire vidéo. Le NV1, la toute première carte graphique NVIDIA, utilisait une mémoire FIFO intégrée à la carte graphique, séparée des autres circuits. Le processeur envoyait les commandes par rafale au GPU, à savoir qu'il envoyait plusieurs dizaines ou centaines de commandes à la suite, avant de passer à autre chose. Le GPU traitait les commandes une par une, à un rythme bien plus lent. Le processeur pouvait consulter la FIFO pour savoir s'il restait des entrées libres et combien. Le processeur savait ainsi combien d'écritures il pouvait envoyer en une fois au GPU.

: Le fonctionnement de la FIFO du NV1 est décrit dans le brevet ''US5805930A : System for FIFO informing the availability of stages to store commands which include data and virtual address sent directly from application programs''.

===Le processeur de commandes===

Le '''processeur de commande''' est un circuit qui gère les commandes envoyées par le processeur. Il lit la commande la plus ancienne dans le tampon de commande, l’interprète, l’exécute, puis passe à la suivante. Le processeur de commande est un circuit assez compliqué. Sur les cartes graphiques anciennes, c'était un circuit séquentiel complexe, fabriqué à la main et était la partie la plus complexe du processeur graphique. Sur les cartes graphiques modernes, c'est un véritable microcontrôleur, avec un processeur, de la mémoire RAM, etc.

Lors de l'exécution d'une commande, le processeur de commande pilote les circuits de la carte graphique. Précisément, il répartit le travail entre les différents circuits de la carte graphique et assure que l'ordre du pipeline est respecté. Le processeur de commande décide à quel processeur ou circuit doit être envoyé une commande.

Pour donner un exemple, prenons la première carte graphique de NVIDIA, le NV1. Il s'agissait d'une carte multimédia qui incorporait non seulement une carte 2D/3D, mais aussi une carte son un contrôleur de disque et de quoi communiquer avec des manettes. De plus, il incorporait un contrôleur DMA pour échanger des données entre RAM système et les autres circuits. Et à tout cela, il fallait ajouter la FIFO de commandes et le processeur de commande. L'ensemble était relié par un bus interne à la carte graphique.

Le processeur de commande servait de gestionnaire principal. Il envoyait des ordres internes aux circuits de rendu 3D, à sa carte son, au contrôleur DMA. Par exemple, lorsque le processeur voulait copier des données en mémoire vidéo, il envoyait une commande de copie, qui était stockée dans le tampon de commande, puis était exécutée par le processeur de commande. Le processeur de commande envoyait alors les ordres adéquats au contrôleur DMA, qui faisait la copie des données. Lors d'un rendu 3D, une commande de rendu 3D est envoyée au NV1, le processeur de commande la traite et l'envoi dans les circuits de rendu 3D.

[[File:Microarchitecture du GPU NV1 de NVIDIA.png|centre|vignette|upright=2|Microarchitecture du GPU NV1 de NVIDIA]]

A chaque instant, le processeur de commande répartit les ''shaders'' sur les processeurs de ''shaders'', en faisant en sorte qu'ils soient utilisés le plus possible. Dans le cas le plus simple, les unités sont alimentées en vertex/pixels les unes après les autres (principe du round-robin), mais des stratégies plus optimisées sont la règle de nos jours. Cela est très important sur les cartes graphiques : répartir plusieurs commandes sur plusieurs processeurs est une tâche difficile. Un chapitre entier sera d'ailleurs dédié à ce sujet.

Il envoie aussi certaines commandes aux circuits fixes, comme l’''input assembler''. Là encore, il faut en sorte que les circuits fixes soient utilisés le mieux possible. Sa tâche est compliquée par le fait que les GPU récents ont plusieurs unités de traitement des sommets et des pixels, plusieurs ROP, plusieurs unités de textures, etc. Et c'est en partie le travail du processeur de commande que de répartir les calculs sur ces différentes unités. C'est là un problème assez compliqué pour le processeur de commande et ce pour tout un tas de raisons que nous ne ferons que survoler. Les contraintes d'ordonnancement de l'API et les règles de celle-ci sont une partie de la réponse. Mais d'autres raisons sont intrinsèques au rendu 3D ou à la conception des circuits.

[[File:Architecture de base d'une carte 3D - 1.png|centre|vignette|upright=2.5|Architecture de base d'une carte 3D - 1]]

Le processeur de commande n'a pas qu'un rôle de répartiteur. Il connait à tout instant l'état de la carte graphique, l'état de chaque sous-circuit. L'implémentation est variable suivant le GPU. La plus simple ajoute un registre d'état à chaque circuit, qui, est consultable en temps réel par le processeur de commande. Mais il est possible d'utiliser un système d'interruptions interne à la puce, ou circuits préviennent le processeur de commande quand ils ont terminé leur travail. Grâce à cela, le processeur de commandes garde en mémoire l'état de traitement de chaque commande : est-ce qu'elle est en train de s’exécuter sur le processeur graphique, est-ce qu'elle est mise en pause, est-ce qu'elle attend une donnée en provenance de la mémoire, est-ce qu'elle est terminée, etc.

==Le fonctionnement du processeur de commandes==

Le processeur de commande lit, décode et exécute des commandes. Intuitivement, on se dit qu'il procède une commande à la fois. Mais les GPU modernes sont plus intelligents et peuvent exécuter plusieurs commandes en même temps, dans des circuits séparés. De nombreuses optimisations de ce type sont utilisées pour gagner en performance. Voyons comment un processeur de commande moderne fonctionne.

===L'ordonnancement et la gestion des ressources===

Le processeur de commande doit souvent mettre en pause certains circuits du pipeline, ainsi que les circuits précédents. Par exemple, si tous les processeurs de ''vertex shader'' sont occupés, l’''input assembler'' ne peut pas charger le paquet suivant car il n'y a aucun processeur de libre pour l’accueillir. Dans ce cas, l'étape d’''input assembly'' est mise en pause en attendant qu'un processeur de ''shader'' soit libre.

La même chose a lieu pour l'étape de rastérisation : si aucun processeur de ''shader'' n'est libre, elle est mise en pause. Sauf que pour la rastérisation, cela a des conséquences sur les circuits précédents la rastérisation. Si un processeur de ''shader'' veut envoyer quelque chose au rastériseur alors qu'il est en pause, il devra lui aussi attendre que le rastériseur soit libre. On a la même chose quand les ROP sont occupés : les ''pixel shader'' ou l'unité de texture doivent parfois être mis en pause, ce qui peut entrainer la mise en pause des étapes précédentes, etc.

En clair : plus un étape est situé vers la fin du pipeline graphique, plus sa mise en pause a de chances de se répercuter sur les étapes précédentes et de les mettre en pause aussi. Le processeur de commande doit gérer ces situations.

===Le pipelining des commandes===

Dans les cartes graphiques les plus rudimentaires, le processeur de commande exécute les commandes dans l'ordre. Il exécute une commande çà la fois et attend qu'une commande soit terminé pour en lancer une autre. Plusieurs commandes sont accumulées dans le tampon de commande, le processeur de commande les traite de la plus ancienne vers la plus récente. Du moins, les anciennes cartes graphiques faisaient comme cela, les cartes graphiques modernes sont un peu plus complexes. Elles n'attendent pas qu'une commande soit totalement terminée avant d'en lancer une nouvelle. Les processeurs de commande actuels sont capables d’exécuter plusieurs commandes en même temps.

L'intérêt est un gain en performance assez important. Pour ceux qui ont déjà eu un cours d'architecture des ordinateurs avancé, lancer plusieurs commandes en même temps permet une forme de pipeline, dont les gains sont substantiels. Par exemple, imaginez qu'une commande de rendu 3D soit bien avancée et n'utilise que les processeurs de ''shaders'' et les ROP, mais laisse les unités géométriques libres. Il est alors possible de démarrer la commande suivante en avance, afin qu'elle remplisse les unités géométriques inutilisées. On a alors deux commandes en cours de traitement : une commande qui utilise la fin du pipeline uniquement, une autre qui utilise seulement le début du pipeline graphique.

Le processeur de commande gère donc plusieurs commandes simultanées, à savoir plusieurs commandes qui en sont à des étapes différentes du pipeline. On peut avoir une commande qui est en cours dans l'étage de gestion de la géométrie, une autre dans le rastériseur, et une autre dans les unités de traitement des pixels. Le fait que les étapes du pipeline graphique sont à effectuer dans un ordre bien précis permet ce genre de chose assez facilement.

Une autre possibilité est de faire des rendus en parallèle. Par exemple, imaginez qu'on ait des circuits séparés pour le rendu 2D et 3D. Prenons l'exemple où le calcul d'une image finale demande de faire un rendu 3D suivi d'un rendu 2D, par exemple un jeu vidéo en 3D qui a un HUD dessiné en 2D. Dans ce cas, on peut démarrer le calcul de l'image suivante dans le pipeline 3D pendant que la précédente est dans les circuits 2D, au lieu de laisser inutilisé le pipeline 3D pendant le rendu 2D.

Mais c'est là un défi compliqué à relever pour le processeur de commande, qui donne lieu à son lot de problèmes. Le problème principal est le partage de ressources entre commandes. Par exemple, on peut prendre le cas où une commande n'utilise pas beaucoup les processeurs de ''shaders''. On pourrait imaginer lancer une seconde commande en parallèle, afin que la seconde commande utiliser les processeurs de ''shaders'' inutilisés. Mais cela n'est possible que si les circuits fixes sont capables d'accepter une seconde commande. Si la première commande sature les circuits fixe, le lancement de la seconde commande sera empêché. Mais si ce n'est pas le cas, les deux commandes pourront être lancées en même temps. Pareil pour le débit mémoire, qui doit alors être partagé entre deux commandes simultanées, ce qui est à prendre en compte.

===La synchronisation de l’exécution des commandes avec le processeur===

Il arrive que le processeur doive savoir où en est le traitement des commandes, ce qui est très utile pour la gestion de la mémoire vidéo. 

Un premier exemple : comment éviter de saturer une carte graphique de commande, alors qu'on ne sait pas si elles traite les commandes rapidement ou non ? L'idéal est de regarder où en est la carte graphique dans l'exécution des commandes. Si elle n'en est qu'au début du tampon de commande et que celui-ci est bien remplit, alors il vaut mieux lever le pied et ne pas envoyer de nouvelles commandes. A l'inverse, si le tampon de commande est presque vide, envoyer des commandes est la meilleure idée possible.

Un autre exemple un peu moins parlant est celui de la gestion de la mémoire vidéo. Rappelons qu'elle est réalisée par le pilote de la carte graphique, sur le processeur principal, qui décide d'allouer et de libérer de la mémoire vidéo. Pour donner un exemple d'utilisation, imaginez que le pilote de la carte graphique doive libérer de la mémoire pour pouvoir ajouter une nouvelle commande. Comment éviter d'enlever une texture tant que les commandes qui l'utilisent ne sont pas terminées ? Ce problème ne se limite pas aux textures, mais vaut pour tout ce qui est placé en mémoire vidéo. 

Il faut donc que la carte graphique trouve un moyen de prévenir le processeur que le traitement de telle commande est terminée, que telle commande en est rendue à tel ou tel point, etc. Pour cela, on a globalement deux grandes solutions. La première est celle des interruptions, abordées dans les chapitres précédents. Mais elles sont assez couteuses et ne sont utilisées que pour des évènements vraiment importants, critiques, qui demandent une réaction rapide du processeur. L'autre solution est celle du ''pooling'', où le processeur monitore la carte graphique à intervalles réguliers. Deux solutions bien connues de ceux qui ont déjà lu un cours d'architecture des ordinateurs digne de ce nom, rien de bien neuf : la carte graphique communique avec le processeur comme tout périphérique.

Pour faciliter l'implémentation du ''pooling'', la carte graphique contient des registres de statut, dans le processeur de commande, qui mémorisent tout ou partie de l'état de la carte graphique. Si un problème survient, certains bits du registre de statut seront mis à 1 pour indiquer que telle erreur bien précise a eu lieu. Il existe aussi un registre de statut qui mémorise le numéro de la commande en cours, ou de la dernière commande terminée, ce qui permet de savoir où en est la carte graphique dans l'exécution des commandes. Et certaines registres de statut sont dédiés à la gestion des commandes. Ils sont totalement programmable, la carte graphique peut écrire dedans sans problème.

Les cartes graphiques récentes incorporent des commandes pour modifier ces registres de statut au besoin. Elles sont appelées des '''commandes de synchronisation''' : les barrières (''fences''). Elles permettent d'écrire une valeur dans un registre de statut quand telle ou telle condition est remplie. Par exemple, si jamais une commande est terminée, on peut écrire la valeur 1 dans tel ou tel registre. La condition en question peut être assez complexe et se résumer à quelque chose du genre : &quot;si jamais toutes les ''shaders'' ont fini de traiter tel ensemble de textures, alors écrit la valeur 1024 dans le registre de statut numéro 9&quot;.

===La synchronisation de l’exécution des commandes intra-GPU===

Lancer plusieurs commandes en parallèle dans le pipeline permet de gagner en performance.Mais cela a un gros défaut : il n'est pas garantit que les commandes se terminent dans l'ordre. Si on démarre une seconde commande après la première, il arrive que la seconde finisse avant. Pire : il n'est pas garantit qu'elles s'exécutent dans l'ordre. Dans la plupart des cas, cela ne pose pas de problèmes. Mais dans d'autres, cela donne des résultats erronés.

Pour donner un exemple, utilisons les commandes de rendu 2D vues plus haut, histoire de simplifier le tout. Imaginez que vous codez un jeu vidéo et que le rendu se fait en 2D, partons sur un jeu de type FPS. Vous avez une série de commandes pour calculer l'image à rendre à l'écran, suivie par une série de commandes finales pour dessiner le HUB. Pour dessiner le HUD, vous utilisez des commandes HOSTDATA_BLT, dont le but est d'écrire une chaîne de caractères à l'écran ou copier une série d'image bitmap dans la mémoire vidéo. Et bien ces commandes HOSTDATA_BLT doivent démarrer une fois que le rendu de l'image est complétement terminé. Imaginez que vous dessiniez le HUD sur une portion de l'image pas encore terminée et que celui-ci est effacé par des écritures ultérieures ! 

Pour éviter tout problème, les GPU incorporent des commandes de synchronisation intra-GPU, destinées au processeur de commande, aussis appelées des '''commandes de sémaphore'''. Elles permettent de mettre en pause le lancement d'une nouvelle commande tant que les précédentes ne sont pas totalement ou partiellement terminées. Les plus simples empêchent le démarrage d'une commande tant que les précédentes ne sont pas terminées. D'autres permettent de démarrer une commande si et seulement si certaines commandes sont terminées. D'autres sont encore plus précises : elles empêchent le démarrage d'une nouvelle commande tant qu'une commande précédente n'a pas atteint un certain stade de son exécution. Là encore, de telles commandes sont des commandes du style &quot;attend que le registre de statut numéro N contienne la valeur adéquate avant de poursuivre l'exécution des commandes&quot;. 

Les commandes en question peuvent être sur le même modèle que précédemment, à savoir des commandes qui lisent les registres de statut. Mais elles peuvent aussi se baser sur le fait que telle ou telle ressource de rendu est libre ou non. Des commandes successives se partagent souvent des données, et que de nombreuses commandes différentes peuvent s'exécuter en même temps. Or, si une commande veut modifier les données utilisées par une autre commande, il faut que l'ordre des commandes soit maintenu : la commande la plus récente ne doit pas modifier les données utilisées par une commande plus ancienne. Avec ce modèle, les sémaphores bloquent une commande tant qu'une ressource (une texture) est utilisée par une autre commande.

{|class=&quot;wikitable&quot;
|-
! Commandes de synchronisation
! Fonction
|-
|NOP 
|Ne rien faire
|-
|WAIT_SEMAPHORE 
|Attendre la synchronisation avec un sémaphore
|-
|WAIT_MEM 
|Attendre que la mémoire vidéo soit disponible et inoccupée par le CPU
|}

==L'arbitrage de l'accès à la carte graphique==

Il n'est pas rare que plusieurs applications souhaitent accéder en même temps à la carte graphique. Imaginons que vous regardez une vidéo en ''streaming'' sur votre navigateur web, avec un programme de ''cloud computing'' de type ''Folding@Home'' qui tourne en arrière-plan, sur Windows. Le décodage de la vidéo est réalisé par la carte graphique, Windows s'occupe de l'affichage du bureau et des fenêtres, le navigateur web doit afficher tout ce qui est autour de la vidéo (la page web), le programme de ''cloud computing'' va lancer ses calculs sur la carte graphique, etc. Des situations de ce genre sont assez courantes et c'est soit le pilote qui s'en charge, soit la carte graphique elle-même.

===L'arbitrage logiciel du GPU===

L'arbitrage logiciel est la méthode la plus simple. Concrètement, c'est le système d'exploitation et/ou le pilote de la carte graphique qui gèrent l'arbitrage du GPU. Dans les deux cas, tout est fait en logiciel. Les commandes sont accumulées dans un tampon de commande, voire plusieurs, et l'OS/pilote décide quelle commande envoyer en priorité.

Sur Windows, avant l'arrivée du modèle de driver dit ''Windows Display Driver Model'', de telles situations étaient gérées simplement. Les applications ajoutaient des commandes dans une file de commande unique. Les commandes étaient exécutées dans l'ordre, en mode premier entrée dans la file premier sorti/exécuté. Il n'y avait pour ainsi dire pas d'arbitrage entre les applications. Et ce n'était pas un problème car, à l'époque, les seules applications qui utilisaient le GPU étaient des jeux vidéos fonctionnant en mode plein écran.

Avec le modèle de driver ''Windows Display Driver Model'' (WDDM), le GPU est maintenant arbitré, à savoir que les applications ont accès à tour de rôle au GPU, certaines ayant droit à plus de temps GPU que d'autres. Chaque programme a accès à la carte graphique durant quelques dizaines ou centaines de millisecondes, à tour de rôle. Si le programme finissait son travail en moins de temps que la durée impartie, il laissait la main au programme suivant. S’il atteignait la durée maximale allouée, il était interrompu pour laisser la place au programme suivant. Et chaque programme avait droit d'accès à la carte graphique chacun à son tour. Un tel algorithme en tourniquet est très simple, mais avait cependant quelques défauts. De nos jours, les algorithmes d'ordonnancement d'accès sont plus élaborés, bien qu'il soit difficile de trouver de la littérature ou des brevets sur le sujet.

Une autre fonctionnalité de WDDM est que les applications utilisant le GPU peuvent se partager la mémoire vidéo sans se marcher dessus. Avant, toutes les applications avaient accès à toute la mémoire vidéo, bien que ce soit par l’intermédiaire de commandes spécifiques. Mais avec WDDM, chaque application dispose de sa propre portion de mémoire vidéo, à laquelle est la seule à avoir accès. Une application ne peut plus lire le contenu réel de la mémoire vidéo, et encore moins lire le contenu des autres applications.

: Il s'agit d'un équivalent à l'isolation des processus pour les programmes Windows, mais appliqué à la mémoire vidéo et non la mémoire système. Et cette isolation est rendue d'autant plus simple que les GPU modernes implémentent un système de mémoire virtuelle à pagination très poussé, avec du swap en mémoire RAM système, une protection mémoire, et bien d'autres fonctionnalités. Nous en reparlerons dans les chapitres sur la mémoire vidéo.

===L'arbitrage accéléré par le GPU===

Depuis 2020, avec l'arrivée de la ''Windows 10 May 2020 update'', Windows est capable de déléguer l'arbitrage du GPU au GPU lui-même. Le  GPU gère lui-même l'arbitrage, du moins en partie. En partie, car l'OS gére les priorité, à savoir quelle application a droit à plus de temps que les autres. Par contre, la gestion du ''quantum'' de temps ou les commutations de contexte (on stoppe une application pour laisser la place à une autre), est du fait du GPU lui-même.

L'avantage est que cela décharge le processeur d'une tâche assez lourde en calcul, pour la déporter sur le GPU. Un autre avantage est que le GPU peut gérer plus finement les ''quantum'' de temps et la commutation de contexte. Le CPU principal gère des durées assez importantes, de l'ordre de la milliseconde. De plus, il doit communiquer avec le GPU par des mécanismes temporellement imprécis, comme des interruptions. Avec l'arbitrage accéléré par le GPU, le GPU n'a plus besoin de communiquer avec le CPU pour l'arbitrage et peut le faire plus précisément, plus immédiatement. Un gain en performance théorique est donc possible.

L'arbitrage accéléré par le GPU est le fait soit du processeur de commandes, soit d'un processeur spécialisé, séparé.

{{NavChapitre | book=Les cartes graphiques
           | prev=La hiérarchie mémoire d'un GPU
           | prevText=La hiérarchie mémoire d'un GPU
           | next=Le pipeline géométrique d'avant DirectX 10
           | netxText=Le pipeline géométrique d'avant DirectX 10
}}{{autocat}}</text>
      <sha1>74kzthjlkdrlrx920c4mcbxr7bxzwz0</sha1>
    </revision>
    <revision>
      <id>744042</id>
      <parentid>744041</parentid>
      <timestamp>2025-06-03T14:25:47Z</timestamp>
      <contributor>
        <username>Mewtow</username>
        <id>31375</id>
      </contributor>
      <minor />
      <comment>/* Le processeur de commandes */</comment>
      <origin>744042</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="33643" sha1="158wrzpajbsh0h3zhjc3bv2zawutqg9" xml:space="preserve">Dans ce chapitre, nous allons parler de tous les intermédiaires qui se placent entre une application de rendu 3D et les circuits de rendu 3D proprement dit. En premier lieu, on trouve le pilote de la carte graphique, aux fonctions multiples et variées. En second lieu, nous allons parler d'un circuit de la carte graphique qui fait l'interface entre le logiciel et les circuits de rendu 3D de la carte graphique : le processeur de commandes. Ce processeur de commandes est un circuit qui sert de chef d'orchestre, qui pilote le fonctionnement global de la carte graphique. API 3D, pilote de carte graphique et processeur de commande travaillent de concert pour que l'application communique avec la carte graphique. Nous allons d'abord voir le pilote de la carte graphique, avant de voir le fonctionnement du processeur de commande.

==Le pilote de carte graphique==

Le pilote de la carte graphique est un logiciel qui s'occupe de faire l'interface entre le logiciel et la carte graphique. De manière générale, les pilotes de périphérique sont des intermédiaires entre les applications/APIs et le matériel. En théorie, le système d'exploitation est censé jouer ce rôle, mais il n'est pas programmé pour être compatible avec tous les périphériques vendus sur le marché. À la place, le système d'exploitation ne gère pas directement certains périphériques, mais fournit de quoi ajouter ce qui manque. Le pilote d'un périphérique sert justement à ajouter ce qui manque : ils ajoutent au système d'exploitation de quoi reconnaître le périphérique, de quoi l'utiliser au mieux. Pour une carte graphique, il a diverses fonctions que nous allons voir ci-dessous.

Avant toute chose, précisons que les systèmes d'exploitation usuels (Windows, Linux, MacOsX et autres) sont fournis avec un pilote de carte graphique générique, compatible avec la plupart des cartes graphiques existantes. Rien de magique derrière cela : toutes les cartes graphiques vendues depuis plusieurs décennies respectent des standards, comme le VGA, le VESA, et d'autres. Et le pilote de base fournit avec le système d'exploitation est justement compatible avec ces standards minimaux. Mais le pilote ne peut pas profiter des fonctionnalités qui sont au-delà de ce standard. L'accélération 3D est presque inexistante avec le pilote de base, qui ne sert qu'à faire du rendu 2D (de quoi afficher l’interface de base du système d'exploitation, comme le bureau de Windows). Et même pour du rendu 2D, la plupart des fonctionnalités de la carte graphique ne sont pas disponibles. Par exemple, certaines résolutions ne sont pas disponibles, notamment les grandes résolutions. Ou encore, les performances sont loin d'être excellentes. Si vous avez déjà utilisé un PC sans pilote de carte graphique installé, vous avez certainement remarqué qu'il était particulièrement lent.

===La gestion des interruptions===

Une fonction particulièrement importante du pilote de carte graphique est la réponse aux interruptions lancées par la carte graphique. Pour rappel, les interruptions sont une fonctionnalité qui permet à un périphérique de communiquer avec le processeur, tout en économisant le temps de calcul de ce dernier. Typiquement, lorsqu'un périphérique lance une interruption, le processeur stoppe son travail et exécute automatiquement une routine d'interruption, un petit programme qui s'occupe de gérer le périphérique, de faire ce qu'il faut, ce que l'interruption a demandé.

Il y a plusieurs interruptions possibles, chacune ayant son propre numéro et sa fonction dédiée, chacune ayant sa propre routine d'interruption. Après tout, la routine qui gère un débordement de la mémoire vidéo n'est pas la même que celle qui gère un changement de fréquence du GPU ou la fin du calcul d'une image 3D. Le pilote fournit l'ensemble des routines d'interruptions nécessaires pour gérer la carte graphique.

===La compilation des ''shaders''===

Le pilote de carte graphique est aussi chargé de traduire les ''shaders'' en code machine. En soi, cette étape est assez complexe, et ressemble beaucoup à la compilation d'un programme informatique normal. Les ''shaders'' sont écrits dans un langage de programmation de haut niveau, comme le HLSL ou le GLSL, mais ce n'est pas ce code source qui est compilé par le pilote de carte graphique. À la place, les ''shaders'' sont pré-compilés vers un langage dit intermédiaire, avant d'être compilé par le pilote en code machine. Le langage intermédiaire, comme son nom l'indique, sert d'intermédiaire entre le code source écrit en HLSL/GLSL et le code machine exécuté par la carte graphique. Il ressemble à un langage assembleur, mais reste malgré tout assez générique pour ne pas être un véritable code machine. Par exemple, il y a peu de limitations quant au nombre de processeurs ou de registres. En clair, il y a deux passes de compilation : une passe de traduction du code source en langage intermédiaire, puis une passe de compilation du code intermédiaire vers le code machine. Notons que la première passe est réalisée par le programmeur des ''shaders'', non pas par l'utilisateur. Par exemple, les ''shaders'' d'un jeu vidéo sont fournis déjà pré-compilés : les fichiers du jeu ne contiennent pas le code source GLSL/HLSL, mais du code intermédiaire.

L'avantage de cette méthode est que le travail du pilote est fortement simplifié. Le pilote de périphérique pourrait compiler directement du code HLSL/GLSL, mais le temps de compilation serait très long et cela aurait un impact sur les performances. Avec l'usage du langage intermédiaire, le gros du travail à été fait lors de la première passe de compilation et le pilote graphique ne fait que finir le travail. Les optimisations importantes ont déjà été réalisées lors de la première passe. Il doit bien faire la traduction, ajouter quelques optimisations de bas niveau par-ci par-là, mais rien de bien gourmand en processeur. Autant dire que cela économise plus le processeur que si on devait compiler complètement les ''shaders'' à chaque exécution.

Fait amusant, il faut savoir que le pilote peut parfois remplacer les ''shaders'' d'un jeu vidéo à la volée. Les pilotes récents embarquent en effet des ''shaders'' alternatifs pour les jeux les plus vendus et/ou les plus populaires. Lorsque vous lancez un de ces jeux vidéo et que le ''shader'' originel s'exécute, le pilote le détecte automatiquement et le remplace par la version améliorée, fournie par le pilote. Évidemment, le ''shader'' alternatif du pilote est optimisé pour le matériel adéquat. Cela permet de gagner en performance, voire en qualité d'image, sans pour autant que les concepteurs du jeu n'aient quoique ce soit à faire.

Enfin, certains ''shaders'' sont fournis par le pilote pour d'autres raisons. Par exemple, les cartes graphiques récentes n'ont pas de circuits fixes pour traiter la géométrie. Autant les anciennes cartes graphiques avaient des circuits de T&amp;L qui s'en occupaient, autant tout cela doit être émulé sur les machines récentes. Sans cette émulation, les vieux jeux vidéo conçus pour exploiter le T&amp;L et d'autres technologies du genre ne fonctionneraient plus du tout. Émuler les circuits fixes disparus sur les cartes récentes est justement le fait de ''shaders'', présents dans le pilote de carte graphique.

===Les autres fonctions===

Le pilote a aussi bien d'autres fonctions. Par exemple, il s'occupe d'initialiser la carte graphique, de fixer la résolution, d'allouer la mémoire vidéo, de gérer le curseur de souris matériel, etc.

==Les commandes graphiques/vidéo/autres : des ordres envoyés au GPU==

Tous les traitements que la carte graphique doit effectuer, qu'il s'agisse de rendu 2D, de calculs 2D, du décodage matérielle d'un flux vidéo, ou de calculs généralistes, sont envoyés par le pilote de la carte graphique, sous la forme de '''commandes'''. Ces commandes demandent à la carte graphique d'effectuer une opération 2D, ou une opération 3D, ou encore le rendu d'une vidéo.

Les commandes graphiques en question varient beaucoup selon la carte graphique. Les commandes sont régulièrement revues et chaque nouvelle architecture a quelques changements par rapport aux modèles plus anciens. Des commandes peuvent apparaître, d'autres disparaître, d'autre voient leur fonctionnement légèrement altéré, etc.

Mais dans les grandes lignes, on peut classer ces commandes en quelques grands types. Les commandes les plus importantes s'occupent de l'affichage 3D : afficher une image à partir de paquets de sommets, préparer le passage d'une image à une autre, changer la résolution, etc. Plus rare, d'autres commandes servent à faire du rendu 2D : afficher un polygone, tracer une ligne, coloriser une surface, etc. Sur les cartes graphiques qui peuvent accélérer le rendu des vidéos, il existe des commandes spécialisées pour l’accélération des vidéos.

Pour donner quelques exemples, prenons les commandes 2D de la carte graphique AMD Radeon X1800.

{|class=&quot;wikitable&quot;
|-
! Commandes 2D 
! Fonction
|-
|PAINT 	
|Peindre un rectangle d'une certaine couleur
|-
|PAINT_MULTI 	
|Peindre des rectangles (pas les mêmes paramètres que PAINT)
|-
|BITBLT 	
|Copie d'un bloc de mémoire dans un autre
|-
|BITBLT_MULTI 	
|Plusieurs copies de blocs de mémoire dans d'autres
|-
|TRANS_BITBLT 	
|Copie de blocs de mémoire avec un masque
|-
|NEXTCHAR 	
|Afficher un caractère avec une certaine couleur
|-
|HOSTDATA_BLT 	
|Écrire une chaîne de caractères à l'écran ou copier une série d'image bitmap dans la mémoire vidéo
|-
|POLYLINE 	
|Afficher des lignes reliées entre elles
|-
|POLYSCANLINES
|Afficher des lignes
|-
|PLY_NEXTSCAN 	
|Afficher plusieurs lignes simples
|-
|SET_SCISSORS 	
|Utiliser des coupes (ciseaux)
|-
|LOAD_PALETTE 	
|Charger la palette pour affichage 2D
|}

===Le tampon de commandes===

L'envoi des commandes à la carte graphique ne se fait pas directement. La carte graphique n'est pas toujours libre pour accepter une nouvelle commande, soit parce qu'elle est occupée par une commande précédente, soit parce qu'elle fait autre chose. Il faut alors faire patienter les données tant que la carte graphique est occupée. Les pilotes de la carte graphique vont les mettre en attente dans le '''tampon de commandes'''. 

Le tampon de commandes est ce qu'on appelle une file, une zone de mémoire dans laquelle on stocke des données dans l'ordre d'ajout. Si le tampon de commandes est plein, le driver n'accepte plus de demandes en provenance des applications. Un tampon de commandes plein est généralement mauvais signe : cela signifie que la carte graphique est trop lente pour traiter les demandes qui lui sont faites. Par contre, il arrive que le tampon de commandes soit vide : dans ce cas, c'est simplement que la carte graphique est trop rapide comparé au processeur, qui n'arrive alors pas à donner assez de commandes à la carte graphique pour l'occuper suffisamment.

Le tampon de commande est soit une mémoire FIFO séparée, soit une portion de la mémoire vidéo. Le NV1, la toute première carte graphique NVIDIA, utilisait une mémoire FIFO intégrée à la carte graphique, séparée des autres circuits. Le processeur envoyait les commandes par rafale au GPU, à savoir qu'il envoyait plusieurs dizaines ou centaines de commandes à la suite, avant de passer à autre chose. Le GPU traitait les commandes une par une, à un rythme bien plus lent. Le processeur pouvait consulter la FIFO pour savoir s'il restait des entrées libres et combien. Le processeur savait ainsi combien d'écritures il pouvait envoyer en une fois au GPU.

: Le fonctionnement de la FIFO du NV1 est décrit dans le brevet ''US5805930A : System for FIFO informing the availability of stages to store commands which include data and virtual address sent directly from application programs''.

===Le processeur de commandes===

Le '''processeur de commande''' est un circuit qui gère les commandes envoyées par le processeur. Il lit la commande la plus ancienne dans le tampon de commande, l’interprète, l’exécute, puis passe à la suivante. Le processeur de commande est un circuit assez compliqué. Sur les cartes graphiques anciennes, c'était un circuit séquentiel complexe, fabriqué à la main et était la partie la plus complexe du processeur graphique. Sur les cartes graphiques modernes, c'est un véritable microcontrôleur, avec un processeur, de la mémoire RAM, etc.

Lors de l'exécution d'une commande, le processeur de commande pilote les circuits de la carte graphique. Précisément, il répartit le travail entre les différents circuits de la carte graphique et assure que l'ordre du pipeline est respecté. Le processeur de commande décide à quel processeur ou circuit doit être envoyé une commande.

Pour donner un exemple, prenons la première carte graphique de NVIDIA, le NV1. Il s'agissait d'une carte multimédia qui incorporait non seulement une carte 2D/3D, mais aussi une carte son un contrôleur de disque et de quoi communiquer avec des manettes. De plus, il incorporait un contrôleur DMA pour échanger des données entre RAM système et les autres circuits. Et à tout cela, il fallait ajouter la FIFO de commandes et le processeur de commande. L'ensemble était relié par un bus interne à la carte graphique.

Le processeur de commande servait de gestionnaire principal. Il envoyait des ordres internes aux circuits de rendu 3D, à sa carte son, au contrôleur DMA. Par exemple, lorsque le processeur voulait copier des données en mémoire vidéo, il envoyait une commande de copie, qui était stockée dans le tampon de commande, puis était exécutée par le processeur de commande. Le processeur de commande envoyait alors les ordres adéquats au contrôleur DMA, qui faisait la copie des données. Lors d'un rendu 3D, une commande de rendu 3D est envoyée au NV1, le processeur de commande la traite et l'envoi dans les circuits de rendu 3D.

[[File:Microarchitecture du GPU NV1 de NVIDIA.png|centre|vignette|upright=2|Microarchitecture du GPU NV1 de NVIDIA]]

Les GPU modernes sont plus complexes, ce qui fait que le processeur de commande a plus de travail. Parmis les nombreuses tâches qui lui sont confiées, il répartit les ''shaders'' sur les processeurs de ''shaders'', en faisant en sorte qu'ils soient utilisés le plus possible. Dans le cas le plus simple, les unités sont alimentées en vertex/pixels les unes après les autres (principe du round-robin), mais des stratégies plus optimisées sont la règle de nos jours. Cela est très important sur les cartes graphiques : répartir plusieurs commandes sur plusieurs processeurs est une tâche difficile. Un chapitre entier sera d'ailleurs dédié à ce sujet.

Il envoie aussi certaines commandes aux circuits fixes, comme l’''input assembler''. Là encore, il faut en sorte que les circuits fixes soient utilisés le mieux possible. Sa tâche est compliquée par le fait que les GPU récents ont plusieurs unités de traitement des sommets et des pixels, plusieurs ROP, plusieurs unités de textures, etc. Et c'est en partie le travail du processeur de commande que de répartir les calculs sur ces différentes unités. C'est là un problème assez compliqué pour le processeur de commande et ce pour tout un tas de raisons que nous ne ferons que survoler. Les contraintes d'ordonnancement de l'API et les règles de celle-ci sont une partie de la réponse. Mais d'autres raisons sont intrinsèques au rendu 3D ou à la conception des circuits.

[[File:Architecture de base d'une carte 3D - 1.png|centre|vignette|upright=2.5|Architecture de base d'une carte 3D - 1]]

Le processeur de commande n'a pas qu'un rôle de répartiteur. Il connait à tout instant l'état de la carte graphique, l'état de chaque sous-circuit. L'implémentation est variable suivant le GPU. La plus simple ajoute un registre d'état à chaque circuit, qui, est consultable en temps réel par le processeur de commande. Mais il est possible d'utiliser un système d'interruptions interne à la puce, ou circuits préviennent le processeur de commande quand ils ont terminé leur travail. Grâce à cela, le processeur de commandes garde en mémoire l'état de traitement de chaque commande : est-ce qu'elle est en train de s’exécuter sur le processeur graphique, est-ce qu'elle est mise en pause, est-ce qu'elle attend une donnée en provenance de la mémoire, est-ce qu'elle est terminée, etc.

==Le fonctionnement du processeur de commandes==

Le processeur de commande lit, décode et exécute des commandes. Intuitivement, on se dit qu'il procède une commande à la fois. Mais les GPU modernes sont plus intelligents et peuvent exécuter plusieurs commandes en même temps, dans des circuits séparés. De nombreuses optimisations de ce type sont utilisées pour gagner en performance. Voyons comment un processeur de commande moderne fonctionne.

===L'ordonnancement et la gestion des ressources===

Le processeur de commande doit souvent mettre en pause certains circuits du pipeline, ainsi que les circuits précédents. Par exemple, si tous les processeurs de ''vertex shader'' sont occupés, l’''input assembler'' ne peut pas charger le paquet suivant car il n'y a aucun processeur de libre pour l’accueillir. Dans ce cas, l'étape d’''input assembly'' est mise en pause en attendant qu'un processeur de ''shader'' soit libre.

La même chose a lieu pour l'étape de rastérisation : si aucun processeur de ''shader'' n'est libre, elle est mise en pause. Sauf que pour la rastérisation, cela a des conséquences sur les circuits précédents la rastérisation. Si un processeur de ''shader'' veut envoyer quelque chose au rastériseur alors qu'il est en pause, il devra lui aussi attendre que le rastériseur soit libre. On a la même chose quand les ROP sont occupés : les ''pixel shader'' ou l'unité de texture doivent parfois être mis en pause, ce qui peut entrainer la mise en pause des étapes précédentes, etc.

En clair : plus un étape est situé vers la fin du pipeline graphique, plus sa mise en pause a de chances de se répercuter sur les étapes précédentes et de les mettre en pause aussi. Le processeur de commande doit gérer ces situations.

===Le pipelining des commandes===

Dans les cartes graphiques les plus rudimentaires, le processeur de commande exécute les commandes dans l'ordre. Il exécute une commande çà la fois et attend qu'une commande soit terminé pour en lancer une autre. Plusieurs commandes sont accumulées dans le tampon de commande, le processeur de commande les traite de la plus ancienne vers la plus récente. Du moins, les anciennes cartes graphiques faisaient comme cela, les cartes graphiques modernes sont un peu plus complexes. Elles n'attendent pas qu'une commande soit totalement terminée avant d'en lancer une nouvelle. Les processeurs de commande actuels sont capables d’exécuter plusieurs commandes en même temps.

L'intérêt est un gain en performance assez important. Pour ceux qui ont déjà eu un cours d'architecture des ordinateurs avancé, lancer plusieurs commandes en même temps permet une forme de pipeline, dont les gains sont substantiels. Par exemple, imaginez qu'une commande de rendu 3D soit bien avancée et n'utilise que les processeurs de ''shaders'' et les ROP, mais laisse les unités géométriques libres. Il est alors possible de démarrer la commande suivante en avance, afin qu'elle remplisse les unités géométriques inutilisées. On a alors deux commandes en cours de traitement : une commande qui utilise la fin du pipeline uniquement, une autre qui utilise seulement le début du pipeline graphique.

Le processeur de commande gère donc plusieurs commandes simultanées, à savoir plusieurs commandes qui en sont à des étapes différentes du pipeline. On peut avoir une commande qui est en cours dans l'étage de gestion de la géométrie, une autre dans le rastériseur, et une autre dans les unités de traitement des pixels. Le fait que les étapes du pipeline graphique sont à effectuer dans un ordre bien précis permet ce genre de chose assez facilement.

Une autre possibilité est de faire des rendus en parallèle. Par exemple, imaginez qu'on ait des circuits séparés pour le rendu 2D et 3D. Prenons l'exemple où le calcul d'une image finale demande de faire un rendu 3D suivi d'un rendu 2D, par exemple un jeu vidéo en 3D qui a un HUD dessiné en 2D. Dans ce cas, on peut démarrer le calcul de l'image suivante dans le pipeline 3D pendant que la précédente est dans les circuits 2D, au lieu de laisser inutilisé le pipeline 3D pendant le rendu 2D.

Mais c'est là un défi compliqué à relever pour le processeur de commande, qui donne lieu à son lot de problèmes. Le problème principal est le partage de ressources entre commandes. Par exemple, on peut prendre le cas où une commande n'utilise pas beaucoup les processeurs de ''shaders''. On pourrait imaginer lancer une seconde commande en parallèle, afin que la seconde commande utiliser les processeurs de ''shaders'' inutilisés. Mais cela n'est possible que si les circuits fixes sont capables d'accepter une seconde commande. Si la première commande sature les circuits fixe, le lancement de la seconde commande sera empêché. Mais si ce n'est pas le cas, les deux commandes pourront être lancées en même temps. Pareil pour le débit mémoire, qui doit alors être partagé entre deux commandes simultanées, ce qui est à prendre en compte.

===La synchronisation de l’exécution des commandes avec le processeur===

Il arrive que le processeur doive savoir où en est le traitement des commandes, ce qui est très utile pour la gestion de la mémoire vidéo. 

Un premier exemple : comment éviter de saturer une carte graphique de commande, alors qu'on ne sait pas si elles traite les commandes rapidement ou non ? L'idéal est de regarder où en est la carte graphique dans l'exécution des commandes. Si elle n'en est qu'au début du tampon de commande et que celui-ci est bien remplit, alors il vaut mieux lever le pied et ne pas envoyer de nouvelles commandes. A l'inverse, si le tampon de commande est presque vide, envoyer des commandes est la meilleure idée possible.

Un autre exemple un peu moins parlant est celui de la gestion de la mémoire vidéo. Rappelons qu'elle est réalisée par le pilote de la carte graphique, sur le processeur principal, qui décide d'allouer et de libérer de la mémoire vidéo. Pour donner un exemple d'utilisation, imaginez que le pilote de la carte graphique doive libérer de la mémoire pour pouvoir ajouter une nouvelle commande. Comment éviter d'enlever une texture tant que les commandes qui l'utilisent ne sont pas terminées ? Ce problème ne se limite pas aux textures, mais vaut pour tout ce qui est placé en mémoire vidéo. 

Il faut donc que la carte graphique trouve un moyen de prévenir le processeur que le traitement de telle commande est terminée, que telle commande en est rendue à tel ou tel point, etc. Pour cela, on a globalement deux grandes solutions. La première est celle des interruptions, abordées dans les chapitres précédents. Mais elles sont assez couteuses et ne sont utilisées que pour des évènements vraiment importants, critiques, qui demandent une réaction rapide du processeur. L'autre solution est celle du ''pooling'', où le processeur monitore la carte graphique à intervalles réguliers. Deux solutions bien connues de ceux qui ont déjà lu un cours d'architecture des ordinateurs digne de ce nom, rien de bien neuf : la carte graphique communique avec le processeur comme tout périphérique.

Pour faciliter l'implémentation du ''pooling'', la carte graphique contient des registres de statut, dans le processeur de commande, qui mémorisent tout ou partie de l'état de la carte graphique. Si un problème survient, certains bits du registre de statut seront mis à 1 pour indiquer que telle erreur bien précise a eu lieu. Il existe aussi un registre de statut qui mémorise le numéro de la commande en cours, ou de la dernière commande terminée, ce qui permet de savoir où en est la carte graphique dans l'exécution des commandes. Et certaines registres de statut sont dédiés à la gestion des commandes. Ils sont totalement programmable, la carte graphique peut écrire dedans sans problème.

Les cartes graphiques récentes incorporent des commandes pour modifier ces registres de statut au besoin. Elles sont appelées des '''commandes de synchronisation''' : les barrières (''fences''). Elles permettent d'écrire une valeur dans un registre de statut quand telle ou telle condition est remplie. Par exemple, si jamais une commande est terminée, on peut écrire la valeur 1 dans tel ou tel registre. La condition en question peut être assez complexe et se résumer à quelque chose du genre : &quot;si jamais toutes les ''shaders'' ont fini de traiter tel ensemble de textures, alors écrit la valeur 1024 dans le registre de statut numéro 9&quot;.

===La synchronisation de l’exécution des commandes intra-GPU===

Lancer plusieurs commandes en parallèle dans le pipeline permet de gagner en performance.Mais cela a un gros défaut : il n'est pas garantit que les commandes se terminent dans l'ordre. Si on démarre une seconde commande après la première, il arrive que la seconde finisse avant. Pire : il n'est pas garantit qu'elles s'exécutent dans l'ordre. Dans la plupart des cas, cela ne pose pas de problèmes. Mais dans d'autres, cela donne des résultats erronés.

Pour donner un exemple, utilisons les commandes de rendu 2D vues plus haut, histoire de simplifier le tout. Imaginez que vous codez un jeu vidéo et que le rendu se fait en 2D, partons sur un jeu de type FPS. Vous avez une série de commandes pour calculer l'image à rendre à l'écran, suivie par une série de commandes finales pour dessiner le HUB. Pour dessiner le HUD, vous utilisez des commandes HOSTDATA_BLT, dont le but est d'écrire une chaîne de caractères à l'écran ou copier une série d'image bitmap dans la mémoire vidéo. Et bien ces commandes HOSTDATA_BLT doivent démarrer une fois que le rendu de l'image est complétement terminé. Imaginez que vous dessiniez le HUD sur une portion de l'image pas encore terminée et que celui-ci est effacé par des écritures ultérieures ! 

Pour éviter tout problème, les GPU incorporent des commandes de synchronisation intra-GPU, destinées au processeur de commande, aussis appelées des '''commandes de sémaphore'''. Elles permettent de mettre en pause le lancement d'une nouvelle commande tant que les précédentes ne sont pas totalement ou partiellement terminées. Les plus simples empêchent le démarrage d'une commande tant que les précédentes ne sont pas terminées. D'autres permettent de démarrer une commande si et seulement si certaines commandes sont terminées. D'autres sont encore plus précises : elles empêchent le démarrage d'une nouvelle commande tant qu'une commande précédente n'a pas atteint un certain stade de son exécution. Là encore, de telles commandes sont des commandes du style &quot;attend que le registre de statut numéro N contienne la valeur adéquate avant de poursuivre l'exécution des commandes&quot;. 

Les commandes en question peuvent être sur le même modèle que précédemment, à savoir des commandes qui lisent les registres de statut. Mais elles peuvent aussi se baser sur le fait que telle ou telle ressource de rendu est libre ou non. Des commandes successives se partagent souvent des données, et que de nombreuses commandes différentes peuvent s'exécuter en même temps. Or, si une commande veut modifier les données utilisées par une autre commande, il faut que l'ordre des commandes soit maintenu : la commande la plus récente ne doit pas modifier les données utilisées par une commande plus ancienne. Avec ce modèle, les sémaphores bloquent une commande tant qu'une ressource (une texture) est utilisée par une autre commande.

{|class=&quot;wikitable&quot;
|-
! Commandes de synchronisation
! Fonction
|-
|NOP 
|Ne rien faire
|-
|WAIT_SEMAPHORE 
|Attendre la synchronisation avec un sémaphore
|-
|WAIT_MEM 
|Attendre que la mémoire vidéo soit disponible et inoccupée par le CPU
|}

==L'arbitrage de l'accès à la carte graphique==

Il n'est pas rare que plusieurs applications souhaitent accéder en même temps à la carte graphique. Imaginons que vous regardez une vidéo en ''streaming'' sur votre navigateur web, avec un programme de ''cloud computing'' de type ''Folding@Home'' qui tourne en arrière-plan, sur Windows. Le décodage de la vidéo est réalisé par la carte graphique, Windows s'occupe de l'affichage du bureau et des fenêtres, le navigateur web doit afficher tout ce qui est autour de la vidéo (la page web), le programme de ''cloud computing'' va lancer ses calculs sur la carte graphique, etc. Des situations de ce genre sont assez courantes et c'est soit le pilote qui s'en charge, soit la carte graphique elle-même.

===L'arbitrage logiciel du GPU===

L'arbitrage logiciel est la méthode la plus simple. Concrètement, c'est le système d'exploitation et/ou le pilote de la carte graphique qui gèrent l'arbitrage du GPU. Dans les deux cas, tout est fait en logiciel. Les commandes sont accumulées dans un tampon de commande, voire plusieurs, et l'OS/pilote décide quelle commande envoyer en priorité.

Sur Windows, avant l'arrivée du modèle de driver dit ''Windows Display Driver Model'', de telles situations étaient gérées simplement. Les applications ajoutaient des commandes dans une file de commande unique. Les commandes étaient exécutées dans l'ordre, en mode premier entrée dans la file premier sorti/exécuté. Il n'y avait pour ainsi dire pas d'arbitrage entre les applications. Et ce n'était pas un problème car, à l'époque, les seules applications qui utilisaient le GPU étaient des jeux vidéos fonctionnant en mode plein écran.

Avec le modèle de driver ''Windows Display Driver Model'' (WDDM), le GPU est maintenant arbitré, à savoir que les applications ont accès à tour de rôle au GPU, certaines ayant droit à plus de temps GPU que d'autres. Chaque programme a accès à la carte graphique durant quelques dizaines ou centaines de millisecondes, à tour de rôle. Si le programme finissait son travail en moins de temps que la durée impartie, il laissait la main au programme suivant. S’il atteignait la durée maximale allouée, il était interrompu pour laisser la place au programme suivant. Et chaque programme avait droit d'accès à la carte graphique chacun à son tour. Un tel algorithme en tourniquet est très simple, mais avait cependant quelques défauts. De nos jours, les algorithmes d'ordonnancement d'accès sont plus élaborés, bien qu'il soit difficile de trouver de la littérature ou des brevets sur le sujet.

Une autre fonctionnalité de WDDM est que les applications utilisant le GPU peuvent se partager la mémoire vidéo sans se marcher dessus. Avant, toutes les applications avaient accès à toute la mémoire vidéo, bien que ce soit par l’intermédiaire de commandes spécifiques. Mais avec WDDM, chaque application dispose de sa propre portion de mémoire vidéo, à laquelle est la seule à avoir accès. Une application ne peut plus lire le contenu réel de la mémoire vidéo, et encore moins lire le contenu des autres applications.

: Il s'agit d'un équivalent à l'isolation des processus pour les programmes Windows, mais appliqué à la mémoire vidéo et non la mémoire système. Et cette isolation est rendue d'autant plus simple que les GPU modernes implémentent un système de mémoire virtuelle à pagination très poussé, avec du swap en mémoire RAM système, une protection mémoire, et bien d'autres fonctionnalités. Nous en reparlerons dans les chapitres sur la mémoire vidéo.

===L'arbitrage accéléré par le GPU===

Depuis 2020, avec l'arrivée de la ''Windows 10 May 2020 update'', Windows est capable de déléguer l'arbitrage du GPU au GPU lui-même. Le  GPU gère lui-même l'arbitrage, du moins en partie. En partie, car l'OS gére les priorité, à savoir quelle application a droit à plus de temps que les autres. Par contre, la gestion du ''quantum'' de temps ou les commutations de contexte (on stoppe une application pour laisser la place à une autre), est du fait du GPU lui-même.

L'avantage est que cela décharge le processeur d'une tâche assez lourde en calcul, pour la déporter sur le GPU. Un autre avantage est que le GPU peut gérer plus finement les ''quantum'' de temps et la commutation de contexte. Le CPU principal gère des durées assez importantes, de l'ordre de la milliseconde. De plus, il doit communiquer avec le GPU par des mécanismes temporellement imprécis, comme des interruptions. Avec l'arbitrage accéléré par le GPU, le GPU n'a plus besoin de communiquer avec le CPU pour l'arbitrage et peut le faire plus précisément, plus immédiatement. Un gain en performance théorique est donc possible.

L'arbitrage accéléré par le GPU est le fait soit du processeur de commandes, soit d'un processeur spécialisé, séparé.

{{NavChapitre | book=Les cartes graphiques
           | prev=La hiérarchie mémoire d'un GPU
           | prevText=La hiérarchie mémoire d'un GPU
           | next=Le pipeline géométrique d'avant DirectX 10
           | netxText=Le pipeline géométrique d'avant DirectX 10
}}{{autocat}}</text>
      <sha1>158wrzpajbsh0h3zhjc3bv2zawutqg9</sha1>
    </revision>
    <revision>
      <id>744043</id>
      <parentid>744042</parentid>
      <timestamp>2025-06-03T14:26:11Z</timestamp>
      <contributor>
        <username>Mewtow</username>
        <id>31375</id>
      </contributor>
      <minor />
      <comment>/* Le processeur de commandes */</comment>
      <origin>744043</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="33545" sha1="h3hs943q28nttedmuxtaupa1gj1aaeo" xml:space="preserve">Dans ce chapitre, nous allons parler de tous les intermédiaires qui se placent entre une application de rendu 3D et les circuits de rendu 3D proprement dit. En premier lieu, on trouve le pilote de la carte graphique, aux fonctions multiples et variées. En second lieu, nous allons parler d'un circuit de la carte graphique qui fait l'interface entre le logiciel et les circuits de rendu 3D de la carte graphique : le processeur de commandes. Ce processeur de commandes est un circuit qui sert de chef d'orchestre, qui pilote le fonctionnement global de la carte graphique. API 3D, pilote de carte graphique et processeur de commande travaillent de concert pour que l'application communique avec la carte graphique. Nous allons d'abord voir le pilote de la carte graphique, avant de voir le fonctionnement du processeur de commande.

==Le pilote de carte graphique==

Le pilote de la carte graphique est un logiciel qui s'occupe de faire l'interface entre le logiciel et la carte graphique. De manière générale, les pilotes de périphérique sont des intermédiaires entre les applications/APIs et le matériel. En théorie, le système d'exploitation est censé jouer ce rôle, mais il n'est pas programmé pour être compatible avec tous les périphériques vendus sur le marché. À la place, le système d'exploitation ne gère pas directement certains périphériques, mais fournit de quoi ajouter ce qui manque. Le pilote d'un périphérique sert justement à ajouter ce qui manque : ils ajoutent au système d'exploitation de quoi reconnaître le périphérique, de quoi l'utiliser au mieux. Pour une carte graphique, il a diverses fonctions que nous allons voir ci-dessous.

Avant toute chose, précisons que les systèmes d'exploitation usuels (Windows, Linux, MacOsX et autres) sont fournis avec un pilote de carte graphique générique, compatible avec la plupart des cartes graphiques existantes. Rien de magique derrière cela : toutes les cartes graphiques vendues depuis plusieurs décennies respectent des standards, comme le VGA, le VESA, et d'autres. Et le pilote de base fournit avec le système d'exploitation est justement compatible avec ces standards minimaux. Mais le pilote ne peut pas profiter des fonctionnalités qui sont au-delà de ce standard. L'accélération 3D est presque inexistante avec le pilote de base, qui ne sert qu'à faire du rendu 2D (de quoi afficher l’interface de base du système d'exploitation, comme le bureau de Windows). Et même pour du rendu 2D, la plupart des fonctionnalités de la carte graphique ne sont pas disponibles. Par exemple, certaines résolutions ne sont pas disponibles, notamment les grandes résolutions. Ou encore, les performances sont loin d'être excellentes. Si vous avez déjà utilisé un PC sans pilote de carte graphique installé, vous avez certainement remarqué qu'il était particulièrement lent.

===La gestion des interruptions===

Une fonction particulièrement importante du pilote de carte graphique est la réponse aux interruptions lancées par la carte graphique. Pour rappel, les interruptions sont une fonctionnalité qui permet à un périphérique de communiquer avec le processeur, tout en économisant le temps de calcul de ce dernier. Typiquement, lorsqu'un périphérique lance une interruption, le processeur stoppe son travail et exécute automatiquement une routine d'interruption, un petit programme qui s'occupe de gérer le périphérique, de faire ce qu'il faut, ce que l'interruption a demandé.

Il y a plusieurs interruptions possibles, chacune ayant son propre numéro et sa fonction dédiée, chacune ayant sa propre routine d'interruption. Après tout, la routine qui gère un débordement de la mémoire vidéo n'est pas la même que celle qui gère un changement de fréquence du GPU ou la fin du calcul d'une image 3D. Le pilote fournit l'ensemble des routines d'interruptions nécessaires pour gérer la carte graphique.

===La compilation des ''shaders''===

Le pilote de carte graphique est aussi chargé de traduire les ''shaders'' en code machine. En soi, cette étape est assez complexe, et ressemble beaucoup à la compilation d'un programme informatique normal. Les ''shaders'' sont écrits dans un langage de programmation de haut niveau, comme le HLSL ou le GLSL, mais ce n'est pas ce code source qui est compilé par le pilote de carte graphique. À la place, les ''shaders'' sont pré-compilés vers un langage dit intermédiaire, avant d'être compilé par le pilote en code machine. Le langage intermédiaire, comme son nom l'indique, sert d'intermédiaire entre le code source écrit en HLSL/GLSL et le code machine exécuté par la carte graphique. Il ressemble à un langage assembleur, mais reste malgré tout assez générique pour ne pas être un véritable code machine. Par exemple, il y a peu de limitations quant au nombre de processeurs ou de registres. En clair, il y a deux passes de compilation : une passe de traduction du code source en langage intermédiaire, puis une passe de compilation du code intermédiaire vers le code machine. Notons que la première passe est réalisée par le programmeur des ''shaders'', non pas par l'utilisateur. Par exemple, les ''shaders'' d'un jeu vidéo sont fournis déjà pré-compilés : les fichiers du jeu ne contiennent pas le code source GLSL/HLSL, mais du code intermédiaire.

L'avantage de cette méthode est que le travail du pilote est fortement simplifié. Le pilote de périphérique pourrait compiler directement du code HLSL/GLSL, mais le temps de compilation serait très long et cela aurait un impact sur les performances. Avec l'usage du langage intermédiaire, le gros du travail à été fait lors de la première passe de compilation et le pilote graphique ne fait que finir le travail. Les optimisations importantes ont déjà été réalisées lors de la première passe. Il doit bien faire la traduction, ajouter quelques optimisations de bas niveau par-ci par-là, mais rien de bien gourmand en processeur. Autant dire que cela économise plus le processeur que si on devait compiler complètement les ''shaders'' à chaque exécution.

Fait amusant, il faut savoir que le pilote peut parfois remplacer les ''shaders'' d'un jeu vidéo à la volée. Les pilotes récents embarquent en effet des ''shaders'' alternatifs pour les jeux les plus vendus et/ou les plus populaires. Lorsque vous lancez un de ces jeux vidéo et que le ''shader'' originel s'exécute, le pilote le détecte automatiquement et le remplace par la version améliorée, fournie par le pilote. Évidemment, le ''shader'' alternatif du pilote est optimisé pour le matériel adéquat. Cela permet de gagner en performance, voire en qualité d'image, sans pour autant que les concepteurs du jeu n'aient quoique ce soit à faire.

Enfin, certains ''shaders'' sont fournis par le pilote pour d'autres raisons. Par exemple, les cartes graphiques récentes n'ont pas de circuits fixes pour traiter la géométrie. Autant les anciennes cartes graphiques avaient des circuits de T&amp;L qui s'en occupaient, autant tout cela doit être émulé sur les machines récentes. Sans cette émulation, les vieux jeux vidéo conçus pour exploiter le T&amp;L et d'autres technologies du genre ne fonctionneraient plus du tout. Émuler les circuits fixes disparus sur les cartes récentes est justement le fait de ''shaders'', présents dans le pilote de carte graphique.

===Les autres fonctions===

Le pilote a aussi bien d'autres fonctions. Par exemple, il s'occupe d'initialiser la carte graphique, de fixer la résolution, d'allouer la mémoire vidéo, de gérer le curseur de souris matériel, etc.

==Les commandes graphiques/vidéo/autres : des ordres envoyés au GPU==

Tous les traitements que la carte graphique doit effectuer, qu'il s'agisse de rendu 2D, de calculs 2D, du décodage matérielle d'un flux vidéo, ou de calculs généralistes, sont envoyés par le pilote de la carte graphique, sous la forme de '''commandes'''. Ces commandes demandent à la carte graphique d'effectuer une opération 2D, ou une opération 3D, ou encore le rendu d'une vidéo.

Les commandes graphiques en question varient beaucoup selon la carte graphique. Les commandes sont régulièrement revues et chaque nouvelle architecture a quelques changements par rapport aux modèles plus anciens. Des commandes peuvent apparaître, d'autres disparaître, d'autre voient leur fonctionnement légèrement altéré, etc.

Mais dans les grandes lignes, on peut classer ces commandes en quelques grands types. Les commandes les plus importantes s'occupent de l'affichage 3D : afficher une image à partir de paquets de sommets, préparer le passage d'une image à une autre, changer la résolution, etc. Plus rare, d'autres commandes servent à faire du rendu 2D : afficher un polygone, tracer une ligne, coloriser une surface, etc. Sur les cartes graphiques qui peuvent accélérer le rendu des vidéos, il existe des commandes spécialisées pour l’accélération des vidéos.

Pour donner quelques exemples, prenons les commandes 2D de la carte graphique AMD Radeon X1800.

{|class=&quot;wikitable&quot;
|-
! Commandes 2D 
! Fonction
|-
|PAINT 	
|Peindre un rectangle d'une certaine couleur
|-
|PAINT_MULTI 	
|Peindre des rectangles (pas les mêmes paramètres que PAINT)
|-
|BITBLT 	
|Copie d'un bloc de mémoire dans un autre
|-
|BITBLT_MULTI 	
|Plusieurs copies de blocs de mémoire dans d'autres
|-
|TRANS_BITBLT 	
|Copie de blocs de mémoire avec un masque
|-
|NEXTCHAR 	
|Afficher un caractère avec une certaine couleur
|-
|HOSTDATA_BLT 	
|Écrire une chaîne de caractères à l'écran ou copier une série d'image bitmap dans la mémoire vidéo
|-
|POLYLINE 	
|Afficher des lignes reliées entre elles
|-
|POLYSCANLINES
|Afficher des lignes
|-
|PLY_NEXTSCAN 	
|Afficher plusieurs lignes simples
|-
|SET_SCISSORS 	
|Utiliser des coupes (ciseaux)
|-
|LOAD_PALETTE 	
|Charger la palette pour affichage 2D
|}

===Le tampon de commandes===

L'envoi des commandes à la carte graphique ne se fait pas directement. La carte graphique n'est pas toujours libre pour accepter une nouvelle commande, soit parce qu'elle est occupée par une commande précédente, soit parce qu'elle fait autre chose. Il faut alors faire patienter les données tant que la carte graphique est occupée. Les pilotes de la carte graphique vont les mettre en attente dans le '''tampon de commandes'''. 

Le tampon de commandes est ce qu'on appelle une file, une zone de mémoire dans laquelle on stocke des données dans l'ordre d'ajout. Si le tampon de commandes est plein, le driver n'accepte plus de demandes en provenance des applications. Un tampon de commandes plein est généralement mauvais signe : cela signifie que la carte graphique est trop lente pour traiter les demandes qui lui sont faites. Par contre, il arrive que le tampon de commandes soit vide : dans ce cas, c'est simplement que la carte graphique est trop rapide comparé au processeur, qui n'arrive alors pas à donner assez de commandes à la carte graphique pour l'occuper suffisamment.

Le tampon de commande est soit une mémoire FIFO séparée, soit une portion de la mémoire vidéo. Le NV1, la toute première carte graphique NVIDIA, utilisait une mémoire FIFO intégrée à la carte graphique, séparée des autres circuits. Le processeur envoyait les commandes par rafale au GPU, à savoir qu'il envoyait plusieurs dizaines ou centaines de commandes à la suite, avant de passer à autre chose. Le GPU traitait les commandes une par une, à un rythme bien plus lent. Le processeur pouvait consulter la FIFO pour savoir s'il restait des entrées libres et combien. Le processeur savait ainsi combien d'écritures il pouvait envoyer en une fois au GPU.

: Le fonctionnement de la FIFO du NV1 est décrit dans le brevet ''US5805930A : System for FIFO informing the availability of stages to store commands which include data and virtual address sent directly from application programs''.

===Le processeur de commandes===

Le '''processeur de commande''' est un circuit qui gère les commandes envoyées par le processeur. Il lit la commande la plus ancienne dans le tampon de commande, l’interprète, l’exécute, puis passe à la suivante. Le processeur de commande est un circuit assez compliqué. Sur les cartes graphiques anciennes, c'était un circuit séquentiel complexe, fabriqué à la main et était la partie la plus complexe du processeur graphique. Sur les cartes graphiques modernes, c'est un véritable microcontrôleur, avec un processeur, de la mémoire RAM, etc.

Lors de l'exécution d'une commande, le processeur de commande pilote les circuits de la carte graphique. Précisément, il répartit le travail entre les différents circuits de la carte graphique et assure que l'ordre du pipeline est respecté. Pour donner un exemple, prenons la première carte graphique de NVIDIA, le NV1. Il s'agissait d'une carte multimédia qui incorporait non seulement une carte 2D/3D, mais aussi une carte son un contrôleur de disque et de quoi communiquer avec des manettes. De plus, il incorporait un contrôleur DMA pour échanger des données entre RAM système et les autres circuits. Et à tout cela, il fallait ajouter la FIFO de commandes et le processeur de commande. L'ensemble était relié par un bus interne à la carte graphique.

Le processeur de commande servait de gestionnaire principal. Il envoyait des ordres internes aux circuits de rendu 3D, à sa carte son, au contrôleur DMA. Par exemple, lorsque le processeur voulait copier des données en mémoire vidéo, il envoyait une commande de copie, qui était stockée dans le tampon de commande, puis était exécutée par le processeur de commande. Le processeur de commande envoyait alors les ordres adéquats au contrôleur DMA, qui faisait la copie des données. Lors d'un rendu 3D, une commande de rendu 3D est envoyée au NV1, le processeur de commande la traite et l'envoi dans les circuits de rendu 3D.

[[File:Microarchitecture du GPU NV1 de NVIDIA.png|centre|vignette|upright=2|Microarchitecture du GPU NV1 de NVIDIA]]

Les GPU modernes sont plus complexes, ce qui fait que le processeur de commande a plus de travail. Parmis les nombreuses tâches qui lui sont confiées, il répartit les ''shaders'' sur les processeurs de ''shaders'', en faisant en sorte qu'ils soient utilisés le plus possible. Dans le cas le plus simple, les unités sont alimentées en vertex/pixels les unes après les autres (principe du round-robin), mais des stratégies plus optimisées sont la règle de nos jours. Cela est très important sur les cartes graphiques : répartir plusieurs commandes sur plusieurs processeurs est une tâche difficile. Un chapitre entier sera d'ailleurs dédié à ce sujet.

Il envoie aussi certaines commandes aux circuits fixes, comme l’''input assembler''. Là encore, il faut en sorte que les circuits fixes soient utilisés le mieux possible. Sa tâche est compliquée par le fait que les GPU récents ont plusieurs unités de traitement des sommets et des pixels, plusieurs ROP, plusieurs unités de textures, etc. Et c'est en partie le travail du processeur de commande que de répartir les calculs sur ces différentes unités. C'est là un problème assez compliqué pour le processeur de commande et ce pour tout un tas de raisons que nous ne ferons que survoler. Les contraintes d'ordonnancement de l'API et les règles de celle-ci sont une partie de la réponse. Mais d'autres raisons sont intrinsèques au rendu 3D ou à la conception des circuits.

[[File:Architecture de base d'une carte 3D - 1.png|centre|vignette|upright=2.5|Architecture de base d'une carte 3D - 1]]

Le processeur de commande n'a pas qu'un rôle de répartiteur. Il connait à tout instant l'état de la carte graphique, l'état de chaque sous-circuit. L'implémentation est variable suivant le GPU. La plus simple ajoute un registre d'état à chaque circuit, qui, est consultable en temps réel par le processeur de commande. Mais il est possible d'utiliser un système d'interruptions interne à la puce, ou circuits préviennent le processeur de commande quand ils ont terminé leur travail. Grâce à cela, le processeur de commandes garde en mémoire l'état de traitement de chaque commande : est-ce qu'elle est en train de s’exécuter sur le processeur graphique, est-ce qu'elle est mise en pause, est-ce qu'elle attend une donnée en provenance de la mémoire, est-ce qu'elle est terminée, etc.

==Le fonctionnement du processeur de commandes==

Le processeur de commande lit, décode et exécute des commandes. Intuitivement, on se dit qu'il procède une commande à la fois. Mais les GPU modernes sont plus intelligents et peuvent exécuter plusieurs commandes en même temps, dans des circuits séparés. De nombreuses optimisations de ce type sont utilisées pour gagner en performance. Voyons comment un processeur de commande moderne fonctionne.

===L'ordonnancement et la gestion des ressources===

Le processeur de commande doit souvent mettre en pause certains circuits du pipeline, ainsi que les circuits précédents. Par exemple, si tous les processeurs de ''vertex shader'' sont occupés, l’''input assembler'' ne peut pas charger le paquet suivant car il n'y a aucun processeur de libre pour l’accueillir. Dans ce cas, l'étape d’''input assembly'' est mise en pause en attendant qu'un processeur de ''shader'' soit libre.

La même chose a lieu pour l'étape de rastérisation : si aucun processeur de ''shader'' n'est libre, elle est mise en pause. Sauf que pour la rastérisation, cela a des conséquences sur les circuits précédents la rastérisation. Si un processeur de ''shader'' veut envoyer quelque chose au rastériseur alors qu'il est en pause, il devra lui aussi attendre que le rastériseur soit libre. On a la même chose quand les ROP sont occupés : les ''pixel shader'' ou l'unité de texture doivent parfois être mis en pause, ce qui peut entrainer la mise en pause des étapes précédentes, etc.

En clair : plus un étape est situé vers la fin du pipeline graphique, plus sa mise en pause a de chances de se répercuter sur les étapes précédentes et de les mettre en pause aussi. Le processeur de commande doit gérer ces situations.

===Le pipelining des commandes===

Dans les cartes graphiques les plus rudimentaires, le processeur de commande exécute les commandes dans l'ordre. Il exécute une commande çà la fois et attend qu'une commande soit terminé pour en lancer une autre. Plusieurs commandes sont accumulées dans le tampon de commande, le processeur de commande les traite de la plus ancienne vers la plus récente. Du moins, les anciennes cartes graphiques faisaient comme cela, les cartes graphiques modernes sont un peu plus complexes. Elles n'attendent pas qu'une commande soit totalement terminée avant d'en lancer une nouvelle. Les processeurs de commande actuels sont capables d’exécuter plusieurs commandes en même temps.

L'intérêt est un gain en performance assez important. Pour ceux qui ont déjà eu un cours d'architecture des ordinateurs avancé, lancer plusieurs commandes en même temps permet une forme de pipeline, dont les gains sont substantiels. Par exemple, imaginez qu'une commande de rendu 3D soit bien avancée et n'utilise que les processeurs de ''shaders'' et les ROP, mais laisse les unités géométriques libres. Il est alors possible de démarrer la commande suivante en avance, afin qu'elle remplisse les unités géométriques inutilisées. On a alors deux commandes en cours de traitement : une commande qui utilise la fin du pipeline uniquement, une autre qui utilise seulement le début du pipeline graphique.

Le processeur de commande gère donc plusieurs commandes simultanées, à savoir plusieurs commandes qui en sont à des étapes différentes du pipeline. On peut avoir une commande qui est en cours dans l'étage de gestion de la géométrie, une autre dans le rastériseur, et une autre dans les unités de traitement des pixels. Le fait que les étapes du pipeline graphique sont à effectuer dans un ordre bien précis permet ce genre de chose assez facilement.

Une autre possibilité est de faire des rendus en parallèle. Par exemple, imaginez qu'on ait des circuits séparés pour le rendu 2D et 3D. Prenons l'exemple où le calcul d'une image finale demande de faire un rendu 3D suivi d'un rendu 2D, par exemple un jeu vidéo en 3D qui a un HUD dessiné en 2D. Dans ce cas, on peut démarrer le calcul de l'image suivante dans le pipeline 3D pendant que la précédente est dans les circuits 2D, au lieu de laisser inutilisé le pipeline 3D pendant le rendu 2D.

Mais c'est là un défi compliqué à relever pour le processeur de commande, qui donne lieu à son lot de problèmes. Le problème principal est le partage de ressources entre commandes. Par exemple, on peut prendre le cas où une commande n'utilise pas beaucoup les processeurs de ''shaders''. On pourrait imaginer lancer une seconde commande en parallèle, afin que la seconde commande utiliser les processeurs de ''shaders'' inutilisés. Mais cela n'est possible que si les circuits fixes sont capables d'accepter une seconde commande. Si la première commande sature les circuits fixe, le lancement de la seconde commande sera empêché. Mais si ce n'est pas le cas, les deux commandes pourront être lancées en même temps. Pareil pour le débit mémoire, qui doit alors être partagé entre deux commandes simultanées, ce qui est à prendre en compte.

===La synchronisation de l’exécution des commandes avec le processeur===

Il arrive que le processeur doive savoir où en est le traitement des commandes, ce qui est très utile pour la gestion de la mémoire vidéo. 

Un premier exemple : comment éviter de saturer une carte graphique de commande, alors qu'on ne sait pas si elles traite les commandes rapidement ou non ? L'idéal est de regarder où en est la carte graphique dans l'exécution des commandes. Si elle n'en est qu'au début du tampon de commande et que celui-ci est bien remplit, alors il vaut mieux lever le pied et ne pas envoyer de nouvelles commandes. A l'inverse, si le tampon de commande est presque vide, envoyer des commandes est la meilleure idée possible.

Un autre exemple un peu moins parlant est celui de la gestion de la mémoire vidéo. Rappelons qu'elle est réalisée par le pilote de la carte graphique, sur le processeur principal, qui décide d'allouer et de libérer de la mémoire vidéo. Pour donner un exemple d'utilisation, imaginez que le pilote de la carte graphique doive libérer de la mémoire pour pouvoir ajouter une nouvelle commande. Comment éviter d'enlever une texture tant que les commandes qui l'utilisent ne sont pas terminées ? Ce problème ne se limite pas aux textures, mais vaut pour tout ce qui est placé en mémoire vidéo. 

Il faut donc que la carte graphique trouve un moyen de prévenir le processeur que le traitement de telle commande est terminée, que telle commande en est rendue à tel ou tel point, etc. Pour cela, on a globalement deux grandes solutions. La première est celle des interruptions, abordées dans les chapitres précédents. Mais elles sont assez couteuses et ne sont utilisées que pour des évènements vraiment importants, critiques, qui demandent une réaction rapide du processeur. L'autre solution est celle du ''pooling'', où le processeur monitore la carte graphique à intervalles réguliers. Deux solutions bien connues de ceux qui ont déjà lu un cours d'architecture des ordinateurs digne de ce nom, rien de bien neuf : la carte graphique communique avec le processeur comme tout périphérique.

Pour faciliter l'implémentation du ''pooling'', la carte graphique contient des registres de statut, dans le processeur de commande, qui mémorisent tout ou partie de l'état de la carte graphique. Si un problème survient, certains bits du registre de statut seront mis à 1 pour indiquer que telle erreur bien précise a eu lieu. Il existe aussi un registre de statut qui mémorise le numéro de la commande en cours, ou de la dernière commande terminée, ce qui permet de savoir où en est la carte graphique dans l'exécution des commandes. Et certaines registres de statut sont dédiés à la gestion des commandes. Ils sont totalement programmable, la carte graphique peut écrire dedans sans problème.

Les cartes graphiques récentes incorporent des commandes pour modifier ces registres de statut au besoin. Elles sont appelées des '''commandes de synchronisation''' : les barrières (''fences''). Elles permettent d'écrire une valeur dans un registre de statut quand telle ou telle condition est remplie. Par exemple, si jamais une commande est terminée, on peut écrire la valeur 1 dans tel ou tel registre. La condition en question peut être assez complexe et se résumer à quelque chose du genre : &quot;si jamais toutes les ''shaders'' ont fini de traiter tel ensemble de textures, alors écrit la valeur 1024 dans le registre de statut numéro 9&quot;.

===La synchronisation de l’exécution des commandes intra-GPU===

Lancer plusieurs commandes en parallèle dans le pipeline permet de gagner en performance.Mais cela a un gros défaut : il n'est pas garantit que les commandes se terminent dans l'ordre. Si on démarre une seconde commande après la première, il arrive que la seconde finisse avant. Pire : il n'est pas garantit qu'elles s'exécutent dans l'ordre. Dans la plupart des cas, cela ne pose pas de problèmes. Mais dans d'autres, cela donne des résultats erronés.

Pour donner un exemple, utilisons les commandes de rendu 2D vues plus haut, histoire de simplifier le tout. Imaginez que vous codez un jeu vidéo et que le rendu se fait en 2D, partons sur un jeu de type FPS. Vous avez une série de commandes pour calculer l'image à rendre à l'écran, suivie par une série de commandes finales pour dessiner le HUB. Pour dessiner le HUD, vous utilisez des commandes HOSTDATA_BLT, dont le but est d'écrire une chaîne de caractères à l'écran ou copier une série d'image bitmap dans la mémoire vidéo. Et bien ces commandes HOSTDATA_BLT doivent démarrer une fois que le rendu de l'image est complétement terminé. Imaginez que vous dessiniez le HUD sur une portion de l'image pas encore terminée et que celui-ci est effacé par des écritures ultérieures ! 

Pour éviter tout problème, les GPU incorporent des commandes de synchronisation intra-GPU, destinées au processeur de commande, aussis appelées des '''commandes de sémaphore'''. Elles permettent de mettre en pause le lancement d'une nouvelle commande tant que les précédentes ne sont pas totalement ou partiellement terminées. Les plus simples empêchent le démarrage d'une commande tant que les précédentes ne sont pas terminées. D'autres permettent de démarrer une commande si et seulement si certaines commandes sont terminées. D'autres sont encore plus précises : elles empêchent le démarrage d'une nouvelle commande tant qu'une commande précédente n'a pas atteint un certain stade de son exécution. Là encore, de telles commandes sont des commandes du style &quot;attend que le registre de statut numéro N contienne la valeur adéquate avant de poursuivre l'exécution des commandes&quot;. 

Les commandes en question peuvent être sur le même modèle que précédemment, à savoir des commandes qui lisent les registres de statut. Mais elles peuvent aussi se baser sur le fait que telle ou telle ressource de rendu est libre ou non. Des commandes successives se partagent souvent des données, et que de nombreuses commandes différentes peuvent s'exécuter en même temps. Or, si une commande veut modifier les données utilisées par une autre commande, il faut que l'ordre des commandes soit maintenu : la commande la plus récente ne doit pas modifier les données utilisées par une commande plus ancienne. Avec ce modèle, les sémaphores bloquent une commande tant qu'une ressource (une texture) est utilisée par une autre commande.

{|class=&quot;wikitable&quot;
|-
! Commandes de synchronisation
! Fonction
|-
|NOP 
|Ne rien faire
|-
|WAIT_SEMAPHORE 
|Attendre la synchronisation avec un sémaphore
|-
|WAIT_MEM 
|Attendre que la mémoire vidéo soit disponible et inoccupée par le CPU
|}

==L'arbitrage de l'accès à la carte graphique==

Il n'est pas rare que plusieurs applications souhaitent accéder en même temps à la carte graphique. Imaginons que vous regardez une vidéo en ''streaming'' sur votre navigateur web, avec un programme de ''cloud computing'' de type ''Folding@Home'' qui tourne en arrière-plan, sur Windows. Le décodage de la vidéo est réalisé par la carte graphique, Windows s'occupe de l'affichage du bureau et des fenêtres, le navigateur web doit afficher tout ce qui est autour de la vidéo (la page web), le programme de ''cloud computing'' va lancer ses calculs sur la carte graphique, etc. Des situations de ce genre sont assez courantes et c'est soit le pilote qui s'en charge, soit la carte graphique elle-même.

===L'arbitrage logiciel du GPU===

L'arbitrage logiciel est la méthode la plus simple. Concrètement, c'est le système d'exploitation et/ou le pilote de la carte graphique qui gèrent l'arbitrage du GPU. Dans les deux cas, tout est fait en logiciel. Les commandes sont accumulées dans un tampon de commande, voire plusieurs, et l'OS/pilote décide quelle commande envoyer en priorité.

Sur Windows, avant l'arrivée du modèle de driver dit ''Windows Display Driver Model'', de telles situations étaient gérées simplement. Les applications ajoutaient des commandes dans une file de commande unique. Les commandes étaient exécutées dans l'ordre, en mode premier entrée dans la file premier sorti/exécuté. Il n'y avait pour ainsi dire pas d'arbitrage entre les applications. Et ce n'était pas un problème car, à l'époque, les seules applications qui utilisaient le GPU étaient des jeux vidéos fonctionnant en mode plein écran.

Avec le modèle de driver ''Windows Display Driver Model'' (WDDM), le GPU est maintenant arbitré, à savoir que les applications ont accès à tour de rôle au GPU, certaines ayant droit à plus de temps GPU que d'autres. Chaque programme a accès à la carte graphique durant quelques dizaines ou centaines de millisecondes, à tour de rôle. Si le programme finissait son travail en moins de temps que la durée impartie, il laissait la main au programme suivant. S’il atteignait la durée maximale allouée, il était interrompu pour laisser la place au programme suivant. Et chaque programme avait droit d'accès à la carte graphique chacun à son tour. Un tel algorithme en tourniquet est très simple, mais avait cependant quelques défauts. De nos jours, les algorithmes d'ordonnancement d'accès sont plus élaborés, bien qu'il soit difficile de trouver de la littérature ou des brevets sur le sujet.

Une autre fonctionnalité de WDDM est que les applications utilisant le GPU peuvent se partager la mémoire vidéo sans se marcher dessus. Avant, toutes les applications avaient accès à toute la mémoire vidéo, bien que ce soit par l’intermédiaire de commandes spécifiques. Mais avec WDDM, chaque application dispose de sa propre portion de mémoire vidéo, à laquelle est la seule à avoir accès. Une application ne peut plus lire le contenu réel de la mémoire vidéo, et encore moins lire le contenu des autres applications.

: Il s'agit d'un équivalent à l'isolation des processus pour les programmes Windows, mais appliqué à la mémoire vidéo et non la mémoire système. Et cette isolation est rendue d'autant plus simple que les GPU modernes implémentent un système de mémoire virtuelle à pagination très poussé, avec du swap en mémoire RAM système, une protection mémoire, et bien d'autres fonctionnalités. Nous en reparlerons dans les chapitres sur la mémoire vidéo.

===L'arbitrage accéléré par le GPU===

Depuis 2020, avec l'arrivée de la ''Windows 10 May 2020 update'', Windows est capable de déléguer l'arbitrage du GPU au GPU lui-même. Le  GPU gère lui-même l'arbitrage, du moins en partie. En partie, car l'OS gére les priorité, à savoir quelle application a droit à plus de temps que les autres. Par contre, la gestion du ''quantum'' de temps ou les commutations de contexte (on stoppe une application pour laisser la place à une autre), est du fait du GPU lui-même.

L'avantage est que cela décharge le processeur d'une tâche assez lourde en calcul, pour la déporter sur le GPU. Un autre avantage est que le GPU peut gérer plus finement les ''quantum'' de temps et la commutation de contexte. Le CPU principal gère des durées assez importantes, de l'ordre de la milliseconde. De plus, il doit communiquer avec le GPU par des mécanismes temporellement imprécis, comme des interruptions. Avec l'arbitrage accéléré par le GPU, le GPU n'a plus besoin de communiquer avec le CPU pour l'arbitrage et peut le faire plus précisément, plus immédiatement. Un gain en performance théorique est donc possible.

L'arbitrage accéléré par le GPU est le fait soit du processeur de commandes, soit d'un processeur spécialisé, séparé.

{{NavChapitre | book=Les cartes graphiques
           | prev=La hiérarchie mémoire d'un GPU
           | prevText=La hiérarchie mémoire d'un GPU
           | next=Le pipeline géométrique d'avant DirectX 10
           | netxText=Le pipeline géométrique d'avant DirectX 10
}}{{autocat}}</text>
      <sha1>h3hs943q28nttedmuxtaupa1gj1aaeo</sha1>
    </revision>
    <revision>
      <id>744044</id>
      <parentid>744043</parentid>
      <timestamp>2025-06-03T14:27:21Z</timestamp>
      <contributor>
        <username>Mewtow</username>
        <id>31375</id>
      </contributor>
      <minor />
      <comment>/* Le fonctionnement du processeur de commandes */</comment>
      <origin>744044</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="33743" sha1="2r4tr591ub3qntygyo65rlq7o47fec8" xml:space="preserve">Dans ce chapitre, nous allons parler de tous les intermédiaires qui se placent entre une application de rendu 3D et les circuits de rendu 3D proprement dit. En premier lieu, on trouve le pilote de la carte graphique, aux fonctions multiples et variées. En second lieu, nous allons parler d'un circuit de la carte graphique qui fait l'interface entre le logiciel et les circuits de rendu 3D de la carte graphique : le processeur de commandes. Ce processeur de commandes est un circuit qui sert de chef d'orchestre, qui pilote le fonctionnement global de la carte graphique. API 3D, pilote de carte graphique et processeur de commande travaillent de concert pour que l'application communique avec la carte graphique. Nous allons d'abord voir le pilote de la carte graphique, avant de voir le fonctionnement du processeur de commande.

==Le pilote de carte graphique==

Le pilote de la carte graphique est un logiciel qui s'occupe de faire l'interface entre le logiciel et la carte graphique. De manière générale, les pilotes de périphérique sont des intermédiaires entre les applications/APIs et le matériel. En théorie, le système d'exploitation est censé jouer ce rôle, mais il n'est pas programmé pour être compatible avec tous les périphériques vendus sur le marché. À la place, le système d'exploitation ne gère pas directement certains périphériques, mais fournit de quoi ajouter ce qui manque. Le pilote d'un périphérique sert justement à ajouter ce qui manque : ils ajoutent au système d'exploitation de quoi reconnaître le périphérique, de quoi l'utiliser au mieux. Pour une carte graphique, il a diverses fonctions que nous allons voir ci-dessous.

Avant toute chose, précisons que les systèmes d'exploitation usuels (Windows, Linux, MacOsX et autres) sont fournis avec un pilote de carte graphique générique, compatible avec la plupart des cartes graphiques existantes. Rien de magique derrière cela : toutes les cartes graphiques vendues depuis plusieurs décennies respectent des standards, comme le VGA, le VESA, et d'autres. Et le pilote de base fournit avec le système d'exploitation est justement compatible avec ces standards minimaux. Mais le pilote ne peut pas profiter des fonctionnalités qui sont au-delà de ce standard. L'accélération 3D est presque inexistante avec le pilote de base, qui ne sert qu'à faire du rendu 2D (de quoi afficher l’interface de base du système d'exploitation, comme le bureau de Windows). Et même pour du rendu 2D, la plupart des fonctionnalités de la carte graphique ne sont pas disponibles. Par exemple, certaines résolutions ne sont pas disponibles, notamment les grandes résolutions. Ou encore, les performances sont loin d'être excellentes. Si vous avez déjà utilisé un PC sans pilote de carte graphique installé, vous avez certainement remarqué qu'il était particulièrement lent.

===La gestion des interruptions===

Une fonction particulièrement importante du pilote de carte graphique est la réponse aux interruptions lancées par la carte graphique. Pour rappel, les interruptions sont une fonctionnalité qui permet à un périphérique de communiquer avec le processeur, tout en économisant le temps de calcul de ce dernier. Typiquement, lorsqu'un périphérique lance une interruption, le processeur stoppe son travail et exécute automatiquement une routine d'interruption, un petit programme qui s'occupe de gérer le périphérique, de faire ce qu'il faut, ce que l'interruption a demandé.

Il y a plusieurs interruptions possibles, chacune ayant son propre numéro et sa fonction dédiée, chacune ayant sa propre routine d'interruption. Après tout, la routine qui gère un débordement de la mémoire vidéo n'est pas la même que celle qui gère un changement de fréquence du GPU ou la fin du calcul d'une image 3D. Le pilote fournit l'ensemble des routines d'interruptions nécessaires pour gérer la carte graphique.

===La compilation des ''shaders''===

Le pilote de carte graphique est aussi chargé de traduire les ''shaders'' en code machine. En soi, cette étape est assez complexe, et ressemble beaucoup à la compilation d'un programme informatique normal. Les ''shaders'' sont écrits dans un langage de programmation de haut niveau, comme le HLSL ou le GLSL, mais ce n'est pas ce code source qui est compilé par le pilote de carte graphique. À la place, les ''shaders'' sont pré-compilés vers un langage dit intermédiaire, avant d'être compilé par le pilote en code machine. Le langage intermédiaire, comme son nom l'indique, sert d'intermédiaire entre le code source écrit en HLSL/GLSL et le code machine exécuté par la carte graphique. Il ressemble à un langage assembleur, mais reste malgré tout assez générique pour ne pas être un véritable code machine. Par exemple, il y a peu de limitations quant au nombre de processeurs ou de registres. En clair, il y a deux passes de compilation : une passe de traduction du code source en langage intermédiaire, puis une passe de compilation du code intermédiaire vers le code machine. Notons que la première passe est réalisée par le programmeur des ''shaders'', non pas par l'utilisateur. Par exemple, les ''shaders'' d'un jeu vidéo sont fournis déjà pré-compilés : les fichiers du jeu ne contiennent pas le code source GLSL/HLSL, mais du code intermédiaire.

L'avantage de cette méthode est que le travail du pilote est fortement simplifié. Le pilote de périphérique pourrait compiler directement du code HLSL/GLSL, mais le temps de compilation serait très long et cela aurait un impact sur les performances. Avec l'usage du langage intermédiaire, le gros du travail à été fait lors de la première passe de compilation et le pilote graphique ne fait que finir le travail. Les optimisations importantes ont déjà été réalisées lors de la première passe. Il doit bien faire la traduction, ajouter quelques optimisations de bas niveau par-ci par-là, mais rien de bien gourmand en processeur. Autant dire que cela économise plus le processeur que si on devait compiler complètement les ''shaders'' à chaque exécution.

Fait amusant, il faut savoir que le pilote peut parfois remplacer les ''shaders'' d'un jeu vidéo à la volée. Les pilotes récents embarquent en effet des ''shaders'' alternatifs pour les jeux les plus vendus et/ou les plus populaires. Lorsque vous lancez un de ces jeux vidéo et que le ''shader'' originel s'exécute, le pilote le détecte automatiquement et le remplace par la version améliorée, fournie par le pilote. Évidemment, le ''shader'' alternatif du pilote est optimisé pour le matériel adéquat. Cela permet de gagner en performance, voire en qualité d'image, sans pour autant que les concepteurs du jeu n'aient quoique ce soit à faire.

Enfin, certains ''shaders'' sont fournis par le pilote pour d'autres raisons. Par exemple, les cartes graphiques récentes n'ont pas de circuits fixes pour traiter la géométrie. Autant les anciennes cartes graphiques avaient des circuits de T&amp;L qui s'en occupaient, autant tout cela doit être émulé sur les machines récentes. Sans cette émulation, les vieux jeux vidéo conçus pour exploiter le T&amp;L et d'autres technologies du genre ne fonctionneraient plus du tout. Émuler les circuits fixes disparus sur les cartes récentes est justement le fait de ''shaders'', présents dans le pilote de carte graphique.

===Les autres fonctions===

Le pilote a aussi bien d'autres fonctions. Par exemple, il s'occupe d'initialiser la carte graphique, de fixer la résolution, d'allouer la mémoire vidéo, de gérer le curseur de souris matériel, etc.

==Les commandes graphiques/vidéo/autres : des ordres envoyés au GPU==

Tous les traitements que la carte graphique doit effectuer, qu'il s'agisse de rendu 2D, de calculs 2D, du décodage matérielle d'un flux vidéo, ou de calculs généralistes, sont envoyés par le pilote de la carte graphique, sous la forme de '''commandes'''. Ces commandes demandent à la carte graphique d'effectuer une opération 2D, ou une opération 3D, ou encore le rendu d'une vidéo.

Les commandes graphiques en question varient beaucoup selon la carte graphique. Les commandes sont régulièrement revues et chaque nouvelle architecture a quelques changements par rapport aux modèles plus anciens. Des commandes peuvent apparaître, d'autres disparaître, d'autre voient leur fonctionnement légèrement altéré, etc.

Mais dans les grandes lignes, on peut classer ces commandes en quelques grands types. Les commandes les plus importantes s'occupent de l'affichage 3D : afficher une image à partir de paquets de sommets, préparer le passage d'une image à une autre, changer la résolution, etc. Plus rare, d'autres commandes servent à faire du rendu 2D : afficher un polygone, tracer une ligne, coloriser une surface, etc. Sur les cartes graphiques qui peuvent accélérer le rendu des vidéos, il existe des commandes spécialisées pour l’accélération des vidéos.

Pour donner quelques exemples, prenons les commandes 2D de la carte graphique AMD Radeon X1800.

{|class=&quot;wikitable&quot;
|-
! Commandes 2D 
! Fonction
|-
|PAINT 	
|Peindre un rectangle d'une certaine couleur
|-
|PAINT_MULTI 	
|Peindre des rectangles (pas les mêmes paramètres que PAINT)
|-
|BITBLT 	
|Copie d'un bloc de mémoire dans un autre
|-
|BITBLT_MULTI 	
|Plusieurs copies de blocs de mémoire dans d'autres
|-
|TRANS_BITBLT 	
|Copie de blocs de mémoire avec un masque
|-
|NEXTCHAR 	
|Afficher un caractère avec une certaine couleur
|-
|HOSTDATA_BLT 	
|Écrire une chaîne de caractères à l'écran ou copier une série d'image bitmap dans la mémoire vidéo
|-
|POLYLINE 	
|Afficher des lignes reliées entre elles
|-
|POLYSCANLINES
|Afficher des lignes
|-
|PLY_NEXTSCAN 	
|Afficher plusieurs lignes simples
|-
|SET_SCISSORS 	
|Utiliser des coupes (ciseaux)
|-
|LOAD_PALETTE 	
|Charger la palette pour affichage 2D
|}

===Le tampon de commandes===

L'envoi des commandes à la carte graphique ne se fait pas directement. La carte graphique n'est pas toujours libre pour accepter une nouvelle commande, soit parce qu'elle est occupée par une commande précédente, soit parce qu'elle fait autre chose. Il faut alors faire patienter les données tant que la carte graphique est occupée. Les pilotes de la carte graphique vont les mettre en attente dans le '''tampon de commandes'''. 

Le tampon de commandes est ce qu'on appelle une file, une zone de mémoire dans laquelle on stocke des données dans l'ordre d'ajout. Si le tampon de commandes est plein, le driver n'accepte plus de demandes en provenance des applications. Un tampon de commandes plein est généralement mauvais signe : cela signifie que la carte graphique est trop lente pour traiter les demandes qui lui sont faites. Par contre, il arrive que le tampon de commandes soit vide : dans ce cas, c'est simplement que la carte graphique est trop rapide comparé au processeur, qui n'arrive alors pas à donner assez de commandes à la carte graphique pour l'occuper suffisamment.

Le tampon de commande est soit une mémoire FIFO séparée, soit une portion de la mémoire vidéo. Le NV1, la toute première carte graphique NVIDIA, utilisait une mémoire FIFO intégrée à la carte graphique, séparée des autres circuits. Le processeur envoyait les commandes par rafale au GPU, à savoir qu'il envoyait plusieurs dizaines ou centaines de commandes à la suite, avant de passer à autre chose. Le GPU traitait les commandes une par une, à un rythme bien plus lent. Le processeur pouvait consulter la FIFO pour savoir s'il restait des entrées libres et combien. Le processeur savait ainsi combien d'écritures il pouvait envoyer en une fois au GPU.

: Le fonctionnement de la FIFO du NV1 est décrit dans le brevet ''US5805930A : System for FIFO informing the availability of stages to store commands which include data and virtual address sent directly from application programs''.

===Le processeur de commandes===

Le '''processeur de commande''' est un circuit qui gère les commandes envoyées par le processeur. Il lit la commande la plus ancienne dans le tampon de commande, l’interprète, l’exécute, puis passe à la suivante. Le processeur de commande est un circuit assez compliqué. Sur les cartes graphiques anciennes, c'était un circuit séquentiel complexe, fabriqué à la main et était la partie la plus complexe du processeur graphique. Sur les cartes graphiques modernes, c'est un véritable microcontrôleur, avec un processeur, de la mémoire RAM, etc.

Lors de l'exécution d'une commande, le processeur de commande pilote les circuits de la carte graphique. Précisément, il répartit le travail entre les différents circuits de la carte graphique et assure que l'ordre du pipeline est respecté. Pour donner un exemple, prenons la première carte graphique de NVIDIA, le NV1. Il s'agissait d'une carte multimédia qui incorporait non seulement une carte 2D/3D, mais aussi une carte son un contrôleur de disque et de quoi communiquer avec des manettes. De plus, il incorporait un contrôleur DMA pour échanger des données entre RAM système et les autres circuits. Et à tout cela, il fallait ajouter la FIFO de commandes et le processeur de commande. L'ensemble était relié par un bus interne à la carte graphique.

Le processeur de commande servait de gestionnaire principal. Il envoyait des ordres internes aux circuits de rendu 3D, à sa carte son, au contrôleur DMA. Par exemple, lorsque le processeur voulait copier des données en mémoire vidéo, il envoyait une commande de copie, qui était stockée dans le tampon de commande, puis était exécutée par le processeur de commande. Le processeur de commande envoyait alors les ordres adéquats au contrôleur DMA, qui faisait la copie des données. Lors d'un rendu 3D, une commande de rendu 3D est envoyée au NV1, le processeur de commande la traite et l'envoi dans les circuits de rendu 3D.

[[File:Microarchitecture du GPU NV1 de NVIDIA.png|centre|vignette|upright=2|Microarchitecture du GPU NV1 de NVIDIA]]

Les GPU modernes sont plus complexes, ce qui fait que le processeur de commande a plus de travail. Parmis les nombreuses tâches qui lui sont confiées, il répartit les ''shaders'' sur les processeurs de ''shaders'', en faisant en sorte qu'ils soient utilisés le plus possible. Dans le cas le plus simple, les unités sont alimentées en vertex/pixels les unes après les autres (principe du round-robin), mais des stratégies plus optimisées sont la règle de nos jours. Cela est très important sur les cartes graphiques : répartir plusieurs commandes sur plusieurs processeurs est une tâche difficile. Un chapitre entier sera d'ailleurs dédié à ce sujet.

Il envoie aussi certaines commandes aux circuits fixes, comme l’''input assembler''. Là encore, il faut en sorte que les circuits fixes soient utilisés le mieux possible. Sa tâche est compliquée par le fait que les GPU récents ont plusieurs unités de traitement des sommets et des pixels, plusieurs ROP, plusieurs unités de textures, etc. Et c'est en partie le travail du processeur de commande que de répartir les calculs sur ces différentes unités. C'est là un problème assez compliqué pour le processeur de commande et ce pour tout un tas de raisons que nous ne ferons que survoler. Les contraintes d'ordonnancement de l'API et les règles de celle-ci sont une partie de la réponse. Mais d'autres raisons sont intrinsèques au rendu 3D ou à la conception des circuits.

[[File:Architecture de base d'une carte 3D - 1.png|centre|vignette|upright=2.5|Architecture de base d'une carte 3D - 1]]

Le processeur de commande n'a pas qu'un rôle de répartiteur. Il connait à tout instant l'état de la carte graphique, l'état de chaque sous-circuit. L'implémentation est variable suivant le GPU. La plus simple ajoute un registre d'état à chaque circuit, qui, est consultable en temps réel par le processeur de commande. Mais il est possible d'utiliser un système d'interruptions interne à la puce, ou circuits préviennent le processeur de commande quand ils ont terminé leur travail. Grâce à cela, le processeur de commandes garde en mémoire l'état de traitement de chaque commande : est-ce qu'elle est en train de s’exécuter sur le processeur graphique, est-ce qu'elle est mise en pause, est-ce qu'elle attend une donnée en provenance de la mémoire, est-ce qu'elle est terminée, etc.

Pour résumer, le processeur de commande lit une commande, répartit le travail sur les différents circuits du GPU, et vérifie en permanence leur état pour déterminer si la commande est en pause, terminée, en cours d'exécution, etc.

==Le fonctionnement du processeur de commandes==

Intuitivement, on se dit que le processeur de commande procède une commande à la fois. Mais les GPU modernes sont plus intelligents et peuvent exécuter plusieurs commandes en même temps, dans des circuits séparés. De nombreuses optimisations de ce type sont utilisées pour gagner en performance. Voyons comment un processeur de commande moderne fonctionne.

===L'ordonnancement et la gestion des ressources===

Le processeur de commande doit souvent mettre en pause certains circuits du pipeline, ainsi que les circuits précédents. Par exemple, si tous les processeurs de ''vertex shader'' sont occupés, l’''input assembler'' ne peut pas charger le paquet suivant car il n'y a aucun processeur de libre pour l’accueillir. Dans ce cas, l'étape d’''input assembly'' est mise en pause en attendant qu'un processeur de ''shader'' soit libre.

La même chose a lieu pour l'étape de rastérisation : si aucun processeur de ''shader'' n'est libre, elle est mise en pause. Sauf que pour la rastérisation, cela a des conséquences sur les circuits précédents la rastérisation. Si un processeur de ''shader'' veut envoyer quelque chose au rastériseur alors qu'il est en pause, il devra lui aussi attendre que le rastériseur soit libre. On a la même chose quand les ROP sont occupés : les ''pixel shader'' ou l'unité de texture doivent parfois être mis en pause, ce qui peut entrainer la mise en pause des étapes précédentes, etc.

En clair : plus un étape est situé vers la fin du pipeline graphique, plus sa mise en pause a de chances de se répercuter sur les étapes précédentes et de les mettre en pause aussi. Le processeur de commande doit gérer ces situations.

===Le pipelining des commandes===

Dans les cartes graphiques les plus rudimentaires, le processeur de commande exécute les commandes dans l'ordre. Il exécute une commande çà la fois et attend qu'une commande soit terminé pour en lancer une autre. Plusieurs commandes sont accumulées dans le tampon de commande, le processeur de commande les traite de la plus ancienne vers la plus récente. Du moins, les anciennes cartes graphiques faisaient comme cela, les cartes graphiques modernes sont un peu plus complexes. Elles n'attendent pas qu'une commande soit totalement terminée avant d'en lancer une nouvelle. Les processeurs de commande actuels sont capables d’exécuter plusieurs commandes en même temps.

L'intérêt est un gain en performance assez important. Pour ceux qui ont déjà eu un cours d'architecture des ordinateurs avancé, lancer plusieurs commandes en même temps permet une forme de pipeline, dont les gains sont substantiels. Par exemple, imaginez qu'une commande de rendu 3D soit bien avancée et n'utilise que les processeurs de ''shaders'' et les ROP, mais laisse les unités géométriques libres. Il est alors possible de démarrer la commande suivante en avance, afin qu'elle remplisse les unités géométriques inutilisées. On a alors deux commandes en cours de traitement : une commande qui utilise la fin du pipeline uniquement, une autre qui utilise seulement le début du pipeline graphique.

Le processeur de commande gère donc plusieurs commandes simultanées, à savoir plusieurs commandes qui en sont à des étapes différentes du pipeline. On peut avoir une commande qui est en cours dans l'étage de gestion de la géométrie, une autre dans le rastériseur, et une autre dans les unités de traitement des pixels. Le fait que les étapes du pipeline graphique sont à effectuer dans un ordre bien précis permet ce genre de chose assez facilement.

Une autre possibilité est de faire des rendus en parallèle. Par exemple, imaginez qu'on ait des circuits séparés pour le rendu 2D et 3D. Prenons l'exemple où le calcul d'une image finale demande de faire un rendu 3D suivi d'un rendu 2D, par exemple un jeu vidéo en 3D qui a un HUD dessiné en 2D. Dans ce cas, on peut démarrer le calcul de l'image suivante dans le pipeline 3D pendant que la précédente est dans les circuits 2D, au lieu de laisser inutilisé le pipeline 3D pendant le rendu 2D.

Mais c'est là un défi compliqué à relever pour le processeur de commande, qui donne lieu à son lot de problèmes. Le problème principal est le partage de ressources entre commandes. Par exemple, on peut prendre le cas où une commande n'utilise pas beaucoup les processeurs de ''shaders''. On pourrait imaginer lancer une seconde commande en parallèle, afin que la seconde commande utiliser les processeurs de ''shaders'' inutilisés. Mais cela n'est possible que si les circuits fixes sont capables d'accepter une seconde commande. Si la première commande sature les circuits fixe, le lancement de la seconde commande sera empêché. Mais si ce n'est pas le cas, les deux commandes pourront être lancées en même temps. Pareil pour le débit mémoire, qui doit alors être partagé entre deux commandes simultanées, ce qui est à prendre en compte.

===La synchronisation de l’exécution des commandes avec le processeur===

Il arrive que le processeur doive savoir où en est le traitement des commandes, ce qui est très utile pour la gestion de la mémoire vidéo. 

Un premier exemple : comment éviter de saturer une carte graphique de commande, alors qu'on ne sait pas si elles traite les commandes rapidement ou non ? L'idéal est de regarder où en est la carte graphique dans l'exécution des commandes. Si elle n'en est qu'au début du tampon de commande et que celui-ci est bien remplit, alors il vaut mieux lever le pied et ne pas envoyer de nouvelles commandes. A l'inverse, si le tampon de commande est presque vide, envoyer des commandes est la meilleure idée possible.

Un autre exemple un peu moins parlant est celui de la gestion de la mémoire vidéo. Rappelons qu'elle est réalisée par le pilote de la carte graphique, sur le processeur principal, qui décide d'allouer et de libérer de la mémoire vidéo. Pour donner un exemple d'utilisation, imaginez que le pilote de la carte graphique doive libérer de la mémoire pour pouvoir ajouter une nouvelle commande. Comment éviter d'enlever une texture tant que les commandes qui l'utilisent ne sont pas terminées ? Ce problème ne se limite pas aux textures, mais vaut pour tout ce qui est placé en mémoire vidéo. 

Il faut donc que la carte graphique trouve un moyen de prévenir le processeur que le traitement de telle commande est terminée, que telle commande en est rendue à tel ou tel point, etc. Pour cela, on a globalement deux grandes solutions. La première est celle des interruptions, abordées dans les chapitres précédents. Mais elles sont assez couteuses et ne sont utilisées que pour des évènements vraiment importants, critiques, qui demandent une réaction rapide du processeur. L'autre solution est celle du ''pooling'', où le processeur monitore la carte graphique à intervalles réguliers. Deux solutions bien connues de ceux qui ont déjà lu un cours d'architecture des ordinateurs digne de ce nom, rien de bien neuf : la carte graphique communique avec le processeur comme tout périphérique.

Pour faciliter l'implémentation du ''pooling'', la carte graphique contient des registres de statut, dans le processeur de commande, qui mémorisent tout ou partie de l'état de la carte graphique. Si un problème survient, certains bits du registre de statut seront mis à 1 pour indiquer que telle erreur bien précise a eu lieu. Il existe aussi un registre de statut qui mémorise le numéro de la commande en cours, ou de la dernière commande terminée, ce qui permet de savoir où en est la carte graphique dans l'exécution des commandes. Et certaines registres de statut sont dédiés à la gestion des commandes. Ils sont totalement programmable, la carte graphique peut écrire dedans sans problème.

Les cartes graphiques récentes incorporent des commandes pour modifier ces registres de statut au besoin. Elles sont appelées des '''commandes de synchronisation''' : les barrières (''fences''). Elles permettent d'écrire une valeur dans un registre de statut quand telle ou telle condition est remplie. Par exemple, si jamais une commande est terminée, on peut écrire la valeur 1 dans tel ou tel registre. La condition en question peut être assez complexe et se résumer à quelque chose du genre : &quot;si jamais toutes les ''shaders'' ont fini de traiter tel ensemble de textures, alors écrit la valeur 1024 dans le registre de statut numéro 9&quot;.

===La synchronisation de l’exécution des commandes intra-GPU===

Lancer plusieurs commandes en parallèle dans le pipeline permet de gagner en performance.Mais cela a un gros défaut : il n'est pas garantit que les commandes se terminent dans l'ordre. Si on démarre une seconde commande après la première, il arrive que la seconde finisse avant. Pire : il n'est pas garantit qu'elles s'exécutent dans l'ordre. Dans la plupart des cas, cela ne pose pas de problèmes. Mais dans d'autres, cela donne des résultats erronés.

Pour donner un exemple, utilisons les commandes de rendu 2D vues plus haut, histoire de simplifier le tout. Imaginez que vous codez un jeu vidéo et que le rendu se fait en 2D, partons sur un jeu de type FPS. Vous avez une série de commandes pour calculer l'image à rendre à l'écran, suivie par une série de commandes finales pour dessiner le HUB. Pour dessiner le HUD, vous utilisez des commandes HOSTDATA_BLT, dont le but est d'écrire une chaîne de caractères à l'écran ou copier une série d'image bitmap dans la mémoire vidéo. Et bien ces commandes HOSTDATA_BLT doivent démarrer une fois que le rendu de l'image est complétement terminé. Imaginez que vous dessiniez le HUD sur une portion de l'image pas encore terminée et que celui-ci est effacé par des écritures ultérieures ! 

Pour éviter tout problème, les GPU incorporent des commandes de synchronisation intra-GPU, destinées au processeur de commande, aussis appelées des '''commandes de sémaphore'''. Elles permettent de mettre en pause le lancement d'une nouvelle commande tant que les précédentes ne sont pas totalement ou partiellement terminées. Les plus simples empêchent le démarrage d'une commande tant que les précédentes ne sont pas terminées. D'autres permettent de démarrer une commande si et seulement si certaines commandes sont terminées. D'autres sont encore plus précises : elles empêchent le démarrage d'une nouvelle commande tant qu'une commande précédente n'a pas atteint un certain stade de son exécution. Là encore, de telles commandes sont des commandes du style &quot;attend que le registre de statut numéro N contienne la valeur adéquate avant de poursuivre l'exécution des commandes&quot;. 

Les commandes en question peuvent être sur le même modèle que précédemment, à savoir des commandes qui lisent les registres de statut. Mais elles peuvent aussi se baser sur le fait que telle ou telle ressource de rendu est libre ou non. Des commandes successives se partagent souvent des données, et que de nombreuses commandes différentes peuvent s'exécuter en même temps. Or, si une commande veut modifier les données utilisées par une autre commande, il faut que l'ordre des commandes soit maintenu : la commande la plus récente ne doit pas modifier les données utilisées par une commande plus ancienne. Avec ce modèle, les sémaphores bloquent une commande tant qu'une ressource (une texture) est utilisée par une autre commande.

{|class=&quot;wikitable&quot;
|-
! Commandes de synchronisation
! Fonction
|-
|NOP 
|Ne rien faire
|-
|WAIT_SEMAPHORE 
|Attendre la synchronisation avec un sémaphore
|-
|WAIT_MEM 
|Attendre que la mémoire vidéo soit disponible et inoccupée par le CPU
|}

==L'arbitrage de l'accès à la carte graphique==

Il n'est pas rare que plusieurs applications souhaitent accéder en même temps à la carte graphique. Imaginons que vous regardez une vidéo en ''streaming'' sur votre navigateur web, avec un programme de ''cloud computing'' de type ''Folding@Home'' qui tourne en arrière-plan, sur Windows. Le décodage de la vidéo est réalisé par la carte graphique, Windows s'occupe de l'affichage du bureau et des fenêtres, le navigateur web doit afficher tout ce qui est autour de la vidéo (la page web), le programme de ''cloud computing'' va lancer ses calculs sur la carte graphique, etc. Des situations de ce genre sont assez courantes et c'est soit le pilote qui s'en charge, soit la carte graphique elle-même.

===L'arbitrage logiciel du GPU===

L'arbitrage logiciel est la méthode la plus simple. Concrètement, c'est le système d'exploitation et/ou le pilote de la carte graphique qui gèrent l'arbitrage du GPU. Dans les deux cas, tout est fait en logiciel. Les commandes sont accumulées dans un tampon de commande, voire plusieurs, et l'OS/pilote décide quelle commande envoyer en priorité.

Sur Windows, avant l'arrivée du modèle de driver dit ''Windows Display Driver Model'', de telles situations étaient gérées simplement. Les applications ajoutaient des commandes dans une file de commande unique. Les commandes étaient exécutées dans l'ordre, en mode premier entrée dans la file premier sorti/exécuté. Il n'y avait pour ainsi dire pas d'arbitrage entre les applications. Et ce n'était pas un problème car, à l'époque, les seules applications qui utilisaient le GPU étaient des jeux vidéos fonctionnant en mode plein écran.

Avec le modèle de driver ''Windows Display Driver Model'' (WDDM), le GPU est maintenant arbitré, à savoir que les applications ont accès à tour de rôle au GPU, certaines ayant droit à plus de temps GPU que d'autres. Chaque programme a accès à la carte graphique durant quelques dizaines ou centaines de millisecondes, à tour de rôle. Si le programme finissait son travail en moins de temps que la durée impartie, il laissait la main au programme suivant. S’il atteignait la durée maximale allouée, il était interrompu pour laisser la place au programme suivant. Et chaque programme avait droit d'accès à la carte graphique chacun à son tour. Un tel algorithme en tourniquet est très simple, mais avait cependant quelques défauts. De nos jours, les algorithmes d'ordonnancement d'accès sont plus élaborés, bien qu'il soit difficile de trouver de la littérature ou des brevets sur le sujet.

Une autre fonctionnalité de WDDM est que les applications utilisant le GPU peuvent se partager la mémoire vidéo sans se marcher dessus. Avant, toutes les applications avaient accès à toute la mémoire vidéo, bien que ce soit par l’intermédiaire de commandes spécifiques. Mais avec WDDM, chaque application dispose de sa propre portion de mémoire vidéo, à laquelle est la seule à avoir accès. Une application ne peut plus lire le contenu réel de la mémoire vidéo, et encore moins lire le contenu des autres applications.

: Il s'agit d'un équivalent à l'isolation des processus pour les programmes Windows, mais appliqué à la mémoire vidéo et non la mémoire système. Et cette isolation est rendue d'autant plus simple que les GPU modernes implémentent un système de mémoire virtuelle à pagination très poussé, avec du swap en mémoire RAM système, une protection mémoire, et bien d'autres fonctionnalités. Nous en reparlerons dans les chapitres sur la mémoire vidéo.

===L'arbitrage accéléré par le GPU===

Depuis 2020, avec l'arrivée de la ''Windows 10 May 2020 update'', Windows est capable de déléguer l'arbitrage du GPU au GPU lui-même. Le  GPU gère lui-même l'arbitrage, du moins en partie. En partie, car l'OS gére les priorité, à savoir quelle application a droit à plus de temps que les autres. Par contre, la gestion du ''quantum'' de temps ou les commutations de contexte (on stoppe une application pour laisser la place à une autre), est du fait du GPU lui-même.

L'avantage est que cela décharge le processeur d'une tâche assez lourde en calcul, pour la déporter sur le GPU. Un autre avantage est que le GPU peut gérer plus finement les ''quantum'' de temps et la commutation de contexte. Le CPU principal gère des durées assez importantes, de l'ordre de la milliseconde. De plus, il doit communiquer avec le GPU par des mécanismes temporellement imprécis, comme des interruptions. Avec l'arbitrage accéléré par le GPU, le GPU n'a plus besoin de communiquer avec le CPU pour l'arbitrage et peut le faire plus précisément, plus immédiatement. Un gain en performance théorique est donc possible.

L'arbitrage accéléré par le GPU est le fait soit du processeur de commandes, soit d'un processeur spécialisé, séparé.

{{NavChapitre | book=Les cartes graphiques
           | prev=La hiérarchie mémoire d'un GPU
           | prevText=La hiérarchie mémoire d'un GPU
           | next=Le pipeline géométrique d'avant DirectX 10
           | netxText=Le pipeline géométrique d'avant DirectX 10
}}{{autocat}}</text>
      <sha1>2r4tr591ub3qntygyo65rlq7o47fec8</sha1>
    </revision>
    <revision>
      <id>744055</id>
      <parentid>744044</parentid>
      <timestamp>2025-06-03T17:00:38Z</timestamp>
      <contributor>
        <username>Mewtow</username>
        <id>31375</id>
      </contributor>
      <minor />
      <comment>/* L'arbitrage accéléré par le GPU */</comment>
      <origin>744055</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="33744" sha1="8bw2xskv9g4ddqpbcwswdw44f5a4jsy" xml:space="preserve">Dans ce chapitre, nous allons parler de tous les intermédiaires qui se placent entre une application de rendu 3D et les circuits de rendu 3D proprement dit. En premier lieu, on trouve le pilote de la carte graphique, aux fonctions multiples et variées. En second lieu, nous allons parler d'un circuit de la carte graphique qui fait l'interface entre le logiciel et les circuits de rendu 3D de la carte graphique : le processeur de commandes. Ce processeur de commandes est un circuit qui sert de chef d'orchestre, qui pilote le fonctionnement global de la carte graphique. API 3D, pilote de carte graphique et processeur de commande travaillent de concert pour que l'application communique avec la carte graphique. Nous allons d'abord voir le pilote de la carte graphique, avant de voir le fonctionnement du processeur de commande.

==Le pilote de carte graphique==

Le pilote de la carte graphique est un logiciel qui s'occupe de faire l'interface entre le logiciel et la carte graphique. De manière générale, les pilotes de périphérique sont des intermédiaires entre les applications/APIs et le matériel. En théorie, le système d'exploitation est censé jouer ce rôle, mais il n'est pas programmé pour être compatible avec tous les périphériques vendus sur le marché. À la place, le système d'exploitation ne gère pas directement certains périphériques, mais fournit de quoi ajouter ce qui manque. Le pilote d'un périphérique sert justement à ajouter ce qui manque : ils ajoutent au système d'exploitation de quoi reconnaître le périphérique, de quoi l'utiliser au mieux. Pour une carte graphique, il a diverses fonctions que nous allons voir ci-dessous.

Avant toute chose, précisons que les systèmes d'exploitation usuels (Windows, Linux, MacOsX et autres) sont fournis avec un pilote de carte graphique générique, compatible avec la plupart des cartes graphiques existantes. Rien de magique derrière cela : toutes les cartes graphiques vendues depuis plusieurs décennies respectent des standards, comme le VGA, le VESA, et d'autres. Et le pilote de base fournit avec le système d'exploitation est justement compatible avec ces standards minimaux. Mais le pilote ne peut pas profiter des fonctionnalités qui sont au-delà de ce standard. L'accélération 3D est presque inexistante avec le pilote de base, qui ne sert qu'à faire du rendu 2D (de quoi afficher l’interface de base du système d'exploitation, comme le bureau de Windows). Et même pour du rendu 2D, la plupart des fonctionnalités de la carte graphique ne sont pas disponibles. Par exemple, certaines résolutions ne sont pas disponibles, notamment les grandes résolutions. Ou encore, les performances sont loin d'être excellentes. Si vous avez déjà utilisé un PC sans pilote de carte graphique installé, vous avez certainement remarqué qu'il était particulièrement lent.

===La gestion des interruptions===

Une fonction particulièrement importante du pilote de carte graphique est la réponse aux interruptions lancées par la carte graphique. Pour rappel, les interruptions sont une fonctionnalité qui permet à un périphérique de communiquer avec le processeur, tout en économisant le temps de calcul de ce dernier. Typiquement, lorsqu'un périphérique lance une interruption, le processeur stoppe son travail et exécute automatiquement une routine d'interruption, un petit programme qui s'occupe de gérer le périphérique, de faire ce qu'il faut, ce que l'interruption a demandé.

Il y a plusieurs interruptions possibles, chacune ayant son propre numéro et sa fonction dédiée, chacune ayant sa propre routine d'interruption. Après tout, la routine qui gère un débordement de la mémoire vidéo n'est pas la même que celle qui gère un changement de fréquence du GPU ou la fin du calcul d'une image 3D. Le pilote fournit l'ensemble des routines d'interruptions nécessaires pour gérer la carte graphique.

===La compilation des ''shaders''===

Le pilote de carte graphique est aussi chargé de traduire les ''shaders'' en code machine. En soi, cette étape est assez complexe, et ressemble beaucoup à la compilation d'un programme informatique normal. Les ''shaders'' sont écrits dans un langage de programmation de haut niveau, comme le HLSL ou le GLSL, mais ce n'est pas ce code source qui est compilé par le pilote de carte graphique. À la place, les ''shaders'' sont pré-compilés vers un langage dit intermédiaire, avant d'être compilé par le pilote en code machine. Le langage intermédiaire, comme son nom l'indique, sert d'intermédiaire entre le code source écrit en HLSL/GLSL et le code machine exécuté par la carte graphique. Il ressemble à un langage assembleur, mais reste malgré tout assez générique pour ne pas être un véritable code machine. Par exemple, il y a peu de limitations quant au nombre de processeurs ou de registres. En clair, il y a deux passes de compilation : une passe de traduction du code source en langage intermédiaire, puis une passe de compilation du code intermédiaire vers le code machine. Notons que la première passe est réalisée par le programmeur des ''shaders'', non pas par l'utilisateur. Par exemple, les ''shaders'' d'un jeu vidéo sont fournis déjà pré-compilés : les fichiers du jeu ne contiennent pas le code source GLSL/HLSL, mais du code intermédiaire.

L'avantage de cette méthode est que le travail du pilote est fortement simplifié. Le pilote de périphérique pourrait compiler directement du code HLSL/GLSL, mais le temps de compilation serait très long et cela aurait un impact sur les performances. Avec l'usage du langage intermédiaire, le gros du travail à été fait lors de la première passe de compilation et le pilote graphique ne fait que finir le travail. Les optimisations importantes ont déjà été réalisées lors de la première passe. Il doit bien faire la traduction, ajouter quelques optimisations de bas niveau par-ci par-là, mais rien de bien gourmand en processeur. Autant dire que cela économise plus le processeur que si on devait compiler complètement les ''shaders'' à chaque exécution.

Fait amusant, il faut savoir que le pilote peut parfois remplacer les ''shaders'' d'un jeu vidéo à la volée. Les pilotes récents embarquent en effet des ''shaders'' alternatifs pour les jeux les plus vendus et/ou les plus populaires. Lorsque vous lancez un de ces jeux vidéo et que le ''shader'' originel s'exécute, le pilote le détecte automatiquement et le remplace par la version améliorée, fournie par le pilote. Évidemment, le ''shader'' alternatif du pilote est optimisé pour le matériel adéquat. Cela permet de gagner en performance, voire en qualité d'image, sans pour autant que les concepteurs du jeu n'aient quoique ce soit à faire.

Enfin, certains ''shaders'' sont fournis par le pilote pour d'autres raisons. Par exemple, les cartes graphiques récentes n'ont pas de circuits fixes pour traiter la géométrie. Autant les anciennes cartes graphiques avaient des circuits de T&amp;L qui s'en occupaient, autant tout cela doit être émulé sur les machines récentes. Sans cette émulation, les vieux jeux vidéo conçus pour exploiter le T&amp;L et d'autres technologies du genre ne fonctionneraient plus du tout. Émuler les circuits fixes disparus sur les cartes récentes est justement le fait de ''shaders'', présents dans le pilote de carte graphique.

===Les autres fonctions===

Le pilote a aussi bien d'autres fonctions. Par exemple, il s'occupe d'initialiser la carte graphique, de fixer la résolution, d'allouer la mémoire vidéo, de gérer le curseur de souris matériel, etc.

==Les commandes graphiques/vidéo/autres : des ordres envoyés au GPU==

Tous les traitements que la carte graphique doit effectuer, qu'il s'agisse de rendu 2D, de calculs 2D, du décodage matérielle d'un flux vidéo, ou de calculs généralistes, sont envoyés par le pilote de la carte graphique, sous la forme de '''commandes'''. Ces commandes demandent à la carte graphique d'effectuer une opération 2D, ou une opération 3D, ou encore le rendu d'une vidéo.

Les commandes graphiques en question varient beaucoup selon la carte graphique. Les commandes sont régulièrement revues et chaque nouvelle architecture a quelques changements par rapport aux modèles plus anciens. Des commandes peuvent apparaître, d'autres disparaître, d'autre voient leur fonctionnement légèrement altéré, etc.

Mais dans les grandes lignes, on peut classer ces commandes en quelques grands types. Les commandes les plus importantes s'occupent de l'affichage 3D : afficher une image à partir de paquets de sommets, préparer le passage d'une image à une autre, changer la résolution, etc. Plus rare, d'autres commandes servent à faire du rendu 2D : afficher un polygone, tracer une ligne, coloriser une surface, etc. Sur les cartes graphiques qui peuvent accélérer le rendu des vidéos, il existe des commandes spécialisées pour l’accélération des vidéos.

Pour donner quelques exemples, prenons les commandes 2D de la carte graphique AMD Radeon X1800.

{|class=&quot;wikitable&quot;
|-
! Commandes 2D 
! Fonction
|-
|PAINT 	
|Peindre un rectangle d'une certaine couleur
|-
|PAINT_MULTI 	
|Peindre des rectangles (pas les mêmes paramètres que PAINT)
|-
|BITBLT 	
|Copie d'un bloc de mémoire dans un autre
|-
|BITBLT_MULTI 	
|Plusieurs copies de blocs de mémoire dans d'autres
|-
|TRANS_BITBLT 	
|Copie de blocs de mémoire avec un masque
|-
|NEXTCHAR 	
|Afficher un caractère avec une certaine couleur
|-
|HOSTDATA_BLT 	
|Écrire une chaîne de caractères à l'écran ou copier une série d'image bitmap dans la mémoire vidéo
|-
|POLYLINE 	
|Afficher des lignes reliées entre elles
|-
|POLYSCANLINES
|Afficher des lignes
|-
|PLY_NEXTSCAN 	
|Afficher plusieurs lignes simples
|-
|SET_SCISSORS 	
|Utiliser des coupes (ciseaux)
|-
|LOAD_PALETTE 	
|Charger la palette pour affichage 2D
|}

===Le tampon de commandes===

L'envoi des commandes à la carte graphique ne se fait pas directement. La carte graphique n'est pas toujours libre pour accepter une nouvelle commande, soit parce qu'elle est occupée par une commande précédente, soit parce qu'elle fait autre chose. Il faut alors faire patienter les données tant que la carte graphique est occupée. Les pilotes de la carte graphique vont les mettre en attente dans le '''tampon de commandes'''. 

Le tampon de commandes est ce qu'on appelle une file, une zone de mémoire dans laquelle on stocke des données dans l'ordre d'ajout. Si le tampon de commandes est plein, le driver n'accepte plus de demandes en provenance des applications. Un tampon de commandes plein est généralement mauvais signe : cela signifie que la carte graphique est trop lente pour traiter les demandes qui lui sont faites. Par contre, il arrive que le tampon de commandes soit vide : dans ce cas, c'est simplement que la carte graphique est trop rapide comparé au processeur, qui n'arrive alors pas à donner assez de commandes à la carte graphique pour l'occuper suffisamment.

Le tampon de commande est soit une mémoire FIFO séparée, soit une portion de la mémoire vidéo. Le NV1, la toute première carte graphique NVIDIA, utilisait une mémoire FIFO intégrée à la carte graphique, séparée des autres circuits. Le processeur envoyait les commandes par rafale au GPU, à savoir qu'il envoyait plusieurs dizaines ou centaines de commandes à la suite, avant de passer à autre chose. Le GPU traitait les commandes une par une, à un rythme bien plus lent. Le processeur pouvait consulter la FIFO pour savoir s'il restait des entrées libres et combien. Le processeur savait ainsi combien d'écritures il pouvait envoyer en une fois au GPU.

: Le fonctionnement de la FIFO du NV1 est décrit dans le brevet ''US5805930A : System for FIFO informing the availability of stages to store commands which include data and virtual address sent directly from application programs''.

===Le processeur de commandes===

Le '''processeur de commande''' est un circuit qui gère les commandes envoyées par le processeur. Il lit la commande la plus ancienne dans le tampon de commande, l’interprète, l’exécute, puis passe à la suivante. Le processeur de commande est un circuit assez compliqué. Sur les cartes graphiques anciennes, c'était un circuit séquentiel complexe, fabriqué à la main et était la partie la plus complexe du processeur graphique. Sur les cartes graphiques modernes, c'est un véritable microcontrôleur, avec un processeur, de la mémoire RAM, etc.

Lors de l'exécution d'une commande, le processeur de commande pilote les circuits de la carte graphique. Précisément, il répartit le travail entre les différents circuits de la carte graphique et assure que l'ordre du pipeline est respecté. Pour donner un exemple, prenons la première carte graphique de NVIDIA, le NV1. Il s'agissait d'une carte multimédia qui incorporait non seulement une carte 2D/3D, mais aussi une carte son un contrôleur de disque et de quoi communiquer avec des manettes. De plus, il incorporait un contrôleur DMA pour échanger des données entre RAM système et les autres circuits. Et à tout cela, il fallait ajouter la FIFO de commandes et le processeur de commande. L'ensemble était relié par un bus interne à la carte graphique.

Le processeur de commande servait de gestionnaire principal. Il envoyait des ordres internes aux circuits de rendu 3D, à sa carte son, au contrôleur DMA. Par exemple, lorsque le processeur voulait copier des données en mémoire vidéo, il envoyait une commande de copie, qui était stockée dans le tampon de commande, puis était exécutée par le processeur de commande. Le processeur de commande envoyait alors les ordres adéquats au contrôleur DMA, qui faisait la copie des données. Lors d'un rendu 3D, une commande de rendu 3D est envoyée au NV1, le processeur de commande la traite et l'envoi dans les circuits de rendu 3D.

[[File:Microarchitecture du GPU NV1 de NVIDIA.png|centre|vignette|upright=2|Microarchitecture du GPU NV1 de NVIDIA]]

Les GPU modernes sont plus complexes, ce qui fait que le processeur de commande a plus de travail. Parmis les nombreuses tâches qui lui sont confiées, il répartit les ''shaders'' sur les processeurs de ''shaders'', en faisant en sorte qu'ils soient utilisés le plus possible. Dans le cas le plus simple, les unités sont alimentées en vertex/pixels les unes après les autres (principe du round-robin), mais des stratégies plus optimisées sont la règle de nos jours. Cela est très important sur les cartes graphiques : répartir plusieurs commandes sur plusieurs processeurs est une tâche difficile. Un chapitre entier sera d'ailleurs dédié à ce sujet.

Il envoie aussi certaines commandes aux circuits fixes, comme l’''input assembler''. Là encore, il faut en sorte que les circuits fixes soient utilisés le mieux possible. Sa tâche est compliquée par le fait que les GPU récents ont plusieurs unités de traitement des sommets et des pixels, plusieurs ROP, plusieurs unités de textures, etc. Et c'est en partie le travail du processeur de commande que de répartir les calculs sur ces différentes unités. C'est là un problème assez compliqué pour le processeur de commande et ce pour tout un tas de raisons que nous ne ferons que survoler. Les contraintes d'ordonnancement de l'API et les règles de celle-ci sont une partie de la réponse. Mais d'autres raisons sont intrinsèques au rendu 3D ou à la conception des circuits.

[[File:Architecture de base d'une carte 3D - 1.png|centre|vignette|upright=2.5|Architecture de base d'une carte 3D - 1]]

Le processeur de commande n'a pas qu'un rôle de répartiteur. Il connait à tout instant l'état de la carte graphique, l'état de chaque sous-circuit. L'implémentation est variable suivant le GPU. La plus simple ajoute un registre d'état à chaque circuit, qui, est consultable en temps réel par le processeur de commande. Mais il est possible d'utiliser un système d'interruptions interne à la puce, ou circuits préviennent le processeur de commande quand ils ont terminé leur travail. Grâce à cela, le processeur de commandes garde en mémoire l'état de traitement de chaque commande : est-ce qu'elle est en train de s’exécuter sur le processeur graphique, est-ce qu'elle est mise en pause, est-ce qu'elle attend une donnée en provenance de la mémoire, est-ce qu'elle est terminée, etc.

Pour résumer, le processeur de commande lit une commande, répartit le travail sur les différents circuits du GPU, et vérifie en permanence leur état pour déterminer si la commande est en pause, terminée, en cours d'exécution, etc.

==Le fonctionnement du processeur de commandes==

Intuitivement, on se dit que le processeur de commande procède une commande à la fois. Mais les GPU modernes sont plus intelligents et peuvent exécuter plusieurs commandes en même temps, dans des circuits séparés. De nombreuses optimisations de ce type sont utilisées pour gagner en performance. Voyons comment un processeur de commande moderne fonctionne.

===L'ordonnancement et la gestion des ressources===

Le processeur de commande doit souvent mettre en pause certains circuits du pipeline, ainsi que les circuits précédents. Par exemple, si tous les processeurs de ''vertex shader'' sont occupés, l’''input assembler'' ne peut pas charger le paquet suivant car il n'y a aucun processeur de libre pour l’accueillir. Dans ce cas, l'étape d’''input assembly'' est mise en pause en attendant qu'un processeur de ''shader'' soit libre.

La même chose a lieu pour l'étape de rastérisation : si aucun processeur de ''shader'' n'est libre, elle est mise en pause. Sauf que pour la rastérisation, cela a des conséquences sur les circuits précédents la rastérisation. Si un processeur de ''shader'' veut envoyer quelque chose au rastériseur alors qu'il est en pause, il devra lui aussi attendre que le rastériseur soit libre. On a la même chose quand les ROP sont occupés : les ''pixel shader'' ou l'unité de texture doivent parfois être mis en pause, ce qui peut entrainer la mise en pause des étapes précédentes, etc.

En clair : plus un étape est situé vers la fin du pipeline graphique, plus sa mise en pause a de chances de se répercuter sur les étapes précédentes et de les mettre en pause aussi. Le processeur de commande doit gérer ces situations.

===Le pipelining des commandes===

Dans les cartes graphiques les plus rudimentaires, le processeur de commande exécute les commandes dans l'ordre. Il exécute une commande çà la fois et attend qu'une commande soit terminé pour en lancer une autre. Plusieurs commandes sont accumulées dans le tampon de commande, le processeur de commande les traite de la plus ancienne vers la plus récente. Du moins, les anciennes cartes graphiques faisaient comme cela, les cartes graphiques modernes sont un peu plus complexes. Elles n'attendent pas qu'une commande soit totalement terminée avant d'en lancer une nouvelle. Les processeurs de commande actuels sont capables d’exécuter plusieurs commandes en même temps.

L'intérêt est un gain en performance assez important. Pour ceux qui ont déjà eu un cours d'architecture des ordinateurs avancé, lancer plusieurs commandes en même temps permet une forme de pipeline, dont les gains sont substantiels. Par exemple, imaginez qu'une commande de rendu 3D soit bien avancée et n'utilise que les processeurs de ''shaders'' et les ROP, mais laisse les unités géométriques libres. Il est alors possible de démarrer la commande suivante en avance, afin qu'elle remplisse les unités géométriques inutilisées. On a alors deux commandes en cours de traitement : une commande qui utilise la fin du pipeline uniquement, une autre qui utilise seulement le début du pipeline graphique.

Le processeur de commande gère donc plusieurs commandes simultanées, à savoir plusieurs commandes qui en sont à des étapes différentes du pipeline. On peut avoir une commande qui est en cours dans l'étage de gestion de la géométrie, une autre dans le rastériseur, et une autre dans les unités de traitement des pixels. Le fait que les étapes du pipeline graphique sont à effectuer dans un ordre bien précis permet ce genre de chose assez facilement.

Une autre possibilité est de faire des rendus en parallèle. Par exemple, imaginez qu'on ait des circuits séparés pour le rendu 2D et 3D. Prenons l'exemple où le calcul d'une image finale demande de faire un rendu 3D suivi d'un rendu 2D, par exemple un jeu vidéo en 3D qui a un HUD dessiné en 2D. Dans ce cas, on peut démarrer le calcul de l'image suivante dans le pipeline 3D pendant que la précédente est dans les circuits 2D, au lieu de laisser inutilisé le pipeline 3D pendant le rendu 2D.

Mais c'est là un défi compliqué à relever pour le processeur de commande, qui donne lieu à son lot de problèmes. Le problème principal est le partage de ressources entre commandes. Par exemple, on peut prendre le cas où une commande n'utilise pas beaucoup les processeurs de ''shaders''. On pourrait imaginer lancer une seconde commande en parallèle, afin que la seconde commande utiliser les processeurs de ''shaders'' inutilisés. Mais cela n'est possible que si les circuits fixes sont capables d'accepter une seconde commande. Si la première commande sature les circuits fixe, le lancement de la seconde commande sera empêché. Mais si ce n'est pas le cas, les deux commandes pourront être lancées en même temps. Pareil pour le débit mémoire, qui doit alors être partagé entre deux commandes simultanées, ce qui est à prendre en compte.

===La synchronisation de l’exécution des commandes avec le processeur===

Il arrive que le processeur doive savoir où en est le traitement des commandes, ce qui est très utile pour la gestion de la mémoire vidéo. 

Un premier exemple : comment éviter de saturer une carte graphique de commande, alors qu'on ne sait pas si elles traite les commandes rapidement ou non ? L'idéal est de regarder où en est la carte graphique dans l'exécution des commandes. Si elle n'en est qu'au début du tampon de commande et que celui-ci est bien remplit, alors il vaut mieux lever le pied et ne pas envoyer de nouvelles commandes. A l'inverse, si le tampon de commande est presque vide, envoyer des commandes est la meilleure idée possible.

Un autre exemple un peu moins parlant est celui de la gestion de la mémoire vidéo. Rappelons qu'elle est réalisée par le pilote de la carte graphique, sur le processeur principal, qui décide d'allouer et de libérer de la mémoire vidéo. Pour donner un exemple d'utilisation, imaginez que le pilote de la carte graphique doive libérer de la mémoire pour pouvoir ajouter une nouvelle commande. Comment éviter d'enlever une texture tant que les commandes qui l'utilisent ne sont pas terminées ? Ce problème ne se limite pas aux textures, mais vaut pour tout ce qui est placé en mémoire vidéo. 

Il faut donc que la carte graphique trouve un moyen de prévenir le processeur que le traitement de telle commande est terminée, que telle commande en est rendue à tel ou tel point, etc. Pour cela, on a globalement deux grandes solutions. La première est celle des interruptions, abordées dans les chapitres précédents. Mais elles sont assez couteuses et ne sont utilisées que pour des évènements vraiment importants, critiques, qui demandent une réaction rapide du processeur. L'autre solution est celle du ''pooling'', où le processeur monitore la carte graphique à intervalles réguliers. Deux solutions bien connues de ceux qui ont déjà lu un cours d'architecture des ordinateurs digne de ce nom, rien de bien neuf : la carte graphique communique avec le processeur comme tout périphérique.

Pour faciliter l'implémentation du ''pooling'', la carte graphique contient des registres de statut, dans le processeur de commande, qui mémorisent tout ou partie de l'état de la carte graphique. Si un problème survient, certains bits du registre de statut seront mis à 1 pour indiquer que telle erreur bien précise a eu lieu. Il existe aussi un registre de statut qui mémorise le numéro de la commande en cours, ou de la dernière commande terminée, ce qui permet de savoir où en est la carte graphique dans l'exécution des commandes. Et certaines registres de statut sont dédiés à la gestion des commandes. Ils sont totalement programmable, la carte graphique peut écrire dedans sans problème.

Les cartes graphiques récentes incorporent des commandes pour modifier ces registres de statut au besoin. Elles sont appelées des '''commandes de synchronisation''' : les barrières (''fences''). Elles permettent d'écrire une valeur dans un registre de statut quand telle ou telle condition est remplie. Par exemple, si jamais une commande est terminée, on peut écrire la valeur 1 dans tel ou tel registre. La condition en question peut être assez complexe et se résumer à quelque chose du genre : &quot;si jamais toutes les ''shaders'' ont fini de traiter tel ensemble de textures, alors écrit la valeur 1024 dans le registre de statut numéro 9&quot;.

===La synchronisation de l’exécution des commandes intra-GPU===

Lancer plusieurs commandes en parallèle dans le pipeline permet de gagner en performance.Mais cela a un gros défaut : il n'est pas garantit que les commandes se terminent dans l'ordre. Si on démarre une seconde commande après la première, il arrive que la seconde finisse avant. Pire : il n'est pas garantit qu'elles s'exécutent dans l'ordre. Dans la plupart des cas, cela ne pose pas de problèmes. Mais dans d'autres, cela donne des résultats erronés.

Pour donner un exemple, utilisons les commandes de rendu 2D vues plus haut, histoire de simplifier le tout. Imaginez que vous codez un jeu vidéo et que le rendu se fait en 2D, partons sur un jeu de type FPS. Vous avez une série de commandes pour calculer l'image à rendre à l'écran, suivie par une série de commandes finales pour dessiner le HUB. Pour dessiner le HUD, vous utilisez des commandes HOSTDATA_BLT, dont le but est d'écrire une chaîne de caractères à l'écran ou copier une série d'image bitmap dans la mémoire vidéo. Et bien ces commandes HOSTDATA_BLT doivent démarrer une fois que le rendu de l'image est complétement terminé. Imaginez que vous dessiniez le HUD sur une portion de l'image pas encore terminée et que celui-ci est effacé par des écritures ultérieures ! 

Pour éviter tout problème, les GPU incorporent des commandes de synchronisation intra-GPU, destinées au processeur de commande, aussis appelées des '''commandes de sémaphore'''. Elles permettent de mettre en pause le lancement d'une nouvelle commande tant que les précédentes ne sont pas totalement ou partiellement terminées. Les plus simples empêchent le démarrage d'une commande tant que les précédentes ne sont pas terminées. D'autres permettent de démarrer une commande si et seulement si certaines commandes sont terminées. D'autres sont encore plus précises : elles empêchent le démarrage d'une nouvelle commande tant qu'une commande précédente n'a pas atteint un certain stade de son exécution. Là encore, de telles commandes sont des commandes du style &quot;attend que le registre de statut numéro N contienne la valeur adéquate avant de poursuivre l'exécution des commandes&quot;. 

Les commandes en question peuvent être sur le même modèle que précédemment, à savoir des commandes qui lisent les registres de statut. Mais elles peuvent aussi se baser sur le fait que telle ou telle ressource de rendu est libre ou non. Des commandes successives se partagent souvent des données, et que de nombreuses commandes différentes peuvent s'exécuter en même temps. Or, si une commande veut modifier les données utilisées par une autre commande, il faut que l'ordre des commandes soit maintenu : la commande la plus récente ne doit pas modifier les données utilisées par une commande plus ancienne. Avec ce modèle, les sémaphores bloquent une commande tant qu'une ressource (une texture) est utilisée par une autre commande.

{|class=&quot;wikitable&quot;
|-
! Commandes de synchronisation
! Fonction
|-
|NOP 
|Ne rien faire
|-
|WAIT_SEMAPHORE 
|Attendre la synchronisation avec un sémaphore
|-
|WAIT_MEM 
|Attendre que la mémoire vidéo soit disponible et inoccupée par le CPU
|}

==L'arbitrage de l'accès à la carte graphique==

Il n'est pas rare que plusieurs applications souhaitent accéder en même temps à la carte graphique. Imaginons que vous regardez une vidéo en ''streaming'' sur votre navigateur web, avec un programme de ''cloud computing'' de type ''Folding@Home'' qui tourne en arrière-plan, sur Windows. Le décodage de la vidéo est réalisé par la carte graphique, Windows s'occupe de l'affichage du bureau et des fenêtres, le navigateur web doit afficher tout ce qui est autour de la vidéo (la page web), le programme de ''cloud computing'' va lancer ses calculs sur la carte graphique, etc. Des situations de ce genre sont assez courantes et c'est soit le pilote qui s'en charge, soit la carte graphique elle-même.

===L'arbitrage logiciel du GPU===

L'arbitrage logiciel est la méthode la plus simple. Concrètement, c'est le système d'exploitation et/ou le pilote de la carte graphique qui gèrent l'arbitrage du GPU. Dans les deux cas, tout est fait en logiciel. Les commandes sont accumulées dans un tampon de commande, voire plusieurs, et l'OS/pilote décide quelle commande envoyer en priorité.

Sur Windows, avant l'arrivée du modèle de driver dit ''Windows Display Driver Model'', de telles situations étaient gérées simplement. Les applications ajoutaient des commandes dans une file de commande unique. Les commandes étaient exécutées dans l'ordre, en mode premier entrée dans la file premier sorti/exécuté. Il n'y avait pour ainsi dire pas d'arbitrage entre les applications. Et ce n'était pas un problème car, à l'époque, les seules applications qui utilisaient le GPU étaient des jeux vidéos fonctionnant en mode plein écran.

Avec le modèle de driver ''Windows Display Driver Model'' (WDDM), le GPU est maintenant arbitré, à savoir que les applications ont accès à tour de rôle au GPU, certaines ayant droit à plus de temps GPU que d'autres. Chaque programme a accès à la carte graphique durant quelques dizaines ou centaines de millisecondes, à tour de rôle. Si le programme finissait son travail en moins de temps que la durée impartie, il laissait la main au programme suivant. S’il atteignait la durée maximale allouée, il était interrompu pour laisser la place au programme suivant. Et chaque programme avait droit d'accès à la carte graphique chacun à son tour. Un tel algorithme en tourniquet est très simple, mais avait cependant quelques défauts. De nos jours, les algorithmes d'ordonnancement d'accès sont plus élaborés, bien qu'il soit difficile de trouver de la littérature ou des brevets sur le sujet.

Une autre fonctionnalité de WDDM est que les applications utilisant le GPU peuvent se partager la mémoire vidéo sans se marcher dessus. Avant, toutes les applications avaient accès à toute la mémoire vidéo, bien que ce soit par l’intermédiaire de commandes spécifiques. Mais avec WDDM, chaque application dispose de sa propre portion de mémoire vidéo, à laquelle est la seule à avoir accès. Une application ne peut plus lire le contenu réel de la mémoire vidéo, et encore moins lire le contenu des autres applications.

: Il s'agit d'un équivalent à l'isolation des processus pour les programmes Windows, mais appliqué à la mémoire vidéo et non la mémoire système. Et cette isolation est rendue d'autant plus simple que les GPU modernes implémentent un système de mémoire virtuelle à pagination très poussé, avec du swap en mémoire RAM système, une protection mémoire, et bien d'autres fonctionnalités. Nous en reparlerons dans les chapitres sur la mémoire vidéo.

===L'arbitrage accéléré par le GPU===

Depuis 2020, avec l'arrivée de la ''Windows 10 May 2020 update'', Windows est capable de déléguer l'arbitrage du GPU au GPU lui-même. Le  GPU gère lui-même l'arbitrage, du moins en partie. En partie, car l'OS gère les priorité, à savoir quelle application a droit à plus de temps que les autres. Par contre, la gestion du ''quantum'' de temps ou les commutations de contexte (on stoppe une application pour laisser la place à une autre), est du fait du GPU lui-même.

L'avantage est que cela décharge le processeur d'une tâche assez lourde en calcul, pour la déporter sur le GPU. Un autre avantage est que le GPU peut gérer plus finement les ''quantum'' de temps et la commutation de contexte. Le CPU principal gère des durées assez importantes, de l'ordre de la milliseconde. De plus, il doit communiquer avec le GPU par des mécanismes temporellement imprécis, comme des interruptions. Avec l'arbitrage accéléré par le GPU, le GPU n'a plus besoin de communiquer avec le CPU pour l'arbitrage et peut le faire plus précisément, plus immédiatement. Un gain en performance théorique est donc possible.

L'arbitrage accéléré par le GPU est le fait soit du processeur de commandes, soit d'un processeur spécialisé, séparé. 

{{NavChapitre | book=Les cartes graphiques
           | prev=La hiérarchie mémoire d'un GPU
           | prevText=La hiérarchie mémoire d'un GPU
           | next=Le pipeline géométrique d'avant DirectX 10
           | netxText=Le pipeline géométrique d'avant DirectX 10
}}{{autocat}}</text>
      <sha1>8bw2xskv9g4ddqpbcwswdw44f5a4jsy</sha1>
    </revision>
    <revision>
      <id>744056</id>
      <parentid>744055</parentid>
      <timestamp>2025-06-03T17:10:57Z</timestamp>
      <contributor>
        <username>Mewtow</username>
        <id>31375</id>
      </contributor>
      <minor />
      <comment>/* L'arbitrage de l'accès à la carte graphique */</comment>
      <origin>744056</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="34970" sha1="hgza7ynnnsy1rde0qmd3o85i3p9zfw3" xml:space="preserve">Dans ce chapitre, nous allons parler de tous les intermédiaires qui se placent entre une application de rendu 3D et les circuits de rendu 3D proprement dit. En premier lieu, on trouve le pilote de la carte graphique, aux fonctions multiples et variées. En second lieu, nous allons parler d'un circuit de la carte graphique qui fait l'interface entre le logiciel et les circuits de rendu 3D de la carte graphique : le processeur de commandes. Ce processeur de commandes est un circuit qui sert de chef d'orchestre, qui pilote le fonctionnement global de la carte graphique. API 3D, pilote de carte graphique et processeur de commande travaillent de concert pour que l'application communique avec la carte graphique. Nous allons d'abord voir le pilote de la carte graphique, avant de voir le fonctionnement du processeur de commande.

==Le pilote de carte graphique==

Le pilote de la carte graphique est un logiciel qui s'occupe de faire l'interface entre le logiciel et la carte graphique. De manière générale, les pilotes de périphérique sont des intermédiaires entre les applications/APIs et le matériel. En théorie, le système d'exploitation est censé jouer ce rôle, mais il n'est pas programmé pour être compatible avec tous les périphériques vendus sur le marché. À la place, le système d'exploitation ne gère pas directement certains périphériques, mais fournit de quoi ajouter ce qui manque. Le pilote d'un périphérique sert justement à ajouter ce qui manque : ils ajoutent au système d'exploitation de quoi reconnaître le périphérique, de quoi l'utiliser au mieux. Pour une carte graphique, il a diverses fonctions que nous allons voir ci-dessous.

Avant toute chose, précisons que les systèmes d'exploitation usuels (Windows, Linux, MacOsX et autres) sont fournis avec un pilote de carte graphique générique, compatible avec la plupart des cartes graphiques existantes. Rien de magique derrière cela : toutes les cartes graphiques vendues depuis plusieurs décennies respectent des standards, comme le VGA, le VESA, et d'autres. Et le pilote de base fournit avec le système d'exploitation est justement compatible avec ces standards minimaux. Mais le pilote ne peut pas profiter des fonctionnalités qui sont au-delà de ce standard. L'accélération 3D est presque inexistante avec le pilote de base, qui ne sert qu'à faire du rendu 2D (de quoi afficher l’interface de base du système d'exploitation, comme le bureau de Windows). Et même pour du rendu 2D, la plupart des fonctionnalités de la carte graphique ne sont pas disponibles. Par exemple, certaines résolutions ne sont pas disponibles, notamment les grandes résolutions. Ou encore, les performances sont loin d'être excellentes. Si vous avez déjà utilisé un PC sans pilote de carte graphique installé, vous avez certainement remarqué qu'il était particulièrement lent.

===La gestion des interruptions===

Une fonction particulièrement importante du pilote de carte graphique est la réponse aux interruptions lancées par la carte graphique. Pour rappel, les interruptions sont une fonctionnalité qui permet à un périphérique de communiquer avec le processeur, tout en économisant le temps de calcul de ce dernier. Typiquement, lorsqu'un périphérique lance une interruption, le processeur stoppe son travail et exécute automatiquement une routine d'interruption, un petit programme qui s'occupe de gérer le périphérique, de faire ce qu'il faut, ce que l'interruption a demandé.

Il y a plusieurs interruptions possibles, chacune ayant son propre numéro et sa fonction dédiée, chacune ayant sa propre routine d'interruption. Après tout, la routine qui gère un débordement de la mémoire vidéo n'est pas la même que celle qui gère un changement de fréquence du GPU ou la fin du calcul d'une image 3D. Le pilote fournit l'ensemble des routines d'interruptions nécessaires pour gérer la carte graphique.

===La compilation des ''shaders''===

Le pilote de carte graphique est aussi chargé de traduire les ''shaders'' en code machine. En soi, cette étape est assez complexe, et ressemble beaucoup à la compilation d'un programme informatique normal. Les ''shaders'' sont écrits dans un langage de programmation de haut niveau, comme le HLSL ou le GLSL, mais ce n'est pas ce code source qui est compilé par le pilote de carte graphique. À la place, les ''shaders'' sont pré-compilés vers un langage dit intermédiaire, avant d'être compilé par le pilote en code machine. Le langage intermédiaire, comme son nom l'indique, sert d'intermédiaire entre le code source écrit en HLSL/GLSL et le code machine exécuté par la carte graphique. Il ressemble à un langage assembleur, mais reste malgré tout assez générique pour ne pas être un véritable code machine. Par exemple, il y a peu de limitations quant au nombre de processeurs ou de registres. En clair, il y a deux passes de compilation : une passe de traduction du code source en langage intermédiaire, puis une passe de compilation du code intermédiaire vers le code machine. Notons que la première passe est réalisée par le programmeur des ''shaders'', non pas par l'utilisateur. Par exemple, les ''shaders'' d'un jeu vidéo sont fournis déjà pré-compilés : les fichiers du jeu ne contiennent pas le code source GLSL/HLSL, mais du code intermédiaire.

L'avantage de cette méthode est que le travail du pilote est fortement simplifié. Le pilote de périphérique pourrait compiler directement du code HLSL/GLSL, mais le temps de compilation serait très long et cela aurait un impact sur les performances. Avec l'usage du langage intermédiaire, le gros du travail à été fait lors de la première passe de compilation et le pilote graphique ne fait que finir le travail. Les optimisations importantes ont déjà été réalisées lors de la première passe. Il doit bien faire la traduction, ajouter quelques optimisations de bas niveau par-ci par-là, mais rien de bien gourmand en processeur. Autant dire que cela économise plus le processeur que si on devait compiler complètement les ''shaders'' à chaque exécution.

Fait amusant, il faut savoir que le pilote peut parfois remplacer les ''shaders'' d'un jeu vidéo à la volée. Les pilotes récents embarquent en effet des ''shaders'' alternatifs pour les jeux les plus vendus et/ou les plus populaires. Lorsque vous lancez un de ces jeux vidéo et que le ''shader'' originel s'exécute, le pilote le détecte automatiquement et le remplace par la version améliorée, fournie par le pilote. Évidemment, le ''shader'' alternatif du pilote est optimisé pour le matériel adéquat. Cela permet de gagner en performance, voire en qualité d'image, sans pour autant que les concepteurs du jeu n'aient quoique ce soit à faire.

Enfin, certains ''shaders'' sont fournis par le pilote pour d'autres raisons. Par exemple, les cartes graphiques récentes n'ont pas de circuits fixes pour traiter la géométrie. Autant les anciennes cartes graphiques avaient des circuits de T&amp;L qui s'en occupaient, autant tout cela doit être émulé sur les machines récentes. Sans cette émulation, les vieux jeux vidéo conçus pour exploiter le T&amp;L et d'autres technologies du genre ne fonctionneraient plus du tout. Émuler les circuits fixes disparus sur les cartes récentes est justement le fait de ''shaders'', présents dans le pilote de carte graphique.

===Les autres fonctions===

Le pilote a aussi bien d'autres fonctions. Par exemple, il s'occupe d'initialiser la carte graphique, de fixer la résolution, d'allouer la mémoire vidéo, de gérer le curseur de souris matériel, etc.

==Les commandes graphiques/vidéo/autres : des ordres envoyés au GPU==

Tous les traitements que la carte graphique doit effectuer, qu'il s'agisse de rendu 2D, de calculs 2D, du décodage matérielle d'un flux vidéo, ou de calculs généralistes, sont envoyés par le pilote de la carte graphique, sous la forme de '''commandes'''. Ces commandes demandent à la carte graphique d'effectuer une opération 2D, ou une opération 3D, ou encore le rendu d'une vidéo.

Les commandes graphiques en question varient beaucoup selon la carte graphique. Les commandes sont régulièrement revues et chaque nouvelle architecture a quelques changements par rapport aux modèles plus anciens. Des commandes peuvent apparaître, d'autres disparaître, d'autre voient leur fonctionnement légèrement altéré, etc.

Mais dans les grandes lignes, on peut classer ces commandes en quelques grands types. Les commandes les plus importantes s'occupent de l'affichage 3D : afficher une image à partir de paquets de sommets, préparer le passage d'une image à une autre, changer la résolution, etc. Plus rare, d'autres commandes servent à faire du rendu 2D : afficher un polygone, tracer une ligne, coloriser une surface, etc. Sur les cartes graphiques qui peuvent accélérer le rendu des vidéos, il existe des commandes spécialisées pour l’accélération des vidéos.

Pour donner quelques exemples, prenons les commandes 2D de la carte graphique AMD Radeon X1800.

{|class=&quot;wikitable&quot;
|-
! Commandes 2D 
! Fonction
|-
|PAINT 	
|Peindre un rectangle d'une certaine couleur
|-
|PAINT_MULTI 	
|Peindre des rectangles (pas les mêmes paramètres que PAINT)
|-
|BITBLT 	
|Copie d'un bloc de mémoire dans un autre
|-
|BITBLT_MULTI 	
|Plusieurs copies de blocs de mémoire dans d'autres
|-
|TRANS_BITBLT 	
|Copie de blocs de mémoire avec un masque
|-
|NEXTCHAR 	
|Afficher un caractère avec une certaine couleur
|-
|HOSTDATA_BLT 	
|Écrire une chaîne de caractères à l'écran ou copier une série d'image bitmap dans la mémoire vidéo
|-
|POLYLINE 	
|Afficher des lignes reliées entre elles
|-
|POLYSCANLINES
|Afficher des lignes
|-
|PLY_NEXTSCAN 	
|Afficher plusieurs lignes simples
|-
|SET_SCISSORS 	
|Utiliser des coupes (ciseaux)
|-
|LOAD_PALETTE 	
|Charger la palette pour affichage 2D
|}

===Le tampon de commandes===

L'envoi des commandes à la carte graphique ne se fait pas directement. La carte graphique n'est pas toujours libre pour accepter une nouvelle commande, soit parce qu'elle est occupée par une commande précédente, soit parce qu'elle fait autre chose. Il faut alors faire patienter les données tant que la carte graphique est occupée. Les pilotes de la carte graphique vont les mettre en attente dans le '''tampon de commandes'''. 

Le tampon de commandes est ce qu'on appelle une file, une zone de mémoire dans laquelle on stocke des données dans l'ordre d'ajout. Si le tampon de commandes est plein, le driver n'accepte plus de demandes en provenance des applications. Un tampon de commandes plein est généralement mauvais signe : cela signifie que la carte graphique est trop lente pour traiter les demandes qui lui sont faites. Par contre, il arrive que le tampon de commandes soit vide : dans ce cas, c'est simplement que la carte graphique est trop rapide comparé au processeur, qui n'arrive alors pas à donner assez de commandes à la carte graphique pour l'occuper suffisamment.

Le tampon de commande est soit une mémoire FIFO séparée, soit une portion de la mémoire vidéo. Le NV1, la toute première carte graphique NVIDIA, utilisait une mémoire FIFO intégrée à la carte graphique, séparée des autres circuits. Le processeur envoyait les commandes par rafale au GPU, à savoir qu'il envoyait plusieurs dizaines ou centaines de commandes à la suite, avant de passer à autre chose. Le GPU traitait les commandes une par une, à un rythme bien plus lent. Le processeur pouvait consulter la FIFO pour savoir s'il restait des entrées libres et combien. Le processeur savait ainsi combien d'écritures il pouvait envoyer en une fois au GPU.

: Le fonctionnement de la FIFO du NV1 est décrit dans le brevet ''US5805930A : System for FIFO informing the availability of stages to store commands which include data and virtual address sent directly from application programs''.

===Le processeur de commandes===

Le '''processeur de commande''' est un circuit qui gère les commandes envoyées par le processeur. Il lit la commande la plus ancienne dans le tampon de commande, l’interprète, l’exécute, puis passe à la suivante. Le processeur de commande est un circuit assez compliqué. Sur les cartes graphiques anciennes, c'était un circuit séquentiel complexe, fabriqué à la main et était la partie la plus complexe du processeur graphique. Sur les cartes graphiques modernes, c'est un véritable microcontrôleur, avec un processeur, de la mémoire RAM, etc.

Lors de l'exécution d'une commande, le processeur de commande pilote les circuits de la carte graphique. Précisément, il répartit le travail entre les différents circuits de la carte graphique et assure que l'ordre du pipeline est respecté. Pour donner un exemple, prenons la première carte graphique de NVIDIA, le NV1. Il s'agissait d'une carte multimédia qui incorporait non seulement une carte 2D/3D, mais aussi une carte son un contrôleur de disque et de quoi communiquer avec des manettes. De plus, il incorporait un contrôleur DMA pour échanger des données entre RAM système et les autres circuits. Et à tout cela, il fallait ajouter la FIFO de commandes et le processeur de commande. L'ensemble était relié par un bus interne à la carte graphique.

Le processeur de commande servait de gestionnaire principal. Il envoyait des ordres internes aux circuits de rendu 3D, à sa carte son, au contrôleur DMA. Par exemple, lorsque le processeur voulait copier des données en mémoire vidéo, il envoyait une commande de copie, qui était stockée dans le tampon de commande, puis était exécutée par le processeur de commande. Le processeur de commande envoyait alors les ordres adéquats au contrôleur DMA, qui faisait la copie des données. Lors d'un rendu 3D, une commande de rendu 3D est envoyée au NV1, le processeur de commande la traite et l'envoi dans les circuits de rendu 3D.

[[File:Microarchitecture du GPU NV1 de NVIDIA.png|centre|vignette|upright=2|Microarchitecture du GPU NV1 de NVIDIA]]

Les GPU modernes sont plus complexes, ce qui fait que le processeur de commande a plus de travail. Parmis les nombreuses tâches qui lui sont confiées, il répartit les ''shaders'' sur les processeurs de ''shaders'', en faisant en sorte qu'ils soient utilisés le plus possible. Dans le cas le plus simple, les unités sont alimentées en vertex/pixels les unes après les autres (principe du round-robin), mais des stratégies plus optimisées sont la règle de nos jours. Cela est très important sur les cartes graphiques : répartir plusieurs commandes sur plusieurs processeurs est une tâche difficile. Un chapitre entier sera d'ailleurs dédié à ce sujet.

Il envoie aussi certaines commandes aux circuits fixes, comme l’''input assembler''. Là encore, il faut en sorte que les circuits fixes soient utilisés le mieux possible. Sa tâche est compliquée par le fait que les GPU récents ont plusieurs unités de traitement des sommets et des pixels, plusieurs ROP, plusieurs unités de textures, etc. Et c'est en partie le travail du processeur de commande que de répartir les calculs sur ces différentes unités. C'est là un problème assez compliqué pour le processeur de commande et ce pour tout un tas de raisons que nous ne ferons que survoler. Les contraintes d'ordonnancement de l'API et les règles de celle-ci sont une partie de la réponse. Mais d'autres raisons sont intrinsèques au rendu 3D ou à la conception des circuits.

[[File:Architecture de base d'une carte 3D - 1.png|centre|vignette|upright=2.5|Architecture de base d'une carte 3D - 1]]

Le processeur de commande n'a pas qu'un rôle de répartiteur. Il connait à tout instant l'état de la carte graphique, l'état de chaque sous-circuit. L'implémentation est variable suivant le GPU. La plus simple ajoute un registre d'état à chaque circuit, qui, est consultable en temps réel par le processeur de commande. Mais il est possible d'utiliser un système d'interruptions interne à la puce, ou circuits préviennent le processeur de commande quand ils ont terminé leur travail. Grâce à cela, le processeur de commandes garde en mémoire l'état de traitement de chaque commande : est-ce qu'elle est en train de s’exécuter sur le processeur graphique, est-ce qu'elle est mise en pause, est-ce qu'elle attend une donnée en provenance de la mémoire, est-ce qu'elle est terminée, etc.

Pour résumer, le processeur de commande lit une commande, répartit le travail sur les différents circuits du GPU, et vérifie en permanence leur état pour déterminer si la commande est en pause, terminée, en cours d'exécution, etc.

==Le fonctionnement du processeur de commandes==

Intuitivement, on se dit que le processeur de commande procède une commande à la fois. Mais les GPU modernes sont plus intelligents et peuvent exécuter plusieurs commandes en même temps, dans des circuits séparés. De nombreuses optimisations de ce type sont utilisées pour gagner en performance. Voyons comment un processeur de commande moderne fonctionne.

===L'ordonnancement et la gestion des ressources===

Le processeur de commande doit souvent mettre en pause certains circuits du pipeline, ainsi que les circuits précédents. Par exemple, si tous les processeurs de ''vertex shader'' sont occupés, l’''input assembler'' ne peut pas charger le paquet suivant car il n'y a aucun processeur de libre pour l’accueillir. Dans ce cas, l'étape d’''input assembly'' est mise en pause en attendant qu'un processeur de ''shader'' soit libre.

La même chose a lieu pour l'étape de rastérisation : si aucun processeur de ''shader'' n'est libre, elle est mise en pause. Sauf que pour la rastérisation, cela a des conséquences sur les circuits précédents la rastérisation. Si un processeur de ''shader'' veut envoyer quelque chose au rastériseur alors qu'il est en pause, il devra lui aussi attendre que le rastériseur soit libre. On a la même chose quand les ROP sont occupés : les ''pixel shader'' ou l'unité de texture doivent parfois être mis en pause, ce qui peut entrainer la mise en pause des étapes précédentes, etc.

En clair : plus un étape est situé vers la fin du pipeline graphique, plus sa mise en pause a de chances de se répercuter sur les étapes précédentes et de les mettre en pause aussi. Le processeur de commande doit gérer ces situations.

===Le pipelining des commandes===

Dans les cartes graphiques les plus rudimentaires, le processeur de commande exécute les commandes dans l'ordre. Il exécute une commande çà la fois et attend qu'une commande soit terminé pour en lancer une autre. Plusieurs commandes sont accumulées dans le tampon de commande, le processeur de commande les traite de la plus ancienne vers la plus récente. Du moins, les anciennes cartes graphiques faisaient comme cela, les cartes graphiques modernes sont un peu plus complexes. Elles n'attendent pas qu'une commande soit totalement terminée avant d'en lancer une nouvelle. Les processeurs de commande actuels sont capables d’exécuter plusieurs commandes en même temps.

L'intérêt est un gain en performance assez important. Pour ceux qui ont déjà eu un cours d'architecture des ordinateurs avancé, lancer plusieurs commandes en même temps permet une forme de pipeline, dont les gains sont substantiels. Par exemple, imaginez qu'une commande de rendu 3D soit bien avancée et n'utilise que les processeurs de ''shaders'' et les ROP, mais laisse les unités géométriques libres. Il est alors possible de démarrer la commande suivante en avance, afin qu'elle remplisse les unités géométriques inutilisées. On a alors deux commandes en cours de traitement : une commande qui utilise la fin du pipeline uniquement, une autre qui utilise seulement le début du pipeline graphique.

Le processeur de commande gère donc plusieurs commandes simultanées, à savoir plusieurs commandes qui en sont à des étapes différentes du pipeline. On peut avoir une commande qui est en cours dans l'étage de gestion de la géométrie, une autre dans le rastériseur, et une autre dans les unités de traitement des pixels. Le fait que les étapes du pipeline graphique sont à effectuer dans un ordre bien précis permet ce genre de chose assez facilement.

Une autre possibilité est de faire des rendus en parallèle. Par exemple, imaginez qu'on ait des circuits séparés pour le rendu 2D et 3D. Prenons l'exemple où le calcul d'une image finale demande de faire un rendu 3D suivi d'un rendu 2D, par exemple un jeu vidéo en 3D qui a un HUD dessiné en 2D. Dans ce cas, on peut démarrer le calcul de l'image suivante dans le pipeline 3D pendant que la précédente est dans les circuits 2D, au lieu de laisser inutilisé le pipeline 3D pendant le rendu 2D.

Mais c'est là un défi compliqué à relever pour le processeur de commande, qui donne lieu à son lot de problèmes. Le problème principal est le partage de ressources entre commandes. Par exemple, on peut prendre le cas où une commande n'utilise pas beaucoup les processeurs de ''shaders''. On pourrait imaginer lancer une seconde commande en parallèle, afin que la seconde commande utiliser les processeurs de ''shaders'' inutilisés. Mais cela n'est possible que si les circuits fixes sont capables d'accepter une seconde commande. Si la première commande sature les circuits fixe, le lancement de la seconde commande sera empêché. Mais si ce n'est pas le cas, les deux commandes pourront être lancées en même temps. Pareil pour le débit mémoire, qui doit alors être partagé entre deux commandes simultanées, ce qui est à prendre en compte.

===La synchronisation de l’exécution des commandes avec le processeur===

Il arrive que le processeur doive savoir où en est le traitement des commandes, ce qui est très utile pour la gestion de la mémoire vidéo. 

Un premier exemple : comment éviter de saturer une carte graphique de commande, alors qu'on ne sait pas si elles traite les commandes rapidement ou non ? L'idéal est de regarder où en est la carte graphique dans l'exécution des commandes. Si elle n'en est qu'au début du tampon de commande et que celui-ci est bien remplit, alors il vaut mieux lever le pied et ne pas envoyer de nouvelles commandes. A l'inverse, si le tampon de commande est presque vide, envoyer des commandes est la meilleure idée possible.

Un autre exemple un peu moins parlant est celui de la gestion de la mémoire vidéo. Rappelons qu'elle est réalisée par le pilote de la carte graphique, sur le processeur principal, qui décide d'allouer et de libérer de la mémoire vidéo. Pour donner un exemple d'utilisation, imaginez que le pilote de la carte graphique doive libérer de la mémoire pour pouvoir ajouter une nouvelle commande. Comment éviter d'enlever une texture tant que les commandes qui l'utilisent ne sont pas terminées ? Ce problème ne se limite pas aux textures, mais vaut pour tout ce qui est placé en mémoire vidéo. 

Il faut donc que la carte graphique trouve un moyen de prévenir le processeur que le traitement de telle commande est terminée, que telle commande en est rendue à tel ou tel point, etc. Pour cela, on a globalement deux grandes solutions. La première est celle des interruptions, abordées dans les chapitres précédents. Mais elles sont assez couteuses et ne sont utilisées que pour des évènements vraiment importants, critiques, qui demandent une réaction rapide du processeur. L'autre solution est celle du ''pooling'', où le processeur monitore la carte graphique à intervalles réguliers. Deux solutions bien connues de ceux qui ont déjà lu un cours d'architecture des ordinateurs digne de ce nom, rien de bien neuf : la carte graphique communique avec le processeur comme tout périphérique.

Pour faciliter l'implémentation du ''pooling'', la carte graphique contient des registres de statut, dans le processeur de commande, qui mémorisent tout ou partie de l'état de la carte graphique. Si un problème survient, certains bits du registre de statut seront mis à 1 pour indiquer que telle erreur bien précise a eu lieu. Il existe aussi un registre de statut qui mémorise le numéro de la commande en cours, ou de la dernière commande terminée, ce qui permet de savoir où en est la carte graphique dans l'exécution des commandes. Et certaines registres de statut sont dédiés à la gestion des commandes. Ils sont totalement programmable, la carte graphique peut écrire dedans sans problème.

Les cartes graphiques récentes incorporent des commandes pour modifier ces registres de statut au besoin. Elles sont appelées des '''commandes de synchronisation''' : les barrières (''fences''). Elles permettent d'écrire une valeur dans un registre de statut quand telle ou telle condition est remplie. Par exemple, si jamais une commande est terminée, on peut écrire la valeur 1 dans tel ou tel registre. La condition en question peut être assez complexe et se résumer à quelque chose du genre : &quot;si jamais toutes les ''shaders'' ont fini de traiter tel ensemble de textures, alors écrit la valeur 1024 dans le registre de statut numéro 9&quot;.

===La synchronisation de l’exécution des commandes intra-GPU===

Lancer plusieurs commandes en parallèle dans le pipeline permet de gagner en performance.Mais cela a un gros défaut : il n'est pas garantit que les commandes se terminent dans l'ordre. Si on démarre une seconde commande après la première, il arrive que la seconde finisse avant. Pire : il n'est pas garantit qu'elles s'exécutent dans l'ordre. Dans la plupart des cas, cela ne pose pas de problèmes. Mais dans d'autres, cela donne des résultats erronés.

Pour donner un exemple, utilisons les commandes de rendu 2D vues plus haut, histoire de simplifier le tout. Imaginez que vous codez un jeu vidéo et que le rendu se fait en 2D, partons sur un jeu de type FPS. Vous avez une série de commandes pour calculer l'image à rendre à l'écran, suivie par une série de commandes finales pour dessiner le HUB. Pour dessiner le HUD, vous utilisez des commandes HOSTDATA_BLT, dont le but est d'écrire une chaîne de caractères à l'écran ou copier une série d'image bitmap dans la mémoire vidéo. Et bien ces commandes HOSTDATA_BLT doivent démarrer une fois que le rendu de l'image est complétement terminé. Imaginez que vous dessiniez le HUD sur une portion de l'image pas encore terminée et que celui-ci est effacé par des écritures ultérieures ! 

Pour éviter tout problème, les GPU incorporent des commandes de synchronisation intra-GPU, destinées au processeur de commande, aussis appelées des '''commandes de sémaphore'''. Elles permettent de mettre en pause le lancement d'une nouvelle commande tant que les précédentes ne sont pas totalement ou partiellement terminées. Les plus simples empêchent le démarrage d'une commande tant que les précédentes ne sont pas terminées. D'autres permettent de démarrer une commande si et seulement si certaines commandes sont terminées. D'autres sont encore plus précises : elles empêchent le démarrage d'une nouvelle commande tant qu'une commande précédente n'a pas atteint un certain stade de son exécution. Là encore, de telles commandes sont des commandes du style &quot;attend que le registre de statut numéro N contienne la valeur adéquate avant de poursuivre l'exécution des commandes&quot;. 

Les commandes en question peuvent être sur le même modèle que précédemment, à savoir des commandes qui lisent les registres de statut. Mais elles peuvent aussi se baser sur le fait que telle ou telle ressource de rendu est libre ou non. Des commandes successives se partagent souvent des données, et que de nombreuses commandes différentes peuvent s'exécuter en même temps. Or, si une commande veut modifier les données utilisées par une autre commande, il faut que l'ordre des commandes soit maintenu : la commande la plus récente ne doit pas modifier les données utilisées par une commande plus ancienne. Avec ce modèle, les sémaphores bloquent une commande tant qu'une ressource (une texture) est utilisée par une autre commande.

{|class=&quot;wikitable&quot;
|-
! Commandes de synchronisation
! Fonction
|-
|NOP 
|Ne rien faire
|-
|WAIT_SEMAPHORE 
|Attendre la synchronisation avec un sémaphore
|-
|WAIT_MEM 
|Attendre que la mémoire vidéo soit disponible et inoccupée par le CPU
|}

==L'arbitrage de l'accès à la carte graphique==

Il n'est pas rare que plusieurs applications souhaitent accéder en même temps à la carte graphique. Imaginons que vous regardez une vidéo en ''streaming'' sur votre navigateur web, avec un programme de ''cloud computing'' de type ''Folding@Home'' qui tourne en arrière-plan, sur Windows. Le décodage de la vidéo est réalisé par la carte graphique, Windows s'occupe de l'affichage du bureau et des fenêtres, le navigateur web doit afficher tout ce qui est autour de la vidéo (la page web), le programme de ''cloud computing'' va lancer ses calculs sur la carte graphique, etc. Des situations de ce genre sont assez courantes et c'est soit le pilote qui s'en charge, soit la carte graphique elle-même.

===L'arbitrage logiciel du GPU===

L'arbitrage logiciel est la méthode la plus simple. Concrètement, c'est le système d'exploitation et/ou le pilote de la carte graphique qui gèrent l'arbitrage du GPU. Dans les deux cas, tout est fait en logiciel. Les commandes sont accumulées dans un tampon de commande, voire plusieurs, et l'OS/pilote décide quelle commande envoyer en priorité.

Sur Windows, avant l'arrivée du modèle de driver dit ''Windows Display Driver Model'', de telles situations étaient gérées simplement. Les applications ajoutaient des commandes dans une file de commande unique. Les commandes étaient exécutées dans l'ordre, en mode premier entrée dans la file premier sorti/exécuté. Il n'y avait pour ainsi dire pas d'arbitrage entre les applications. Et ce n'était pas un problème car, à l'époque, les seules applications qui utilisaient le GPU étaient des jeux vidéos fonctionnant en mode plein écran.

Avec le modèle de driver ''Windows Display Driver Model'' (WDDM), le GPU est maintenant arbitré, à savoir que les applications ont accès à tour de rôle au GPU, certaines ayant droit à plus de temps GPU que d'autres. Chaque programme a accès à la carte graphique durant quelques dizaines ou centaines de millisecondes, à tour de rôle. Si le programme finissait son travail en moins de temps que la durée impartie, il laissait la main au programme suivant. S’il atteignait la durée maximale allouée, il était interrompu pour laisser la place au programme suivant. Et chaque programme avait droit d'accès à la carte graphique chacun à son tour. Un tel algorithme en tourniquet est très simple, mais avait cependant quelques défauts. De nos jours, les algorithmes d'ordonnancement d'accès sont plus élaborés, bien qu'il soit difficile de trouver de la littérature ou des brevets sur le sujet.

Une autre fonctionnalité de WDDM est que les applications utilisant le GPU peuvent se partager la mémoire vidéo sans se marcher dessus. Avant, toutes les applications avaient accès à toute la mémoire vidéo, bien que ce soit par l’intermédiaire de commandes spécifiques. Mais avec WDDM, chaque application dispose de sa propre portion de mémoire vidéo, à laquelle est la seule à avoir accès. Une application ne peut plus lire le contenu réel de la mémoire vidéo, et encore moins lire le contenu des autres applications.

: Il s'agit d'un équivalent à l'isolation des processus pour les programmes Windows, mais appliqué à la mémoire vidéo et non la mémoire système. Et cette isolation est rendue d'autant plus simple que les GPU modernes implémentent un système de mémoire virtuelle à pagination très poussé, avec du swap en mémoire RAM système, une protection mémoire, et bien d'autres fonctionnalités. Nous en reparlerons dans les chapitres sur la mémoire vidéo.

===L'arbitrage accéléré par le GPU===

Depuis 2020, avec l'arrivée de la ''Windows 10 May 2020 update'', Windows est capable de déléguer l'arbitrage du GPU au GPU lui-même. Le  GPU gère lui-même l'arbitrage, du moins en partie. En partie, car l'OS gère les priorité, à savoir quelle application a droit à plus de temps que les autres. Par contre, la gestion du ''quantum'' de temps ou les commutations de contexte (on stoppe une application pour laisser la place à une autre), est du fait du GPU lui-même.

L'avantage est que cela décharge le processeur d'une tâche assez lourde en calcul, pour la déporter sur le GPU. Un autre avantage est que le GPU peut gérer plus finement les ''quantum'' de temps et la commutation de contexte. Le CPU principal gère des durées assez importantes, de l'ordre de la milliseconde. De plus, il doit communiquer avec le GPU par des mécanismes temporellement imprécis, comme des interruptions. Avec l'arbitrage accéléré par le GPU, le GPU n'a plus besoin de communiquer avec le CPU pour l'arbitrage et peut le faire plus précisément, plus immédiatement. Un gain en performance théorique est donc possible.

L'arbitrage accéléré par le GPU est le fait soit du processeur de commandes, soit d'un processeur spécialisé, séparé.

===L'exemple du NV1===

La carte NVIDIA NV1 avait diverses optimisations pour supporter plusieurs applications à la fois. L'une d'entre elle est le support de plusieurs tampons de commande. La carte graphique gérait en tout 128 tampons de commandes, chacun contenant 32 commandes consécutives. Le tout permettait à 128 logiciels différents d'avoir chacun son propre tampon de commande. L'implémentation du NV1 utilisait en réalité une FIFO unique, dans une mémoire RAM unique, qui était segmentée en 128 sous-FIFOs. Mais il est techniquement possible d'utiliser plusieurs FIFOs séparées connectées à un multiplexeur en sortie et un démultiplexeur en entrée.

Le NV1 utilisait des adresses de 23 bits, ce qui fait 8 méga-octets de RAM. Les 8 méga-octets étaient découpées en 128 blocs de mémoire consécutifs, chacun étant associé à une application et faisant 64 kilo-octets. Les adresses de 23 bits étaient donc découpées en une portion de 7 bit pour identifier le logiciel qui envoie la commande, et une portion de 16 bits pour identifier la position des données dans le bloc de RAM. Une entrée dans la FIFO du NV1 faisait 48 bits, contenant une donnée de 32 bits et les 16 bits de l'adresse.

{{NavChapitre | book=Les cartes graphiques
           | prev=La hiérarchie mémoire d'un GPU
           | prevText=La hiérarchie mémoire d'un GPU
           | next=Le pipeline géométrique d'avant DirectX 10
           | netxText=Le pipeline géométrique d'avant DirectX 10
}}{{autocat}}</text>
      <sha1>hgza7ynnnsy1rde0qmd3o85i3p9zfw3</sha1>
    </revision>
  </page>
  <page>
    <title>Neurosciences/Le métabolisme cérébral</title>
    <ns>0</ns>
    <id>70529</id>
    <revision>
      <id>744030</id>
      <parentid>743943</parentid>
      <timestamp>2025-06-03T13:18:31Z</timestamp>
      <contributor>
        <username>Mewtow</username>
        <id>31375</id>
      </contributor>
      <minor />
      <comment>/* Le fer */</comment>
      <origin>744030</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="56143" sha1="nfmew6j7v43fv7bh3yghcl982g6yrg2" xml:space="preserve">Le cerveau est un organe qui consomme beaucoup d'énergie : près de 20% de la consommation énergétique du corps est de son fait, alors qu'il ne représente que 2 % de sa masse. Il faut dire que faire fonctionner les neurones demande de l'énergie, d'autant plus que ceux-ci sont actifs. Générer des potentiels d'action demande une certaine énergie, produire des neurotransmetteurs aussi, sans compter l'action des pompes et canaux ioniques de la membrane. Le cerveau utilise la majeure partie de son énergie pour faire fonctionner ses pompes et canaux ioniques, principalement les pompes. Celles-ci vont, pour rappel, pomper certains ions en dehors de la cellule, contre leur gradient de concentration. Cela demande naturellement de l'énergie, pour contrer l'effet de la concentration plus importante dans le milieu extérieur. Chaque pompe va ainsi utiliser une ou plusieurs molécules d'ATP pour faire sortir un ion. Cela ne parait n'être pas grand-chose, mais cela compte pour 50% du métabolisme de base du cerveau !

==Le métabolisme énergétique du cerveau==

Le cerveau est un organe qui consomme beaucoup d'énergie. On estime qu'il est responsable, à lui seul d'environ 25 % de la consommation énergétique du corps. La valeur exacte varie beaucoup selon beaucoup de paramètres. Par exemple, on sait que la consommation énergétique du cerveau dépend de sa température. On estime qu'une réduction de 1°C réduit la consommation énergétique cérébrale de 6 à 5 %. Cela a d'ailleurs des applications thérapeutiques, dans les cas d'AVC, d'arrêt cardiaque ou d'autres situations similaires où le cerveau manque d'oxygène. Dans ces situations, on refroidit le cerveau pour ralentir son métabolisme. Cela réduit l'apparition de lésions cérébrales, causées par un métabolisme anormal lié au manque d'oxygène. Quoi qu’il en soit, le métabolisme cérébral dépend de bien d'autres paramètres, et il serait inutile d'en faire une liste exhaustive.

===Les sources d'énergie du cerveau===

Les neurones sont comme toutes les cellules : ils consomment des nutriments pour fabriquer de l'énergie, qu'ils emmagasinent sous forme d'ATP dans la cellule. En temps normal, ces nutriments sont des sucres, mais le cerveau peut aussi bruler des dérivés de la désagrégation des graisses ou des protéines si le sucre vient à manquer. Cette combustion des nutriments, implique toute une série de réactions chimiques très compliquées. Ceux qui s'y connaissent en biologie devraient connaitre les notions de fermentation ou de respiration cellulaires, voire le cycle de Krebs. Nous n'allons pas revenir sur ces notions fondamentales de la biologie, mais nous allons remarquer que la combustion des nutriments peut se faire soit en présence d'oxygène, soit sans. Quand les nutriments sont brulés en présence d'oxygène, les réactions chimiques sont des réactions dites de ''respiration cellulaire''. Dans le cas contraire, ce sont des réactions de ''fermentation''. Les neurones sont capables à la fois de respiration cellulaire que de fermentation. Vu que les neurones consomment beaucoup d'énergie, le processus principal est la respiration, ce qui fait que le cerveau a besoin d'oxygène pour fonctionner. Pour résumer, le cerveau a principalement besoin de sucres et d'oxygène, mais il peut consommer des graisses en cas de manque. 

====Le glucose et l'oxygène====

En temps normal, le cerveau consomme du sucre par respiration cellulaire, la fermentation étant minimale. Le sucre le plus utilisé par le cerveau est le glucose, du moins en temps normal, mais des molécules similaires au glucose peuvent être utilisées en lieu de place de celui-ci : c'est le cas pour le pyruvate, le mannose et le lactate. Les expériences qui ont montré cela sont assez simples à expliquer. Elles se bornent à comparer la composition du sang entre les artères qui alimentent le cerveau et les veines qui en sortent. Ces mesures montrent alors que le sang est identique entre l'entrée et la sortie, si ce n'est que sa teneur en glucose et en oxygène est plus basse dans les veines que dans les artères, sans compter que sa teneur en dioxyde de carbone augmente.

Les mesures précédentes traduisent le fait que le cerveau utilise ce qu'on appelle la respiration cellulaire aérobie pour produire son énergie : il consomme de l'oxygène et du glucose et produit de l'énergie et du dioxyde de carbone. Cependant, ces mesures montrent que tout l'oxygène n'est pas converti de cette manière. Si tout le glucose était utilisé ainsi, 100 grammes de cerveau devraient consommer 26 millimoles de glucose par minutes. Or, la valeur mesurée est de 31 millimoles par minutes. Il y a donc une petite différence de 4,4 millimoles par minutes, qui est utilisée autrement. Dans le détail, on verra que ce glucose est transformé et stocké dans les astrocytes et les neurones, il est mis en réserve.

====Les lipides et acides gras====

Outre le glucose, les protéines et des dérivés de la désagrégation des graisses peuvent être consommés par le cerveau pour produire de l'énergie. Encore une fois, cette production s'effectue par le biais de la respiration cellulaire aérobie et le cerveau n'est pas le seul à pouvoir faire cela (tous les tissus peuvent brûler des protéines ou des lipides dans le cycle de Krebs). Par contre, le métabolisme cérébral des graisses est différent du métabolisme des autres tissus. En effet, le cerveau ne peut pas bruler les acides gras pour produire de l'énergie, contrairement aux autres tissus. La raison est que les acides gras ne peuvent pas traverser la barrière hémato-encéphalique. En revanche, le cerveau peut bruler les '''corps cétoniques''', des dérivés de la désagrégation des graisses qui peuvent traverser la barrière hémato-encéphalique et alimenter le cerveau en énergie. Parmi les corps cétoniques, deux alimentent le cerveau et le cœur en énergie : l'acétylacétate et le β-D-hydroxybutyrate.

Cependant, la production de corps cétoniques n'arrive que dans des conditions très particulières. Il faut que le corps manque de sucres (glucose) au point que le foie en est réduit à bruler des graisses. Le métabolisme des lipides et acides gras donne alors naissance à des corps cétoniques, par un processus dit de cétogenèse. Par exemple, cela arrive en cas de diabète ou de jeûne : l'alimentation en sucre étant alors inadéquate, le cerveau doit utiliser d'autres voies que la consommation de glucose. Un autre exemple est celui des nouveaux-nés allaités, dont l'alimentation est très riche en lipides et en acides gras. Dans tous les exemples précédents, les réactions chimiques utilisées pour produire de l'énergie à partir de lipides ou de protéines sont les mêmes : les voies métaboliques des nouveaux-nés sont réactivées en cas de jeûne ou de diabète.

===L'hypoxie cérébrale===

Quand l'oxygène vient à manquer, on fait face à une situation d'''hypoxie cérébrale''. Une telle situation arrive notamment lors d'un AVC ou d'un arrêt cardiaque, quand le cerveau n'est plus irrigué par le sang. L'oxygène n'est plus apporté au cerveau, qui réagit pour faire face à la pénurie. Le cerveau a beau avoir une grosse consommation énergétique, il a des réserves très faibles en nutriments. Ce qui fait que l'hypoxie commence à causer des problèmes en quelques minutes, voire quelques secondes. Il se produit alors une cascade de réactions chimiques, qui endommage les neurones et entraine leur mort. Cette cascade se produit en deux étapes : une première étape liée à la carence en oxygène, une autre quand le sang revient dans le cerveau et où l'oxygène revient. Ces deux étapes laissent des dommages cérébraux massifs, qu'il s'agisse du manque d'oxygène ou des dommages de la seconde étape, appelés dommages de re-perfusion.

====La cascade ischémique====

La première étape est une série de réactions chimiques qui s'appelle la '''cascade ischémique''', qui fait suite à un manque d'oxygène. Pour faire simple, le cerveau réagit en passant à des réactions de fermentation pour consommer les sucres. Mais l'usage de la fermentation pose divers problèmes. En premier lieu, elle ne fournit pas assez d'énergie pour les pompes et canaux ioniques. L'équilibre ionique du cerveau est alors perturbé, avec une accumulation d'ions dans ou en dehors des neurones. En second lieu, la fermentation produit des déchets qui sont toxiques pour les neurones. Or, ceux-ci peuvent entrainer des dommages s'ils ne sont pas évacués du cerveau. La majorité des dommages provient, de manière indirecte, du déséquilibre ionique, qui intoxique les neurones de l'intérieur.

Le dysfonctionnement principal est l'arrêt de certaines pompes ioniques, notamment des pompes au potassium, au calcium et au sodium. Cela mène à une ''accumulation de sodium et de calcium dans les neurones''. En premier lieu, le calcium va s'accumuler dans les neurones. Or, le calcium est toxique pour les cellules, ce qui peut forcer l'apoptose des cellules (leur suicide). De plus, ce calcium favorise la libération des neurotransmetteurs, dont le glutamate. Or, le glutamate fait rentrer encore plus de calcium via les récepteurs NMDA et AMPA. Rappelons que c'est pour cela que le glutamate a des propriétés excitotxiques, à savoir qu'il peut exciter les neurones à l'excès, jusqu’à en devenir toxique. Les effets excitotoxiques du glutamate proviennent de là, et ceux-ci s'expriment avec force lors de l'ischémie, bien plus que dans des conditions normales. Limiter les dégâts de la cascade ischémique demande d'agir vite afin de stopper celle-ci avant qu'un trop grand nombre de neurones soient morts. Une autre possibilité serait d'atténuer l'excitotoxicité du glutamate, en utilisant des antagonistes des récepteurs NMDA et AMPA. Mais cette stratégie n'a pas donné de bons résultats dans les études réalisées à l'heure actuelle (mi-2017).

Un autre défaut est que le sodium s'accumule dans les neurones, ce qui en perturbe l'équilibre hydroélectrique (pour les connaisseurs, l'équilibre osmotique). Les raisons à cela sont multiples. Déjà, les pompes ioniques calcium-sodium vont tenter d'évacuer le calcium dans les neurones, mais cela fait rentrer du sodium. De plus, certaines pompes ioniques potassium-sodium vont dysfonctionner, en raison du manque d'ATP, ce qui réduit l'élimination de sodium intraneuronale. Tout cela fait que les neurones tendent à accumuler beaucoup d'ions sodium dans leur cytoplasme. Sans rentrer dans les détails, cela a une conséquence : de l'eau s'accumule dans les neurones, qui gonflent. Il se produit alors un œdème cérébral, qui fait gonfler le cerveau et le compresse sur le crâne. Cette pression entraine des lésions assez graves, si elle est assez intense. Mais nous en reparlerons dans le chapitre sur la pression intracrânienne, qui parlera des œdèmes cérébraux en général.

Enfin, la fermentation produit des déchets métaboliques, les deux principaux étant : le lactate et des ions hydrogène. Les deux sont toxiques pour les neurones, quand ils sont en excès, ce qui est le cas lors d'une hypoxie cérébrale. L'accumulation de lactate est moins problématique que l'accumulation des ions hydrogène. Cette dernière fait que le pH diminue, entraînant une acidose métabolique,  perturbant les réactions chimiques cérébrales.

[[File:Cascade ischémique 02.svg|centre|vignette|upright=3.0|Description simplifiée de la cascade ischémique.]]

==Les interactions neurones-astrocytes==

Les molécules dissoutes dans le sang doivent traverser la barrière hémato-encéphalique pour arriver aux neurones. Leur passage à travers celle-ci fait intervenir des molécules appelées ''transporteurs''. Pour rappel, ce sont des &quot;récepteurs&quot; qui permettent à une molécule de passer d'un côté à l'autre d'une membrane cellulaire. Ici, la molécule en question est une molécule sanguine et les membranes sont celles de la barrière hémato-encéphalique. Les transporteurs sont spécialisés, dans le sens où ils ne laissent passer que quelques molécules bien précises et pas les autres. Par exemple, les transporteurs pour le glucose permettent uniquement le passage du glucose, mais pas des autres molécules. Quoi qu’il en soit, les molécules sanguines traversent la barrière hémato-encéphalique, du moins pour celles qui ont un transporteur adapté, mais elles n'arrivent pas directement dans les neurones ou dans le fluide entre les neurones. Rappelons que la barrière hémato-encéphalique est composée de deux couches : un vaisseau sanguin, entouré par des astrocytes. Les transporteurs localisés à la surface des vaisseaux sanguins cérébraux permettent aux molécules de passer dans les astrocytes, qui se chargent ensuite de les redistribuer aux neurones par divers mécanismes. Pour résumer, les molécules traversent la barrière hémato-encéphalique, se retrouvent dans les astrocytes, puis sont transférées aux neurones à la demande. Autant dire que les interactions entre neurones et astrocytes sont très importantes pour le métabolisme cérébral.

Rappelons que les astrocytes n'ont pas beaucoup de transporteurs différents, les principaux étant les transporteurs pour le glucose. L'absence de transporteurs pour de nombreuses molécules/ions empêche la majorité des ions et molécules de traverser les astrocytes et d'atteindre le cerveau. C'est pour cela que la barrière hémato-encéphalique est aussi sélective.

===Le métabolisme du glucose===

Les astrocytes ont un rôle très important dans le métabolisme énergétique des neurones. Pour simplifier, les astrocytes servent de réservoir d'énergie à disposition des neurones : ils captent le glucose sanguin, le mettent en réserve, et le distribuent aux neurones à la demande. Ils servent donc de réservoir d'énergie, dans lequel les neurones alentours peuvent puiser s'ils en ont besoin. À noter que les astrocytes stockent l'énergie non pas sous la forme de glucose, mais dans des molécules de glycogène et de lactate. Rappelons que le glycogène est synthétisé à partir du glucose. Le glycogène se fabrique en liant plusieurs molécules de glucose entre elles, d'une manière extrêmement compacte. C'est la forme sous laquelle les sucres sont stockés dans la plupart des cellules, cette molécule contenant une grande quantité d'énergie dans un volume très petit. Les astrocytes en concentrent de grandes quantités pour répondre aux besoins métaboliques des neurones, ainsi que pour leur fonctionnement. Si le besoin s'en fait sentir, les liaisons de la molécule de glycogène sont brisées par des enzymes, ce qui libère de nombreuses molécules de glucose, de lactate, ou d'autres formes de sucres.

Le transfert du glucose des astrocytes aux neurones peut se faire de diverses manières, mais il se fait principalement sous la forme de lactate. Les astrocytes libèrent du lactate dans le milieu extracellulaire, qui est capté par les neurones. Ce lactate est produit dans les astrocytes par dégradation du glucose et est destiné non au stockage, mais à la consommation immédiate. Dans le détail, le glucose est dégradé en pyruvate, qui est lui-même transformé en lactate. Le lactate est alors envoyé aux neurones, qui synthétisent du pyruvate avec, pyruvate qui est utilisé par la respiration aérobie (cycle de Krebs). On peut préciser que la libération du lactate par les astrocytes est couplée aux besoins des neurones par divers mécanismes. Ce qui veut dire que les astrocytes détectent que les neurones ont besoin d'énergie, et libèrent du lactate selon quand les besoins s'en font sentir. Le premier est que les neurones ont surtout besoin d'énergie, et donc de sucres, après avoir émis des potentiels d'action. Or, les astrocytes mesurent en permanence la quantité de neurotransmetteurs dans le milieu extra-cellulaire : plus il y en a, plus les neurones ont dépensés d'énergie pour les émettre et plus ils ont besoin d'énergie. Pour être plus précis, ils mesurent la quantité de glutamate, non de tous les neurotransmetteurs. Pour résumer, la liaison du glutamate sur les récepteurs astrocytaires va stimuler la libération du lactate dans le milieu extra-cellulaire, qui est ensuite assimilé par les neurones.

Évidemment, le métabolisme du glucose implique l'existence de transporteurs du glucose à la surface des astrocytes et des neurones. Dans l'ensemble des tissus, il existe quatorze transporteurs du glucose différents, qui n'ont pas la même composition chimique et sont de forme différente. Ils sont appelés GLUT-1, GLUT-2, GLUT-3, ..., GLUT-14, GLUT étant l'abréviation de ''GLUcose-Transporter''. Ils ne sont pas spécifiques du glucose, mais peuvent aussi servir de transporteurs à d'autres &quot;sucres&quot;. Par exemple, le GLUT-5 sert de transporteur pour le glucose, mais aussi le fructose. D'autres servent de transporteur pour l'urate, le myoinositol et quelques autres molécules. Toujours est-il que l'on peut classer ces transporteurs du glucose en trois grandes catégories, mais seuls ceux de la première sont présents dans le cerveau, à savoir les récepteurs de GLUT-1 à GLUT-4 et le GLUT-14. Le transporteur GLUT1 est surtout présent dans la membrane des astrocytes, de même que le transporteur GLUT2. Le premier est présent dans tous les astrocytes cérébraux, alors que GLUT2 est présent dans certaines astrocytes, localisés dans des aires cérébrales bien précises (hypothalamus et tronc cérébral). Le transporteur GLUT3 est la chasse gardée des neurones.

===Le métabolisme du cholestérol===

Le cholestérol est un lipide intervenant dans de nombreuses fonctions métaboliques du corps, et joue notamment un rôle dans le fonctionnement du cerveau. Il s'agit en effet d'un des composants principaux de la myéline qui entoure les axones (la gaine de myéline). Sachant que plus de la moitié du cerveau est composée de substance blanche, donc de myéline, il n'est pas étonnant que le cerveau soit l'organe le plus riche de tous en cholestérol. Certaines études estiment que près de 20% du cholestérol total est localisé dans le cerveau. De plus, le cholestérol est un composant de la membrane des neurones et des cellules gliales. Plus les axones et dendrites d'un neurone se développent, plus ceux-ci doivent fabriquer de membrane cellulaire pour donner naissance aux axones et dendrites. Pour résumer, les besoins en cholestérol augmentent avec l'apparition de nouvelles synapses et dendrites.

La quantité de cholestérol cérébral reste approximativement constante au cours du temps. Ce n'est que lors de myélinisation du système nerveux que le cholestérol est fortement synthétisé. Lors de ces périodes, la formation des gaines de myéline augmente les besoins en cholestérol, qui ne peuvent être assouvis que par une synthèse importante. Les périodes de développement des synapses/neurones entrainent une forte consommation en cholestérol, les besoins étant alors fortement augmentés. En-dehors de ces périodes où les besoins sont augmentés, la synthèse de cholestérol cérébral est contrebalancée par sa consommation et son élimination. Le métabolisme cérébral du cholestérol est illustré dans le schéma ci-dessous, que je vous invite à regarder avant de lire ce qui va suivre.

[[File:Cerebrosterol.jpg|centre|vignette|upright=2|Métabolisme cérébral du cholestérol.]]

Le cholestérol sanguin n'est pas la source de cholestérol cérébral, vu que le cholestérol sanguin ne traverse pas la barrière hémato-encéphalique. Le cholestérol cérébral est synthétisé par les astrocytes, encore eux, sous la forme d'apolipoprotéines (ApoE). Ces apolipoprotéines sont synthétisées sous une forme immature, avant d'être finalisées par l'action de protéines membranaires de type ABCA. Elles sont ensuite absorbées par les neurones et sont transformées en cholestérol à l'intérieur des neurones, via l'action d'une enzyme.

Le cholestérol des neurones va ensuite être utilisé par le neurone. Il servira notamment dans la fabrication de la membrane du neurone. Rappelons que le neurone ne produit pas sa gaine de myéline, mais que ce sont les oligodendrocytes qui le font, ce qui fait que le choléstérol capté par les neurones ne sert pas à fabriquer la gaine de myéline. Mais l'utilisation principale du cholestérol intra-neuronal est de loin la formation de protéines appelées bêta-amyloides, présentes à la surface des cellules. On peut signaler que cette protéine est impliquée dans la maladie d'Alzheimer, bien que l'on sache mal comment... Rappelons que le cholestérol cérébral est aussi impliqué dans la fabrication de neurostéroïdes, des stéroïdes qui modulent l'action du GABA et du glutamate. Leur fabrication demande une conversion du cholestérol en prégnénolone, qui est elle-même transformée en divers stéroïdes, puis en neurostéroïdes. La conversion du cholestérol en prégnénolone est effectuée par l'enzyme CYP450scc et a lieu dans les mitochondries. Pour cela, le cholestérol est capté un transporteur qui capte le cholestérol cytoplasmique et le fait rentrer dans les mitochondries, à l'intérieur desquelles il s'effectue la transformation.

Il arrive que le cerveau produise un peu plus de cholestérol que demandé. Dans ce cas, le cholestérol produit en excès (non-utilisé par le cerveau) est soit stocké, soit éliminépar diverses voies métaboliques. Seul 1% du cholestérol cérébral est stocké dans les neurones et astrocytes. Il y prend alors la forme de gouttelettes de graisses de petite taille. Ce stockage demande que le cholestérol subisse des modifications chimiques, induites par une enzyme appelée cholesterol acyltransferase 1 (ACAT1/SOAT1).

Les neurones qui contiennent l'enzyme CYP46 peuvent dégrader le cholestérol en excès en une molécule appelée cérébrostérol. Appellation bien plus facile à retenir que le nom scientifique du cérébrostérol, à savoir : 24S-hydroxycholestérol. Ce cérébrostérol est émis dans le milieu-extracellulaire où il est soit éliminé, soit recyclé par les astrocytes. Le cérébrostérol peut traverser la barrière hémato-encéphalique, ce qui lui permet d'être éliminé dans la circulation sanguine. Plus de 2/3 du cérébrostérol est éliminé, le reste étant capté par les astrocytes et recyclé en ApoE.

===Le métabolisme des neurotransmetteurs===

Les astrocytes ne vont pas seulement fournir des nutriments aux neurones : ils vont aussi jouer un grand rôle dans le recyclage de certains neurotransmetteurs, comme le GABA, le glutamate, la glycine, et autres. Dans les faits, ces neurotransmetteurs sont produits à partir respectivement de sérine (glycine) et de glutamine (glutamate et GABA).

Prenons le cas de la sérine et de la glycine comme premier exemple. La sérine est produite dans les astrocytes à partir du glucose, avant d'être envoyé aux neurones. Les neurones vont alors synthétiser de la glycine à partir de cette sérine et l'utiliser comme neurotransmetteur. Après utilisation, la glycine est recapturée par les astrocytes et est alors dégradée en sérine. Et un nouveau cycle recommence : la sérine synthétisée peut alors être utilisée renvoyée aux neurones, et ainsi de suite.

Il en est de même pour le glutamate et le GABA. Ces deux neurotransmetteurs sont recapturés par les astrocytes, qui les dégradent en glutamine. Cette glutamine est alors renvoyée aux neurones, qui pourront re-synthétiser du glutamate et/ou du GABA et les utiliser comme neurotransmetteurs. Il faut noter que le glutamate peut aussi être synthétisé par les astrocytes et les neurones non pas à partir de glutamine, mais à partir d'une molécule produite par le cycle de Krebs (respiration aérobie).

[[File:Major metabolic fluxes in neuron-astrocyte coupling for resting conditions.png|centre|vignette|upright=3.0|Major metabolic fluxes (μmol/g tissue/min) in neuron-astrocyte coupling for resting conditions. The fluxes were calculated with the objective of maximizing the glutamate/glutamine/GABA cycle fluxes between the two cell types with subsequent minimization of Euclidean norm of fluxes, using the uptake rates given in Table 1 as constraints. Thick arrows show uptake and release reactions. Dashed arrows indicate shuttling of metabolites between the two cell types. Only key pathway fluxes are represented here for simplicity. The flux distributions for all the reactions listed in Additional File 1 are given in Additional File 4:Supplementary Table 3. (Description is figure caption from original article).]]

==Les vitamines et le cerveau==

Dans les sections précédentes du chapitre, nous avons surtout parlé de l'alimentation en énergie du cerveau. Mais il ne faut pas oublier que de nombreuses réactions chimiques permettent d'utiliser cette énergie et de la stocker. De plus, certaines réactions métaboliques permettent de synthétiser des neurotransmetteurs, de façonner la paroi des neurones, de contrôler les différences de concentrations en ions dans le neurone, et ainsi de suite. Ces réactions font naturellement appel à de nombreuses enzymes et autres protéines, la plupart étant synthétisées à partir des nutriments, mais aussi à partir de vitamines. Le cerveau est de loin un des plus gros consommateur de vitamines du corps.

D'ailleurs, il faut signaler que le cerveau est naturellement riche en vitamines, celui-ci ayant des réserves assez importantes. C'est notamment le cas pour les vitamines B, qui sont séquestrées dans le cerveau. Aussi, il n'est pas étonnant que leur teneur cérébrale soit largement supérieure à leur concentration sanguine. Par exemple, la concentration en vitamine B9 est près de 4 fois supérieure à la concentration sanguine, de même que la concentration en vitamine B5 et B8 est près de 50 fois plus importante dans le cerveau que dans le sang. Grâce à cela, le cerveau peut survivre à une déficience assez légère et/ou temporaire en vitamines. Cependant, cela n’empêche pas des déficiences en vitamines dans des situations extrêmes, comme un alcoolisme chronique ou un jeune prolongé. Ces déficiences peuvent avoir des conséquences neuropsychiatriques assez importantes, comme nous allons le voir maintenant. Dans ce qui va suivre, nous allons étudier les quatre vitamines les plus importantes pour le cerveau, à savoir les vitamines B1, B6, B9 et B12.

===Les vitamines B9 et B12===

Les vitamines B9 et B12 fonctionnent en tandem dans le corps, un manque de vitamine B12 pouvant être masqué par une complémentation de B9 et réciproquement. Ces cas sont cependant rares, vu que la carence en vitamine B12 ou B9 est exceptionnelle de nos jours. Elle ne touche que les végétariens qui ne se complémentent pas en vitamine B12 (et encore, après quelques mois ou années de ce régime sans complémentation) ou les personnes ayant des problèmes d'absorption des vitamines (anémie de Biermer, usage d'antiacides prolongé, problèmes intestinaux…). La récupération est souvent totale après complémentation en B12 ou B9, mais quelques patients peuvent avoir des séquelles s'ils ne sont pas pris en charge rapidement.

La vitamine B9, aussi appelée acide folique, a un métabolisme assez compliqué et est impliquée dans la réplication de l'ADN ou le métabolisme de certains acides aminés. La voie métabolique qui nous intéresse est cependant assez simple : l'acide folique est absorbé par les intestins, puis est transformé par le foie en acide lévoméfolique (5-méthyl-THF), la forme de vitamine B9 qui est absorbée par le cerveau. Ce métabolite peut traverser la barrière hémato-encéphalique en passant à travers un récepteur spécifique : le récepteur folate-alpha. Des déficits au niveau de ce récepteur peuvent entraîner une '''déficience cérébrale en folate''' dans laquelle seul le cerveau subit un déficit en B9, alors que le reste du corps a une alimentation vitaminique normale. Les symptômes sont une hypotonie, des crises épileptiques et un retard mental/psychomoteur. Sa cause principale est une maladie génétique très rare, liée à une mutation du gène FOLR1, le gène qui code pour le récepteur cérébral du folate. Une autre cause est la présence dans le sang d'anticorps qui visent ce récepteur, ce qui est une maladie auto-immune extrêmement rare.

La carence en vitamine B12 entraîne un '''syndrome neuro-anémique''', dont le nom traduit ses symptômes : une anémie et des symptômes neuropsychiatriques variés. Pour ce qui est des manifestations psychiatriques, les symptômes vont de symptômes mineurs (troubles du sommeil, dépression) à des symptômes plus graves pouvant aller jusqu’à la démence ou des crises psychotiques. Le symptôme neurologique le plus grave est une démyélinisation du système nerveux dont les symptômes sont semblables à la sclérose en plaque, qui peut toucher la moelle épinière, les nerfs et/ou le cerveau. L'atteinte des nerfs périphériques fait que ceux-ci perdent leur gaine de myéline, donnant des polynévrites assez marquées. L'atteinte médullaire touche essentiellement le faisceau pyramidal ainsi que les cordons antérieurs (système des colonnes dorsales). L’atteinte du faisceau pyramidal et des nerfs moteurs se traduit par l'apparition de troubles moteurs tels qu’une paralysie, une spasticité, un défaut de coordination motrice ou autre. L'atteinte des nerfs sensitifs et des colonnes dorsales médullaires est la cause de troubles sensitifs variés : douleurs dans les extrémités, picotements, sensations de décharges électriques, et cætera.

===La vitamine B6===

Nous avons vu il y a quelques chapitres que la vitamine B6 est primordiale dans la synthèse de la sérotonine et de la dopamine, du GABA et de la mélatonine. Pour rappel, la vitamine B6 est une coenzyme associée à plusieurs enzymes. Elle active l'enzyme ''dopa-décarboxylase'', qui dégrade le 5-HT est transformé en sérotonine et la L-DOPA en dopamine. C'est aussi la coenzyme de la GAD, qui dégrade le glutamate en GABA.

La vitamine B6 existe sous plusieurs formes différentes, mais seules trois d'entre elles entrent dans le cerveau : le pyridoxal, la pyridoxine et la pyridoxamine. Ce sont des formes inactives, qui demandent à être phosphatées pour devenir des formes actives de la vitamine B6, à savoir du phosphate de pyridoxal, du phosphate de pyridoxine ou du phosphate de pyridoxamine. Dans le cerveau, les formes inactives de B6 sont transformées en phosphate de pyridoxal par deux enzymes : la PK et la PNPO (''Pyridoxine 5'-phosphate oxidase''). Le phosphate de pyridoxal intervient ensuite dans la dégradation de la lysine et de la proline (deux acides aminés), via deux voies métaboliques différentes dans laquelle de nombreuses enzymes interviennent. Dans ce réseau métabolique, divers troubles peuvent survenir.

La plus fréquente, la ''carence en vitamine B6'' perturbe le fonctionnement global du cerveau. Une déficience en vitamine B6 entraine donc une baisse de production des neurotransmetteurs cités plus haut, qui touche préférentiellement la synthèse du GABA et de la sérotonine. La baisse de GABA induite se traduit par une hausse de l'activité électrique des neurones, avec deux conséquences principales : un mauvais sommeil et, plus rarement, des crises épileptiques. La baisse de sérotonine et de dopamine se manifeste quant à elle par un état anxio-dépressif et une hausse de l'impulsivité et de la nervosité. La déficience peut aussi se manifester dans le système nerveux périphérique par une inflammation généralisée des nerfs (une polynévrite). À l'inverse, une surdose de vitamine B6 n'entraine pas de symptômes clairs, tant que la surdose n'est pas prolongée. Cependant, une complémentation en B6 prolongée durant plusieurs mois peut engendrer des névrites totalement réversibles avec l'arrêt de la supplémentation.

L''''épilepsie sensible au phosphate de pyridoxal''' est une maladie génétique à transmission autosomique dominante. Elle est causée par une ''déficience en PNPO'', qui touche la synthèse du phosphate de pyrixodal à partir des formes inactives de B6. Avec cette maladie,  l'enzyme PNPO n'est pas synthétisée, ce qui fait que la vitamine B6 n'agit plus du tout dans le cerveau. Cela entraine une carence massive en B6 active dans le cerveau. En conséquence, la synthèse des neurotransmetteurs est perturbée et le métabolisme neuronal des acides aminés est perturbé. Le résultat est une encéphalopathie épileptique néonatale, qui survient dès les premières heures de vie du bébé atteint. Elle ne réagit pas aux traitements habituels et n'est soignée que par un traitement à base de phosphate de pyridoxine/pyridoxal. D'autres symptômes peuvent survenir, comme une hypotonie, des troubles respiratoires, des mouvements anormaux, etc.

Similaire à la maladie précédente, l''''épilepsie pyridoxine-dépendante''' est un ensemble de maladies génétiques caractérisées par une encéphalopathie néonatale similaire à la maladie précédente. Les crises épileptiques sont de type myocloniques, avec un tracé typique sur l'EEG. La seule différence est que la maladie est sensible à un traitement à base de pyridoxine, une forme inactive de la B6, là où la précédente a besoin de la forme active de la B6. L'identification de cette maladie est souvent difficile à faire et le diagnostic se fait après administration de vitamine B6 ou un diagnostic génétique. Elle se manifeste très tôt : dans les premiers jours ou mois de vie pour les formes précoces, vers 1 à 3 ans pour les formes tardives. Ce syndrome touche entre une naissance sur 500 000 et une naissance sur 400 000. Ses causes sont nombreuses et de nombreux mutations génétiques peuvent la causer. Dans les grandes lignes, il existe deux sous-syndromes principaux : une forme précoce qui apparait dans les premières heures de vie, et une forme tardive qui apparait vers 1 à 3 ans.
* La forme précoce exprime une épilepsie prénatale dès 20 semaines de gestation. L'épilepsie se manifeste rapidement et toutes les formes de crises épileptiques peuvent survenir : myoclonies, absences, crises toniques, toniques-cloniques. Elle est souvent secondée par de l'irritabilité et une réaction excessive aux stimuli, ainsi que par des malformations cérébrales diverses (hydrocéphalie, malformations du corps calleux, ...). On peut observer des troubles métaboliques généraux, des troubles respiratoires, et bien d'autres symptômes divers. Sans traitements, la maladie entraine un retard mental et divers déficits neurologique et développementaux. La forme précoce la plus fréquente est causée par une mutation qui perturbe la synthèse de l'antiquitine, une enzyme de la voie de dégradation de la lysine.
* Par contraste, la forme tardive apparait avant 3 ans et répond initialement aux médicaments anti-épileptiques, avant que ces traitements cessent de faire effet. L'épilepsie est isolée, avec peu d'autres symptômes neurologiques et une absence de malformations cérébrales.

===La vitamine B1===

La vitamine B1, aussi appelée thiamine, est une vitamine du fameux cycle de Krebs (une série de réactions chimiques qui fournit de l'énergie aux cellules vivantes). Une carence en vitamine B1 entraine une pénurie d'énergie et d'ATP dans les cellules, qui se mettent à dysfonctionner et parfois à mourir. Le système nerveux étant un tissu très gourmand d'un point de vue métabolique, toute carence en vitamine B1 retenti en premier lieu sur le fonctionnement cérébral. Autant dire qu'elle est extrêmement importante pour le système nerveux, des carences pouvant être tout aussi graves que les carences en vitamines B12 ou B6. La carence en thiamine cause un stress métabolique aux neurones, qui cause des dysfonctionnements divers des potentiels d'action, mais qui peut aussi entrainer souvent la mort du neurone par apoptose. De plus, la carence va aussi modifier la recapture du glutamate, entrainant l'apparition d'une excitotoxicité (le glutamate excite les neurones à mort). Beaucoup de neurones dysfonctionnent, quand ils ne meurent rapidement, ce qui cause l'apparition d'une maladie : l''''encéphalopathie de Wernicke'''.

Ses symptômes sont souvent assez clairs, 80% des cas manifestant la triade : défaut de coordination des mouvements (ataxie), paralysie des yeux (ophtalmoplégie) et confusion (delirium). D'autres symptômes peuvent se faire jour, comme une profonde amnésie, une perte de la mémoire à court-terme, une psychose, ou des troubles végétatifs. L'origine de ces symptômes est liée à diverses atteintes du thalamus, de l'hypothalamus et du tronc cérébral. Par exemple, la paralysie oculaire provient d'une atteinte des noyaux des nerfs crâniens oculomoteurs. L&quot;amnésie est quant à elle liée à une atteinte des corps mamillaires de l'hypothalamus. Une carence prolongée en B1 s'observe surtout chez les alcooliques, l'alcool stoppant l'absorption intestinale de la B1.

Chez certains patients, l'encéphalopathie de Wernicke évolue vers des troubles cognitifs permanents. La démence qui en résulte est appelée le '''syndrome de Korsakoff''', du nom de son découvreur. Son symptôme principal est une amnésie assez particulière. Nous allons devoir parler rapidement de l'amnésie, chose qui sera détaillé dans le chapitre sur la mémoire. L'amnésie du syndrome de Krosakoff est une perte de la mémoire à court-terme, avec une incapacité à mémoriser de nouveaux souvenirs ou de nouvelles connaissances. Les savoirs et souvenirs déjà acquis sont relativement préservés, bien que quelques déficits peuvent se voir. L'amnésie porte donc essentiellement sur les acquisitions qui suivent le traumatisme, cette forme d'amnésie étant appelée amnésie antérograde. L'amnésie qui touche les souvenirs d'avant l'apparition du syndrome est appelée amnésie rétrograde. L'amnésie du syndrome de Korsakoff est essentiellement antérograde, bien qu'une faible amnésie rétrograde soit possible. Si amnésie rétrograde il y a, celle-ci ne touche généralement que les souvenirs et savoirs récents, qui datent de quelques mois, années ou décennies avant le syndrome. Outre l'amnésie, divers troubles cognitifs peuvent se manifester, que ce soit des troubles du langage (aphasie), des troubles de la reconnaissance des objets et de la catégorisation (agnosie) ou des troubles intellectuels.

==Les minéraux et le cerveau==

Outre les vitamines, les mal-nommés « minéraux » sont d'une importance capitale pour le fonctionnement normal du cerveau. Les « minéraux » les plus importants sont de loin les ions Calcium, Potassium et Sodium, sans lesquels il ne peut y avoir de potentiels d'action. Leur rôle a déjà été abordé dans le chapitre sur potentiel d'action et nous n'en reparlerons pas ici. Les autres ions que nous allons aborder sont le magnésium, le cuivre, le fer et quelques autres. Vous remarquerez qu'il s'agit d'ions métalliques, à quelques exceptions près.

Tous les ions ont une concentration particulièrement bien régulée, le cerveau disposant de toute une machinerie chimique pour régler leur concentration. Il faut dire que ces ions deviennent toxiques quand ils sont en grandes quantités. C'est notamment le cas des ions métalliques, qui sont impliqués dans des réactions d’oxydoréduction qui créent des molécules « poisons » (des radicaux libres). En temps normal, les produits nocifs de ces réactions sont éliminés ou dégradés par la machinerie cellulaire du cerveau, mais ces processus sont dépassés quand la concentration en ions métalliques devient trop importante. De même, une déficience est nuisible pour les neurones, ces ions servant dans de nombreuses réactions chimiques importantes pour le fonctionnement des neurones.

La concentration en ions du cerveau est sévèrement contrôlée par divers mécanismes, dans lesquels la barrière hémato-encéphalique joue un rôle crucial. Elle protège le cerveau des variations de concentration ionique du sang. Par exemple, prenons le cas où la concentration en sodium du sang augmente, suite à la consommation d'un aliment particulier, d'une réponse hormonale, ou d'un supplément alimentaire. Le cerveau ne va pas être impacté par cette variation, et en sera isolé : la concentration ionique intracérébrale restera la même. C'est grâce à la barrière hémato-encéphalique, qui isole le cerveau des vaisseaux sanguins. L'absorption d'ions dans le cerveau, ou leur excrétion, est réalisée par des canaux ioniques et/ou des transporteurs, qui se trouvent à la surface de la barrière hématoencéphalique. Elles vont se lier aux minéraux ou aux vitamines à absorber et vont les rapatrier dans les astrocytes pour l'absorption. Une partie des ions est perdue dans le liquide céphalorachidien, et est emportée avec lui lors de son excrétion dans le sang.

===Le magnésium===

L'ion magnésium a aussi été vu dans le chapitre sur les récepteurs synaptiques et la plasticité synaptique. Nous avons vu que les récepteurs NMDA du glutamate sont bloqués par un ion magnésium, qui bouche le canal ionique. Du moins, c'est le cas tant que le potentiel du neurone reste inférieur à -60 mV. Si la tension dépasse ce seuil, l'ion Magnésium est éjecté et le canal ionique s'ouvre, excitant le neurone. On devine donc qu'un manque en magnésium se traduit par une hyper-excitabilité neuronale, alors qu'un excès de Magnésium entraine une hypo-excitabilité neuronale. Dans les deux cas, l'atteinte neuronale est diffuse, mais ciblée sur les neurones sensibles au glutamate.
* La déficience en magnésium entraine des symptômes neurologiques qui vont d'une simple asthénie et/ou une faiblesse musculaire, à des symptômes plus sérieux comme des convulsions et plus rarement un coma.
* Pour un excès en magnésium, les symptômes neurologiques sont frustres pour les faibles hypermagnésémies, mais bien plus lourds dans les cas graves. À faible dose en excès, le magnésium entraine une simple léthargie et/ou asthénie. Pour un excès assez fort, elle surtout des symptômes neuromusculaires. Il a, à hautes doses, un effet sur la jonction neuromusculaire similaire à celui du curare. En clair, elle cause une décontraction musculaire, une diminution des réflexes, des paralysies (notamment respiratoires). Dans certains cas extrêmes, on observe une dilatation pupillaire liée à un blocage du système nerveux sympathique.

===Le cuivre===

Le cuivre traverse la barrière hémato-encéphalique par le biais de deux transporteurs nommés CRT1 et APH7A, et s'accumule dans le cerveau. S'il y a trop de cuivre dans le cerveau, l'excès de cuivre est éliminé dans le liquide cérébrospinal, puis dans le sang, via l'action des mêmes transporteurs.

[[File:Metabolisme cerebral du cuivre.png|centre|vignette|upright=2.5|Métabolisme cérébral du cuivre]]

Les mêmes transporteurs sont présents à la surface des neurones et des cellules gliales, ce qui leur permet d'absorber du cuivre s'il en ont besoin. Le cuivre n'a pas de rôle physiologique clair au niveau du cerveau, au moment où j'écris ces lignes. Tout ce que l'on sait est que des excès ou des carences entrainent de nombreux symptômes au niveau du foie, du cerveau et d'autres tissus/organes. Chez certaines personnes, les transporteurs du cuivre dysfonctionnent, ce qui fait que le cuivre ne rentre pas, ou au contraire s'accumule, dans les tissus. 

La '''maladie de Menkes''' est causée par un dysfonctionnement du transporteur ATP7A, qui entraine une déficience en cuivre, qui touche notamment le cerveau. Une des conséquences est que le cuivre ne traverse plus la barrière hémato-encéphalique. Les neurones privés de cuivre meurent rapidement, la myéline ne se forme pas autour des axones. Les patients montrent un manque de tonus musculaire (hypotonie), de l'épilepsie et des symptômes neurologiques variés. On observe aussi un visage déformé, caractéristique de la maladie, une perte des cheveux, et quelques autres symptômes. Il s'agit d'une maladie grave qui apparait quelques mois après la naissance. Les enfants touchés ne dépassent pas l'âge de 3-5 ans.

Les maladies liées à l'accumulation de cuivre dans le cerveau se manifestent (entre autres) par des symptômes neurologiques assez francs. Le cuivre s'accumule de préférence dans les ganglions de la base, qui sont les premiers touchés par un excès de cuivre, ce qui entraine des symptômes caractéristiques : parkinsonisme, mouvements involontaires anormaux (chorée, tics, dyskinésies, autres), troubles psychiatriques variés, atteinte cognitive.

&lt;noinclude&gt;[[File:Kayser-Fleischer ring.jpg|vignette|Anneau de Kayser-Fleischer, caractéristique de la maladie de Wilson.]]&lt;/noinclude&gt;

La '''maladie de Wilson''' est une maladie (en fait, un ensemble de maladies génétiques) qui entraine une accumulation de cuivre dans l'organisme. Les organes les plus touchés sont le foie et le cerveau. Seuls une moitié des patients manifestent ces symptômes neuropsychiatriques. Les autres symptômes sont des problèmes de foie et aux yeux, parfois au cœur et aux reins. Les patients ont presque tous des troubles au foie, notamment une cirrhose, qui peuvent cependant passer inaperçus quand leurs symptômes sont frustres (ictère, fatigue, saignements, hypertension dans la veine porte, ...). Chez certains patients, on observe un anneau brun sur le pourtour des iris et des yeux, quasi-pathognomonique de la maladie. Au niveau cérébral, l'accumulation de cuivre est toxique pour les neurones, qui meurent progressivement. Les symptômes de la maladie traduisent une atteinte des ganglions de la base, qui sont les aires cérébrales les plus touchées par l'accumulation de cuivre.
* Les symptômes neurologiques sont des problèmes d'équilibre (ataxie), un parkinsonisme, des troubles du tonus musculaire (dystonie). Par contre, les troubles sensoriels sont très rares, au point que leur présence signifie pour le médecin qu'il vaut mieux chercher un autre diagnostic. Plus rarement, une épilepsie peut survenir, mais ce n'est pas un symptôme diagnostic.
* Les symptômes psychiatriques sont assez variés, mais sont essentiellement des troubles du comportement : désinhibition, irritabilité extrême, impulsivité, etc. On observe aussi fréquemment des troubles l'humeur (dépression), de l'anxiété. On observe plus rarement une psychose (syndrome regroupant hallucinations, délires, désorganisation de la pensée et troubles du comportement). Il arrive que les patients subissent des troubles cognitifs/intellectuels, qui miment une démence : pertes de mémoire, des troubles de l'idéation (pensée ralentie), et autres.

===Le fer===

Le fer est utilisé par tous les tissus et toutes les cellules du corps humain. Il est présent dans l'hémoglobine des globules rouge, la molécule qui fixe l'oxygène et le CO2 sanguin. Les autres cellules en ont besoin pour fabriquer de l'énergie sous forme d'ATP. Pour être précis, il sert pour la respiration cellulaire, au niveau de la chaine de transport d'électrons des mitochondries (ce détail aura son importance pour l'ataxie de Friedrich). Et cela vaut aussi pour les neurones et cellules gliales. De plus, les neurones ont besoin de fer pour fabriquer certains neurotransmetteurs. Toutes les monoamines sont synthétisées par des enzymes dont le fer est une co-enzyme.

Dans le sang, le fer se lie à une molécule de transport appelée la '''transferrine'''. Elle capture le fer libre, le transporte dans le sang et le relâche au niveau des tissus qui en ont besoin. La transferrine est tellement efficace qu'il n'y a presque pas d'ions Fer isolés, dissous dans le sang. Pour rentrer dans le cerveau, la transferrine doit traverser la barrière-hématoencéphalique. Nous en avions déjà parlé dans le chapitre sur la barrière hémato-encéphalique, aussi nous ne reviendrons pas dessus. Toujours est-il que le fer rentre dans le cerveau sous trois formes : du fer lié à de la transferrine, des ions &lt;math&gt;Fe^{2+}&lt;/math&gt; et des ions &lt;math&gt;Fe^{3+}&lt;/math&gt;.

Une fois dans le cerveau, une partie du &lt;math&gt;Fe^{2+}&lt;/math&gt; est immédiatement oxydé en &lt;math&gt;Fe^{3+}&lt;/math&gt; par diverses enzymes appelés des ferroxydases (l'''Hephaestine'' étant la plus connue). Le fer &lt;math&gt;Fe^{3+}&lt;/math&gt; ne tarde pas à se lier à de la transferrine intra-cérébrale. Car oui, il y a de la transferrine dans le cerveau. Une partie provient de la transferrine sanguine, une autre partie est produite localement dans les plexus choroïdes.

Précisons que la transferrine sanguine est saturée à seulement 30% de sa capacité de transport maximale, la transferrine cérébrale atteint presque 100%. Il s'agit pourtant de la même molécule, mais les différences chimiques entre le sang et le tissu cérébral font que... Une conséquence est la transferrine ne peut pas servir de tampon en cas d'excès en fer cérébral, vu qu'elle est déjà chargée au maximum, ce qui rend les neurones très sensibles à une surcharge en fer.

La répartition du Fer n'est pas uniforme dans le cerveau. Premièrement, le fer s'accumule de préférence dans les cellules gliales plutôt que dans les neurones, avec une préférence pour les oligodendrocytes que les astrocytes. Comparé aux neurones, il y a environ 5 fois plus de fer dans les oligodendrocytes et 3 fois plus dans les astrocytes. La raison est que la synthèse de la myéline, réalisée par les oligodendrocytes, demande pas mal de fer. Au-delà de ces différences cellulaires, il y a une répartition inégale au niveau anatomique. Le fer s'accumule préférentiellement dans les ganglions de la base et la substance noire (la ''substantia nigra pars compacta'', pour être précis). Et cela explique pourquoi certaines maladies entrainant un excès de fer dans le cerveau se traduisent par des syndromes parkinsonien, comme on va le voir à l'instant.

Les neurones ne peuvent pas faire de stocks de fer, car ils ne produisent pas de ferritine, une enzyme qui peut faire des réserves de fer. Par contre, les cellules gliales en sont capables. Elles produisent de la ferritine, ce qui leur permet de faire des réserves de fer. De même, la barrière hémato-encéphalique peut émettre des molécules de ferritine, qui sont captées par les oligodendrocytes. Ils peuvent ainsi internaliser la ferritine produite par la BHE si besoin. Les oligodendrocytes ont des stocks de ferritine plus important que ceux des astrocytes, vu qu'ils ont des besoins en fer plus important (métabvolisme + fabrication myéline).

Les astrocytes peuvent absorber le fer de deux manières. La première absorbe les ions &lt;math&gt;Fe^{2+}&lt;/math&gt; via un canal ionique/transporteur nommé le DMT1. La seconde absorbe la transferrine cérébrale de la même manière que le fait la barrière hémato-encéphalique. La transferrine est absorbée, le fer s'en détache, puis est convertit en ion &lt;math&gt;Fe^{2+}&lt;/math&gt;. Les astrocytes peuvent ensuite éliminer le fer en excès via un transporteur nommé la ferroportine. Les neurones font la même chose que les astrocytes, avec les mêmes canaux ioniques, les mêmes enzymes, la ferroportine en cas d'excès, etc.

La régulation du taux de fer sanguin est en partie le fait des astrocytes. Ils produisent une hormone appelée l'hepcidine, qui régule le taux de fer sanguin. L'hepcidine agit notamment sur la ferroportine, une molécule de transport du fer, qui permet au fer de rentrer dans le cerveau. L'hepcidine bloque ce transporteur, sans compter qu'il détruit les transporteurs &quot;en trop&quot; en les internalisant dans les cellules de la barrière hémato-encéphalique.

[[File:Iron BBB.jpg|centre|vignette|upright=2.5|Les différentes voies de traversée de la barrière hémato-encéphalique pour le fer. Le transport vésiculaire normal est illustré sur la cellule de droite, la voie utilisant la ferroportine est illustré sur la cellule du milieu.]]

Quelques rares maladies génétiques entrainent une  accumulation de fer dans le cerveau. Elles sont regroupées sous le nom de '''''Neurodegeneration with brain iron accumulation''''', abrévié NBIA. L'accumulation touche en priorité les ganglions de la base et se traduit donc par un syndrome parkinsonien ou d'autres mouvements anormaux (chorée, dystonies), parfois couplés à un déclin intellectuel/cognitif. Les médecins ont identifié une petite dizaine de sous-types de NBIA, chacun se distinguant des autres par le gène muté et les mécanismes de l'accumulation du fer.

{|class=&quot;wikitable&quot;
|-
!Type de NBIA
!Gène muté
|-
!Neurodégénération associée à la panthotenate-kinase (PKAN)
|PANK2
|-
!Neurodégénération associée à PLA2G6 (PLAN)
|PLA2G6
|- 
!Neurodegeneration associée aux protéines de la membrane mitochondriale (MPAN)
|C19orf12
|-
!Neurodégénération associée à la protéine Beta-Propeller (BPAN)
|WDR45
|-
!FAHN
|FA2H
|-
!Syndrome de Kufor-Rakeb
|ATP13A2
|-
!Neuroferritinopathy
|FTL
|-
!Acéruloplasminémie
|CP
|-
!Syndrome de Woodhouse-Sakati
|DCAF17
|-
!CoPAN 
|COASY
|}

: Pour ceux qui veulent en savoir plus sur les NBIA, je conseille la lecture de ce lien : [https://www.nbiadisorders.org/about-nbia/overview-of-nbia-disorders NBIA disorders association]

Mais il existe des maladies qui sont causées non pas par une accumulation de Fer dans le cerveau, mais par des dysfonctionnements plus compliqués à expliquer. L''''ataxie de Friedreich''' est une de ces maladies. Cette maladie est causée par une mutation qui perturbe la fabrication d'une enzyme, la frataxine. Le métabolisme intracellulaire du Fer est perturbé, et plus précisément le métabolisme mitochondrial. Le résultat est que les cellules des tissus fortement consommateurs d'ATP meurent rapidement, les neurones ne faisant pas exception. De plus, la gaine de myéline des neurones se dégrade et finit par disparaitre, sans être remplacée.

La maladie démarre aux alentours de l'adolescence et se manifeste principalement par des problèmes d'équilibre et de coordination des mouvements (une ataxie, qui donne son nom à la maladie). Par la suite, on observe des troubles neurologiques moteurs et sensoriels, assez divers, d'apparition progressive. Certains sont causés par une atteinte du cervelet (troubles de l’articulation, des mouvements oculaires), d'autres par une atteinte faisceau pyramidal (paralysie, faiblesse musculaire), et/ou par une atteinte de la moelle épinière.

Typiquement, le patient a du mal à marcher, perd facilement l'équilibre, a du mal à coordonner ses mouvements. Puis, le patient perd progressivement l'usage de ses bras et de ses jambes, il ressent une faiblesse musculaire envahissante. Parfois, il a du mal à articuler, ses mouvements oculaires sont erratiques. Quand sa moelle épinière et atteinte, sa sensibilité corporelle se dégrade, son sens du toucher et sa proprioception disparaissent.

Beaucoup plus rarement, les nerfs optiques et auditifs se démyélinisent, causant perte d'acuité visuelle ou auditive, cécité, surdité, etc. Précisons pour finir que la maladie ne touche pas que le cerveau, mais cause aussi des atteintes cardiaques (très fréquentes), une scoliose ou d'autres déformations osseuses, et parfois un diabète (10-20% des patients).

&lt;noinclude&gt;
{{NavChapitre | book=Neurosciences
           | prev=La barrière hémato-encéphalique
           | prevText=La barrière hémato-encéphalique
           | next=La pression intracrânienne
           | nextText=La pression intracrânienne
}}{{autocat}}
&lt;/noinclude&gt;</text>
      <sha1>nfmew6j7v43fv7bh3yghcl982g6yrg2</sha1>
    </revision>
  </page>
  <page>
    <title>Fonctionnement d'un ordinateur/Introduction</title>
    <ns>0</ns>
    <id>71086</id>
    <revision>
      <id>744100</id>
      <parentid>743981</parentid>
      <timestamp>2025-06-04T20:28:46Z</timestamp>
      <contributor>
        <username>Mewtow</username>
        <id>31375</id>
      </contributor>
      <minor />
      <comment>/* Les premières générations : des ordinateurs qui prenaient des pièces de bâtiment entières */</comment>
      <origin>744100</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="39639" sha1="jh2bob1simzeqtrl9eepd1sf47kwlad" xml:space="preserve">Pour commencer, nous allons voir qu'il existe de nombreux types d'ordinateurs. Le plus connu est certainement le PC, l'ordinateur personnel, que vous avez sans doute dans votre salon. Les ordinateurs portables sont un deuxième type d'ordinateur assez intuitif, que vous avez peut-être. Mais il y a aussi d'autres types d'ordinateurs auxquels vous n'avez jamais été confrontés.

==Les différents types d'ordinateurs==

Dans cette section, nous allons décrire rapidement les ordinateurs les plus courant, mais surtout voir ce qu'il y a à l'intérieur d'un ordinateur.

===L'ordinateur de type PC fixe===

De l'extérieur, l'ordinateur est composé d'une unité centrale sur laquelle on branche des périphériques.

[[File:Typical computer architecture systems.jpg|vignette|upright=1.5|Exemples de périphériques, connectés à une unité centrale (ici appelée à tort ''operating system'').]]

Les '''périphériques''' regroupent l'écran, la souris, le clavier, l'imprimante, et bien d'autres choses. Ils permettent à l'utilisateur d'interagir avec l'ordinateur : un clavier permet de saisir du texte sous dans un fichier, une souris enregistre des déplacements de la main en déplacement du curseur, un écran affiche des données d’images/vidéos, un haut-parleur émet du son, etc. Tout ce qui est branché sur un ordinateur est, formellement un périphérique.

L''''unité centrale''' est là où se trouvent tous les composants importants d'un ordinateur, ceux qui font des calculs, qui exécutent des logiciels, qui mémorisent vos données, etc. Voici ce à quoi ressemble l'intérieur de l'unité centrale. Trois sections sont visibles : l'alimentation électrique en haut à gauche, la carte mère en bas à gauche et en jaune/orange, les disques et lecteurs à droite des câbles. Et on voit aussi beaucoup de câbles.

[[File:Asus P5K-SEIntel E6320.jpg|centre|vignette|upright=2|Exemple d'unité centrale.]]

Tout en haut à gauche, se trouve l''''alimentation électrique''', qui convertit le courant de la prise électrique en un courant plus faible, utilisable par les autres composants. Elle émet de nombreux câbles assez gros, qui sont reliés au reste. Les PC actuels utilisent des alimentations électriques standardisées, qui fournissent trois tensions au reste de l'ordinateur : une tension de 12 Volts, une de 5 Volts, une de 3,3 Volts.

À droite, caché par la partie &quot;métallique&quot; du boitier, se trouvent les lecteurs de CD/DVD, et les disques durs. Les lecteurs CD-ROM ou DVD-ROM permettaient de lire des CD ou des DVD. Je parle au passé, car ils ont aujourd'hui disparu des ordinateurs modernes. Les '''disques durs''' sont des mémoires de stockage, qui mémorisent vos données de manière permanente. De nos jours, ils sont remplacés par des SSD, qui sont des disques durs électroniques, là où les disques durs proprement dit sont des mémoires magnétiques. Nous verrons la différence dans deux chapitres dédiés, un sur les disques durs, l'autre sur les SSD.

En bas à droite, se trouve la '''carte mère''' un support plat, en plastique ou en céramique, sur laquelle sont soudés/connectés les autres composants. Sur celle-ci, de nombreux composants sont soudés, d'autres sont branchés dessus avec des câbles, d'autres sont connectés dessus avec des connecteurs. Ils sont reliés entre eux par des fils conducteurs, le plus souvent du cuivre ou de l’aluminium, ce qui leur permet de s’échanger des données. Sur les cartes simples, ces fils sont intégrés dans la carte électronique, dans des creux du plastique. Ils portent le nom de pistes.

Avant, les disques durs, SSD et lecteurs de CD/DVD sont branchés dessus via des connecteurs dédiés, appelés des connecteurs S-ATA. De nos jours, ils sont branchés sur un autre connecteur, grâce à l'interface NVME. Toujours est-il qu'ils sont reliés à la carte mère par des câbles, ce qui montre que ce sont des sortes de périphériques interne. Ils sont placés dans le boitier, mais on aurait tout aussi bien pu les mettre à l'extérieur, vu qu'ils communiquent avec l'ordinateur par l'intermédiaire d'un câble ou d'un connecteur dédié.

Mais deux autres composants très importants sont eux placés sur la carte mère, directement. Ils ont chacun un connecteur dédié, sur lequel ils sont branchés directement, sans passer par l'intermédiaire d'un câble, mais sans être soudés non plus. Il s'agit du processeur et de la mémoire RAM, deux composants centraux des PC modernes.

[[File:Pentium III SL4CB.jpg|thumb|Processeur Pentium III.]]

Le '''processeur''' traite les données, les modifie, les manipule. Pour faire simple, il s’agit d’une grosse calculatrice hyper-puissante. Il comprend à la fois un circuit qui fait des calculs, et un circuit de contrôle qui s'occupe de séquencer les calculs dans l'ordre demandé. Il est souvent caché sous un radiateur, lui-même surmonté par un ventilateur. En effet, un processeur chauffe beaucoup, ce qui demande d'évacuer cette chaleur. Un chapitre entier expliquera pourquoi les processeurs chauffent, ainsi que les techniques utilisées pour limiter leur production de chaleur et leur consommation électrique.

La '''mémoire vive''' conserve des informations/données temporairement, tant que le processeur en a besoin. Elle prend la forme de barrettes de RAM, comme montré ci-dessous.

[[File:2 gb ddr2 667.jpg|centre|vignette|upright=2|Barrette de RAM.]]

Outre ces composants dits principaux, un ordinateur peut comprendre plusieurs composants moins importants, surtout présents sur les ordinateurs personnels. Ils sont techniquement facultatifs, mais sont très présents dans les ordinateurs personnels. Cependant, certains ordinateurs spécialisés s'en passent. Il s'agit des diverses '''cartes d'extension''' sont branchées sur la carte mère. Elles permettent d’accélérer certains calculs ou certaines applications, afin de décharger le processeur. Par exemple, la carte graphique s'occupe des calculs graphiques, qu'il s'agisse de graphismes 3D de jeux vidéos ou de l'affichage en 2D du bureau. Dans un autre registre, la carte son prend en charge le microphone et les haut-parleurs.

[[Fichier:Personal computer, exploded 4.svg|thumb|upright=1.0|Éclaté d'un ordinateur de type PC :&lt;br /&gt;
1 : Écran ;&lt;br /&gt;
2 : Carte mère ;&lt;br /&gt;
3 : Processeur ;&lt;br /&gt;
4 : Câble Parallel ATA ;&lt;br /&gt;
5 : Mémoire vive (RAM) ;&lt;br /&gt;
6 : Carte d'extension ;&lt;br /&gt;
7 : Alimentation électrique ;&lt;br /&gt;
8 : Lecteur de disque optique ;&lt;br /&gt;
9 : Disque dur ;&lt;br /&gt;
10 : Clavier ;&lt;br /&gt;
11 : Souris.]]

Si on regarde une carte mère de face, on voit un grand nombre de connecteurs, mais aussi des circuits électroniques soudés à la carte mère.

[[File:Architecture matérielle d'une carte mère.png|centre|vignette|upright=2.0|Architecture matérielle d'une carte mère]]

Les '''connecteurs''' sont là où on branche les périphériques, la carte graphique, le processeur, la mémoire, etc. Dans l'ensemble, toute carte mère contient les connecteurs suivants :
* Le processeur vient s’enchâsser dans la carte mère sur un connecteur particulier : le '''socket'''. Celui-ci varie suivant la carte mère et le processeur, ce qui est source d'incompatibilités.
* Les barrettes de mémoire RAM s’enchâssent dans un autre type de connecteurs: les '''slots mémoire'''.
* Les mémoires de masse disposent de leurs propres connecteurs : connecteurs P-ATA pour les anciens disques durs, et S-ATA pour les récents.
* Les périphériques (clavier, souris, USB, Firewire, ...) sont connectés sur un ensemble de connecteurs dédiés, localisés à l'arrière du boitier de l'unité centrale. 
* Les autres périphériques sont placés dans l'unité centrale et sont connectés via des connecteurs spécialisés. Ces périphériques sont des cartes imprimées, d'où leur nom de '''cartes filles'''. On peut notamment citer les cartes réseau, les cartes son, ou les cartes vidéo.

===Les ordinateurs portables===

[[File:Samsung QX-511 (2).JPG|vignette|Ordinateur portable Samsung QX-511 (2), pour illustration.]]

Un ordinateur portable est identique à un ordinateur de type PC. Si vous ouvrez votre ordinateur portable (attention à la garantie), vous retrouverez les mêmes composants qu'un PC à l'intérieur. Un point important est la présence d'une batterie à l'intérieur du PC portable, absente des PC fixes.

[[File:LG gram 14Z90Q mainboard with battery.jpg|centre|vignette|upright=2|LG gram 14Z90Q avec sa batterie.]]

Une fois la batterie et les circuits associés retiré, la seule différence notable est que tous les composants sont soudés sur la carte mère, au lieu d'être branchés sur des connecteurs, à part éventuellement la RAM et le disque dur.

[[File:LG gram 14Z90Q mainboard without battery.jpg|centre|vignette|upright=2|LG gram 14Z90Q sans sa batterie.]]

La RAM est parfois soudée sur la carte mère, d'autres fois sous la forme de barrettes de mémoire vive semblables à celles des PC. Dans le dernier cas, elle est connectée à des connecteurs spécifiques, ce qui permet de les changer/upgrader. Les PC portables sont parfois construits de manière à pouvoir changer la RAM facilement, en ouvrant un cache spécial, concu pour.

[[File:Lenovo G555 состав - Донор.JPG|centre|vignette|upright=2|Lenovo G555.]]

La conception d'un ordinateur portable est légèrement différente de celle d'un PC, pour des raisons thermiques. Un PC fixe a plus de place pour évacuer sa chaleur. Les ventilateurs peuvent plus facilement déplacer l'air dans le boitier, même si le flux d'air dans le boitier est éventuellement gêné par la carte graphique. Mais l'évacuation de la chaleur est assez efficace. Sur les PC portables, leur finesse fait que le trajet de l'air est beaucoup plus contraint. Évacuer la chaleur produite par l'ordinateur est plus complexe, ce qui demande d'utiliser des systèmes de refroidissement et de ventilation spécifiques.

Là où les PC fixes se débrouillent avec des radiateurs et des ventilateurs posés sur le processeur, les PC portables font autrement. Ils ne peuvent pas forcément mettre le ventilateur sur le processeur. A la place, ils mettent le ventilateur à côté, mais le processeur est surmonté par un mécanisme de transmission de la chaleur, qui transfère la chaleur du processeur vers le ventilateur.

[[File:Diagram - How a laptop cooling system works.png|centre|vignette|upright=2|Comment fonctionne le système de ventilation d'un ordinateur portable, en anglais.]]

Les difficultés pour dissiper la chaleur font que les ordinateurs portables utilisent souvent des composants peu performants, mais qui chauffent peu. En effet, nous verrons que plus un composant est puissant, plus il chauffe. La relation n'est pas parfaite, mais les processeurs haute performance chauffent plus que les modèles d'entrée ou milieu de gamme moins puissants. En conséquence, les PC portables sont souvent moins puissants que les PC fixes, même pour les modèles dit ''gaming''.

===Les serveurs et ''mainframes''===

Les grandes entreprises utilisent des ordinateurs de grande taille, très puissants, appelés des ''mainframes''. Ils sont souvent confondus avec les serveurs par le grand public, il y a une différence entre les deux. Un serveur est une fonction logicielle/réseau, pas un type d'ordinateur. Mais laissons cette différence de côté, ce qui est dit pour les ''mainframes'' sert pour les gros serveurs haute performance.

[[File:IBM Z15 mainframe.jpg|vignette|Exemple de ''mainframe''' de type IBM Z15.]]

Les anciens ''mainframes'' des années 50-80 avaient une taille pouvant être impressionnante, au point de prendre une pièce complète d'un bâtiment. Mais de nos jours, les ''mainframes'' tiennent dans une grosse armoire un peu haute. Les ''mainframes'' doivent rester allumé en permanence et ne doivent pas être éteint, sauf éventuellement quelques jours par an pour des opérations de maintenance. Ils utilisent pour cela des techniques spécifiques, avec beaucoup de redondance interne.

[[File:ACONIT hall grandes machines.jpg|centre|vignette|upright=2|''Mainframe'' ACONIT.]]

Les ''mainframes'' sont aussi conçus pour mutualiser au maximum leur utilisation, ils peuvent être utilisés par plusieurs utilisateurs à la suite, voire en même temps. Pour cela, les anciens ''mainframes'' étaient capables de faire tourner plusieurs applications distinctes l'une à la suite de l'autre, avec des commutations fréquentes entre logiciels. De nos jours, ils sont capables d'exécuter un grand nombre de tâches en même temps, grâce à la présence de plusieurs processeurs. Les ''mainframes'' modernes sont même capables de faire tourner plusieurs systèmes d'exploitation en même temps si besoin.

Les anciens ''mainframes'' étaient des ordinateurs assez simples, avec un processeur, de la mémoire RAM, un ou plusieurs disques durs, pas plus. Le ''mainframe'' était tellement énorme et cher que les entreprises n'en avaient qu'un seul pour toute l'entreprise. Les employés avaient sur leur bureau des terminaux, qui permettaient d'accéder à l'ordinateur central, mais n'étaient pas des ordinateurs. Les terminaux étaient des composants électroniques simples, avec un écran, un clavier et une souris, mais sans processeur. Ils envoyaient des données au ''mainframe'', ils en recevaient de sa part, mais tout traitement était réalisé sur le ''mainframe''. L'arrivée sur le marché des ordinateurs personnels, de type PC fixe/portable, a entrainé l'abandon de ce genre de pratique, tous les employés ont maintenant un ordinateur rien que pour eux.

{|
|-
! colspan=&quot;2&quot; | Exemples de terminaux
|-
|[[File:Terminal-in2-sm9400.jpg|centre|vignette|upright=1.5|Exemple de terminal. Notez la présence d'un écran et d'un clavier, mais l'asbence d'une unité centrale.]]
|[[File:Chromatics CT4100.jpg|vignette|upright=1.5|Autre exemple de terminal. Le clavier est couplé à un stylo CRT, qui remplacait la souris et agissait sur l'écran comme s'il était tactile.]]
|-
! colspan=&quot;2&quot; | Intérieur d'un terminal
|-
|[[File:CT1024 Monitor.jpg|vignette|upright=1.5|Terminal CT1024, sans le boitier extérieur.]]
|[[File:CT1024 Terminal System.jpg|vignette|upright=1.5|Terminal CT1024, description des composants interne.]]
|}

De nos jours, les ''mainframes'' contiennent en réalité plusieurs ordinateurs simples interconnectés via un réseau local. Un ''mainframe'' qui tient dans une armoire contient facilement une dizaine ou centaine de processeurs, plein de RAM, des disques durs séparés dans une armoire distincte, etc. Vu qu'ils communiquent uniquement via le réseau, ils n'ont pas d'interface, pas d'écran, 'entrée via clavier/souris. Le tout est commandé avec une console de commande, typiquement un ordinateur portable ou un terminal assez simple séparé de l'armoire, qui permet à un administrateur de faire des opérations de surveillance, configuration et maintenance. Il peut y avoir une console de commande pour plusieurs armoires séparées, la console peut même être dans un autre bâtiment et accéder au ''mainframe'' par le réseau.

[[File:IBM System Z9 (type 2094 inside).jpg|centre|vignette|upright=2|''Mainframe'' de type IBM System Z9. L'ordinateur portable sert de console pour qu'un administrateur fasse des opérations de surveillance, configuration et maintenance.]]

Les processeurs et la RAM sont typiquement installés sur des cartes amovibles, qui sont connectées au fond de l'armoire lors de l'installation. Il est même possible de retirer ou d'ajouter des cartes en fonctionnement, afin d'ajouter/retirer des processeurs, des disques durs, etc. Ce qui est très utile si un composant est en panne et qu'il faut le remplacer. 

[[File:IBM TotalStorage Exp400.jpg|centre|vignette|upright=2|IBM TotalStorage Exp400]]

==Un peu d'abstraction : qu'est-ce qu'un ordinateur ?==

Un ordinateur comprend donc un processeur, plusieurs mémoires, des cartes d'extension et une carte mère pour connecter le tout. Mais il s'agit là d'une description assez terre-à-terre de ce qu'est un ordinateur. Une autre description, plus abstraite, se base sur le fait qu'un ordinateur est une énorme calculatrice programmable. Elle permet d'expliquer pourquoi il y a une distinction entre processeur et mémoire, entre unité centrale et périphériques. Tout ce qui va suivre pourra vous paraitre assez abstrait, mais rassurez-vous : les prochains chapitres rendront tout cela plus concrets.

===La séparation entre entrées-sorties et traitement===

L'unité centrale peut être vue comme une énorme calculatrice ultra-puissante, qui exécute des commandes/opérations. Mais à elle seule, elle ne servirait à rien, il faut interagir avec par l'intermédiaire de plusieurs périphériques. Il existe deux types de périphériques, qui sont conceptuellement différents. Les périphériques comme le clavier ou la souris permettent d'envoyer des informations à l'ordinateur, d'agir sur celui-ci. A l'inverse, les écrans transmettent des informations dans le sens inverse : de l'ordinateur vers l'utilisateur. Les premiers sont appelés des '''entrées''', les seconds des '''sorties'''.

Dans un ordinateur, les informations sont représentées sous la forme de nombres. Toute donnée dans un ordinateur est codée avec un ou plusieurs nombres regroupés dans une donnée, un fichier, ou autre. Et la transmissions avec les entrées et sorties se fait là-encore avec des nombres. Par exemple, quand vous appuyez sur votre clavier, le clavier envoie un numéro de touche à l'unité centrale, qui indique quelle touche a été appuyée. L'image à afficher à l'écran est codée sous la forme d'une suite de nombres (un par pixel). L'image est envoyée à l'écran, qui traduit la suite de nombre en image à afficher. Les entrées traduisent des actions utilisateurs en nombres, on dit que les entrées encodent les actions utilisateur. Les sorties font la traduction inverse, elles transforment des suites de nombres en une action physique. On dit qu'elles décodent des informations.

Pour résumer, toute appareil électronique est composé par :
* Des '''entrées''' sur lesquelles l'utilisateur agit sur l'ordinateur. Les entrées transforment les actions de l'utilisateur en nombres, qui sont interprétés par l'ordinateur.
* Une '''unité de traitement''', qui manipule des nombres et fait des calculs/opérations dessus. Les nombres proviennent des entrées, du disque dur, ou d'autres sources, peu importe.
* Des '''sorties''', qui va récupèrent le résultat calculé par l'unité de traitement pour en faire quelque chose : écrire sur une imprimante ou sur un moniteur, émettre du son,...

[[File:Ordinateur théorique Simple 1.png|centre|vignette|upright=2|Ordinateur théorique Simple 1]]

L'unité de traitement proprement dite, celle qui fait les calculs, est couplée à une mémoire qui mémorise les opérandes et résultats des calculs. La séparation entre processeur et mémoire est nécessaire pour qu'un appareil électronique soit qualifié d'ordinateur. De nombreux appareils n'ont pas de séparation entre unité de traitement et mémoire, comme certaines vielles radios AM/FM.

[[File:Schéma de principe d'un ordinateur.png|centre|vignette|upright=2|Schéma de principe d'un ordinateur]]

===Un ordinateur est un appareil programmable===

Les appareils simples sont non-programmables, ce qui veut dire qu’ils sont conçus pour une utilisation particulière et qu’ils ne peuvent pas faire autre chose. Par exemple, les circuits électroniques d’un lecteur de DVD ne peuvent pas être transformé en lecteur audio ou en console de jeux... Les circuits non-programmables sont câblés une bonne fois pour toute, et on ne peut pas les modifier. On peut parfois reconfigurer le circuit, pour faire varier certains paramètres, via des interrupteurs ou des boutons, mais cela s’arrête là. Et cela pose un problème : à chaque problème qu'on veut résoudre en utilisant un automate, on doit recréer un nouveau circuit.

À l'inverse, un ordinateur n’est pas conçu pour une utilisation particulière, contrairement aux autres objets techniques. Il est possible de modifier leur fonction du jour au lendemain, on peut lui faire faire ce qu’on veut. On dit qu'ils sont '''programmables'''. Pour cela, il suffit d’utiliser un logiciel, une application, un programme (ces termes sont synonymes), qui fait ce que l'on souhaite. La totalité des logiciels présents sur un ordinateur sont des programmes comme les autres, même le système d'exploitation (Windows, Linux, ...) ne fait pas exception.

Un programme est une suite de d'instructions, chaque instruction effectuant une action dans l'ordinateur. Sur les ordinateurs modernes, la majorité de ces instructions effectuent une opération arithmétique, comme une addition, une multiplication, une soustraction, etc. Les ordinateurs modernes sont donc de grosses calculettes très puissantes, capables d'effectuer des millions d'opérations par secondes. Et qui dit opération dit nombres : un ordinateur gère nativement des nombres, qui sont codés en binaire sur la quasi-totalité des ordinateurs modernes.

Une instruction est représentée dans un ordinateur par une série de nombres : un nombre qui indique quelle opération/commande effectuer et des autres nombres pour coder les données (ou de quoi les retrouver dans l'ordinateur). L'ordinateur récupére les commandes une par une, les traduit en opération à effectuer, exécuter l'opération, et enregistre le résultat. Puis il recommence avec la commande suivante.

[[File:Ordinateur Théorique Complexe 1.png|centre|vignette|upright=3|Ordinateur Théorique Complexe. En jaune, le programme informatique, la liste de commande. Le rectangle gris est l'ordinateur proprement dit.]]

De nombreux appareils sont programmables, mais tous ne sont pas des ordinateurs. Par exemple, certains circuits programmables nommés FPGA n'en sont pas. Pour être qualifié d'ordinateur, un appareil programmable doit avoir un processeur séparé de la mémoire. De plus, il doit utiliser un '''codage numérique''', chose que nous allons aborder dans le chapitre suivant.

===Les ordinateurs à programme mémorisé ou programme externe===

Au tout début de l'informatique, on utilisait des cartes perforées en plastique, sur lesquelles on inscrivait le programme à exécuter, les données à traiter, bref : tout ce qu'on donnait à manger à l'ordinateur. Par la suite, les premiers ordinateurs grand public, comme les Amstrad ou les Commodore, utilisaient des cassettes audio magnétiques pour stocker les programmes. Dans le même style, les consoles de jeu utilisaient autrefois des cartouches de jeu, qui contenaient le programme du jeu à exécuter. Pour résumer, les anciens ordinateurs mémorisaient les programmes sur un support externe, lu par un périphérique. De tels ordinateurs sont dits à '''programme externe'''.

: D’anciens ordinateurs personnels, comme l’Amstrad ou le Commodore, permettaient de taper les programmes à exécuter à la main, au clavier, avant d’appuyer une touche pour les exécuter. Nul besoin de vous dire que les cassettes audio étaient plus pratiques.

Mais de nos jours, les programmes sont enregistrés sur le disque dur de l'ordinateur ou dans une mémoire intégrée à l'ordinateur. On dit qu'ils sont installés, ce qui est un mot bien compliqué pour dire que le programme est enregistré sur le disque dur de l’ordinateur. A défaut de disque dur, le programme/logiciel est enregistré dans une mémoire spécialisée pour le stockage. Par exemple, sur les cartes électroniques grand public de marque Arduino, les programmes sont envoyés à la carte via le port USB, mais les programmes sont enregistrés dans la carte Arduino, dans une mémoire FLASH dédiée. Disque dur ou non, le programme est mémorisé dans la mémoire de l'ordinateur. Il est possible d'installer ou de désinstaller les programmes en modifiant le contenu de la mémoire. Le terme utilisé est alors celui de '''programme stocké en mémoire'''.

Les programmes à installer sont disponibles soit sur un périphérique, comme un DVD ou une clé USB, soit sont téléchargés depuis internet. Les premiers PC fournissaient les logiciels sur des disquettes, qui contenaient un programme d'installation pour enregistrer le programme sur le disque dur de l'ordinateur. Par la suite, le support des logiciels a migré vers les CD et DVD, les logiciels devenant de plus en plus gros. De nos jours, la majorité des applications sont téléchargées depuis le net, l'usage de périphériques est devenu obsolète, même les consoles de jeu abandonnent cette méthode de distribution.

==Les générations d'ordinateurs : un historique rapide==

L'informatique a beaucoup évolué dans le temps. Et une bonne partie de cette évolution tient à l'évolution de l’électronique sous-jacente. Les ordinateurs actuels sont fabriqués avec des transistors, des petits composants électroniques qui servent d'interrupteur programmables, qu'on détaillera dans ce qui suit. Mais ça n'a pas toujours été le cas. Et cela permet de distinguer plusieurs '''générations d'ordinateurs'''.

===Les premières générations : des ordinateurs qui prenaient des pièces de bâtiment entières===

La '''première génération d'ordinateur''' est celle des ordinateurs datant d'avant l'invention du transistor. Ils étaient conçus avec des tubes à vide ou des relais, des composants électroniques assez rudimentaires. Les ordinateurs de première génération étaient très simples, ils ne géraient que quelques opérations simples : l'addition, la soustraction, pas grand chose de plus. A quelques exceptions près, ils ne géraient pas la multiplication et encore moins la division, ils n'avaient pas assez de relais ou de tubes à vides à disposition pour cela.

Le tout premier ordinateur est le Z1, un modèle unique inventé par Konrad Suze entre 1936 et 1938. Le processeur du Z1 gérait non pas des nombres entiers, mais des nombres à virgule (des nombres dits flottants, pour être précis). Les nombres en question étaient encodés sur 22 bits, ce dont les informaticiens n'ont plus l'habitude. Le processeur du Z1 était capable de faire des additions et des soustractions, car il intégrait un circuit additionneur-soustracteur basique. Des circuits annexes permettaient de faire des multiplications et des divisions en enchainant des additions/soustractions successives. Il fonctionnait à une fréquence de 1 Hz, ce qui fait qu'il pouvait faire une addition/soustraction par seconde maximum.

Niveau mémoire, la RAM de l'ordinateur était très limitée : seulement 16 nombres de 22 bits chacun. Les programmes étaient enregistrés sur des cartes perforées, à savoir des cartes en papier dans lesquelles un 1 est codé par un trou dans le papier et un 0 par une absence de trou. Les programmes étaient exécutés par l'ordinateur quand on insérait la carte perforée dans le lecteur et qu'on appuyait sur un bouton.

[[File:CartePerforée.jpg|centre|vignette|upright=2|Carte Perforée.]]

[[File:IBM 7070.jpg|vignette|Cartes imprimées de l'IBM 704, avec des transistors et résistances dessus.]]

La '''seconde génération''' est celle des ordinateurs fabriqués avec des '''transistors''' isolés, reliés entre avec des fils électriques. Les transistors en question possèdent trois broches, des pattes métalliques sur lesquelles on connecte des fils électriques. Le transistor s'utilise le plus souvent comme un interrupteur commandé par sa troisième broche. Le courant qui traverse les deux premières broches passe ou ne passe pas selon ce qu'on met sur la troisième.

[[File:Transistor basic flow.svg|centre|vignette|Un transistor est un morceau de conducteur, dont la conductivité est contrôlée par sa troisième broche/borne.]]

Les ordinateurs de seconde génération avaient entre 1000 et 500 000 transistors. Les capacités des ordinateurs étaient donc nettement supérieures à celles des ordinateurs de première génération. Une part non négligeable des ordinateurs de seconde génération supportait l'opération de multiplication, absente sur les ordinateurs de première génération. Néanmoins, cela variait beaucoup selon les ordinateurs.

Un exemple assez hors du commun est celui du premier modèle de l'IBM 1620. Le tout premier modèle n'avait aucun circuit de calcul, il n'était même pas capable de faire une addition ou une multiplication. A la place, il utilisait une table d'addition et une table de multiplication en mémoire RAM. Les deux tables devaient être initialisées par le logiciel lors du démarrage de la machine. La table d'addition faisait une centaine de chiffre, la table de multiplication faisait le double. Le processeur de l'ordinateur gérait des instructions pour faire des additions ou des multiplications, mais ces opérations lisaient le résultat dans la table d'addition. Les calculs étaient fait chiffre par chiffre, avec un encodage partiellement décimal, partiellement binaire (des chiffres décimaux étaient encodés en binaire, nous en reparlerons quand nous parlerons du BCD) !

[[File:KL CoreMemory.jpg|vignette|Mémoire à tore de ferrite.]]

Les transistors n'étaient utilisés que pour le processeur et les circuits annexes. La mémoire n'était pas faite en transistors, pas à cette époque. La mémoire était une mémoire aujourd'hui abandonnée, appelée une '''mémoire à tores de ferrite'''. Elle sera détaillée dans un chapitre ultérieur. Mais sachez pour le moment qu'il s'agit d'une mémoire au support magnétique, les données étant stockées sur un support magnétique.

Transistors comme tubes à vide prenaient beaucoup de place, ce qui fait que les ordinateurs étaient assez gros. Concrètement, ils prenaient une pièce de bâtiment entière dans le meilleur des cas. C'était l'époque des gros ''mainframes'', reliés à des terminaux, peu puissants comparé aux standards actuels. Seules les grandes entreprises et les grands instituts de recherche pouvaient se payer les services de ce genre d'ordinateurs. Seuls les professionnels avaient accès à ce genre d'équipement.

===La troisième génération : le circuit intégré===

[[File:D8259AC-2.jpg|vignette|Exemple de circuit intégré.]]

La troisième génération est toujours fabriquée avec des transistors, mais dont la taille a été réduite. Avec l'évolution de la technologie, les transistors ont diminué en taille, de plus en plus. Ils sont devenus tellement petits qu'ils ont finit par être regroupés dans des '''circuits intégrés''', des circuits regroupent plusieurs transistors sur la même puce de silicium. Les circuits intégrés se présentent le plus souvent sous la forme de boitiers rectangulaires, comme illustré ci-contre. D'autres ont des boitiers de forme carrées, comme ceux que l'on peut trouver sur les barrettes de mémoire RAM, ou à l'intérieur des clés USB/ disques SSD.

Lors de cette génération, les processeurs étaient fournis en pièces détachées qu'il fallait relier entre elles. Le processeur était composé de plusieurs circuits intégrés séparés, impossible de mettre un processeur dans un seul boitier. Un exemple de processeur conçu en kit est la série des Intel 3000. Elle regroupe plusieurs circuits séparés aux noms à coucher dehors, mais dont vous comprendrez ce qu'ils veulent dire dans les chapitres adéquats : l'Intel 3001 est un séquenceur, l'Intel 3002 regroupe unité de calcul et registres, le 3003 est un circuit d'anticipation de retenue complémentaire du 3002, le 3212 est une mémoire tampon, le 3214 est une unité de gestion des interruptions, les 3216/3226 sont des interfaces de bus mémoire. On pourrait aussi citer la famille de circuits intégrés AMD Am2900.

Même si le processeur était en pièce détachées, utiliser une dizaine de circuits intégrés était nettement mieux que d'utiliser plusieurs milliers de transistors individuels. En conséquence, les ordinateurs ont vu leur taille grandement réduite, passant de pièces entières à une simple armoire, voire à quelques cartes intégrées superposées. De plus, le prix des circuits intégré était abordable, du moins comparé aux ordinateurs d'avant. Le prix des ordinateurs a alors grandement décru, permettant à des entreprises et administrations de taille modeste de s'équiper d'ordinateurs.

===La quatrième génération : le microprocesseur===

[[File:MOS6502.svg|vignette|Microprocesseur, ici un processeur MOS6502, de la quatrième génération.]]

Lors de la troisième génération, les circuits intégrés regroupaient plusieurs dizaines ou centaines de transistors, mais sont rapidement montés en gamme. De centaines de transistors, ils sont passé au milliers de transistors, puis au millions et maintenant au-delà du milliard. Les transistors étaient devenus tellement petits, tellement miniaturisés, qu'il était devenu possible de mettre un processeur entier dans un circuit intégré. C'est ainsi qu'est né le microprocesseur, à savoir un processeur qui tient tout entier dans un seul circuit imprimé. La quatrième génération d’ordinateur est celle des ordinateurs basés autour d'un microprocesseur.

Les tout premiers microprocesseurs étaient des processeurs à application militaire, comme le processeur du F-14 CADC ou celui de l'Air data computer. Le tout premier microprocesseur commercialisé au grand public est le 4004 d'Intel, sorti en 1971. L'intel 4004 comprenait environ 2300 transistors, avait une fréquence de 740 MHz, pouvait faire 46 opérations différentes, et manipulait des entiers de 4 bits. Il était au départ un processeur de commande, prévu pour être intégré dans la calculatrice Busicom calculator 141-P, mais il fut utilisé pour d'autres applications quelque temps plus tard. Immédiatement après le 4004, les premiers microprocesseurs 8 bits furent commercialisés. Le 4004 fut suivi par le 8008 et quelques autres processeurs 8 bits extrêmement connus, comme le 8080 d'Intel, le 68000 de Motorola, le 6502 ou le Z80.

Les microprocesseurs permirent encore uen fois de réduire la taille des ordinateurs, qui pouvaient tenir dans un boitier de PC, ou un boitier de console de jeu. Le prix des ordinateurs a aussi chuté en même temps que les transistors était miniaturisés. C'est cette invention qui permis l'invention des consoles de jeux et des mini-ordinateurs, à savoir les ordinateurs personnels. Sans miniaturisation, on n'aurait pas d'ordinateur personnel, pas de PC fixe ou portable.

==L'organisation du cours : les différents niveaux d'explication==

Le fonctionnement d'un ordinateur est assez complexe à expliquer car les explications peuvent se faire sur plusieurs niveaux. Par plusieurs niveaux, on veut dire qu'un ordinateur est composé de composants très simples, qui sont assemblés pour donner des composants eux-même plus complexes, qui sont eux-même regrouper, etc. Étudier tout cela demande de voir plusieurs niveaux, allant de transistors très petits à des processeurs multicœurs. Les niveaux les plus bas sont de l'électronique pur et dure, alors que ceux plus haut sont à mi-chemin entre électronique et informatique.

===Les niveaux d'abstraction en architecture des ordinateurs===

Les trois premiers niveaux sont de l'électronique pur et dure. Ils correspondent aux premiers chapitres du cours, qui porteront sur les circuits électroniques en général.
* Le premier niveau est celui des '''transistors''', des circuits intégrés, des ''wafer'' et autres circuits de très petite taille.
* Le second niveau est celui des '''portes logiques''', des circuits très basiques, très simples, à la base de tous les autres.
* Le troisième niveau est celui dit de la '''''Register Transfer Level''''', où un circuit électronique est construit à partir de circuits basiques, dont des registres et autres circuits dits combinatoires.
Les deux niveaux suivants sont de l'informatique proprement dit. C'est dans ces deux niveaux qu'on étudie les ordinateurs proprement dit, les circuits qu'il y a dedans et non l'électronique en général.
* Le quatrième niveau est celui de la '''microarchitecture''', qui étudie ce qu'il y a à l'intérieur d'un processeur, d'une mémoire, des périphériques et autres.
* Le cinquième niveau est celui de l''''architecture externe''', qui décrit l'interface du processeur, de la mémoire, d'un périphérique ou autre. Par décrire l'interface, on veut dire : comment un programmeur voit le processeur et la mémoire, comment il peut les manipuler. Une architecture externe unique peut avoir plusieurs microarchitecture, ce qui fait qu'on sépare les deux. Tout cela sera plus clair quand on passera aux chapitres sur le processeur et les mémoires.

Nous n'allons pas voir les 5 niveaux dans l'ordre, des transistors vers l'architecture externe. En réalité, nous allons procéder autrement. La première partie du cours portera sur les trois premiers niveaux, le reste sur les deux autres. Les 5 niveaux seront vus dans des chapitres séparés, du moins le plus possible. Au niveau pédagogique, tout est plus simple si on scinde les 5 niveaux. Bien sûr, il y a quelques explications qui demandent de voir plusieurs niveaux à la fois. Par exemple, dans le chapitre sur les mémoires caches, nous auront des explications portant sur la RTL, la microarchitecture du cache et son architecture externe. Mais le gros du cours tentera de séparer le plus possible les 5 niveaux.

===Les trois parties principales du cours===

Nous allons commencer par parler du binaire, avant de voir les portes logiques. Avec ces portes logiques, nous allons voir comment fabriquer des circuits basiques qui reviendront très souvent dans la suite du cours. Nous verrons les registres, les décodeurs, les additionneurs et plein d'autres circuits. Puis, nous reviendrons au niveau des transistors pour finir la première partie. La raison est que c'est plus simple de faire comme cela. Tout ce qui a trait aux transistors sert à expliquer comment fabriquer des portes logiques, et il faut expliquer les portes logiques pour voir le niveau de la RTL.

Une fois la première partie finie, nous allons voir les différents composants d'un ordinateur. Une première partie expliquera ce qu'il y a dans un ordinateur, quels sont ses composants. Nous y parlerons de l'architecture de base, de la hiérarchie mémoire, des tendances technologiques, et d'autres généralités qui serviront de base pour la suite. Puis, nous verrons dans l'ordre les bus électroniques, les mémoires RAM/ROM, le processeur, les périphériques, les mémoires de stockage (SSD et disques durs) et les mémoires caches. Pour chaque composant, nous allons voir leur architecture externe, avant de voir leur microarchitecture. La raison est que la microarchitecture ne peut se comprendre que quand on sait quelle architecture externe elle implémente.

Enfin, dans une troisième partie, nous allons voir les optimisations majeures présentes dans tous les ordinateurs modernes, avec une partie sur le pipeline et le parallélisme d'instruction, et une autre sur les architectures parallèles. Pour finir, les annexes de fin parlerons de sujets un peu à part.

&lt;noinclude&gt;
{{NavChapitre | book=Fonctionnement d'un ordinateur
           | next=L'encodage des données
           | nextText=L'encodage des données
}}
&lt;/noinclude&gt;</text>
      <sha1>jh2bob1simzeqtrl9eepd1sf47kwlad</sha1>
    </revision>
    <revision>
      <id>744101</id>
      <parentid>744100</parentid>
      <timestamp>2025-06-04T20:37:27Z</timestamp>
      <contributor>
        <username>Mewtow</username>
        <id>31375</id>
      </contributor>
      <minor />
      <comment>/* Les premières générations : des ordinateurs qui prenaient des pièces de bâtiment entières */</comment>
      <origin>744101</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="40469" sha1="0x87lmmo49lp19392ti0gjo536gqnf5" xml:space="preserve">Pour commencer, nous allons voir qu'il existe de nombreux types d'ordinateurs. Le plus connu est certainement le PC, l'ordinateur personnel, que vous avez sans doute dans votre salon. Les ordinateurs portables sont un deuxième type d'ordinateur assez intuitif, que vous avez peut-être. Mais il y a aussi d'autres types d'ordinateurs auxquels vous n'avez jamais été confrontés.

==Les différents types d'ordinateurs==

Dans cette section, nous allons décrire rapidement les ordinateurs les plus courant, mais surtout voir ce qu'il y a à l'intérieur d'un ordinateur.

===L'ordinateur de type PC fixe===

De l'extérieur, l'ordinateur est composé d'une unité centrale sur laquelle on branche des périphériques.

[[File:Typical computer architecture systems.jpg|vignette|upright=1.5|Exemples de périphériques, connectés à une unité centrale (ici appelée à tort ''operating system'').]]

Les '''périphériques''' regroupent l'écran, la souris, le clavier, l'imprimante, et bien d'autres choses. Ils permettent à l'utilisateur d'interagir avec l'ordinateur : un clavier permet de saisir du texte sous dans un fichier, une souris enregistre des déplacements de la main en déplacement du curseur, un écran affiche des données d’images/vidéos, un haut-parleur émet du son, etc. Tout ce qui est branché sur un ordinateur est, formellement un périphérique.

L''''unité centrale''' est là où se trouvent tous les composants importants d'un ordinateur, ceux qui font des calculs, qui exécutent des logiciels, qui mémorisent vos données, etc. Voici ce à quoi ressemble l'intérieur de l'unité centrale. Trois sections sont visibles : l'alimentation électrique en haut à gauche, la carte mère en bas à gauche et en jaune/orange, les disques et lecteurs à droite des câbles. Et on voit aussi beaucoup de câbles.

[[File:Asus P5K-SEIntel E6320.jpg|centre|vignette|upright=2|Exemple d'unité centrale.]]

Tout en haut à gauche, se trouve l''''alimentation électrique''', qui convertit le courant de la prise électrique en un courant plus faible, utilisable par les autres composants. Elle émet de nombreux câbles assez gros, qui sont reliés au reste. Les PC actuels utilisent des alimentations électriques standardisées, qui fournissent trois tensions au reste de l'ordinateur : une tension de 12 Volts, une de 5 Volts, une de 3,3 Volts.

À droite, caché par la partie &quot;métallique&quot; du boitier, se trouvent les lecteurs de CD/DVD, et les disques durs. Les lecteurs CD-ROM ou DVD-ROM permettaient de lire des CD ou des DVD. Je parle au passé, car ils ont aujourd'hui disparu des ordinateurs modernes. Les '''disques durs''' sont des mémoires de stockage, qui mémorisent vos données de manière permanente. De nos jours, ils sont remplacés par des SSD, qui sont des disques durs électroniques, là où les disques durs proprement dit sont des mémoires magnétiques. Nous verrons la différence dans deux chapitres dédiés, un sur les disques durs, l'autre sur les SSD.

En bas à droite, se trouve la '''carte mère''' un support plat, en plastique ou en céramique, sur laquelle sont soudés/connectés les autres composants. Sur celle-ci, de nombreux composants sont soudés, d'autres sont branchés dessus avec des câbles, d'autres sont connectés dessus avec des connecteurs. Ils sont reliés entre eux par des fils conducteurs, le plus souvent du cuivre ou de l’aluminium, ce qui leur permet de s’échanger des données. Sur les cartes simples, ces fils sont intégrés dans la carte électronique, dans des creux du plastique. Ils portent le nom de pistes.

Avant, les disques durs, SSD et lecteurs de CD/DVD sont branchés dessus via des connecteurs dédiés, appelés des connecteurs S-ATA. De nos jours, ils sont branchés sur un autre connecteur, grâce à l'interface NVME. Toujours est-il qu'ils sont reliés à la carte mère par des câbles, ce qui montre que ce sont des sortes de périphériques interne. Ils sont placés dans le boitier, mais on aurait tout aussi bien pu les mettre à l'extérieur, vu qu'ils communiquent avec l'ordinateur par l'intermédiaire d'un câble ou d'un connecteur dédié.

Mais deux autres composants très importants sont eux placés sur la carte mère, directement. Ils ont chacun un connecteur dédié, sur lequel ils sont branchés directement, sans passer par l'intermédiaire d'un câble, mais sans être soudés non plus. Il s'agit du processeur et de la mémoire RAM, deux composants centraux des PC modernes.

[[File:Pentium III SL4CB.jpg|thumb|Processeur Pentium III.]]

Le '''processeur''' traite les données, les modifie, les manipule. Pour faire simple, il s’agit d’une grosse calculatrice hyper-puissante. Il comprend à la fois un circuit qui fait des calculs, et un circuit de contrôle qui s'occupe de séquencer les calculs dans l'ordre demandé. Il est souvent caché sous un radiateur, lui-même surmonté par un ventilateur. En effet, un processeur chauffe beaucoup, ce qui demande d'évacuer cette chaleur. Un chapitre entier expliquera pourquoi les processeurs chauffent, ainsi que les techniques utilisées pour limiter leur production de chaleur et leur consommation électrique.

La '''mémoire vive''' conserve des informations/données temporairement, tant que le processeur en a besoin. Elle prend la forme de barrettes de RAM, comme montré ci-dessous.

[[File:2 gb ddr2 667.jpg|centre|vignette|upright=2|Barrette de RAM.]]

Outre ces composants dits principaux, un ordinateur peut comprendre plusieurs composants moins importants, surtout présents sur les ordinateurs personnels. Ils sont techniquement facultatifs, mais sont très présents dans les ordinateurs personnels. Cependant, certains ordinateurs spécialisés s'en passent. Il s'agit des diverses '''cartes d'extension''' sont branchées sur la carte mère. Elles permettent d’accélérer certains calculs ou certaines applications, afin de décharger le processeur. Par exemple, la carte graphique s'occupe des calculs graphiques, qu'il s'agisse de graphismes 3D de jeux vidéos ou de l'affichage en 2D du bureau. Dans un autre registre, la carte son prend en charge le microphone et les haut-parleurs.

[[Fichier:Personal computer, exploded 4.svg|thumb|upright=1.0|Éclaté d'un ordinateur de type PC :&lt;br /&gt;
1 : Écran ;&lt;br /&gt;
2 : Carte mère ;&lt;br /&gt;
3 : Processeur ;&lt;br /&gt;
4 : Câble Parallel ATA ;&lt;br /&gt;
5 : Mémoire vive (RAM) ;&lt;br /&gt;
6 : Carte d'extension ;&lt;br /&gt;
7 : Alimentation électrique ;&lt;br /&gt;
8 : Lecteur de disque optique ;&lt;br /&gt;
9 : Disque dur ;&lt;br /&gt;
10 : Clavier ;&lt;br /&gt;
11 : Souris.]]

Si on regarde une carte mère de face, on voit un grand nombre de connecteurs, mais aussi des circuits électroniques soudés à la carte mère.

[[File:Architecture matérielle d'une carte mère.png|centre|vignette|upright=2.0|Architecture matérielle d'une carte mère]]

Les '''connecteurs''' sont là où on branche les périphériques, la carte graphique, le processeur, la mémoire, etc. Dans l'ensemble, toute carte mère contient les connecteurs suivants :
* Le processeur vient s’enchâsser dans la carte mère sur un connecteur particulier : le '''socket'''. Celui-ci varie suivant la carte mère et le processeur, ce qui est source d'incompatibilités.
* Les barrettes de mémoire RAM s’enchâssent dans un autre type de connecteurs: les '''slots mémoire'''.
* Les mémoires de masse disposent de leurs propres connecteurs : connecteurs P-ATA pour les anciens disques durs, et S-ATA pour les récents.
* Les périphériques (clavier, souris, USB, Firewire, ...) sont connectés sur un ensemble de connecteurs dédiés, localisés à l'arrière du boitier de l'unité centrale. 
* Les autres périphériques sont placés dans l'unité centrale et sont connectés via des connecteurs spécialisés. Ces périphériques sont des cartes imprimées, d'où leur nom de '''cartes filles'''. On peut notamment citer les cartes réseau, les cartes son, ou les cartes vidéo.

===Les ordinateurs portables===

[[File:Samsung QX-511 (2).JPG|vignette|Ordinateur portable Samsung QX-511 (2), pour illustration.]]

Un ordinateur portable est identique à un ordinateur de type PC. Si vous ouvrez votre ordinateur portable (attention à la garantie), vous retrouverez les mêmes composants qu'un PC à l'intérieur. Un point important est la présence d'une batterie à l'intérieur du PC portable, absente des PC fixes.

[[File:LG gram 14Z90Q mainboard with battery.jpg|centre|vignette|upright=2|LG gram 14Z90Q avec sa batterie.]]

Une fois la batterie et les circuits associés retiré, la seule différence notable est que tous les composants sont soudés sur la carte mère, au lieu d'être branchés sur des connecteurs, à part éventuellement la RAM et le disque dur.

[[File:LG gram 14Z90Q mainboard without battery.jpg|centre|vignette|upright=2|LG gram 14Z90Q sans sa batterie.]]

La RAM est parfois soudée sur la carte mère, d'autres fois sous la forme de barrettes de mémoire vive semblables à celles des PC. Dans le dernier cas, elle est connectée à des connecteurs spécifiques, ce qui permet de les changer/upgrader. Les PC portables sont parfois construits de manière à pouvoir changer la RAM facilement, en ouvrant un cache spécial, concu pour.

[[File:Lenovo G555 состав - Донор.JPG|centre|vignette|upright=2|Lenovo G555.]]

La conception d'un ordinateur portable est légèrement différente de celle d'un PC, pour des raisons thermiques. Un PC fixe a plus de place pour évacuer sa chaleur. Les ventilateurs peuvent plus facilement déplacer l'air dans le boitier, même si le flux d'air dans le boitier est éventuellement gêné par la carte graphique. Mais l'évacuation de la chaleur est assez efficace. Sur les PC portables, leur finesse fait que le trajet de l'air est beaucoup plus contraint. Évacuer la chaleur produite par l'ordinateur est plus complexe, ce qui demande d'utiliser des systèmes de refroidissement et de ventilation spécifiques.

Là où les PC fixes se débrouillent avec des radiateurs et des ventilateurs posés sur le processeur, les PC portables font autrement. Ils ne peuvent pas forcément mettre le ventilateur sur le processeur. A la place, ils mettent le ventilateur à côté, mais le processeur est surmonté par un mécanisme de transmission de la chaleur, qui transfère la chaleur du processeur vers le ventilateur.

[[File:Diagram - How a laptop cooling system works.png|centre|vignette|upright=2|Comment fonctionne le système de ventilation d'un ordinateur portable, en anglais.]]

Les difficultés pour dissiper la chaleur font que les ordinateurs portables utilisent souvent des composants peu performants, mais qui chauffent peu. En effet, nous verrons que plus un composant est puissant, plus il chauffe. La relation n'est pas parfaite, mais les processeurs haute performance chauffent plus que les modèles d'entrée ou milieu de gamme moins puissants. En conséquence, les PC portables sont souvent moins puissants que les PC fixes, même pour les modèles dit ''gaming''.

===Les serveurs et ''mainframes''===

Les grandes entreprises utilisent des ordinateurs de grande taille, très puissants, appelés des ''mainframes''. Ils sont souvent confondus avec les serveurs par le grand public, il y a une différence entre les deux. Un serveur est une fonction logicielle/réseau, pas un type d'ordinateur. Mais laissons cette différence de côté, ce qui est dit pour les ''mainframes'' sert pour les gros serveurs haute performance.

[[File:IBM Z15 mainframe.jpg|vignette|Exemple de ''mainframe''' de type IBM Z15.]]

Les anciens ''mainframes'' des années 50-80 avaient une taille pouvant être impressionnante, au point de prendre une pièce complète d'un bâtiment. Mais de nos jours, les ''mainframes'' tiennent dans une grosse armoire un peu haute. Les ''mainframes'' doivent rester allumé en permanence et ne doivent pas être éteint, sauf éventuellement quelques jours par an pour des opérations de maintenance. Ils utilisent pour cela des techniques spécifiques, avec beaucoup de redondance interne.

[[File:ACONIT hall grandes machines.jpg|centre|vignette|upright=2|''Mainframe'' ACONIT.]]

Les ''mainframes'' sont aussi conçus pour mutualiser au maximum leur utilisation, ils peuvent être utilisés par plusieurs utilisateurs à la suite, voire en même temps. Pour cela, les anciens ''mainframes'' étaient capables de faire tourner plusieurs applications distinctes l'une à la suite de l'autre, avec des commutations fréquentes entre logiciels. De nos jours, ils sont capables d'exécuter un grand nombre de tâches en même temps, grâce à la présence de plusieurs processeurs. Les ''mainframes'' modernes sont même capables de faire tourner plusieurs systèmes d'exploitation en même temps si besoin.

Les anciens ''mainframes'' étaient des ordinateurs assez simples, avec un processeur, de la mémoire RAM, un ou plusieurs disques durs, pas plus. Le ''mainframe'' était tellement énorme et cher que les entreprises n'en avaient qu'un seul pour toute l'entreprise. Les employés avaient sur leur bureau des terminaux, qui permettaient d'accéder à l'ordinateur central, mais n'étaient pas des ordinateurs. Les terminaux étaient des composants électroniques simples, avec un écran, un clavier et une souris, mais sans processeur. Ils envoyaient des données au ''mainframe'', ils en recevaient de sa part, mais tout traitement était réalisé sur le ''mainframe''. L'arrivée sur le marché des ordinateurs personnels, de type PC fixe/portable, a entrainé l'abandon de ce genre de pratique, tous les employés ont maintenant un ordinateur rien que pour eux.

{|
|-
! colspan=&quot;2&quot; | Exemples de terminaux
|-
|[[File:Terminal-in2-sm9400.jpg|centre|vignette|upright=1.5|Exemple de terminal. Notez la présence d'un écran et d'un clavier, mais l'asbence d'une unité centrale.]]
|[[File:Chromatics CT4100.jpg|vignette|upright=1.5|Autre exemple de terminal. Le clavier est couplé à un stylo CRT, qui remplacait la souris et agissait sur l'écran comme s'il était tactile.]]
|-
! colspan=&quot;2&quot; | Intérieur d'un terminal
|-
|[[File:CT1024 Monitor.jpg|vignette|upright=1.5|Terminal CT1024, sans le boitier extérieur.]]
|[[File:CT1024 Terminal System.jpg|vignette|upright=1.5|Terminal CT1024, description des composants interne.]]
|}

De nos jours, les ''mainframes'' contiennent en réalité plusieurs ordinateurs simples interconnectés via un réseau local. Un ''mainframe'' qui tient dans une armoire contient facilement une dizaine ou centaine de processeurs, plein de RAM, des disques durs séparés dans une armoire distincte, etc. Vu qu'ils communiquent uniquement via le réseau, ils n'ont pas d'interface, pas d'écran, 'entrée via clavier/souris. Le tout est commandé avec une console de commande, typiquement un ordinateur portable ou un terminal assez simple séparé de l'armoire, qui permet à un administrateur de faire des opérations de surveillance, configuration et maintenance. Il peut y avoir une console de commande pour plusieurs armoires séparées, la console peut même être dans un autre bâtiment et accéder au ''mainframe'' par le réseau.

[[File:IBM System Z9 (type 2094 inside).jpg|centre|vignette|upright=2|''Mainframe'' de type IBM System Z9. L'ordinateur portable sert de console pour qu'un administrateur fasse des opérations de surveillance, configuration et maintenance.]]

Les processeurs et la RAM sont typiquement installés sur des cartes amovibles, qui sont connectées au fond de l'armoire lors de l'installation. Il est même possible de retirer ou d'ajouter des cartes en fonctionnement, afin d'ajouter/retirer des processeurs, des disques durs, etc. Ce qui est très utile si un composant est en panne et qu'il faut le remplacer. 

[[File:IBM TotalStorage Exp400.jpg|centre|vignette|upright=2|IBM TotalStorage Exp400]]

==Un peu d'abstraction : qu'est-ce qu'un ordinateur ?==

Un ordinateur comprend donc un processeur, plusieurs mémoires, des cartes d'extension et une carte mère pour connecter le tout. Mais il s'agit là d'une description assez terre-à-terre de ce qu'est un ordinateur. Une autre description, plus abstraite, se base sur le fait qu'un ordinateur est une énorme calculatrice programmable. Elle permet d'expliquer pourquoi il y a une distinction entre processeur et mémoire, entre unité centrale et périphériques. Tout ce qui va suivre pourra vous paraitre assez abstrait, mais rassurez-vous : les prochains chapitres rendront tout cela plus concrets.

===La séparation entre entrées-sorties et traitement===

L'unité centrale peut être vue comme une énorme calculatrice ultra-puissante, qui exécute des commandes/opérations. Mais à elle seule, elle ne servirait à rien, il faut interagir avec par l'intermédiaire de plusieurs périphériques. Il existe deux types de périphériques, qui sont conceptuellement différents. Les périphériques comme le clavier ou la souris permettent d'envoyer des informations à l'ordinateur, d'agir sur celui-ci. A l'inverse, les écrans transmettent des informations dans le sens inverse : de l'ordinateur vers l'utilisateur. Les premiers sont appelés des '''entrées''', les seconds des '''sorties'''.

Dans un ordinateur, les informations sont représentées sous la forme de nombres. Toute donnée dans un ordinateur est codée avec un ou plusieurs nombres regroupés dans une donnée, un fichier, ou autre. Et la transmissions avec les entrées et sorties se fait là-encore avec des nombres. Par exemple, quand vous appuyez sur votre clavier, le clavier envoie un numéro de touche à l'unité centrale, qui indique quelle touche a été appuyée. L'image à afficher à l'écran est codée sous la forme d'une suite de nombres (un par pixel). L'image est envoyée à l'écran, qui traduit la suite de nombre en image à afficher. Les entrées traduisent des actions utilisateurs en nombres, on dit que les entrées encodent les actions utilisateur. Les sorties font la traduction inverse, elles transforment des suites de nombres en une action physique. On dit qu'elles décodent des informations.

Pour résumer, toute appareil électronique est composé par :
* Des '''entrées''' sur lesquelles l'utilisateur agit sur l'ordinateur. Les entrées transforment les actions de l'utilisateur en nombres, qui sont interprétés par l'ordinateur.
* Une '''unité de traitement''', qui manipule des nombres et fait des calculs/opérations dessus. Les nombres proviennent des entrées, du disque dur, ou d'autres sources, peu importe.
* Des '''sorties''', qui va récupèrent le résultat calculé par l'unité de traitement pour en faire quelque chose : écrire sur une imprimante ou sur un moniteur, émettre du son,...

[[File:Ordinateur théorique Simple 1.png|centre|vignette|upright=2|Ordinateur théorique Simple 1]]

L'unité de traitement proprement dite, celle qui fait les calculs, est couplée à une mémoire qui mémorise les opérandes et résultats des calculs. La séparation entre processeur et mémoire est nécessaire pour qu'un appareil électronique soit qualifié d'ordinateur. De nombreux appareils n'ont pas de séparation entre unité de traitement et mémoire, comme certaines vielles radios AM/FM.

[[File:Schéma de principe d'un ordinateur.png|centre|vignette|upright=2|Schéma de principe d'un ordinateur]]

===Un ordinateur est un appareil programmable===

Les appareils simples sont non-programmables, ce qui veut dire qu’ils sont conçus pour une utilisation particulière et qu’ils ne peuvent pas faire autre chose. Par exemple, les circuits électroniques d’un lecteur de DVD ne peuvent pas être transformé en lecteur audio ou en console de jeux... Les circuits non-programmables sont câblés une bonne fois pour toute, et on ne peut pas les modifier. On peut parfois reconfigurer le circuit, pour faire varier certains paramètres, via des interrupteurs ou des boutons, mais cela s’arrête là. Et cela pose un problème : à chaque problème qu'on veut résoudre en utilisant un automate, on doit recréer un nouveau circuit.

À l'inverse, un ordinateur n’est pas conçu pour une utilisation particulière, contrairement aux autres objets techniques. Il est possible de modifier leur fonction du jour au lendemain, on peut lui faire faire ce qu’on veut. On dit qu'ils sont '''programmables'''. Pour cela, il suffit d’utiliser un logiciel, une application, un programme (ces termes sont synonymes), qui fait ce que l'on souhaite. La totalité des logiciels présents sur un ordinateur sont des programmes comme les autres, même le système d'exploitation (Windows, Linux, ...) ne fait pas exception.

Un programme est une suite de d'instructions, chaque instruction effectuant une action dans l'ordinateur. Sur les ordinateurs modernes, la majorité de ces instructions effectuent une opération arithmétique, comme une addition, une multiplication, une soustraction, etc. Les ordinateurs modernes sont donc de grosses calculettes très puissantes, capables d'effectuer des millions d'opérations par secondes. Et qui dit opération dit nombres : un ordinateur gère nativement des nombres, qui sont codés en binaire sur la quasi-totalité des ordinateurs modernes.

Une instruction est représentée dans un ordinateur par une série de nombres : un nombre qui indique quelle opération/commande effectuer et des autres nombres pour coder les données (ou de quoi les retrouver dans l'ordinateur). L'ordinateur récupére les commandes une par une, les traduit en opération à effectuer, exécuter l'opération, et enregistre le résultat. Puis il recommence avec la commande suivante.

[[File:Ordinateur Théorique Complexe 1.png|centre|vignette|upright=3|Ordinateur Théorique Complexe. En jaune, le programme informatique, la liste de commande. Le rectangle gris est l'ordinateur proprement dit.]]

De nombreux appareils sont programmables, mais tous ne sont pas des ordinateurs. Par exemple, certains circuits programmables nommés FPGA n'en sont pas. Pour être qualifié d'ordinateur, un appareil programmable doit avoir un processeur séparé de la mémoire. De plus, il doit utiliser un '''codage numérique''', chose que nous allons aborder dans le chapitre suivant.

===Les ordinateurs à programme mémorisé ou programme externe===

Au tout début de l'informatique, on utilisait des cartes perforées en plastique, sur lesquelles on inscrivait le programme à exécuter, les données à traiter, bref : tout ce qu'on donnait à manger à l'ordinateur. Par la suite, les premiers ordinateurs grand public, comme les Amstrad ou les Commodore, utilisaient des cassettes audio magnétiques pour stocker les programmes. Dans le même style, les consoles de jeu utilisaient autrefois des cartouches de jeu, qui contenaient le programme du jeu à exécuter. Pour résumer, les anciens ordinateurs mémorisaient les programmes sur un support externe, lu par un périphérique. De tels ordinateurs sont dits à '''programme externe'''.

: D’anciens ordinateurs personnels, comme l’Amstrad ou le Commodore, permettaient de taper les programmes à exécuter à la main, au clavier, avant d’appuyer une touche pour les exécuter. Nul besoin de vous dire que les cassettes audio étaient plus pratiques.

Mais de nos jours, les programmes sont enregistrés sur le disque dur de l'ordinateur ou dans une mémoire intégrée à l'ordinateur. On dit qu'ils sont installés, ce qui est un mot bien compliqué pour dire que le programme est enregistré sur le disque dur de l’ordinateur. A défaut de disque dur, le programme/logiciel est enregistré dans une mémoire spécialisée pour le stockage. Par exemple, sur les cartes électroniques grand public de marque Arduino, les programmes sont envoyés à la carte via le port USB, mais les programmes sont enregistrés dans la carte Arduino, dans une mémoire FLASH dédiée. Disque dur ou non, le programme est mémorisé dans la mémoire de l'ordinateur. Il est possible d'installer ou de désinstaller les programmes en modifiant le contenu de la mémoire. Le terme utilisé est alors celui de '''programme stocké en mémoire'''.

Les programmes à installer sont disponibles soit sur un périphérique, comme un DVD ou une clé USB, soit sont téléchargés depuis internet. Les premiers PC fournissaient les logiciels sur des disquettes, qui contenaient un programme d'installation pour enregistrer le programme sur le disque dur de l'ordinateur. Par la suite, le support des logiciels a migré vers les CD et DVD, les logiciels devenant de plus en plus gros. De nos jours, la majorité des applications sont téléchargées depuis le net, l'usage de périphériques est devenu obsolète, même les consoles de jeu abandonnent cette méthode de distribution.

==Les générations d'ordinateurs : un historique rapide==

L'informatique a beaucoup évolué dans le temps. Et une bonne partie de cette évolution tient à l'évolution de l’électronique sous-jacente. Les ordinateurs actuels sont fabriqués avec des transistors, des petits composants électroniques qui servent d'interrupteur programmables, qu'on détaillera dans ce qui suit. Mais ça n'a pas toujours été le cas. Et cela permet de distinguer plusieurs '''générations d'ordinateurs'''.

===Le ordinateurs électro-mécaniques : les premiers ordinateurs===

Le tout premier ordinateur est le '''Z1''', un modèle unique inventé par Konrad Suze entre 1936 et 1938. Son processeur gérait non pas des nombres entiers, mais des nombres à virgule (des nombres dits flottants, pour être précis), encodés sur 22 bits. Le processeur du Z1 était capable de faire des additions et des soustractions, car il intégrait un circuit additionneur-soustracteur basique. Des circuits annexes permettaient de faire des multiplications et des divisions en enchainant des additions/soustractions successives. Il fonctionnait à une fréquence de 1 Hz, ce qui fait qu'il pouvait faire une addition/soustraction par seconde maximum.

[[File:Blue-punch-card-front.png|vignette|upright=0.5|Carte Perforée.]]

Niveau mémoire, la RAM de l'ordinateur était très limitée : seulement 16 nombres de 22 bits chacun. S'il s'agissait d'une mémoire électronique, les programmes étaient mémorisés sur une mémoire mécanique. Les programmes étaient enregistrés sur des cartes perforées, à savoir des cartes en papier dans lesquelles un 1 est codé par un trou dans le papier et un 0 par une absence de trou. Les programmes étaient exécutés par l'ordinateur quand on insérait la carte perforée dans le lecteur et qu'on appuyait sur un bouton.

Après sa destruction dans un bombardement lors de la seconde guerre mondiale, le Z1 a été remplacé par un modèle dit Z2, lui-même suivi par le Z3, qui n'étaient que des améliorations du Z1. Tous étaient des ordinateurs dit '''électro-mécaniques''', car ils mélangeaient des composants électroniques (des relais) et des composants mécaniques (tout ce qui a trait aux cartes perforées, notamment). Les ordinateur qui ont suivi, avant les années 50, étaient tous de ce type. En 1944, le Harvard Mark I a été mis en service, suivi par le Z4 l'année suivante.

[[File:German Museum of Technology, Berlin 2017 024.jpg|centre|vignette|upright=2|Réplique du Z1 au ''German Museum of Technology'' de Berlin, 2017.]]

===Les premières générations : des ordinateurs qui prenaient des pièces de bâtiment entières===

[[File:IBM 7070.jpg|vignette|Cartes imprimées de l'IBM 704, avec des transistors et résistances dessus.]]

La '''première génération d'ordinateur''' est celle des ordinateurs datant d'avant l'invention du transistor. Ils étaient conçus avec des tubes à vide ou des relais, des composants électroniques assez rudimentaires. Les ordinateurs de première génération étaient très simples, ils ne géraient que quelques opérations simples : l'addition, la soustraction, pas grand chose de plus. A quelques exceptions près, ils ne géraient pas la multiplication et encore moins la division, ils n'avaient pas assez de relais ou de tubes à vides à disposition pour cela.

La '''seconde génération''' est celle des ordinateurs fabriqués avec des '''transistors''' isolés, reliés entre avec des fils électriques. Les transistors en question possèdent trois broches, des pattes métalliques sur lesquelles on connecte des fils électriques. Le transistor s'utilise le plus souvent comme un interrupteur commandé par sa troisième broche. Le courant qui traverse les deux premières broches passe ou ne passe pas selon ce qu'on met sur la troisième.

[[File:Transistor basic flow.svg|centre|vignette|Un transistor est un morceau de conducteur, dont la conductivité est contrôlée par sa troisième broche/borne.]]

Les ordinateurs de seconde génération avaient entre 1000 et 500 000 transistors. Les capacités des ordinateurs étaient donc nettement supérieures à celles des ordinateurs de première génération. Une part non négligeable des ordinateurs de seconde génération supportait l'opération de multiplication, absente sur les ordinateurs de première génération. Néanmoins, cela variait beaucoup selon les ordinateurs.

Un exemple assez hors du commun est celui du premier modèle de l'IBM 1620. Le tout premier modèle n'avait aucun circuit de calcul, il n'était même pas capable de faire une addition ou une multiplication. A la place, il utilisait une table d'addition et une table de multiplication en mémoire RAM. Les deux tables devaient être initialisées par le logiciel lors du démarrage de la machine. La table d'addition faisait une centaine de chiffre, la table de multiplication faisait le double. Le processeur de l'ordinateur gérait des instructions pour faire des additions ou des multiplications, mais ces opérations lisaient le résultat dans la table d'addition. Les calculs étaient fait chiffre par chiffre, avec un encodage partiellement décimal, partiellement binaire (des chiffres décimaux étaient encodés en binaire, nous en reparlerons quand nous parlerons du BCD) !

[[File:KL CoreMemory.jpg|vignette|Mémoire à tore de ferrite.]]

Les transistors n'étaient utilisés que pour le processeur et les circuits annexes. La mémoire n'était pas faite en transistors, pas à cette époque. La mémoire était une mémoire aujourd'hui abandonnée, appelée une '''mémoire à tores de ferrite'''. Elle sera détaillée dans un chapitre ultérieur. Mais sachez pour le moment qu'il s'agit d'une mémoire au support magnétique, les données étant stockées sur un support magnétique.

Transistors comme tubes à vide prenaient beaucoup de place, ce qui fait que les ordinateurs étaient assez gros. Concrètement, ils prenaient une pièce de bâtiment entière dans le meilleur des cas. C'était l'époque des gros ''mainframes'', reliés à des terminaux, peu puissants comparé aux standards actuels. Seules les grandes entreprises et les grands instituts de recherche pouvaient se payer les services de ce genre d'ordinateurs. Seuls les professionnels avaient accès à ce genre d'équipement.

===La troisième génération : le circuit intégré===

[[File:D8259AC-2.jpg|vignette|Exemple de circuit intégré.]]

La troisième génération est toujours fabriquée avec des transistors, mais dont la taille a été réduite. Avec l'évolution de la technologie, les transistors ont diminué en taille, de plus en plus. Ils sont devenus tellement petits qu'ils ont finit par être regroupés dans des '''circuits intégrés''', des circuits regroupent plusieurs transistors sur la même puce de silicium. Les circuits intégrés se présentent le plus souvent sous la forme de boitiers rectangulaires, comme illustré ci-contre. D'autres ont des boitiers de forme carrées, comme ceux que l'on peut trouver sur les barrettes de mémoire RAM, ou à l'intérieur des clés USB/ disques SSD.

Lors de cette génération, les processeurs étaient fournis en pièces détachées qu'il fallait relier entre elles. Le processeur était composé de plusieurs circuits intégrés séparés, impossible de mettre un processeur dans un seul boitier. Un exemple de processeur conçu en kit est la série des Intel 3000. Elle regroupe plusieurs circuits séparés aux noms à coucher dehors, mais dont vous comprendrez ce qu'ils veulent dire dans les chapitres adéquats : l'Intel 3001 est un séquenceur, l'Intel 3002 regroupe unité de calcul et registres, le 3003 est un circuit d'anticipation de retenue complémentaire du 3002, le 3212 est une mémoire tampon, le 3214 est une unité de gestion des interruptions, les 3216/3226 sont des interfaces de bus mémoire. On pourrait aussi citer la famille de circuits intégrés AMD Am2900.

Même si le processeur était en pièce détachées, utiliser une dizaine de circuits intégrés était nettement mieux que d'utiliser plusieurs milliers de transistors individuels. En conséquence, les ordinateurs ont vu leur taille grandement réduite, passant de pièces entières à une simple armoire, voire à quelques cartes intégrées superposées. De plus, le prix des circuits intégré était abordable, du moins comparé aux ordinateurs d'avant. Le prix des ordinateurs a alors grandement décru, permettant à des entreprises et administrations de taille modeste de s'équiper d'ordinateurs.

===La quatrième génération : le microprocesseur===

[[File:MOS6502.svg|vignette|Microprocesseur, ici un processeur MOS6502, de la quatrième génération.]]

Lors de la troisième génération, les circuits intégrés regroupaient plusieurs dizaines ou centaines de transistors, mais sont rapidement montés en gamme. De centaines de transistors, ils sont passé au milliers de transistors, puis au millions et maintenant au-delà du milliard. Les transistors étaient devenus tellement petits, tellement miniaturisés, qu'il était devenu possible de mettre un processeur entier dans un circuit intégré. C'est ainsi qu'est né le microprocesseur, à savoir un processeur qui tient tout entier dans un seul circuit imprimé. La quatrième génération d’ordinateur est celle des ordinateurs basés autour d'un microprocesseur.

Les tout premiers microprocesseurs étaient des processeurs à application militaire, comme le processeur du F-14 CADC ou celui de l'Air data computer. Le tout premier microprocesseur commercialisé au grand public est le 4004 d'Intel, sorti en 1971. L'intel 4004 comprenait environ 2300 transistors, avait une fréquence de 740 MHz, pouvait faire 46 opérations différentes, et manipulait des entiers de 4 bits. Il était au départ un processeur de commande, prévu pour être intégré dans la calculatrice Busicom calculator 141-P, mais il fut utilisé pour d'autres applications quelque temps plus tard. Immédiatement après le 4004, les premiers microprocesseurs 8 bits furent commercialisés. Le 4004 fut suivi par le 8008 et quelques autres processeurs 8 bits extrêmement connus, comme le 8080 d'Intel, le 68000 de Motorola, le 6502 ou le Z80.

Les microprocesseurs permirent encore uen fois de réduire la taille des ordinateurs, qui pouvaient tenir dans un boitier de PC, ou un boitier de console de jeu. Le prix des ordinateurs a aussi chuté en même temps que les transistors était miniaturisés. C'est cette invention qui permis l'invention des consoles de jeux et des mini-ordinateurs, à savoir les ordinateurs personnels. Sans miniaturisation, on n'aurait pas d'ordinateur personnel, pas de PC fixe ou portable.

==L'organisation du cours : les différents niveaux d'explication==

Le fonctionnement d'un ordinateur est assez complexe à expliquer car les explications peuvent se faire sur plusieurs niveaux. Par plusieurs niveaux, on veut dire qu'un ordinateur est composé de composants très simples, qui sont assemblés pour donner des composants eux-même plus complexes, qui sont eux-même regrouper, etc. Étudier tout cela demande de voir plusieurs niveaux, allant de transistors très petits à des processeurs multicœurs. Les niveaux les plus bas sont de l'électronique pur et dure, alors que ceux plus haut sont à mi-chemin entre électronique et informatique.

===Les niveaux d'abstraction en architecture des ordinateurs===

Les trois premiers niveaux sont de l'électronique pur et dure. Ils correspondent aux premiers chapitres du cours, qui porteront sur les circuits électroniques en général.
* Le premier niveau est celui des '''transistors''', des circuits intégrés, des ''wafer'' et autres circuits de très petite taille.
* Le second niveau est celui des '''portes logiques''', des circuits très basiques, très simples, à la base de tous les autres.
* Le troisième niveau est celui dit de la '''''Register Transfer Level''''', où un circuit électronique est construit à partir de circuits basiques, dont des registres et autres circuits dits combinatoires.
Les deux niveaux suivants sont de l'informatique proprement dit. C'est dans ces deux niveaux qu'on étudie les ordinateurs proprement dit, les circuits qu'il y a dedans et non l'électronique en général.
* Le quatrième niveau est celui de la '''microarchitecture''', qui étudie ce qu'il y a à l'intérieur d'un processeur, d'une mémoire, des périphériques et autres.
* Le cinquième niveau est celui de l''''architecture externe''', qui décrit l'interface du processeur, de la mémoire, d'un périphérique ou autre. Par décrire l'interface, on veut dire : comment un programmeur voit le processeur et la mémoire, comment il peut les manipuler. Une architecture externe unique peut avoir plusieurs microarchitecture, ce qui fait qu'on sépare les deux. Tout cela sera plus clair quand on passera aux chapitres sur le processeur et les mémoires.

Nous n'allons pas voir les 5 niveaux dans l'ordre, des transistors vers l'architecture externe. En réalité, nous allons procéder autrement. La première partie du cours portera sur les trois premiers niveaux, le reste sur les deux autres. Les 5 niveaux seront vus dans des chapitres séparés, du moins le plus possible. Au niveau pédagogique, tout est plus simple si on scinde les 5 niveaux. Bien sûr, il y a quelques explications qui demandent de voir plusieurs niveaux à la fois. Par exemple, dans le chapitre sur les mémoires caches, nous auront des explications portant sur la RTL, la microarchitecture du cache et son architecture externe. Mais le gros du cours tentera de séparer le plus possible les 5 niveaux.

===Les trois parties principales du cours===

Nous allons commencer par parler du binaire, avant de voir les portes logiques. Avec ces portes logiques, nous allons voir comment fabriquer des circuits basiques qui reviendront très souvent dans la suite du cours. Nous verrons les registres, les décodeurs, les additionneurs et plein d'autres circuits. Puis, nous reviendrons au niveau des transistors pour finir la première partie. La raison est que c'est plus simple de faire comme cela. Tout ce qui a trait aux transistors sert à expliquer comment fabriquer des portes logiques, et il faut expliquer les portes logiques pour voir le niveau de la RTL.

Une fois la première partie finie, nous allons voir les différents composants d'un ordinateur. Une première partie expliquera ce qu'il y a dans un ordinateur, quels sont ses composants. Nous y parlerons de l'architecture de base, de la hiérarchie mémoire, des tendances technologiques, et d'autres généralités qui serviront de base pour la suite. Puis, nous verrons dans l'ordre les bus électroniques, les mémoires RAM/ROM, le processeur, les périphériques, les mémoires de stockage (SSD et disques durs) et les mémoires caches. Pour chaque composant, nous allons voir leur architecture externe, avant de voir leur microarchitecture. La raison est que la microarchitecture ne peut se comprendre que quand on sait quelle architecture externe elle implémente.

Enfin, dans une troisième partie, nous allons voir les optimisations majeures présentes dans tous les ordinateurs modernes, avec une partie sur le pipeline et le parallélisme d'instruction, et une autre sur les architectures parallèles. Pour finir, les annexes de fin parlerons de sujets un peu à part.

&lt;noinclude&gt;
{{NavChapitre | book=Fonctionnement d'un ordinateur
           | next=L'encodage des données
           | nextText=L'encodage des données
}}
&lt;/noinclude&gt;</text>
      <sha1>0x87lmmo49lp19392ti0gjo536gqnf5</sha1>
    </revision>
    <revision>
      <id>744102</id>
      <parentid>744101</parentid>
      <timestamp>2025-06-04T20:37:56Z</timestamp>
      <contributor>
        <username>Mewtow</username>
        <id>31375</id>
      </contributor>
      <minor />
      <comment>/* Les premières générations : des ordinateurs qui prenaient des pièces de bâtiment entières */</comment>
      <origin>744102</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="40532" sha1="1ok14p5hrxzjt46knoaqm0a8r9oq8wc" xml:space="preserve">Pour commencer, nous allons voir qu'il existe de nombreux types d'ordinateurs. Le plus connu est certainement le PC, l'ordinateur personnel, que vous avez sans doute dans votre salon. Les ordinateurs portables sont un deuxième type d'ordinateur assez intuitif, que vous avez peut-être. Mais il y a aussi d'autres types d'ordinateurs auxquels vous n'avez jamais été confrontés.

==Les différents types d'ordinateurs==

Dans cette section, nous allons décrire rapidement les ordinateurs les plus courant, mais surtout voir ce qu'il y a à l'intérieur d'un ordinateur.

===L'ordinateur de type PC fixe===

De l'extérieur, l'ordinateur est composé d'une unité centrale sur laquelle on branche des périphériques.

[[File:Typical computer architecture systems.jpg|vignette|upright=1.5|Exemples de périphériques, connectés à une unité centrale (ici appelée à tort ''operating system'').]]

Les '''périphériques''' regroupent l'écran, la souris, le clavier, l'imprimante, et bien d'autres choses. Ils permettent à l'utilisateur d'interagir avec l'ordinateur : un clavier permet de saisir du texte sous dans un fichier, une souris enregistre des déplacements de la main en déplacement du curseur, un écran affiche des données d’images/vidéos, un haut-parleur émet du son, etc. Tout ce qui est branché sur un ordinateur est, formellement un périphérique.

L''''unité centrale''' est là où se trouvent tous les composants importants d'un ordinateur, ceux qui font des calculs, qui exécutent des logiciels, qui mémorisent vos données, etc. Voici ce à quoi ressemble l'intérieur de l'unité centrale. Trois sections sont visibles : l'alimentation électrique en haut à gauche, la carte mère en bas à gauche et en jaune/orange, les disques et lecteurs à droite des câbles. Et on voit aussi beaucoup de câbles.

[[File:Asus P5K-SEIntel E6320.jpg|centre|vignette|upright=2|Exemple d'unité centrale.]]

Tout en haut à gauche, se trouve l''''alimentation électrique''', qui convertit le courant de la prise électrique en un courant plus faible, utilisable par les autres composants. Elle émet de nombreux câbles assez gros, qui sont reliés au reste. Les PC actuels utilisent des alimentations électriques standardisées, qui fournissent trois tensions au reste de l'ordinateur : une tension de 12 Volts, une de 5 Volts, une de 3,3 Volts.

À droite, caché par la partie &quot;métallique&quot; du boitier, se trouvent les lecteurs de CD/DVD, et les disques durs. Les lecteurs CD-ROM ou DVD-ROM permettaient de lire des CD ou des DVD. Je parle au passé, car ils ont aujourd'hui disparu des ordinateurs modernes. Les '''disques durs''' sont des mémoires de stockage, qui mémorisent vos données de manière permanente. De nos jours, ils sont remplacés par des SSD, qui sont des disques durs électroniques, là où les disques durs proprement dit sont des mémoires magnétiques. Nous verrons la différence dans deux chapitres dédiés, un sur les disques durs, l'autre sur les SSD.

En bas à droite, se trouve la '''carte mère''' un support plat, en plastique ou en céramique, sur laquelle sont soudés/connectés les autres composants. Sur celle-ci, de nombreux composants sont soudés, d'autres sont branchés dessus avec des câbles, d'autres sont connectés dessus avec des connecteurs. Ils sont reliés entre eux par des fils conducteurs, le plus souvent du cuivre ou de l’aluminium, ce qui leur permet de s’échanger des données. Sur les cartes simples, ces fils sont intégrés dans la carte électronique, dans des creux du plastique. Ils portent le nom de pistes.

Avant, les disques durs, SSD et lecteurs de CD/DVD sont branchés dessus via des connecteurs dédiés, appelés des connecteurs S-ATA. De nos jours, ils sont branchés sur un autre connecteur, grâce à l'interface NVME. Toujours est-il qu'ils sont reliés à la carte mère par des câbles, ce qui montre que ce sont des sortes de périphériques interne. Ils sont placés dans le boitier, mais on aurait tout aussi bien pu les mettre à l'extérieur, vu qu'ils communiquent avec l'ordinateur par l'intermédiaire d'un câble ou d'un connecteur dédié.

Mais deux autres composants très importants sont eux placés sur la carte mère, directement. Ils ont chacun un connecteur dédié, sur lequel ils sont branchés directement, sans passer par l'intermédiaire d'un câble, mais sans être soudés non plus. Il s'agit du processeur et de la mémoire RAM, deux composants centraux des PC modernes.

[[File:Pentium III SL4CB.jpg|thumb|Processeur Pentium III.]]

Le '''processeur''' traite les données, les modifie, les manipule. Pour faire simple, il s’agit d’une grosse calculatrice hyper-puissante. Il comprend à la fois un circuit qui fait des calculs, et un circuit de contrôle qui s'occupe de séquencer les calculs dans l'ordre demandé. Il est souvent caché sous un radiateur, lui-même surmonté par un ventilateur. En effet, un processeur chauffe beaucoup, ce qui demande d'évacuer cette chaleur. Un chapitre entier expliquera pourquoi les processeurs chauffent, ainsi que les techniques utilisées pour limiter leur production de chaleur et leur consommation électrique.

La '''mémoire vive''' conserve des informations/données temporairement, tant que le processeur en a besoin. Elle prend la forme de barrettes de RAM, comme montré ci-dessous.

[[File:2 gb ddr2 667.jpg|centre|vignette|upright=2|Barrette de RAM.]]

Outre ces composants dits principaux, un ordinateur peut comprendre plusieurs composants moins importants, surtout présents sur les ordinateurs personnels. Ils sont techniquement facultatifs, mais sont très présents dans les ordinateurs personnels. Cependant, certains ordinateurs spécialisés s'en passent. Il s'agit des diverses '''cartes d'extension''' sont branchées sur la carte mère. Elles permettent d’accélérer certains calculs ou certaines applications, afin de décharger le processeur. Par exemple, la carte graphique s'occupe des calculs graphiques, qu'il s'agisse de graphismes 3D de jeux vidéos ou de l'affichage en 2D du bureau. Dans un autre registre, la carte son prend en charge le microphone et les haut-parleurs.

[[Fichier:Personal computer, exploded 4.svg|thumb|upright=1.0|Éclaté d'un ordinateur de type PC :&lt;br /&gt;
1 : Écran ;&lt;br /&gt;
2 : Carte mère ;&lt;br /&gt;
3 : Processeur ;&lt;br /&gt;
4 : Câble Parallel ATA ;&lt;br /&gt;
5 : Mémoire vive (RAM) ;&lt;br /&gt;
6 : Carte d'extension ;&lt;br /&gt;
7 : Alimentation électrique ;&lt;br /&gt;
8 : Lecteur de disque optique ;&lt;br /&gt;
9 : Disque dur ;&lt;br /&gt;
10 : Clavier ;&lt;br /&gt;
11 : Souris.]]

Si on regarde une carte mère de face, on voit un grand nombre de connecteurs, mais aussi des circuits électroniques soudés à la carte mère.

[[File:Architecture matérielle d'une carte mère.png|centre|vignette|upright=2.0|Architecture matérielle d'une carte mère]]

Les '''connecteurs''' sont là où on branche les périphériques, la carte graphique, le processeur, la mémoire, etc. Dans l'ensemble, toute carte mère contient les connecteurs suivants :
* Le processeur vient s’enchâsser dans la carte mère sur un connecteur particulier : le '''socket'''. Celui-ci varie suivant la carte mère et le processeur, ce qui est source d'incompatibilités.
* Les barrettes de mémoire RAM s’enchâssent dans un autre type de connecteurs: les '''slots mémoire'''.
* Les mémoires de masse disposent de leurs propres connecteurs : connecteurs P-ATA pour les anciens disques durs, et S-ATA pour les récents.
* Les périphériques (clavier, souris, USB, Firewire, ...) sont connectés sur un ensemble de connecteurs dédiés, localisés à l'arrière du boitier de l'unité centrale. 
* Les autres périphériques sont placés dans l'unité centrale et sont connectés via des connecteurs spécialisés. Ces périphériques sont des cartes imprimées, d'où leur nom de '''cartes filles'''. On peut notamment citer les cartes réseau, les cartes son, ou les cartes vidéo.

===Les ordinateurs portables===

[[File:Samsung QX-511 (2).JPG|vignette|Ordinateur portable Samsung QX-511 (2), pour illustration.]]

Un ordinateur portable est identique à un ordinateur de type PC. Si vous ouvrez votre ordinateur portable (attention à la garantie), vous retrouverez les mêmes composants qu'un PC à l'intérieur. Un point important est la présence d'une batterie à l'intérieur du PC portable, absente des PC fixes.

[[File:LG gram 14Z90Q mainboard with battery.jpg|centre|vignette|upright=2|LG gram 14Z90Q avec sa batterie.]]

Une fois la batterie et les circuits associés retiré, la seule différence notable est que tous les composants sont soudés sur la carte mère, au lieu d'être branchés sur des connecteurs, à part éventuellement la RAM et le disque dur.

[[File:LG gram 14Z90Q mainboard without battery.jpg|centre|vignette|upright=2|LG gram 14Z90Q sans sa batterie.]]

La RAM est parfois soudée sur la carte mère, d'autres fois sous la forme de barrettes de mémoire vive semblables à celles des PC. Dans le dernier cas, elle est connectée à des connecteurs spécifiques, ce qui permet de les changer/upgrader. Les PC portables sont parfois construits de manière à pouvoir changer la RAM facilement, en ouvrant un cache spécial, concu pour.

[[File:Lenovo G555 состав - Донор.JPG|centre|vignette|upright=2|Lenovo G555.]]

La conception d'un ordinateur portable est légèrement différente de celle d'un PC, pour des raisons thermiques. Un PC fixe a plus de place pour évacuer sa chaleur. Les ventilateurs peuvent plus facilement déplacer l'air dans le boitier, même si le flux d'air dans le boitier est éventuellement gêné par la carte graphique. Mais l'évacuation de la chaleur est assez efficace. Sur les PC portables, leur finesse fait que le trajet de l'air est beaucoup plus contraint. Évacuer la chaleur produite par l'ordinateur est plus complexe, ce qui demande d'utiliser des systèmes de refroidissement et de ventilation spécifiques.

Là où les PC fixes se débrouillent avec des radiateurs et des ventilateurs posés sur le processeur, les PC portables font autrement. Ils ne peuvent pas forcément mettre le ventilateur sur le processeur. A la place, ils mettent le ventilateur à côté, mais le processeur est surmonté par un mécanisme de transmission de la chaleur, qui transfère la chaleur du processeur vers le ventilateur.

[[File:Diagram - How a laptop cooling system works.png|centre|vignette|upright=2|Comment fonctionne le système de ventilation d'un ordinateur portable, en anglais.]]

Les difficultés pour dissiper la chaleur font que les ordinateurs portables utilisent souvent des composants peu performants, mais qui chauffent peu. En effet, nous verrons que plus un composant est puissant, plus il chauffe. La relation n'est pas parfaite, mais les processeurs haute performance chauffent plus que les modèles d'entrée ou milieu de gamme moins puissants. En conséquence, les PC portables sont souvent moins puissants que les PC fixes, même pour les modèles dit ''gaming''.

===Les serveurs et ''mainframes''===

Les grandes entreprises utilisent des ordinateurs de grande taille, très puissants, appelés des ''mainframes''. Ils sont souvent confondus avec les serveurs par le grand public, il y a une différence entre les deux. Un serveur est une fonction logicielle/réseau, pas un type d'ordinateur. Mais laissons cette différence de côté, ce qui est dit pour les ''mainframes'' sert pour les gros serveurs haute performance.

[[File:IBM Z15 mainframe.jpg|vignette|Exemple de ''mainframe''' de type IBM Z15.]]

Les anciens ''mainframes'' des années 50-80 avaient une taille pouvant être impressionnante, au point de prendre une pièce complète d'un bâtiment. Mais de nos jours, les ''mainframes'' tiennent dans une grosse armoire un peu haute. Les ''mainframes'' doivent rester allumé en permanence et ne doivent pas être éteint, sauf éventuellement quelques jours par an pour des opérations de maintenance. Ils utilisent pour cela des techniques spécifiques, avec beaucoup de redondance interne.

[[File:ACONIT hall grandes machines.jpg|centre|vignette|upright=2|''Mainframe'' ACONIT.]]

Les ''mainframes'' sont aussi conçus pour mutualiser au maximum leur utilisation, ils peuvent être utilisés par plusieurs utilisateurs à la suite, voire en même temps. Pour cela, les anciens ''mainframes'' étaient capables de faire tourner plusieurs applications distinctes l'une à la suite de l'autre, avec des commutations fréquentes entre logiciels. De nos jours, ils sont capables d'exécuter un grand nombre de tâches en même temps, grâce à la présence de plusieurs processeurs. Les ''mainframes'' modernes sont même capables de faire tourner plusieurs systèmes d'exploitation en même temps si besoin.

Les anciens ''mainframes'' étaient des ordinateurs assez simples, avec un processeur, de la mémoire RAM, un ou plusieurs disques durs, pas plus. Le ''mainframe'' était tellement énorme et cher que les entreprises n'en avaient qu'un seul pour toute l'entreprise. Les employés avaient sur leur bureau des terminaux, qui permettaient d'accéder à l'ordinateur central, mais n'étaient pas des ordinateurs. Les terminaux étaient des composants électroniques simples, avec un écran, un clavier et une souris, mais sans processeur. Ils envoyaient des données au ''mainframe'', ils en recevaient de sa part, mais tout traitement était réalisé sur le ''mainframe''. L'arrivée sur le marché des ordinateurs personnels, de type PC fixe/portable, a entrainé l'abandon de ce genre de pratique, tous les employés ont maintenant un ordinateur rien que pour eux.

{|
|-
! colspan=&quot;2&quot; | Exemples de terminaux
|-
|[[File:Terminal-in2-sm9400.jpg|centre|vignette|upright=1.5|Exemple de terminal. Notez la présence d'un écran et d'un clavier, mais l'asbence d'une unité centrale.]]
|[[File:Chromatics CT4100.jpg|vignette|upright=1.5|Autre exemple de terminal. Le clavier est couplé à un stylo CRT, qui remplacait la souris et agissait sur l'écran comme s'il était tactile.]]
|-
! colspan=&quot;2&quot; | Intérieur d'un terminal
|-
|[[File:CT1024 Monitor.jpg|vignette|upright=1.5|Terminal CT1024, sans le boitier extérieur.]]
|[[File:CT1024 Terminal System.jpg|vignette|upright=1.5|Terminal CT1024, description des composants interne.]]
|}

De nos jours, les ''mainframes'' contiennent en réalité plusieurs ordinateurs simples interconnectés via un réseau local. Un ''mainframe'' qui tient dans une armoire contient facilement une dizaine ou centaine de processeurs, plein de RAM, des disques durs séparés dans une armoire distincte, etc. Vu qu'ils communiquent uniquement via le réseau, ils n'ont pas d'interface, pas d'écran, 'entrée via clavier/souris. Le tout est commandé avec une console de commande, typiquement un ordinateur portable ou un terminal assez simple séparé de l'armoire, qui permet à un administrateur de faire des opérations de surveillance, configuration et maintenance. Il peut y avoir une console de commande pour plusieurs armoires séparées, la console peut même être dans un autre bâtiment et accéder au ''mainframe'' par le réseau.

[[File:IBM System Z9 (type 2094 inside).jpg|centre|vignette|upright=2|''Mainframe'' de type IBM System Z9. L'ordinateur portable sert de console pour qu'un administrateur fasse des opérations de surveillance, configuration et maintenance.]]

Les processeurs et la RAM sont typiquement installés sur des cartes amovibles, qui sont connectées au fond de l'armoire lors de l'installation. Il est même possible de retirer ou d'ajouter des cartes en fonctionnement, afin d'ajouter/retirer des processeurs, des disques durs, etc. Ce qui est très utile si un composant est en panne et qu'il faut le remplacer. 

[[File:IBM TotalStorage Exp400.jpg|centre|vignette|upright=2|IBM TotalStorage Exp400]]

==Un peu d'abstraction : qu'est-ce qu'un ordinateur ?==

Un ordinateur comprend donc un processeur, plusieurs mémoires, des cartes d'extension et une carte mère pour connecter le tout. Mais il s'agit là d'une description assez terre-à-terre de ce qu'est un ordinateur. Une autre description, plus abstraite, se base sur le fait qu'un ordinateur est une énorme calculatrice programmable. Elle permet d'expliquer pourquoi il y a une distinction entre processeur et mémoire, entre unité centrale et périphériques. Tout ce qui va suivre pourra vous paraitre assez abstrait, mais rassurez-vous : les prochains chapitres rendront tout cela plus concrets.

===La séparation entre entrées-sorties et traitement===

L'unité centrale peut être vue comme une énorme calculatrice ultra-puissante, qui exécute des commandes/opérations. Mais à elle seule, elle ne servirait à rien, il faut interagir avec par l'intermédiaire de plusieurs périphériques. Il existe deux types de périphériques, qui sont conceptuellement différents. Les périphériques comme le clavier ou la souris permettent d'envoyer des informations à l'ordinateur, d'agir sur celui-ci. A l'inverse, les écrans transmettent des informations dans le sens inverse : de l'ordinateur vers l'utilisateur. Les premiers sont appelés des '''entrées''', les seconds des '''sorties'''.

Dans un ordinateur, les informations sont représentées sous la forme de nombres. Toute donnée dans un ordinateur est codée avec un ou plusieurs nombres regroupés dans une donnée, un fichier, ou autre. Et la transmissions avec les entrées et sorties se fait là-encore avec des nombres. Par exemple, quand vous appuyez sur votre clavier, le clavier envoie un numéro de touche à l'unité centrale, qui indique quelle touche a été appuyée. L'image à afficher à l'écran est codée sous la forme d'une suite de nombres (un par pixel). L'image est envoyée à l'écran, qui traduit la suite de nombre en image à afficher. Les entrées traduisent des actions utilisateurs en nombres, on dit que les entrées encodent les actions utilisateur. Les sorties font la traduction inverse, elles transforment des suites de nombres en une action physique. On dit qu'elles décodent des informations.

Pour résumer, toute appareil électronique est composé par :
* Des '''entrées''' sur lesquelles l'utilisateur agit sur l'ordinateur. Les entrées transforment les actions de l'utilisateur en nombres, qui sont interprétés par l'ordinateur.
* Une '''unité de traitement''', qui manipule des nombres et fait des calculs/opérations dessus. Les nombres proviennent des entrées, du disque dur, ou d'autres sources, peu importe.
* Des '''sorties''', qui va récupèrent le résultat calculé par l'unité de traitement pour en faire quelque chose : écrire sur une imprimante ou sur un moniteur, émettre du son,...

[[File:Ordinateur théorique Simple 1.png|centre|vignette|upright=2|Ordinateur théorique Simple 1]]

L'unité de traitement proprement dite, celle qui fait les calculs, est couplée à une mémoire qui mémorise les opérandes et résultats des calculs. La séparation entre processeur et mémoire est nécessaire pour qu'un appareil électronique soit qualifié d'ordinateur. De nombreux appareils n'ont pas de séparation entre unité de traitement et mémoire, comme certaines vielles radios AM/FM.

[[File:Schéma de principe d'un ordinateur.png|centre|vignette|upright=2|Schéma de principe d'un ordinateur]]

===Un ordinateur est un appareil programmable===

Les appareils simples sont non-programmables, ce qui veut dire qu’ils sont conçus pour une utilisation particulière et qu’ils ne peuvent pas faire autre chose. Par exemple, les circuits électroniques d’un lecteur de DVD ne peuvent pas être transformé en lecteur audio ou en console de jeux... Les circuits non-programmables sont câblés une bonne fois pour toute, et on ne peut pas les modifier. On peut parfois reconfigurer le circuit, pour faire varier certains paramètres, via des interrupteurs ou des boutons, mais cela s’arrête là. Et cela pose un problème : à chaque problème qu'on veut résoudre en utilisant un automate, on doit recréer un nouveau circuit.

À l'inverse, un ordinateur n’est pas conçu pour une utilisation particulière, contrairement aux autres objets techniques. Il est possible de modifier leur fonction du jour au lendemain, on peut lui faire faire ce qu’on veut. On dit qu'ils sont '''programmables'''. Pour cela, il suffit d’utiliser un logiciel, une application, un programme (ces termes sont synonymes), qui fait ce que l'on souhaite. La totalité des logiciels présents sur un ordinateur sont des programmes comme les autres, même le système d'exploitation (Windows, Linux, ...) ne fait pas exception.

Un programme est une suite de d'instructions, chaque instruction effectuant une action dans l'ordinateur. Sur les ordinateurs modernes, la majorité de ces instructions effectuent une opération arithmétique, comme une addition, une multiplication, une soustraction, etc. Les ordinateurs modernes sont donc de grosses calculettes très puissantes, capables d'effectuer des millions d'opérations par secondes. Et qui dit opération dit nombres : un ordinateur gère nativement des nombres, qui sont codés en binaire sur la quasi-totalité des ordinateurs modernes.

Une instruction est représentée dans un ordinateur par une série de nombres : un nombre qui indique quelle opération/commande effectuer et des autres nombres pour coder les données (ou de quoi les retrouver dans l'ordinateur). L'ordinateur récupére les commandes une par une, les traduit en opération à effectuer, exécuter l'opération, et enregistre le résultat. Puis il recommence avec la commande suivante.

[[File:Ordinateur Théorique Complexe 1.png|centre|vignette|upright=3|Ordinateur Théorique Complexe. En jaune, le programme informatique, la liste de commande. Le rectangle gris est l'ordinateur proprement dit.]]

De nombreux appareils sont programmables, mais tous ne sont pas des ordinateurs. Par exemple, certains circuits programmables nommés FPGA n'en sont pas. Pour être qualifié d'ordinateur, un appareil programmable doit avoir un processeur séparé de la mémoire. De plus, il doit utiliser un '''codage numérique''', chose que nous allons aborder dans le chapitre suivant.

===Les ordinateurs à programme mémorisé ou programme externe===

Au tout début de l'informatique, on utilisait des cartes perforées en plastique, sur lesquelles on inscrivait le programme à exécuter, les données à traiter, bref : tout ce qu'on donnait à manger à l'ordinateur. Par la suite, les premiers ordinateurs grand public, comme les Amstrad ou les Commodore, utilisaient des cassettes audio magnétiques pour stocker les programmes. Dans le même style, les consoles de jeu utilisaient autrefois des cartouches de jeu, qui contenaient le programme du jeu à exécuter. Pour résumer, les anciens ordinateurs mémorisaient les programmes sur un support externe, lu par un périphérique. De tels ordinateurs sont dits à '''programme externe'''.

: D’anciens ordinateurs personnels, comme l’Amstrad ou le Commodore, permettaient de taper les programmes à exécuter à la main, au clavier, avant d’appuyer une touche pour les exécuter. Nul besoin de vous dire que les cassettes audio étaient plus pratiques.

Mais de nos jours, les programmes sont enregistrés sur le disque dur de l'ordinateur ou dans une mémoire intégrée à l'ordinateur. On dit qu'ils sont installés, ce qui est un mot bien compliqué pour dire que le programme est enregistré sur le disque dur de l’ordinateur. A défaut de disque dur, le programme/logiciel est enregistré dans une mémoire spécialisée pour le stockage. Par exemple, sur les cartes électroniques grand public de marque Arduino, les programmes sont envoyés à la carte via le port USB, mais les programmes sont enregistrés dans la carte Arduino, dans une mémoire FLASH dédiée. Disque dur ou non, le programme est mémorisé dans la mémoire de l'ordinateur. Il est possible d'installer ou de désinstaller les programmes en modifiant le contenu de la mémoire. Le terme utilisé est alors celui de '''programme stocké en mémoire'''.

Les programmes à installer sont disponibles soit sur un périphérique, comme un DVD ou une clé USB, soit sont téléchargés depuis internet. Les premiers PC fournissaient les logiciels sur des disquettes, qui contenaient un programme d'installation pour enregistrer le programme sur le disque dur de l'ordinateur. Par la suite, le support des logiciels a migré vers les CD et DVD, les logiciels devenant de plus en plus gros. De nos jours, la majorité des applications sont téléchargées depuis le net, l'usage de périphériques est devenu obsolète, même les consoles de jeu abandonnent cette méthode de distribution.

==Les générations d'ordinateurs : un historique rapide==

L'informatique a beaucoup évolué dans le temps. Et une bonne partie de cette évolution tient à l'évolution de l’électronique sous-jacente. Les ordinateurs actuels sont fabriqués avec des transistors, des petits composants électroniques qui servent d'interrupteur programmables, qu'on détaillera dans ce qui suit. Mais ça n'a pas toujours été le cas. Et cela permet de distinguer plusieurs '''générations d'ordinateurs'''.

===Le ordinateurs électro-mécaniques : les premiers ordinateurs===

Le tout premier ordinateur est le '''Z1''', un modèle unique inventé par Konrad Suze entre 1936 et 1938. Son processeur gérait non pas des nombres entiers, mais des nombres à virgule (des nombres dits flottants, pour être précis), encodés sur 22 bits. Le processeur du Z1 était capable de faire des additions et des soustractions, car il intégrait un circuit additionneur-soustracteur basique. Des circuits annexes permettaient de faire des multiplications et des divisions en enchainant des additions/soustractions successives. Il fonctionnait à une fréquence de 1 Hz, ce qui fait qu'il pouvait faire une addition/soustraction par seconde maximum.

[[File:Blue-punch-card-front.png|vignette|upright=0.5|Carte Perforée.]]

Niveau mémoire, la RAM de l'ordinateur était très limitée : seulement 16 nombres de 22 bits chacun. S'il s'agissait d'une mémoire électronique, les programmes étaient mémorisés sur une mémoire mécanique. Les programmes étaient enregistrés sur des cartes perforées, à savoir des cartes en papier dans lesquelles un 1 est codé par un trou dans le papier et un 0 par une absence de trou. Les programmes étaient exécutés par l'ordinateur quand on insérait la carte perforée dans le lecteur et qu'on appuyait sur un bouton.

Après sa destruction dans un bombardement lors de la seconde guerre mondiale, le Z1 a été remplacé par un modèle dit Z2, lui-même suivi par le Z3, qui n'étaient que des améliorations du Z1. Tous étaient des ordinateurs dit '''électro-mécaniques''', car ils mélangeaient des composants électroniques (des relais) et des composants mécaniques (tout ce qui a trait aux cartes perforées, notamment). Les ordinateur qui ont suivi, avant les années 50, étaient tous de ce type. En 1944, le Harvard Mark I a été mis en service, suivi par le Z4 l'année suivante.

[[File:German Museum of Technology, Berlin 2017 024.jpg|centre|vignette|upright=2|Réplique du Z1 au ''German Museum of Technology'' de Berlin, 2017.]]

===Les premières générations : des ordinateurs qui prenaient des pièces de bâtiment entières===

[[File:IBM 7070.jpg|vignette|Cartes imprimées de l'IBM 704, avec des transistors et résistances dessus.]]

La '''première génération d'ordinateur''' est celle située entre les premiers ordinateurs électro-mécaniques et les ordinateurs datant d'avant l'invention du transistor. Ils étaient conçus avec des tubes à vide ou des relais, des composants électroniques assez rudimentaires. Les ordinateurs de première génération étaient très simples, ils ne géraient que quelques opérations simples : l'addition, la soustraction, pas grand chose de plus. A quelques exceptions près, ils ne géraient pas la multiplication et encore moins la division, ils n'avaient pas assez de relais ou de tubes à vides à disposition pour cela.

La '''seconde génération''' est celle des ordinateurs fabriqués avec des '''transistors''' isolés, reliés entre avec des fils électriques. Les transistors en question possèdent trois broches, des pattes métalliques sur lesquelles on connecte des fils électriques. Le transistor s'utilise le plus souvent comme un interrupteur commandé par sa troisième broche. Le courant qui traverse les deux premières broches passe ou ne passe pas selon ce qu'on met sur la troisième.

[[File:Transistor basic flow.svg|centre|vignette|Un transistor est un morceau de conducteur, dont la conductivité est contrôlée par sa troisième broche/borne.]]

Les ordinateurs de seconde génération avaient entre 1000 et 500 000 transistors. Les capacités des ordinateurs étaient donc nettement supérieures à celles des ordinateurs de première génération. Une part non négligeable des ordinateurs de seconde génération supportait l'opération de multiplication, absente sur les ordinateurs de première génération. Néanmoins, cela variait beaucoup selon les ordinateurs.

Un exemple assez hors du commun est celui du premier modèle de l'IBM 1620. Le tout premier modèle n'avait aucun circuit de calcul, il n'était même pas capable de faire une addition ou une multiplication. A la place, il utilisait une table d'addition et une table de multiplication en mémoire RAM. Les deux tables devaient être initialisées par le logiciel lors du démarrage de la machine. La table d'addition faisait une centaine de chiffre, la table de multiplication faisait le double. Le processeur de l'ordinateur gérait des instructions pour faire des additions ou des multiplications, mais ces opérations lisaient le résultat dans la table d'addition. Les calculs étaient fait chiffre par chiffre, avec un encodage partiellement décimal, partiellement binaire (des chiffres décimaux étaient encodés en binaire, nous en reparlerons quand nous parlerons du BCD) !

[[File:KL CoreMemory.jpg|vignette|Mémoire à tore de ferrite.]]

Les transistors n'étaient utilisés que pour le processeur et les circuits annexes. La mémoire n'était pas faite en transistors, pas à cette époque. La mémoire était une mémoire aujourd'hui abandonnée, appelée une '''mémoire à tores de ferrite'''. Elle sera détaillée dans un chapitre ultérieur. Mais sachez pour le moment qu'il s'agit d'une mémoire au support magnétique, les données étant stockées sur un support magnétique.

Transistors comme tubes à vide prenaient beaucoup de place, ce qui fait que les ordinateurs étaient assez gros. Concrètement, ils prenaient une pièce de bâtiment entière dans le meilleur des cas. C'était l'époque des gros ''mainframes'', reliés à des terminaux, peu puissants comparé aux standards actuels. Seules les grandes entreprises et les grands instituts de recherche pouvaient se payer les services de ce genre d'ordinateurs. Seuls les professionnels avaient accès à ce genre d'équipement.

===La troisième génération : le circuit intégré===

[[File:D8259AC-2.jpg|vignette|Exemple de circuit intégré.]]

La troisième génération est toujours fabriquée avec des transistors, mais dont la taille a été réduite. Avec l'évolution de la technologie, les transistors ont diminué en taille, de plus en plus. Ils sont devenus tellement petits qu'ils ont finit par être regroupés dans des '''circuits intégrés''', des circuits regroupent plusieurs transistors sur la même puce de silicium. Les circuits intégrés se présentent le plus souvent sous la forme de boitiers rectangulaires, comme illustré ci-contre. D'autres ont des boitiers de forme carrées, comme ceux que l'on peut trouver sur les barrettes de mémoire RAM, ou à l'intérieur des clés USB/ disques SSD.

Lors de cette génération, les processeurs étaient fournis en pièces détachées qu'il fallait relier entre elles. Le processeur était composé de plusieurs circuits intégrés séparés, impossible de mettre un processeur dans un seul boitier. Un exemple de processeur conçu en kit est la série des Intel 3000. Elle regroupe plusieurs circuits séparés aux noms à coucher dehors, mais dont vous comprendrez ce qu'ils veulent dire dans les chapitres adéquats : l'Intel 3001 est un séquenceur, l'Intel 3002 regroupe unité de calcul et registres, le 3003 est un circuit d'anticipation de retenue complémentaire du 3002, le 3212 est une mémoire tampon, le 3214 est une unité de gestion des interruptions, les 3216/3226 sont des interfaces de bus mémoire. On pourrait aussi citer la famille de circuits intégrés AMD Am2900.

Même si le processeur était en pièce détachées, utiliser une dizaine de circuits intégrés était nettement mieux que d'utiliser plusieurs milliers de transistors individuels. En conséquence, les ordinateurs ont vu leur taille grandement réduite, passant de pièces entières à une simple armoire, voire à quelques cartes intégrées superposées. De plus, le prix des circuits intégré était abordable, du moins comparé aux ordinateurs d'avant. Le prix des ordinateurs a alors grandement décru, permettant à des entreprises et administrations de taille modeste de s'équiper d'ordinateurs.

===La quatrième génération : le microprocesseur===

[[File:MOS6502.svg|vignette|Microprocesseur, ici un processeur MOS6502, de la quatrième génération.]]

Lors de la troisième génération, les circuits intégrés regroupaient plusieurs dizaines ou centaines de transistors, mais sont rapidement montés en gamme. De centaines de transistors, ils sont passé au milliers de transistors, puis au millions et maintenant au-delà du milliard. Les transistors étaient devenus tellement petits, tellement miniaturisés, qu'il était devenu possible de mettre un processeur entier dans un circuit intégré. C'est ainsi qu'est né le microprocesseur, à savoir un processeur qui tient tout entier dans un seul circuit imprimé. La quatrième génération d’ordinateur est celle des ordinateurs basés autour d'un microprocesseur.

Les tout premiers microprocesseurs étaient des processeurs à application militaire, comme le processeur du F-14 CADC ou celui de l'Air data computer. Le tout premier microprocesseur commercialisé au grand public est le 4004 d'Intel, sorti en 1971. L'intel 4004 comprenait environ 2300 transistors, avait une fréquence de 740 MHz, pouvait faire 46 opérations différentes, et manipulait des entiers de 4 bits. Il était au départ un processeur de commande, prévu pour être intégré dans la calculatrice Busicom calculator 141-P, mais il fut utilisé pour d'autres applications quelque temps plus tard. Immédiatement après le 4004, les premiers microprocesseurs 8 bits furent commercialisés. Le 4004 fut suivi par le 8008 et quelques autres processeurs 8 bits extrêmement connus, comme le 8080 d'Intel, le 68000 de Motorola, le 6502 ou le Z80.

Les microprocesseurs permirent encore uen fois de réduire la taille des ordinateurs, qui pouvaient tenir dans un boitier de PC, ou un boitier de console de jeu. Le prix des ordinateurs a aussi chuté en même temps que les transistors était miniaturisés. C'est cette invention qui permis l'invention des consoles de jeux et des mini-ordinateurs, à savoir les ordinateurs personnels. Sans miniaturisation, on n'aurait pas d'ordinateur personnel, pas de PC fixe ou portable.

==L'organisation du cours : les différents niveaux d'explication==

Le fonctionnement d'un ordinateur est assez complexe à expliquer car les explications peuvent se faire sur plusieurs niveaux. Par plusieurs niveaux, on veut dire qu'un ordinateur est composé de composants très simples, qui sont assemblés pour donner des composants eux-même plus complexes, qui sont eux-même regrouper, etc. Étudier tout cela demande de voir plusieurs niveaux, allant de transistors très petits à des processeurs multicœurs. Les niveaux les plus bas sont de l'électronique pur et dure, alors que ceux plus haut sont à mi-chemin entre électronique et informatique.

===Les niveaux d'abstraction en architecture des ordinateurs===

Les trois premiers niveaux sont de l'électronique pur et dure. Ils correspondent aux premiers chapitres du cours, qui porteront sur les circuits électroniques en général.
* Le premier niveau est celui des '''transistors''', des circuits intégrés, des ''wafer'' et autres circuits de très petite taille.
* Le second niveau est celui des '''portes logiques''', des circuits très basiques, très simples, à la base de tous les autres.
* Le troisième niveau est celui dit de la '''''Register Transfer Level''''', où un circuit électronique est construit à partir de circuits basiques, dont des registres et autres circuits dits combinatoires.
Les deux niveaux suivants sont de l'informatique proprement dit. C'est dans ces deux niveaux qu'on étudie les ordinateurs proprement dit, les circuits qu'il y a dedans et non l'électronique en général.
* Le quatrième niveau est celui de la '''microarchitecture''', qui étudie ce qu'il y a à l'intérieur d'un processeur, d'une mémoire, des périphériques et autres.
* Le cinquième niveau est celui de l''''architecture externe''', qui décrit l'interface du processeur, de la mémoire, d'un périphérique ou autre. Par décrire l'interface, on veut dire : comment un programmeur voit le processeur et la mémoire, comment il peut les manipuler. Une architecture externe unique peut avoir plusieurs microarchitecture, ce qui fait qu'on sépare les deux. Tout cela sera plus clair quand on passera aux chapitres sur le processeur et les mémoires.

Nous n'allons pas voir les 5 niveaux dans l'ordre, des transistors vers l'architecture externe. En réalité, nous allons procéder autrement. La première partie du cours portera sur les trois premiers niveaux, le reste sur les deux autres. Les 5 niveaux seront vus dans des chapitres séparés, du moins le plus possible. Au niveau pédagogique, tout est plus simple si on scinde les 5 niveaux. Bien sûr, il y a quelques explications qui demandent de voir plusieurs niveaux à la fois. Par exemple, dans le chapitre sur les mémoires caches, nous auront des explications portant sur la RTL, la microarchitecture du cache et son architecture externe. Mais le gros du cours tentera de séparer le plus possible les 5 niveaux.

===Les trois parties principales du cours===

Nous allons commencer par parler du binaire, avant de voir les portes logiques. Avec ces portes logiques, nous allons voir comment fabriquer des circuits basiques qui reviendront très souvent dans la suite du cours. Nous verrons les registres, les décodeurs, les additionneurs et plein d'autres circuits. Puis, nous reviendrons au niveau des transistors pour finir la première partie. La raison est que c'est plus simple de faire comme cela. Tout ce qui a trait aux transistors sert à expliquer comment fabriquer des portes logiques, et il faut expliquer les portes logiques pour voir le niveau de la RTL.

Une fois la première partie finie, nous allons voir les différents composants d'un ordinateur. Une première partie expliquera ce qu'il y a dans un ordinateur, quels sont ses composants. Nous y parlerons de l'architecture de base, de la hiérarchie mémoire, des tendances technologiques, et d'autres généralités qui serviront de base pour la suite. Puis, nous verrons dans l'ordre les bus électroniques, les mémoires RAM/ROM, le processeur, les périphériques, les mémoires de stockage (SSD et disques durs) et les mémoires caches. Pour chaque composant, nous allons voir leur architecture externe, avant de voir leur microarchitecture. La raison est que la microarchitecture ne peut se comprendre que quand on sait quelle architecture externe elle implémente.

Enfin, dans une troisième partie, nous allons voir les optimisations majeures présentes dans tous les ordinateurs modernes, avec une partie sur le pipeline et le parallélisme d'instruction, et une autre sur les architectures parallèles. Pour finir, les annexes de fin parlerons de sujets un peu à part.

&lt;noinclude&gt;
{{NavChapitre | book=Fonctionnement d'un ordinateur
           | next=L'encodage des données
           | nextText=L'encodage des données
}}
&lt;/noinclude&gt;</text>
      <sha1>1ok14p5hrxzjt46knoaqm0a8r9oq8wc</sha1>
    </revision>
    <revision>
      <id>744103</id>
      <parentid>744102</parentid>
      <timestamp>2025-06-04T20:42:32Z</timestamp>
      <contributor>
        <username>Mewtow</username>
        <id>31375</id>
      </contributor>
      <minor />
      <comment>/* Le ordinateurs électro-mécaniques : les premiers ordinateurs */</comment>
      <origin>744103</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="40436" sha1="3gd1ujny5bzik8cjjx66800t174pmbt" xml:space="preserve">Pour commencer, nous allons voir qu'il existe de nombreux types d'ordinateurs. Le plus connu est certainement le PC, l'ordinateur personnel, que vous avez sans doute dans votre salon. Les ordinateurs portables sont un deuxième type d'ordinateur assez intuitif, que vous avez peut-être. Mais il y a aussi d'autres types d'ordinateurs auxquels vous n'avez jamais été confrontés.

==Les différents types d'ordinateurs==

Dans cette section, nous allons décrire rapidement les ordinateurs les plus courant, mais surtout voir ce qu'il y a à l'intérieur d'un ordinateur.

===L'ordinateur de type PC fixe===

De l'extérieur, l'ordinateur est composé d'une unité centrale sur laquelle on branche des périphériques.

[[File:Typical computer architecture systems.jpg|vignette|upright=1.5|Exemples de périphériques, connectés à une unité centrale (ici appelée à tort ''operating system'').]]

Les '''périphériques''' regroupent l'écran, la souris, le clavier, l'imprimante, et bien d'autres choses. Ils permettent à l'utilisateur d'interagir avec l'ordinateur : un clavier permet de saisir du texte sous dans un fichier, une souris enregistre des déplacements de la main en déplacement du curseur, un écran affiche des données d’images/vidéos, un haut-parleur émet du son, etc. Tout ce qui est branché sur un ordinateur est, formellement un périphérique.

L''''unité centrale''' est là où se trouvent tous les composants importants d'un ordinateur, ceux qui font des calculs, qui exécutent des logiciels, qui mémorisent vos données, etc. Voici ce à quoi ressemble l'intérieur de l'unité centrale. Trois sections sont visibles : l'alimentation électrique en haut à gauche, la carte mère en bas à gauche et en jaune/orange, les disques et lecteurs à droite des câbles. Et on voit aussi beaucoup de câbles.

[[File:Asus P5K-SEIntel E6320.jpg|centre|vignette|upright=2|Exemple d'unité centrale.]]

Tout en haut à gauche, se trouve l''''alimentation électrique''', qui convertit le courant de la prise électrique en un courant plus faible, utilisable par les autres composants. Elle émet de nombreux câbles assez gros, qui sont reliés au reste. Les PC actuels utilisent des alimentations électriques standardisées, qui fournissent trois tensions au reste de l'ordinateur : une tension de 12 Volts, une de 5 Volts, une de 3,3 Volts.

À droite, caché par la partie &quot;métallique&quot; du boitier, se trouvent les lecteurs de CD/DVD, et les disques durs. Les lecteurs CD-ROM ou DVD-ROM permettaient de lire des CD ou des DVD. Je parle au passé, car ils ont aujourd'hui disparu des ordinateurs modernes. Les '''disques durs''' sont des mémoires de stockage, qui mémorisent vos données de manière permanente. De nos jours, ils sont remplacés par des SSD, qui sont des disques durs électroniques, là où les disques durs proprement dit sont des mémoires magnétiques. Nous verrons la différence dans deux chapitres dédiés, un sur les disques durs, l'autre sur les SSD.

En bas à droite, se trouve la '''carte mère''' un support plat, en plastique ou en céramique, sur laquelle sont soudés/connectés les autres composants. Sur celle-ci, de nombreux composants sont soudés, d'autres sont branchés dessus avec des câbles, d'autres sont connectés dessus avec des connecteurs. Ils sont reliés entre eux par des fils conducteurs, le plus souvent du cuivre ou de l’aluminium, ce qui leur permet de s’échanger des données. Sur les cartes simples, ces fils sont intégrés dans la carte électronique, dans des creux du plastique. Ils portent le nom de pistes.

Avant, les disques durs, SSD et lecteurs de CD/DVD sont branchés dessus via des connecteurs dédiés, appelés des connecteurs S-ATA. De nos jours, ils sont branchés sur un autre connecteur, grâce à l'interface NVME. Toujours est-il qu'ils sont reliés à la carte mère par des câbles, ce qui montre que ce sont des sortes de périphériques interne. Ils sont placés dans le boitier, mais on aurait tout aussi bien pu les mettre à l'extérieur, vu qu'ils communiquent avec l'ordinateur par l'intermédiaire d'un câble ou d'un connecteur dédié.

Mais deux autres composants très importants sont eux placés sur la carte mère, directement. Ils ont chacun un connecteur dédié, sur lequel ils sont branchés directement, sans passer par l'intermédiaire d'un câble, mais sans être soudés non plus. Il s'agit du processeur et de la mémoire RAM, deux composants centraux des PC modernes.

[[File:Pentium III SL4CB.jpg|thumb|Processeur Pentium III.]]

Le '''processeur''' traite les données, les modifie, les manipule. Pour faire simple, il s’agit d’une grosse calculatrice hyper-puissante. Il comprend à la fois un circuit qui fait des calculs, et un circuit de contrôle qui s'occupe de séquencer les calculs dans l'ordre demandé. Il est souvent caché sous un radiateur, lui-même surmonté par un ventilateur. En effet, un processeur chauffe beaucoup, ce qui demande d'évacuer cette chaleur. Un chapitre entier expliquera pourquoi les processeurs chauffent, ainsi que les techniques utilisées pour limiter leur production de chaleur et leur consommation électrique.

La '''mémoire vive''' conserve des informations/données temporairement, tant que le processeur en a besoin. Elle prend la forme de barrettes de RAM, comme montré ci-dessous.

[[File:2 gb ddr2 667.jpg|centre|vignette|upright=2|Barrette de RAM.]]

Outre ces composants dits principaux, un ordinateur peut comprendre plusieurs composants moins importants, surtout présents sur les ordinateurs personnels. Ils sont techniquement facultatifs, mais sont très présents dans les ordinateurs personnels. Cependant, certains ordinateurs spécialisés s'en passent. Il s'agit des diverses '''cartes d'extension''' sont branchées sur la carte mère. Elles permettent d’accélérer certains calculs ou certaines applications, afin de décharger le processeur. Par exemple, la carte graphique s'occupe des calculs graphiques, qu'il s'agisse de graphismes 3D de jeux vidéos ou de l'affichage en 2D du bureau. Dans un autre registre, la carte son prend en charge le microphone et les haut-parleurs.

[[Fichier:Personal computer, exploded 4.svg|thumb|upright=1.0|Éclaté d'un ordinateur de type PC :&lt;br /&gt;
1 : Écran ;&lt;br /&gt;
2 : Carte mère ;&lt;br /&gt;
3 : Processeur ;&lt;br /&gt;
4 : Câble Parallel ATA ;&lt;br /&gt;
5 : Mémoire vive (RAM) ;&lt;br /&gt;
6 : Carte d'extension ;&lt;br /&gt;
7 : Alimentation électrique ;&lt;br /&gt;
8 : Lecteur de disque optique ;&lt;br /&gt;
9 : Disque dur ;&lt;br /&gt;
10 : Clavier ;&lt;br /&gt;
11 : Souris.]]

Si on regarde une carte mère de face, on voit un grand nombre de connecteurs, mais aussi des circuits électroniques soudés à la carte mère.

[[File:Architecture matérielle d'une carte mère.png|centre|vignette|upright=2.0|Architecture matérielle d'une carte mère]]

Les '''connecteurs''' sont là où on branche les périphériques, la carte graphique, le processeur, la mémoire, etc. Dans l'ensemble, toute carte mère contient les connecteurs suivants :
* Le processeur vient s’enchâsser dans la carte mère sur un connecteur particulier : le '''socket'''. Celui-ci varie suivant la carte mère et le processeur, ce qui est source d'incompatibilités.
* Les barrettes de mémoire RAM s’enchâssent dans un autre type de connecteurs: les '''slots mémoire'''.
* Les mémoires de masse disposent de leurs propres connecteurs : connecteurs P-ATA pour les anciens disques durs, et S-ATA pour les récents.
* Les périphériques (clavier, souris, USB, Firewire, ...) sont connectés sur un ensemble de connecteurs dédiés, localisés à l'arrière du boitier de l'unité centrale. 
* Les autres périphériques sont placés dans l'unité centrale et sont connectés via des connecteurs spécialisés. Ces périphériques sont des cartes imprimées, d'où leur nom de '''cartes filles'''. On peut notamment citer les cartes réseau, les cartes son, ou les cartes vidéo.

===Les ordinateurs portables===

[[File:Samsung QX-511 (2).JPG|vignette|Ordinateur portable Samsung QX-511 (2), pour illustration.]]

Un ordinateur portable est identique à un ordinateur de type PC. Si vous ouvrez votre ordinateur portable (attention à la garantie), vous retrouverez les mêmes composants qu'un PC à l'intérieur. Un point important est la présence d'une batterie à l'intérieur du PC portable, absente des PC fixes.

[[File:LG gram 14Z90Q mainboard with battery.jpg|centre|vignette|upright=2|LG gram 14Z90Q avec sa batterie.]]

Une fois la batterie et les circuits associés retiré, la seule différence notable est que tous les composants sont soudés sur la carte mère, au lieu d'être branchés sur des connecteurs, à part éventuellement la RAM et le disque dur.

[[File:LG gram 14Z90Q mainboard without battery.jpg|centre|vignette|upright=2|LG gram 14Z90Q sans sa batterie.]]

La RAM est parfois soudée sur la carte mère, d'autres fois sous la forme de barrettes de mémoire vive semblables à celles des PC. Dans le dernier cas, elle est connectée à des connecteurs spécifiques, ce qui permet de les changer/upgrader. Les PC portables sont parfois construits de manière à pouvoir changer la RAM facilement, en ouvrant un cache spécial, concu pour.

[[File:Lenovo G555 состав - Донор.JPG|centre|vignette|upright=2|Lenovo G555.]]

La conception d'un ordinateur portable est légèrement différente de celle d'un PC, pour des raisons thermiques. Un PC fixe a plus de place pour évacuer sa chaleur. Les ventilateurs peuvent plus facilement déplacer l'air dans le boitier, même si le flux d'air dans le boitier est éventuellement gêné par la carte graphique. Mais l'évacuation de la chaleur est assez efficace. Sur les PC portables, leur finesse fait que le trajet de l'air est beaucoup plus contraint. Évacuer la chaleur produite par l'ordinateur est plus complexe, ce qui demande d'utiliser des systèmes de refroidissement et de ventilation spécifiques.

Là où les PC fixes se débrouillent avec des radiateurs et des ventilateurs posés sur le processeur, les PC portables font autrement. Ils ne peuvent pas forcément mettre le ventilateur sur le processeur. A la place, ils mettent le ventilateur à côté, mais le processeur est surmonté par un mécanisme de transmission de la chaleur, qui transfère la chaleur du processeur vers le ventilateur.

[[File:Diagram - How a laptop cooling system works.png|centre|vignette|upright=2|Comment fonctionne le système de ventilation d'un ordinateur portable, en anglais.]]

Les difficultés pour dissiper la chaleur font que les ordinateurs portables utilisent souvent des composants peu performants, mais qui chauffent peu. En effet, nous verrons que plus un composant est puissant, plus il chauffe. La relation n'est pas parfaite, mais les processeurs haute performance chauffent plus que les modèles d'entrée ou milieu de gamme moins puissants. En conséquence, les PC portables sont souvent moins puissants que les PC fixes, même pour les modèles dit ''gaming''.

===Les serveurs et ''mainframes''===

Les grandes entreprises utilisent des ordinateurs de grande taille, très puissants, appelés des ''mainframes''. Ils sont souvent confondus avec les serveurs par le grand public, il y a une différence entre les deux. Un serveur est une fonction logicielle/réseau, pas un type d'ordinateur. Mais laissons cette différence de côté, ce qui est dit pour les ''mainframes'' sert pour les gros serveurs haute performance.

[[File:IBM Z15 mainframe.jpg|vignette|Exemple de ''mainframe''' de type IBM Z15.]]

Les anciens ''mainframes'' des années 50-80 avaient une taille pouvant être impressionnante, au point de prendre une pièce complète d'un bâtiment. Mais de nos jours, les ''mainframes'' tiennent dans une grosse armoire un peu haute. Les ''mainframes'' doivent rester allumé en permanence et ne doivent pas être éteint, sauf éventuellement quelques jours par an pour des opérations de maintenance. Ils utilisent pour cela des techniques spécifiques, avec beaucoup de redondance interne.

[[File:ACONIT hall grandes machines.jpg|centre|vignette|upright=2|''Mainframe'' ACONIT.]]

Les ''mainframes'' sont aussi conçus pour mutualiser au maximum leur utilisation, ils peuvent être utilisés par plusieurs utilisateurs à la suite, voire en même temps. Pour cela, les anciens ''mainframes'' étaient capables de faire tourner plusieurs applications distinctes l'une à la suite de l'autre, avec des commutations fréquentes entre logiciels. De nos jours, ils sont capables d'exécuter un grand nombre de tâches en même temps, grâce à la présence de plusieurs processeurs. Les ''mainframes'' modernes sont même capables de faire tourner plusieurs systèmes d'exploitation en même temps si besoin.

Les anciens ''mainframes'' étaient des ordinateurs assez simples, avec un processeur, de la mémoire RAM, un ou plusieurs disques durs, pas plus. Le ''mainframe'' était tellement énorme et cher que les entreprises n'en avaient qu'un seul pour toute l'entreprise. Les employés avaient sur leur bureau des terminaux, qui permettaient d'accéder à l'ordinateur central, mais n'étaient pas des ordinateurs. Les terminaux étaient des composants électroniques simples, avec un écran, un clavier et une souris, mais sans processeur. Ils envoyaient des données au ''mainframe'', ils en recevaient de sa part, mais tout traitement était réalisé sur le ''mainframe''. L'arrivée sur le marché des ordinateurs personnels, de type PC fixe/portable, a entrainé l'abandon de ce genre de pratique, tous les employés ont maintenant un ordinateur rien que pour eux.

{|
|-
! colspan=&quot;2&quot; | Exemples de terminaux
|-
|[[File:Terminal-in2-sm9400.jpg|centre|vignette|upright=1.5|Exemple de terminal. Notez la présence d'un écran et d'un clavier, mais l'asbence d'une unité centrale.]]
|[[File:Chromatics CT4100.jpg|vignette|upright=1.5|Autre exemple de terminal. Le clavier est couplé à un stylo CRT, qui remplacait la souris et agissait sur l'écran comme s'il était tactile.]]
|-
! colspan=&quot;2&quot; | Intérieur d'un terminal
|-
|[[File:CT1024 Monitor.jpg|vignette|upright=1.5|Terminal CT1024, sans le boitier extérieur.]]
|[[File:CT1024 Terminal System.jpg|vignette|upright=1.5|Terminal CT1024, description des composants interne.]]
|}

De nos jours, les ''mainframes'' contiennent en réalité plusieurs ordinateurs simples interconnectés via un réseau local. Un ''mainframe'' qui tient dans une armoire contient facilement une dizaine ou centaine de processeurs, plein de RAM, des disques durs séparés dans une armoire distincte, etc. Vu qu'ils communiquent uniquement via le réseau, ils n'ont pas d'interface, pas d'écran, 'entrée via clavier/souris. Le tout est commandé avec une console de commande, typiquement un ordinateur portable ou un terminal assez simple séparé de l'armoire, qui permet à un administrateur de faire des opérations de surveillance, configuration et maintenance. Il peut y avoir une console de commande pour plusieurs armoires séparées, la console peut même être dans un autre bâtiment et accéder au ''mainframe'' par le réseau.

[[File:IBM System Z9 (type 2094 inside).jpg|centre|vignette|upright=2|''Mainframe'' de type IBM System Z9. L'ordinateur portable sert de console pour qu'un administrateur fasse des opérations de surveillance, configuration et maintenance.]]

Les processeurs et la RAM sont typiquement installés sur des cartes amovibles, qui sont connectées au fond de l'armoire lors de l'installation. Il est même possible de retirer ou d'ajouter des cartes en fonctionnement, afin d'ajouter/retirer des processeurs, des disques durs, etc. Ce qui est très utile si un composant est en panne et qu'il faut le remplacer. 

[[File:IBM TotalStorage Exp400.jpg|centre|vignette|upright=2|IBM TotalStorage Exp400]]

==Un peu d'abstraction : qu'est-ce qu'un ordinateur ?==

Un ordinateur comprend donc un processeur, plusieurs mémoires, des cartes d'extension et une carte mère pour connecter le tout. Mais il s'agit là d'une description assez terre-à-terre de ce qu'est un ordinateur. Une autre description, plus abstraite, se base sur le fait qu'un ordinateur est une énorme calculatrice programmable. Elle permet d'expliquer pourquoi il y a une distinction entre processeur et mémoire, entre unité centrale et périphériques. Tout ce qui va suivre pourra vous paraitre assez abstrait, mais rassurez-vous : les prochains chapitres rendront tout cela plus concrets.

===La séparation entre entrées-sorties et traitement===

L'unité centrale peut être vue comme une énorme calculatrice ultra-puissante, qui exécute des commandes/opérations. Mais à elle seule, elle ne servirait à rien, il faut interagir avec par l'intermédiaire de plusieurs périphériques. Il existe deux types de périphériques, qui sont conceptuellement différents. Les périphériques comme le clavier ou la souris permettent d'envoyer des informations à l'ordinateur, d'agir sur celui-ci. A l'inverse, les écrans transmettent des informations dans le sens inverse : de l'ordinateur vers l'utilisateur. Les premiers sont appelés des '''entrées''', les seconds des '''sorties'''.

Dans un ordinateur, les informations sont représentées sous la forme de nombres. Toute donnée dans un ordinateur est codée avec un ou plusieurs nombres regroupés dans une donnée, un fichier, ou autre. Et la transmissions avec les entrées et sorties se fait là-encore avec des nombres. Par exemple, quand vous appuyez sur votre clavier, le clavier envoie un numéro de touche à l'unité centrale, qui indique quelle touche a été appuyée. L'image à afficher à l'écran est codée sous la forme d'une suite de nombres (un par pixel). L'image est envoyée à l'écran, qui traduit la suite de nombre en image à afficher. Les entrées traduisent des actions utilisateurs en nombres, on dit que les entrées encodent les actions utilisateur. Les sorties font la traduction inverse, elles transforment des suites de nombres en une action physique. On dit qu'elles décodent des informations.

Pour résumer, toute appareil électronique est composé par :
* Des '''entrées''' sur lesquelles l'utilisateur agit sur l'ordinateur. Les entrées transforment les actions de l'utilisateur en nombres, qui sont interprétés par l'ordinateur.
* Une '''unité de traitement''', qui manipule des nombres et fait des calculs/opérations dessus. Les nombres proviennent des entrées, du disque dur, ou d'autres sources, peu importe.
* Des '''sorties''', qui va récupèrent le résultat calculé par l'unité de traitement pour en faire quelque chose : écrire sur une imprimante ou sur un moniteur, émettre du son,...

[[File:Ordinateur théorique Simple 1.png|centre|vignette|upright=2|Ordinateur théorique Simple 1]]

L'unité de traitement proprement dite, celle qui fait les calculs, est couplée à une mémoire qui mémorise les opérandes et résultats des calculs. La séparation entre processeur et mémoire est nécessaire pour qu'un appareil électronique soit qualifié d'ordinateur. De nombreux appareils n'ont pas de séparation entre unité de traitement et mémoire, comme certaines vielles radios AM/FM.

[[File:Schéma de principe d'un ordinateur.png|centre|vignette|upright=2|Schéma de principe d'un ordinateur]]

===Un ordinateur est un appareil programmable===

Les appareils simples sont non-programmables, ce qui veut dire qu’ils sont conçus pour une utilisation particulière et qu’ils ne peuvent pas faire autre chose. Par exemple, les circuits électroniques d’un lecteur de DVD ne peuvent pas être transformé en lecteur audio ou en console de jeux... Les circuits non-programmables sont câblés une bonne fois pour toute, et on ne peut pas les modifier. On peut parfois reconfigurer le circuit, pour faire varier certains paramètres, via des interrupteurs ou des boutons, mais cela s’arrête là. Et cela pose un problème : à chaque problème qu'on veut résoudre en utilisant un automate, on doit recréer un nouveau circuit.

À l'inverse, un ordinateur n’est pas conçu pour une utilisation particulière, contrairement aux autres objets techniques. Il est possible de modifier leur fonction du jour au lendemain, on peut lui faire faire ce qu’on veut. On dit qu'ils sont '''programmables'''. Pour cela, il suffit d’utiliser un logiciel, une application, un programme (ces termes sont synonymes), qui fait ce que l'on souhaite. La totalité des logiciels présents sur un ordinateur sont des programmes comme les autres, même le système d'exploitation (Windows, Linux, ...) ne fait pas exception.

Un programme est une suite de d'instructions, chaque instruction effectuant une action dans l'ordinateur. Sur les ordinateurs modernes, la majorité de ces instructions effectuent une opération arithmétique, comme une addition, une multiplication, une soustraction, etc. Les ordinateurs modernes sont donc de grosses calculettes très puissantes, capables d'effectuer des millions d'opérations par secondes. Et qui dit opération dit nombres : un ordinateur gère nativement des nombres, qui sont codés en binaire sur la quasi-totalité des ordinateurs modernes.

Une instruction est représentée dans un ordinateur par une série de nombres : un nombre qui indique quelle opération/commande effectuer et des autres nombres pour coder les données (ou de quoi les retrouver dans l'ordinateur). L'ordinateur récupére les commandes une par une, les traduit en opération à effectuer, exécuter l'opération, et enregistre le résultat. Puis il recommence avec la commande suivante.

[[File:Ordinateur Théorique Complexe 1.png|centre|vignette|upright=3|Ordinateur Théorique Complexe. En jaune, le programme informatique, la liste de commande. Le rectangle gris est l'ordinateur proprement dit.]]

De nombreux appareils sont programmables, mais tous ne sont pas des ordinateurs. Par exemple, certains circuits programmables nommés FPGA n'en sont pas. Pour être qualifié d'ordinateur, un appareil programmable doit avoir un processeur séparé de la mémoire. De plus, il doit utiliser un '''codage numérique''', chose que nous allons aborder dans le chapitre suivant.

===Les ordinateurs à programme mémorisé ou programme externe===

Au tout début de l'informatique, on utilisait des cartes perforées en plastique, sur lesquelles on inscrivait le programme à exécuter, les données à traiter, bref : tout ce qu'on donnait à manger à l'ordinateur. Par la suite, les premiers ordinateurs grand public, comme les Amstrad ou les Commodore, utilisaient des cassettes audio magnétiques pour stocker les programmes. Dans le même style, les consoles de jeu utilisaient autrefois des cartouches de jeu, qui contenaient le programme du jeu à exécuter. Pour résumer, les anciens ordinateurs mémorisaient les programmes sur un support externe, lu par un périphérique. De tels ordinateurs sont dits à '''programme externe'''.

: D’anciens ordinateurs personnels, comme l’Amstrad ou le Commodore, permettaient de taper les programmes à exécuter à la main, au clavier, avant d’appuyer une touche pour les exécuter. Nul besoin de vous dire que les cassettes audio étaient plus pratiques.

Mais de nos jours, les programmes sont enregistrés sur le disque dur de l'ordinateur ou dans une mémoire intégrée à l'ordinateur. On dit qu'ils sont installés, ce qui est un mot bien compliqué pour dire que le programme est enregistré sur le disque dur de l’ordinateur. A défaut de disque dur, le programme/logiciel est enregistré dans une mémoire spécialisée pour le stockage. Par exemple, sur les cartes électroniques grand public de marque Arduino, les programmes sont envoyés à la carte via le port USB, mais les programmes sont enregistrés dans la carte Arduino, dans une mémoire FLASH dédiée. Disque dur ou non, le programme est mémorisé dans la mémoire de l'ordinateur. Il est possible d'installer ou de désinstaller les programmes en modifiant le contenu de la mémoire. Le terme utilisé est alors celui de '''programme stocké en mémoire'''.

Les programmes à installer sont disponibles soit sur un périphérique, comme un DVD ou une clé USB, soit sont téléchargés depuis internet. Les premiers PC fournissaient les logiciels sur des disquettes, qui contenaient un programme d'installation pour enregistrer le programme sur le disque dur de l'ordinateur. Par la suite, le support des logiciels a migré vers les CD et DVD, les logiciels devenant de plus en plus gros. De nos jours, la majorité des applications sont téléchargées depuis le net, l'usage de périphériques est devenu obsolète, même les consoles de jeu abandonnent cette méthode de distribution.

==Les générations d'ordinateurs : un historique rapide==

L'informatique a beaucoup évolué dans le temps. Et une bonne partie de cette évolution tient à l'évolution de l’électronique sous-jacente. Les ordinateurs actuels sont fabriqués avec des transistors, des petits composants électroniques qui servent d'interrupteur programmables, qu'on détaillera dans ce qui suit. Mais ça n'a pas toujours été le cas. Et cela permet de distinguer plusieurs '''générations d'ordinateurs'''.

===Le ordinateurs électro-mécaniques : les premiers ordinateurs===

Le tout premier ordinateur est le '''Z1''', un modèle unique inventé par Konrad Suze entre 1936 et 1938. Son processeur gérait non pas des nombres entiers, mais des nombres à virgule (des nombres dits flottants, pour être précis), encodés sur 22 bits. Le processeur du Z1 était capable de faire des additions et des soustractions, car il intégrait un circuit additionneur-soustracteur basique. Des circuits annexes permettaient de faire des multiplications et des divisions en enchainant des additions/soustractions successives. Il fonctionnait à une fréquence de 1 Hz, ce qui fait qu'il pouvait faire une addition/soustraction par seconde maximum.

[[File:Blue-punch-card-front.png|vignette|upright=0.5|Carte Perforée.]]

Niveau mémoire, la RAM de l'ordinateur était très limitée : seulement 16 nombres de 22 bits chacun. S'il s'agissait d'une mémoire électronique, les programmes étaient mémorisés sur une mémoire mécanique. Les programmes étaient enregistrés sur des cartes perforées, à savoir des cartes en papier dans lesquelles un 1 est codé par un trou dans le papier et un 0 par une absence de trou. Les programmes étaient exécutés par l'ordinateur quand on insérait la carte perforée dans le lecteur et qu'on appuyait sur un bouton.

Après sa destruction dans un bombardement lors de la seconde guerre mondiale, le Z1 a été remplacé par un modèle dit Z2, lui-même suivi par le Z3, qui n'étaient que des améliorations du Z1. Tous étaient des ordinateurs dit '''électro-mécaniques''', car ils mélangeaient des composants électroniques (des relais) et des composants mécaniques (tout ce qui a trait aux cartes perforées, notamment). Les ordinateur qui ont suivi, avant 1944, étaient tous de ce type.

[[File:German Museum of Technology, Berlin 2017 024.jpg|centre|vignette|upright=2|Réplique du Z1 au ''German Museum of Technology'' de Berlin, 2017.]]

===Les premières générations : des ordinateurs qui prenaient des pièces de bâtiment entières===

[[File:IBM 7070.jpg|vignette|Cartes imprimées de l'IBM 704, avec des transistors et résistances dessus.]]

La '''première génération d'ordinateur''' est celle située entre les premiers ordinateurs électro-mécaniques et les ordinateurs datant d'avant l'invention du transistor. Ils étaient conçus avec des tubes à vide ou des relais, des composants électroniques assez rudimentaires. Les ordinateurs de première génération étaient très simples, ils ne géraient que quelques opérations simples : l'addition, la soustraction, pas grand chose de plus. A quelques exceptions près, ils ne géraient pas la multiplication et encore moins la division, ils n'avaient pas assez de relais ou de tubes à vides à disposition pour cela.

La '''seconde génération''' est celle des ordinateurs fabriqués avec des '''transistors''' isolés, reliés entre avec des fils électriques. Les transistors en question possèdent trois broches, des pattes métalliques sur lesquelles on connecte des fils électriques. Le transistor s'utilise le plus souvent comme un interrupteur commandé par sa troisième broche. Le courant qui traverse les deux premières broches passe ou ne passe pas selon ce qu'on met sur la troisième.

[[File:Transistor basic flow.svg|centre|vignette|Un transistor est un morceau de conducteur, dont la conductivité est contrôlée par sa troisième broche/borne.]]

Les ordinateurs de seconde génération avaient entre 1000 et 500 000 transistors. Les capacités des ordinateurs étaient donc nettement supérieures à celles des ordinateurs de première génération. Une part non négligeable des ordinateurs de seconde génération supportait l'opération de multiplication, absente sur les ordinateurs de première génération. Néanmoins, cela variait beaucoup selon les ordinateurs.

Un exemple assez hors du commun est celui du premier modèle de l'IBM 1620. Le tout premier modèle n'avait aucun circuit de calcul, il n'était même pas capable de faire une addition ou une multiplication. A la place, il utilisait une table d'addition et une table de multiplication en mémoire RAM. Les deux tables devaient être initialisées par le logiciel lors du démarrage de la machine. La table d'addition faisait une centaine de chiffre, la table de multiplication faisait le double. Le processeur de l'ordinateur gérait des instructions pour faire des additions ou des multiplications, mais ces opérations lisaient le résultat dans la table d'addition. Les calculs étaient fait chiffre par chiffre, avec un encodage partiellement décimal, partiellement binaire (des chiffres décimaux étaient encodés en binaire, nous en reparlerons quand nous parlerons du BCD) !

[[File:KL CoreMemory.jpg|vignette|Mémoire à tore de ferrite.]]

Les transistors n'étaient utilisés que pour le processeur et les circuits annexes. La mémoire n'était pas faite en transistors, pas à cette époque. La mémoire était une mémoire aujourd'hui abandonnée, appelée une '''mémoire à tores de ferrite'''. Elle sera détaillée dans un chapitre ultérieur. Mais sachez pour le moment qu'il s'agit d'une mémoire au support magnétique, les données étant stockées sur un support magnétique.

Transistors comme tubes à vide prenaient beaucoup de place, ce qui fait que les ordinateurs étaient assez gros. Concrètement, ils prenaient une pièce de bâtiment entière dans le meilleur des cas. C'était l'époque des gros ''mainframes'', reliés à des terminaux, peu puissants comparé aux standards actuels. Seules les grandes entreprises et les grands instituts de recherche pouvaient se payer les services de ce genre d'ordinateurs. Seuls les professionnels avaient accès à ce genre d'équipement.

===La troisième génération : le circuit intégré===

[[File:D8259AC-2.jpg|vignette|Exemple de circuit intégré.]]

La troisième génération est toujours fabriquée avec des transistors, mais dont la taille a été réduite. Avec l'évolution de la technologie, les transistors ont diminué en taille, de plus en plus. Ils sont devenus tellement petits qu'ils ont finit par être regroupés dans des '''circuits intégrés''', des circuits regroupent plusieurs transistors sur la même puce de silicium. Les circuits intégrés se présentent le plus souvent sous la forme de boitiers rectangulaires, comme illustré ci-contre. D'autres ont des boitiers de forme carrées, comme ceux que l'on peut trouver sur les barrettes de mémoire RAM, ou à l'intérieur des clés USB/ disques SSD.

Lors de cette génération, les processeurs étaient fournis en pièces détachées qu'il fallait relier entre elles. Le processeur était composé de plusieurs circuits intégrés séparés, impossible de mettre un processeur dans un seul boitier. Un exemple de processeur conçu en kit est la série des Intel 3000. Elle regroupe plusieurs circuits séparés aux noms à coucher dehors, mais dont vous comprendrez ce qu'ils veulent dire dans les chapitres adéquats : l'Intel 3001 est un séquenceur, l'Intel 3002 regroupe unité de calcul et registres, le 3003 est un circuit d'anticipation de retenue complémentaire du 3002, le 3212 est une mémoire tampon, le 3214 est une unité de gestion des interruptions, les 3216/3226 sont des interfaces de bus mémoire. On pourrait aussi citer la famille de circuits intégrés AMD Am2900.

Même si le processeur était en pièce détachées, utiliser une dizaine de circuits intégrés était nettement mieux que d'utiliser plusieurs milliers de transistors individuels. En conséquence, les ordinateurs ont vu leur taille grandement réduite, passant de pièces entières à une simple armoire, voire à quelques cartes intégrées superposées. De plus, le prix des circuits intégré était abordable, du moins comparé aux ordinateurs d'avant. Le prix des ordinateurs a alors grandement décru, permettant à des entreprises et administrations de taille modeste de s'équiper d'ordinateurs.

===La quatrième génération : le microprocesseur===

[[File:MOS6502.svg|vignette|Microprocesseur, ici un processeur MOS6502, de la quatrième génération.]]

Lors de la troisième génération, les circuits intégrés regroupaient plusieurs dizaines ou centaines de transistors, mais sont rapidement montés en gamme. De centaines de transistors, ils sont passé au milliers de transistors, puis au millions et maintenant au-delà du milliard. Les transistors étaient devenus tellement petits, tellement miniaturisés, qu'il était devenu possible de mettre un processeur entier dans un circuit intégré. C'est ainsi qu'est né le microprocesseur, à savoir un processeur qui tient tout entier dans un seul circuit imprimé. La quatrième génération d’ordinateur est celle des ordinateurs basés autour d'un microprocesseur.

Les tout premiers microprocesseurs étaient des processeurs à application militaire, comme le processeur du F-14 CADC ou celui de l'Air data computer. Le tout premier microprocesseur commercialisé au grand public est le 4004 d'Intel, sorti en 1971. L'intel 4004 comprenait environ 2300 transistors, avait une fréquence de 740 MHz, pouvait faire 46 opérations différentes, et manipulait des entiers de 4 bits. Il était au départ un processeur de commande, prévu pour être intégré dans la calculatrice Busicom calculator 141-P, mais il fut utilisé pour d'autres applications quelque temps plus tard. Immédiatement après le 4004, les premiers microprocesseurs 8 bits furent commercialisés. Le 4004 fut suivi par le 8008 et quelques autres processeurs 8 bits extrêmement connus, comme le 8080 d'Intel, le 68000 de Motorola, le 6502 ou le Z80.

Les microprocesseurs permirent encore uen fois de réduire la taille des ordinateurs, qui pouvaient tenir dans un boitier de PC, ou un boitier de console de jeu. Le prix des ordinateurs a aussi chuté en même temps que les transistors était miniaturisés. C'est cette invention qui permis l'invention des consoles de jeux et des mini-ordinateurs, à savoir les ordinateurs personnels. Sans miniaturisation, on n'aurait pas d'ordinateur personnel, pas de PC fixe ou portable.

==L'organisation du cours : les différents niveaux d'explication==

Le fonctionnement d'un ordinateur est assez complexe à expliquer car les explications peuvent se faire sur plusieurs niveaux. Par plusieurs niveaux, on veut dire qu'un ordinateur est composé de composants très simples, qui sont assemblés pour donner des composants eux-même plus complexes, qui sont eux-même regrouper, etc. Étudier tout cela demande de voir plusieurs niveaux, allant de transistors très petits à des processeurs multicœurs. Les niveaux les plus bas sont de l'électronique pur et dure, alors que ceux plus haut sont à mi-chemin entre électronique et informatique.

===Les niveaux d'abstraction en architecture des ordinateurs===

Les trois premiers niveaux sont de l'électronique pur et dure. Ils correspondent aux premiers chapitres du cours, qui porteront sur les circuits électroniques en général.
* Le premier niveau est celui des '''transistors''', des circuits intégrés, des ''wafer'' et autres circuits de très petite taille.
* Le second niveau est celui des '''portes logiques''', des circuits très basiques, très simples, à la base de tous les autres.
* Le troisième niveau est celui dit de la '''''Register Transfer Level''''', où un circuit électronique est construit à partir de circuits basiques, dont des registres et autres circuits dits combinatoires.
Les deux niveaux suivants sont de l'informatique proprement dit. C'est dans ces deux niveaux qu'on étudie les ordinateurs proprement dit, les circuits qu'il y a dedans et non l'électronique en général.
* Le quatrième niveau est celui de la '''microarchitecture''', qui étudie ce qu'il y a à l'intérieur d'un processeur, d'une mémoire, des périphériques et autres.
* Le cinquième niveau est celui de l''''architecture externe''', qui décrit l'interface du processeur, de la mémoire, d'un périphérique ou autre. Par décrire l'interface, on veut dire : comment un programmeur voit le processeur et la mémoire, comment il peut les manipuler. Une architecture externe unique peut avoir plusieurs microarchitecture, ce qui fait qu'on sépare les deux. Tout cela sera plus clair quand on passera aux chapitres sur le processeur et les mémoires.

Nous n'allons pas voir les 5 niveaux dans l'ordre, des transistors vers l'architecture externe. En réalité, nous allons procéder autrement. La première partie du cours portera sur les trois premiers niveaux, le reste sur les deux autres. Les 5 niveaux seront vus dans des chapitres séparés, du moins le plus possible. Au niveau pédagogique, tout est plus simple si on scinde les 5 niveaux. Bien sûr, il y a quelques explications qui demandent de voir plusieurs niveaux à la fois. Par exemple, dans le chapitre sur les mémoires caches, nous auront des explications portant sur la RTL, la microarchitecture du cache et son architecture externe. Mais le gros du cours tentera de séparer le plus possible les 5 niveaux.

===Les trois parties principales du cours===

Nous allons commencer par parler du binaire, avant de voir les portes logiques. Avec ces portes logiques, nous allons voir comment fabriquer des circuits basiques qui reviendront très souvent dans la suite du cours. Nous verrons les registres, les décodeurs, les additionneurs et plein d'autres circuits. Puis, nous reviendrons au niveau des transistors pour finir la première partie. La raison est que c'est plus simple de faire comme cela. Tout ce qui a trait aux transistors sert à expliquer comment fabriquer des portes logiques, et il faut expliquer les portes logiques pour voir le niveau de la RTL.

Une fois la première partie finie, nous allons voir les différents composants d'un ordinateur. Une première partie expliquera ce qu'il y a dans un ordinateur, quels sont ses composants. Nous y parlerons de l'architecture de base, de la hiérarchie mémoire, des tendances technologiques, et d'autres généralités qui serviront de base pour la suite. Puis, nous verrons dans l'ordre les bus électroniques, les mémoires RAM/ROM, le processeur, les périphériques, les mémoires de stockage (SSD et disques durs) et les mémoires caches. Pour chaque composant, nous allons voir leur architecture externe, avant de voir leur microarchitecture. La raison est que la microarchitecture ne peut se comprendre que quand on sait quelle architecture externe elle implémente.

Enfin, dans une troisième partie, nous allons voir les optimisations majeures présentes dans tous les ordinateurs modernes, avec une partie sur le pipeline et le parallélisme d'instruction, et une autre sur les architectures parallèles. Pour finir, les annexes de fin parlerons de sujets un peu à part.

&lt;noinclude&gt;
{{NavChapitre | book=Fonctionnement d'un ordinateur
           | next=L'encodage des données
           | nextText=L'encodage des données
}}
&lt;/noinclude&gt;</text>
      <sha1>3gd1ujny5bzik8cjjx66800t174pmbt</sha1>
    </revision>
    <revision>
      <id>744104</id>
      <parentid>744103</parentid>
      <timestamp>2025-06-04T20:50:11Z</timestamp>
      <contributor>
        <username>Mewtow</username>
        <id>31375</id>
      </contributor>
      <minor />
      <comment>/* Les premières générations : des ordinateurs qui prenaient des pièces de bâtiment entières */</comment>
      <origin>744104</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="41648" sha1="36aktwmhiv8hi8qy5hs007nuy7zd6iw" xml:space="preserve">Pour commencer, nous allons voir qu'il existe de nombreux types d'ordinateurs. Le plus connu est certainement le PC, l'ordinateur personnel, que vous avez sans doute dans votre salon. Les ordinateurs portables sont un deuxième type d'ordinateur assez intuitif, que vous avez peut-être. Mais il y a aussi d'autres types d'ordinateurs auxquels vous n'avez jamais été confrontés.

==Les différents types d'ordinateurs==

Dans cette section, nous allons décrire rapidement les ordinateurs les plus courant, mais surtout voir ce qu'il y a à l'intérieur d'un ordinateur.

===L'ordinateur de type PC fixe===

De l'extérieur, l'ordinateur est composé d'une unité centrale sur laquelle on branche des périphériques.

[[File:Typical computer architecture systems.jpg|vignette|upright=1.5|Exemples de périphériques, connectés à une unité centrale (ici appelée à tort ''operating system'').]]

Les '''périphériques''' regroupent l'écran, la souris, le clavier, l'imprimante, et bien d'autres choses. Ils permettent à l'utilisateur d'interagir avec l'ordinateur : un clavier permet de saisir du texte sous dans un fichier, une souris enregistre des déplacements de la main en déplacement du curseur, un écran affiche des données d’images/vidéos, un haut-parleur émet du son, etc. Tout ce qui est branché sur un ordinateur est, formellement un périphérique.

L''''unité centrale''' est là où se trouvent tous les composants importants d'un ordinateur, ceux qui font des calculs, qui exécutent des logiciels, qui mémorisent vos données, etc. Voici ce à quoi ressemble l'intérieur de l'unité centrale. Trois sections sont visibles : l'alimentation électrique en haut à gauche, la carte mère en bas à gauche et en jaune/orange, les disques et lecteurs à droite des câbles. Et on voit aussi beaucoup de câbles.

[[File:Asus P5K-SEIntel E6320.jpg|centre|vignette|upright=2|Exemple d'unité centrale.]]

Tout en haut à gauche, se trouve l''''alimentation électrique''', qui convertit le courant de la prise électrique en un courant plus faible, utilisable par les autres composants. Elle émet de nombreux câbles assez gros, qui sont reliés au reste. Les PC actuels utilisent des alimentations électriques standardisées, qui fournissent trois tensions au reste de l'ordinateur : une tension de 12 Volts, une de 5 Volts, une de 3,3 Volts.

À droite, caché par la partie &quot;métallique&quot; du boitier, se trouvent les lecteurs de CD/DVD, et les disques durs. Les lecteurs CD-ROM ou DVD-ROM permettaient de lire des CD ou des DVD. Je parle au passé, car ils ont aujourd'hui disparu des ordinateurs modernes. Les '''disques durs''' sont des mémoires de stockage, qui mémorisent vos données de manière permanente. De nos jours, ils sont remplacés par des SSD, qui sont des disques durs électroniques, là où les disques durs proprement dit sont des mémoires magnétiques. Nous verrons la différence dans deux chapitres dédiés, un sur les disques durs, l'autre sur les SSD.

En bas à droite, se trouve la '''carte mère''' un support plat, en plastique ou en céramique, sur laquelle sont soudés/connectés les autres composants. Sur celle-ci, de nombreux composants sont soudés, d'autres sont branchés dessus avec des câbles, d'autres sont connectés dessus avec des connecteurs. Ils sont reliés entre eux par des fils conducteurs, le plus souvent du cuivre ou de l’aluminium, ce qui leur permet de s’échanger des données. Sur les cartes simples, ces fils sont intégrés dans la carte électronique, dans des creux du plastique. Ils portent le nom de pistes.

Avant, les disques durs, SSD et lecteurs de CD/DVD sont branchés dessus via des connecteurs dédiés, appelés des connecteurs S-ATA. De nos jours, ils sont branchés sur un autre connecteur, grâce à l'interface NVME. Toujours est-il qu'ils sont reliés à la carte mère par des câbles, ce qui montre que ce sont des sortes de périphériques interne. Ils sont placés dans le boitier, mais on aurait tout aussi bien pu les mettre à l'extérieur, vu qu'ils communiquent avec l'ordinateur par l'intermédiaire d'un câble ou d'un connecteur dédié.

Mais deux autres composants très importants sont eux placés sur la carte mère, directement. Ils ont chacun un connecteur dédié, sur lequel ils sont branchés directement, sans passer par l'intermédiaire d'un câble, mais sans être soudés non plus. Il s'agit du processeur et de la mémoire RAM, deux composants centraux des PC modernes.

[[File:Pentium III SL4CB.jpg|thumb|Processeur Pentium III.]]

Le '''processeur''' traite les données, les modifie, les manipule. Pour faire simple, il s’agit d’une grosse calculatrice hyper-puissante. Il comprend à la fois un circuit qui fait des calculs, et un circuit de contrôle qui s'occupe de séquencer les calculs dans l'ordre demandé. Il est souvent caché sous un radiateur, lui-même surmonté par un ventilateur. En effet, un processeur chauffe beaucoup, ce qui demande d'évacuer cette chaleur. Un chapitre entier expliquera pourquoi les processeurs chauffent, ainsi que les techniques utilisées pour limiter leur production de chaleur et leur consommation électrique.

La '''mémoire vive''' conserve des informations/données temporairement, tant que le processeur en a besoin. Elle prend la forme de barrettes de RAM, comme montré ci-dessous.

[[File:2 gb ddr2 667.jpg|centre|vignette|upright=2|Barrette de RAM.]]

Outre ces composants dits principaux, un ordinateur peut comprendre plusieurs composants moins importants, surtout présents sur les ordinateurs personnels. Ils sont techniquement facultatifs, mais sont très présents dans les ordinateurs personnels. Cependant, certains ordinateurs spécialisés s'en passent. Il s'agit des diverses '''cartes d'extension''' sont branchées sur la carte mère. Elles permettent d’accélérer certains calculs ou certaines applications, afin de décharger le processeur. Par exemple, la carte graphique s'occupe des calculs graphiques, qu'il s'agisse de graphismes 3D de jeux vidéos ou de l'affichage en 2D du bureau. Dans un autre registre, la carte son prend en charge le microphone et les haut-parleurs.

[[Fichier:Personal computer, exploded 4.svg|thumb|upright=1.0|Éclaté d'un ordinateur de type PC :&lt;br /&gt;
1 : Écran ;&lt;br /&gt;
2 : Carte mère ;&lt;br /&gt;
3 : Processeur ;&lt;br /&gt;
4 : Câble Parallel ATA ;&lt;br /&gt;
5 : Mémoire vive (RAM) ;&lt;br /&gt;
6 : Carte d'extension ;&lt;br /&gt;
7 : Alimentation électrique ;&lt;br /&gt;
8 : Lecteur de disque optique ;&lt;br /&gt;
9 : Disque dur ;&lt;br /&gt;
10 : Clavier ;&lt;br /&gt;
11 : Souris.]]

Si on regarde une carte mère de face, on voit un grand nombre de connecteurs, mais aussi des circuits électroniques soudés à la carte mère.

[[File:Architecture matérielle d'une carte mère.png|centre|vignette|upright=2.0|Architecture matérielle d'une carte mère]]

Les '''connecteurs''' sont là où on branche les périphériques, la carte graphique, le processeur, la mémoire, etc. Dans l'ensemble, toute carte mère contient les connecteurs suivants :
* Le processeur vient s’enchâsser dans la carte mère sur un connecteur particulier : le '''socket'''. Celui-ci varie suivant la carte mère et le processeur, ce qui est source d'incompatibilités.
* Les barrettes de mémoire RAM s’enchâssent dans un autre type de connecteurs: les '''slots mémoire'''.
* Les mémoires de masse disposent de leurs propres connecteurs : connecteurs P-ATA pour les anciens disques durs, et S-ATA pour les récents.
* Les périphériques (clavier, souris, USB, Firewire, ...) sont connectés sur un ensemble de connecteurs dédiés, localisés à l'arrière du boitier de l'unité centrale. 
* Les autres périphériques sont placés dans l'unité centrale et sont connectés via des connecteurs spécialisés. Ces périphériques sont des cartes imprimées, d'où leur nom de '''cartes filles'''. On peut notamment citer les cartes réseau, les cartes son, ou les cartes vidéo.

===Les ordinateurs portables===

[[File:Samsung QX-511 (2).JPG|vignette|Ordinateur portable Samsung QX-511 (2), pour illustration.]]

Un ordinateur portable est identique à un ordinateur de type PC. Si vous ouvrez votre ordinateur portable (attention à la garantie), vous retrouverez les mêmes composants qu'un PC à l'intérieur. Un point important est la présence d'une batterie à l'intérieur du PC portable, absente des PC fixes.

[[File:LG gram 14Z90Q mainboard with battery.jpg|centre|vignette|upright=2|LG gram 14Z90Q avec sa batterie.]]

Une fois la batterie et les circuits associés retiré, la seule différence notable est que tous les composants sont soudés sur la carte mère, au lieu d'être branchés sur des connecteurs, à part éventuellement la RAM et le disque dur.

[[File:LG gram 14Z90Q mainboard without battery.jpg|centre|vignette|upright=2|LG gram 14Z90Q sans sa batterie.]]

La RAM est parfois soudée sur la carte mère, d'autres fois sous la forme de barrettes de mémoire vive semblables à celles des PC. Dans le dernier cas, elle est connectée à des connecteurs spécifiques, ce qui permet de les changer/upgrader. Les PC portables sont parfois construits de manière à pouvoir changer la RAM facilement, en ouvrant un cache spécial, concu pour.

[[File:Lenovo G555 состав - Донор.JPG|centre|vignette|upright=2|Lenovo G555.]]

La conception d'un ordinateur portable est légèrement différente de celle d'un PC, pour des raisons thermiques. Un PC fixe a plus de place pour évacuer sa chaleur. Les ventilateurs peuvent plus facilement déplacer l'air dans le boitier, même si le flux d'air dans le boitier est éventuellement gêné par la carte graphique. Mais l'évacuation de la chaleur est assez efficace. Sur les PC portables, leur finesse fait que le trajet de l'air est beaucoup plus contraint. Évacuer la chaleur produite par l'ordinateur est plus complexe, ce qui demande d'utiliser des systèmes de refroidissement et de ventilation spécifiques.

Là où les PC fixes se débrouillent avec des radiateurs et des ventilateurs posés sur le processeur, les PC portables font autrement. Ils ne peuvent pas forcément mettre le ventilateur sur le processeur. A la place, ils mettent le ventilateur à côté, mais le processeur est surmonté par un mécanisme de transmission de la chaleur, qui transfère la chaleur du processeur vers le ventilateur.

[[File:Diagram - How a laptop cooling system works.png|centre|vignette|upright=2|Comment fonctionne le système de ventilation d'un ordinateur portable, en anglais.]]

Les difficultés pour dissiper la chaleur font que les ordinateurs portables utilisent souvent des composants peu performants, mais qui chauffent peu. En effet, nous verrons que plus un composant est puissant, plus il chauffe. La relation n'est pas parfaite, mais les processeurs haute performance chauffent plus que les modèles d'entrée ou milieu de gamme moins puissants. En conséquence, les PC portables sont souvent moins puissants que les PC fixes, même pour les modèles dit ''gaming''.

===Les serveurs et ''mainframes''===

Les grandes entreprises utilisent des ordinateurs de grande taille, très puissants, appelés des ''mainframes''. Ils sont souvent confondus avec les serveurs par le grand public, il y a une différence entre les deux. Un serveur est une fonction logicielle/réseau, pas un type d'ordinateur. Mais laissons cette différence de côté, ce qui est dit pour les ''mainframes'' sert pour les gros serveurs haute performance.

[[File:IBM Z15 mainframe.jpg|vignette|Exemple de ''mainframe''' de type IBM Z15.]]

Les anciens ''mainframes'' des années 50-80 avaient une taille pouvant être impressionnante, au point de prendre une pièce complète d'un bâtiment. Mais de nos jours, les ''mainframes'' tiennent dans une grosse armoire un peu haute. Les ''mainframes'' doivent rester allumé en permanence et ne doivent pas être éteint, sauf éventuellement quelques jours par an pour des opérations de maintenance. Ils utilisent pour cela des techniques spécifiques, avec beaucoup de redondance interne.

[[File:ACONIT hall grandes machines.jpg|centre|vignette|upright=2|''Mainframe'' ACONIT.]]

Les ''mainframes'' sont aussi conçus pour mutualiser au maximum leur utilisation, ils peuvent être utilisés par plusieurs utilisateurs à la suite, voire en même temps. Pour cela, les anciens ''mainframes'' étaient capables de faire tourner plusieurs applications distinctes l'une à la suite de l'autre, avec des commutations fréquentes entre logiciels. De nos jours, ils sont capables d'exécuter un grand nombre de tâches en même temps, grâce à la présence de plusieurs processeurs. Les ''mainframes'' modernes sont même capables de faire tourner plusieurs systèmes d'exploitation en même temps si besoin.

Les anciens ''mainframes'' étaient des ordinateurs assez simples, avec un processeur, de la mémoire RAM, un ou plusieurs disques durs, pas plus. Le ''mainframe'' était tellement énorme et cher que les entreprises n'en avaient qu'un seul pour toute l'entreprise. Les employés avaient sur leur bureau des terminaux, qui permettaient d'accéder à l'ordinateur central, mais n'étaient pas des ordinateurs. Les terminaux étaient des composants électroniques simples, avec un écran, un clavier et une souris, mais sans processeur. Ils envoyaient des données au ''mainframe'', ils en recevaient de sa part, mais tout traitement était réalisé sur le ''mainframe''. L'arrivée sur le marché des ordinateurs personnels, de type PC fixe/portable, a entrainé l'abandon de ce genre de pratique, tous les employés ont maintenant un ordinateur rien que pour eux.

{|
|-
! colspan=&quot;2&quot; | Exemples de terminaux
|-
|[[File:Terminal-in2-sm9400.jpg|centre|vignette|upright=1.5|Exemple de terminal. Notez la présence d'un écran et d'un clavier, mais l'asbence d'une unité centrale.]]
|[[File:Chromatics CT4100.jpg|vignette|upright=1.5|Autre exemple de terminal. Le clavier est couplé à un stylo CRT, qui remplacait la souris et agissait sur l'écran comme s'il était tactile.]]
|-
! colspan=&quot;2&quot; | Intérieur d'un terminal
|-
|[[File:CT1024 Monitor.jpg|vignette|upright=1.5|Terminal CT1024, sans le boitier extérieur.]]
|[[File:CT1024 Terminal System.jpg|vignette|upright=1.5|Terminal CT1024, description des composants interne.]]
|}

De nos jours, les ''mainframes'' contiennent en réalité plusieurs ordinateurs simples interconnectés via un réseau local. Un ''mainframe'' qui tient dans une armoire contient facilement une dizaine ou centaine de processeurs, plein de RAM, des disques durs séparés dans une armoire distincte, etc. Vu qu'ils communiquent uniquement via le réseau, ils n'ont pas d'interface, pas d'écran, 'entrée via clavier/souris. Le tout est commandé avec une console de commande, typiquement un ordinateur portable ou un terminal assez simple séparé de l'armoire, qui permet à un administrateur de faire des opérations de surveillance, configuration et maintenance. Il peut y avoir une console de commande pour plusieurs armoires séparées, la console peut même être dans un autre bâtiment et accéder au ''mainframe'' par le réseau.

[[File:IBM System Z9 (type 2094 inside).jpg|centre|vignette|upright=2|''Mainframe'' de type IBM System Z9. L'ordinateur portable sert de console pour qu'un administrateur fasse des opérations de surveillance, configuration et maintenance.]]

Les processeurs et la RAM sont typiquement installés sur des cartes amovibles, qui sont connectées au fond de l'armoire lors de l'installation. Il est même possible de retirer ou d'ajouter des cartes en fonctionnement, afin d'ajouter/retirer des processeurs, des disques durs, etc. Ce qui est très utile si un composant est en panne et qu'il faut le remplacer. 

[[File:IBM TotalStorage Exp400.jpg|centre|vignette|upright=2|IBM TotalStorage Exp400]]

==Un peu d'abstraction : qu'est-ce qu'un ordinateur ?==

Un ordinateur comprend donc un processeur, plusieurs mémoires, des cartes d'extension et une carte mère pour connecter le tout. Mais il s'agit là d'une description assez terre-à-terre de ce qu'est un ordinateur. Une autre description, plus abstraite, se base sur le fait qu'un ordinateur est une énorme calculatrice programmable. Elle permet d'expliquer pourquoi il y a une distinction entre processeur et mémoire, entre unité centrale et périphériques. Tout ce qui va suivre pourra vous paraitre assez abstrait, mais rassurez-vous : les prochains chapitres rendront tout cela plus concrets.

===La séparation entre entrées-sorties et traitement===

L'unité centrale peut être vue comme une énorme calculatrice ultra-puissante, qui exécute des commandes/opérations. Mais à elle seule, elle ne servirait à rien, il faut interagir avec par l'intermédiaire de plusieurs périphériques. Il existe deux types de périphériques, qui sont conceptuellement différents. Les périphériques comme le clavier ou la souris permettent d'envoyer des informations à l'ordinateur, d'agir sur celui-ci. A l'inverse, les écrans transmettent des informations dans le sens inverse : de l'ordinateur vers l'utilisateur. Les premiers sont appelés des '''entrées''', les seconds des '''sorties'''.

Dans un ordinateur, les informations sont représentées sous la forme de nombres. Toute donnée dans un ordinateur est codée avec un ou plusieurs nombres regroupés dans une donnée, un fichier, ou autre. Et la transmissions avec les entrées et sorties se fait là-encore avec des nombres. Par exemple, quand vous appuyez sur votre clavier, le clavier envoie un numéro de touche à l'unité centrale, qui indique quelle touche a été appuyée. L'image à afficher à l'écran est codée sous la forme d'une suite de nombres (un par pixel). L'image est envoyée à l'écran, qui traduit la suite de nombre en image à afficher. Les entrées traduisent des actions utilisateurs en nombres, on dit que les entrées encodent les actions utilisateur. Les sorties font la traduction inverse, elles transforment des suites de nombres en une action physique. On dit qu'elles décodent des informations.

Pour résumer, toute appareil électronique est composé par :
* Des '''entrées''' sur lesquelles l'utilisateur agit sur l'ordinateur. Les entrées transforment les actions de l'utilisateur en nombres, qui sont interprétés par l'ordinateur.
* Une '''unité de traitement''', qui manipule des nombres et fait des calculs/opérations dessus. Les nombres proviennent des entrées, du disque dur, ou d'autres sources, peu importe.
* Des '''sorties''', qui va récupèrent le résultat calculé par l'unité de traitement pour en faire quelque chose : écrire sur une imprimante ou sur un moniteur, émettre du son,...

[[File:Ordinateur théorique Simple 1.png|centre|vignette|upright=2|Ordinateur théorique Simple 1]]

L'unité de traitement proprement dite, celle qui fait les calculs, est couplée à une mémoire qui mémorise les opérandes et résultats des calculs. La séparation entre processeur et mémoire est nécessaire pour qu'un appareil électronique soit qualifié d'ordinateur. De nombreux appareils n'ont pas de séparation entre unité de traitement et mémoire, comme certaines vielles radios AM/FM.

[[File:Schéma de principe d'un ordinateur.png|centre|vignette|upright=2|Schéma de principe d'un ordinateur]]

===Un ordinateur est un appareil programmable===

Les appareils simples sont non-programmables, ce qui veut dire qu’ils sont conçus pour une utilisation particulière et qu’ils ne peuvent pas faire autre chose. Par exemple, les circuits électroniques d’un lecteur de DVD ne peuvent pas être transformé en lecteur audio ou en console de jeux... Les circuits non-programmables sont câblés une bonne fois pour toute, et on ne peut pas les modifier. On peut parfois reconfigurer le circuit, pour faire varier certains paramètres, via des interrupteurs ou des boutons, mais cela s’arrête là. Et cela pose un problème : à chaque problème qu'on veut résoudre en utilisant un automate, on doit recréer un nouveau circuit.

À l'inverse, un ordinateur n’est pas conçu pour une utilisation particulière, contrairement aux autres objets techniques. Il est possible de modifier leur fonction du jour au lendemain, on peut lui faire faire ce qu’on veut. On dit qu'ils sont '''programmables'''. Pour cela, il suffit d’utiliser un logiciel, une application, un programme (ces termes sont synonymes), qui fait ce que l'on souhaite. La totalité des logiciels présents sur un ordinateur sont des programmes comme les autres, même le système d'exploitation (Windows, Linux, ...) ne fait pas exception.

Un programme est une suite de d'instructions, chaque instruction effectuant une action dans l'ordinateur. Sur les ordinateurs modernes, la majorité de ces instructions effectuent une opération arithmétique, comme une addition, une multiplication, une soustraction, etc. Les ordinateurs modernes sont donc de grosses calculettes très puissantes, capables d'effectuer des millions d'opérations par secondes. Et qui dit opération dit nombres : un ordinateur gère nativement des nombres, qui sont codés en binaire sur la quasi-totalité des ordinateurs modernes.

Une instruction est représentée dans un ordinateur par une série de nombres : un nombre qui indique quelle opération/commande effectuer et des autres nombres pour coder les données (ou de quoi les retrouver dans l'ordinateur). L'ordinateur récupére les commandes une par une, les traduit en opération à effectuer, exécuter l'opération, et enregistre le résultat. Puis il recommence avec la commande suivante.

[[File:Ordinateur Théorique Complexe 1.png|centre|vignette|upright=3|Ordinateur Théorique Complexe. En jaune, le programme informatique, la liste de commande. Le rectangle gris est l'ordinateur proprement dit.]]

De nombreux appareils sont programmables, mais tous ne sont pas des ordinateurs. Par exemple, certains circuits programmables nommés FPGA n'en sont pas. Pour être qualifié d'ordinateur, un appareil programmable doit avoir un processeur séparé de la mémoire. De plus, il doit utiliser un '''codage numérique''', chose que nous allons aborder dans le chapitre suivant.

===Les ordinateurs à programme mémorisé ou programme externe===

Au tout début de l'informatique, on utilisait des cartes perforées en plastique, sur lesquelles on inscrivait le programme à exécuter, les données à traiter, bref : tout ce qu'on donnait à manger à l'ordinateur. Par la suite, les premiers ordinateurs grand public, comme les Amstrad ou les Commodore, utilisaient des cassettes audio magnétiques pour stocker les programmes. Dans le même style, les consoles de jeu utilisaient autrefois des cartouches de jeu, qui contenaient le programme du jeu à exécuter. Pour résumer, les anciens ordinateurs mémorisaient les programmes sur un support externe, lu par un périphérique. De tels ordinateurs sont dits à '''programme externe'''.

: D’anciens ordinateurs personnels, comme l’Amstrad ou le Commodore, permettaient de taper les programmes à exécuter à la main, au clavier, avant d’appuyer une touche pour les exécuter. Nul besoin de vous dire que les cassettes audio étaient plus pratiques.

Mais de nos jours, les programmes sont enregistrés sur le disque dur de l'ordinateur ou dans une mémoire intégrée à l'ordinateur. On dit qu'ils sont installés, ce qui est un mot bien compliqué pour dire que le programme est enregistré sur le disque dur de l’ordinateur. A défaut de disque dur, le programme/logiciel est enregistré dans une mémoire spécialisée pour le stockage. Par exemple, sur les cartes électroniques grand public de marque Arduino, les programmes sont envoyés à la carte via le port USB, mais les programmes sont enregistrés dans la carte Arduino, dans une mémoire FLASH dédiée. Disque dur ou non, le programme est mémorisé dans la mémoire de l'ordinateur. Il est possible d'installer ou de désinstaller les programmes en modifiant le contenu de la mémoire. Le terme utilisé est alors celui de '''programme stocké en mémoire'''.

Les programmes à installer sont disponibles soit sur un périphérique, comme un DVD ou une clé USB, soit sont téléchargés depuis internet. Les premiers PC fournissaient les logiciels sur des disquettes, qui contenaient un programme d'installation pour enregistrer le programme sur le disque dur de l'ordinateur. Par la suite, le support des logiciels a migré vers les CD et DVD, les logiciels devenant de plus en plus gros. De nos jours, la majorité des applications sont téléchargées depuis le net, l'usage de périphériques est devenu obsolète, même les consoles de jeu abandonnent cette méthode de distribution.

==Les générations d'ordinateurs : un historique rapide==

L'informatique a beaucoup évolué dans le temps. Et une bonne partie de cette évolution tient à l'évolution de l’électronique sous-jacente. Les ordinateurs actuels sont fabriqués avec des transistors, des petits composants électroniques qui servent d'interrupteur programmables, qu'on détaillera dans ce qui suit. Mais ça n'a pas toujours été le cas. Et cela permet de distinguer plusieurs '''générations d'ordinateurs'''.

===Le ordinateurs électro-mécaniques : les premiers ordinateurs===

Le tout premier ordinateur est le '''Z1''', un modèle unique inventé par Konrad Suze entre 1936 et 1938. Son processeur gérait non pas des nombres entiers, mais des nombres à virgule (des nombres dits flottants, pour être précis), encodés sur 22 bits. Le processeur du Z1 était capable de faire des additions et des soustractions, car il intégrait un circuit additionneur-soustracteur basique. Des circuits annexes permettaient de faire des multiplications et des divisions en enchainant des additions/soustractions successives. Il fonctionnait à une fréquence de 1 Hz, ce qui fait qu'il pouvait faire une addition/soustraction par seconde maximum.

[[File:Blue-punch-card-front.png|vignette|upright=0.5|Carte Perforée.]]

Niveau mémoire, la RAM de l'ordinateur était très limitée : seulement 16 nombres de 22 bits chacun. S'il s'agissait d'une mémoire électronique, les programmes étaient mémorisés sur une mémoire mécanique. Les programmes étaient enregistrés sur des cartes perforées, à savoir des cartes en papier dans lesquelles un 1 est codé par un trou dans le papier et un 0 par une absence de trou. Les programmes étaient exécutés par l'ordinateur quand on insérait la carte perforée dans le lecteur et qu'on appuyait sur un bouton.

Après sa destruction dans un bombardement lors de la seconde guerre mondiale, le Z1 a été remplacé par un modèle dit Z2, lui-même suivi par le Z3, qui n'étaient que des améliorations du Z1. Tous étaient des ordinateurs dit '''électro-mécaniques''', car ils mélangeaient des composants électroniques (des relais) et des composants mécaniques (tout ce qui a trait aux cartes perforées, notamment). Les ordinateur qui ont suivi, avant 1944, étaient tous de ce type.

[[File:German Museum of Technology, Berlin 2017 024.jpg|centre|vignette|upright=2|Réplique du Z1 au ''German Museum of Technology'' de Berlin, 2017.]]

===Les premières générations : des ordinateurs qui prenaient des pièces de bâtiment entières===

A partir de 1944, de nombreux ordinateurs plus puissants ont été mis sur le marché. Des grandes noms de l'histoire de l'informatique date de cette époque : le Harvard Mark I et le Colossus Mark 1 (UK) ont tous deux été mis en service en 1944, suivi par le Z4 l'année suivante. Ils ont servis pour les cryptanalystes pour casser les codes utilisés par les allemands pour leurs transmissions, pendant la seconde guerre mondiale.

Mais c'est l'arrivée de l'ENIAC en 1945 qui a changé la donne. Cet ordinateur a introduit plusieurs innovations majeures. La première est assez technique, il s'agit de la turing-complétude, et a trait aux programmes qui peuvent être écrit pour un ordinateur. Nous ne la détaillerons pas ici. La seconde innovation est que le programme n'était plus mémorisé sur des cartes perforée, mais dans une mémoire électronique dans l'ordinateur lui-même. En clair, l'ENIAC était le premier '''''Stored-program computer''''', ordinateur à programme enregistré en français. Enfin, l'ENIAC était composé non pas de relais et l'élèments mécaniques, mais uniquement de tubes à vides, des composants électroniques assez rudimentaires plus ou moins équivalents aux transistors modernes.

[[File:IBM 7070.jpg|vignette|Cartes imprimées de l'IBM 704, avec des transistors et résistances dessus.]]

Les ordinateurs qui ont suivi l'ENIAC sont regroupés dans la '''première génération d'ordinateur'''. Ils étaient conçus avec des tubes à vide, ce qui les place entre les premiers ordinateurs électro-mécaniques et les ordinateurs utilisant des transistors. Les ordinateurs de première génération étaient très simples, ils ne géraient que quelques opérations simples : l'addition, la soustraction, pas grand chose de plus. A quelques exceptions près, ils ne géraient pas la multiplication et encore moins la division, ils n'avaient pas assez de relais ou de tubes à vides à disposition pour cela.

La '''seconde génération''' est celle des ordinateurs fabriqués avec des '''transistors''' isolés, reliés entre avec des fils électriques. Les transistors en question possèdent trois broches, des pattes métalliques sur lesquelles on connecte des fils électriques. Le transistor s'utilise le plus souvent comme un interrupteur commandé par sa troisième broche. Le courant qui traverse les deux premières broches passe ou ne passe pas selon ce qu'on met sur la troisième.

[[File:Transistor basic flow.svg|centre|vignette|Un transistor est un morceau de conducteur, dont la conductivité est contrôlée par sa troisième broche/borne.]]

Les ordinateurs de seconde génération avaient entre 1000 et 500 000 transistors. Les capacités des ordinateurs étaient donc nettement supérieures à celles des ordinateurs de première génération. Une part non négligeable des ordinateurs de seconde génération supportait l'opération de multiplication, absente sur les ordinateurs de première génération. Néanmoins, cela variait beaucoup selon les ordinateurs.

Un exemple assez hors du commun est celui du premier modèle de l'IBM 1620. Le tout premier modèle n'avait aucun circuit de calcul, il n'était même pas capable de faire une addition ou une multiplication. A la place, il utilisait une table d'addition et une table de multiplication en mémoire RAM. Les deux tables devaient être initialisées par le logiciel lors du démarrage de la machine. La table d'addition faisait une centaine de chiffre, la table de multiplication faisait le double. Le processeur de l'ordinateur gérait des instructions pour faire des additions ou des multiplications, mais ces opérations lisaient le résultat dans la table d'addition. Les calculs étaient fait chiffre par chiffre, avec un encodage partiellement décimal, partiellement binaire (des chiffres décimaux étaient encodés en binaire, nous en reparlerons quand nous parlerons du BCD) !

[[File:KL CoreMemory.jpg|vignette|Mémoire à tore de ferrite.]]

Les transistors n'étaient utilisés que pour le processeur et les circuits annexes. La mémoire n'était pas faite en transistors, pas à cette époque. La mémoire était une mémoire aujourd'hui abandonnée, appelée une '''mémoire à tores de ferrite'''. Elle sera détaillée dans un chapitre ultérieur. Mais sachez pour le moment qu'il s'agit d'une mémoire au support magnétique, les données étant stockées sur un support magnétique.

Transistors comme tubes à vide prenaient beaucoup de place, ce qui fait que les ordinateurs étaient assez gros. Concrètement, ils prenaient une pièce de bâtiment entière dans le meilleur des cas. C'était l'époque des gros ''mainframes'', reliés à des terminaux, peu puissants comparé aux standards actuels. Seules les grandes entreprises et les grands instituts de recherche pouvaient se payer les services de ce genre d'ordinateurs. Seuls les professionnels avaient accès à ce genre d'équipement.

===La troisième génération : le circuit intégré===

[[File:D8259AC-2.jpg|vignette|Exemple de circuit intégré.]]

La troisième génération est toujours fabriquée avec des transistors, mais dont la taille a été réduite. Avec l'évolution de la technologie, les transistors ont diminué en taille, de plus en plus. Ils sont devenus tellement petits qu'ils ont finit par être regroupés dans des '''circuits intégrés''', des circuits regroupent plusieurs transistors sur la même puce de silicium. Les circuits intégrés se présentent le plus souvent sous la forme de boitiers rectangulaires, comme illustré ci-contre. D'autres ont des boitiers de forme carrées, comme ceux que l'on peut trouver sur les barrettes de mémoire RAM, ou à l'intérieur des clés USB/ disques SSD.

Lors de cette génération, les processeurs étaient fournis en pièces détachées qu'il fallait relier entre elles. Le processeur était composé de plusieurs circuits intégrés séparés, impossible de mettre un processeur dans un seul boitier. Un exemple de processeur conçu en kit est la série des Intel 3000. Elle regroupe plusieurs circuits séparés aux noms à coucher dehors, mais dont vous comprendrez ce qu'ils veulent dire dans les chapitres adéquats : l'Intel 3001 est un séquenceur, l'Intel 3002 regroupe unité de calcul et registres, le 3003 est un circuit d'anticipation de retenue complémentaire du 3002, le 3212 est une mémoire tampon, le 3214 est une unité de gestion des interruptions, les 3216/3226 sont des interfaces de bus mémoire. On pourrait aussi citer la famille de circuits intégrés AMD Am2900.

Même si le processeur était en pièce détachées, utiliser une dizaine de circuits intégrés était nettement mieux que d'utiliser plusieurs milliers de transistors individuels. En conséquence, les ordinateurs ont vu leur taille grandement réduite, passant de pièces entières à une simple armoire, voire à quelques cartes intégrées superposées. De plus, le prix des circuits intégré était abordable, du moins comparé aux ordinateurs d'avant. Le prix des ordinateurs a alors grandement décru, permettant à des entreprises et administrations de taille modeste de s'équiper d'ordinateurs.

===La quatrième génération : le microprocesseur===

[[File:MOS6502.svg|vignette|Microprocesseur, ici un processeur MOS6502, de la quatrième génération.]]

Lors de la troisième génération, les circuits intégrés regroupaient plusieurs dizaines ou centaines de transistors, mais sont rapidement montés en gamme. De centaines de transistors, ils sont passé au milliers de transistors, puis au millions et maintenant au-delà du milliard. Les transistors étaient devenus tellement petits, tellement miniaturisés, qu'il était devenu possible de mettre un processeur entier dans un circuit intégré. C'est ainsi qu'est né le microprocesseur, à savoir un processeur qui tient tout entier dans un seul circuit imprimé. La quatrième génération d’ordinateur est celle des ordinateurs basés autour d'un microprocesseur.

Les tout premiers microprocesseurs étaient des processeurs à application militaire, comme le processeur du F-14 CADC ou celui de l'Air data computer. Le tout premier microprocesseur commercialisé au grand public est le 4004 d'Intel, sorti en 1971. L'intel 4004 comprenait environ 2300 transistors, avait une fréquence de 740 MHz, pouvait faire 46 opérations différentes, et manipulait des entiers de 4 bits. Il était au départ un processeur de commande, prévu pour être intégré dans la calculatrice Busicom calculator 141-P, mais il fut utilisé pour d'autres applications quelque temps plus tard. Immédiatement après le 4004, les premiers microprocesseurs 8 bits furent commercialisés. Le 4004 fut suivi par le 8008 et quelques autres processeurs 8 bits extrêmement connus, comme le 8080 d'Intel, le 68000 de Motorola, le 6502 ou le Z80.

Les microprocesseurs permirent encore uen fois de réduire la taille des ordinateurs, qui pouvaient tenir dans un boitier de PC, ou un boitier de console de jeu. Le prix des ordinateurs a aussi chuté en même temps que les transistors était miniaturisés. C'est cette invention qui permis l'invention des consoles de jeux et des mini-ordinateurs, à savoir les ordinateurs personnels. Sans miniaturisation, on n'aurait pas d'ordinateur personnel, pas de PC fixe ou portable.

==L'organisation du cours : les différents niveaux d'explication==

Le fonctionnement d'un ordinateur est assez complexe à expliquer car les explications peuvent se faire sur plusieurs niveaux. Par plusieurs niveaux, on veut dire qu'un ordinateur est composé de composants très simples, qui sont assemblés pour donner des composants eux-même plus complexes, qui sont eux-même regrouper, etc. Étudier tout cela demande de voir plusieurs niveaux, allant de transistors très petits à des processeurs multicœurs. Les niveaux les plus bas sont de l'électronique pur et dure, alors que ceux plus haut sont à mi-chemin entre électronique et informatique.

===Les niveaux d'abstraction en architecture des ordinateurs===

Les trois premiers niveaux sont de l'électronique pur et dure. Ils correspondent aux premiers chapitres du cours, qui porteront sur les circuits électroniques en général.
* Le premier niveau est celui des '''transistors''', des circuits intégrés, des ''wafer'' et autres circuits de très petite taille.
* Le second niveau est celui des '''portes logiques''', des circuits très basiques, très simples, à la base de tous les autres.
* Le troisième niveau est celui dit de la '''''Register Transfer Level''''', où un circuit électronique est construit à partir de circuits basiques, dont des registres et autres circuits dits combinatoires.
Les deux niveaux suivants sont de l'informatique proprement dit. C'est dans ces deux niveaux qu'on étudie les ordinateurs proprement dit, les circuits qu'il y a dedans et non l'électronique en général.
* Le quatrième niveau est celui de la '''microarchitecture''', qui étudie ce qu'il y a à l'intérieur d'un processeur, d'une mémoire, des périphériques et autres.
* Le cinquième niveau est celui de l''''architecture externe''', qui décrit l'interface du processeur, de la mémoire, d'un périphérique ou autre. Par décrire l'interface, on veut dire : comment un programmeur voit le processeur et la mémoire, comment il peut les manipuler. Une architecture externe unique peut avoir plusieurs microarchitecture, ce qui fait qu'on sépare les deux. Tout cela sera plus clair quand on passera aux chapitres sur le processeur et les mémoires.

Nous n'allons pas voir les 5 niveaux dans l'ordre, des transistors vers l'architecture externe. En réalité, nous allons procéder autrement. La première partie du cours portera sur les trois premiers niveaux, le reste sur les deux autres. Les 5 niveaux seront vus dans des chapitres séparés, du moins le plus possible. Au niveau pédagogique, tout est plus simple si on scinde les 5 niveaux. Bien sûr, il y a quelques explications qui demandent de voir plusieurs niveaux à la fois. Par exemple, dans le chapitre sur les mémoires caches, nous auront des explications portant sur la RTL, la microarchitecture du cache et son architecture externe. Mais le gros du cours tentera de séparer le plus possible les 5 niveaux.

===Les trois parties principales du cours===

Nous allons commencer par parler du binaire, avant de voir les portes logiques. Avec ces portes logiques, nous allons voir comment fabriquer des circuits basiques qui reviendront très souvent dans la suite du cours. Nous verrons les registres, les décodeurs, les additionneurs et plein d'autres circuits. Puis, nous reviendrons au niveau des transistors pour finir la première partie. La raison est que c'est plus simple de faire comme cela. Tout ce qui a trait aux transistors sert à expliquer comment fabriquer des portes logiques, et il faut expliquer les portes logiques pour voir le niveau de la RTL.

Une fois la première partie finie, nous allons voir les différents composants d'un ordinateur. Une première partie expliquera ce qu'il y a dans un ordinateur, quels sont ses composants. Nous y parlerons de l'architecture de base, de la hiérarchie mémoire, des tendances technologiques, et d'autres généralités qui serviront de base pour la suite. Puis, nous verrons dans l'ordre les bus électroniques, les mémoires RAM/ROM, le processeur, les périphériques, les mémoires de stockage (SSD et disques durs) et les mémoires caches. Pour chaque composant, nous allons voir leur architecture externe, avant de voir leur microarchitecture. La raison est que la microarchitecture ne peut se comprendre que quand on sait quelle architecture externe elle implémente.

Enfin, dans une troisième partie, nous allons voir les optimisations majeures présentes dans tous les ordinateurs modernes, avec une partie sur le pipeline et le parallélisme d'instruction, et une autre sur les architectures parallèles. Pour finir, les annexes de fin parlerons de sujets un peu à part.

&lt;noinclude&gt;
{{NavChapitre | book=Fonctionnement d'un ordinateur
           | next=L'encodage des données
           | nextText=L'encodage des données
}}
&lt;/noinclude&gt;</text>
      <sha1>36aktwmhiv8hi8qy5hs007nuy7zd6iw</sha1>
    </revision>
    <revision>
      <id>744105</id>
      <parentid>744104</parentid>
      <timestamp>2025-06-04T20:50:37Z</timestamp>
      <contributor>
        <username>Mewtow</username>
        <id>31375</id>
      </contributor>
      <minor />
      <comment>/* Le ordinateurs électro-mécaniques : les premiers ordinateurs */</comment>
      <origin>744105</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="41649" sha1="73yof63znezra7jthlx96bha2p2m7p4" xml:space="preserve">Pour commencer, nous allons voir qu'il existe de nombreux types d'ordinateurs. Le plus connu est certainement le PC, l'ordinateur personnel, que vous avez sans doute dans votre salon. Les ordinateurs portables sont un deuxième type d'ordinateur assez intuitif, que vous avez peut-être. Mais il y a aussi d'autres types d'ordinateurs auxquels vous n'avez jamais été confrontés.

==Les différents types d'ordinateurs==

Dans cette section, nous allons décrire rapidement les ordinateurs les plus courant, mais surtout voir ce qu'il y a à l'intérieur d'un ordinateur.

===L'ordinateur de type PC fixe===

De l'extérieur, l'ordinateur est composé d'une unité centrale sur laquelle on branche des périphériques.

[[File:Typical computer architecture systems.jpg|vignette|upright=1.5|Exemples de périphériques, connectés à une unité centrale (ici appelée à tort ''operating system'').]]

Les '''périphériques''' regroupent l'écran, la souris, le clavier, l'imprimante, et bien d'autres choses. Ils permettent à l'utilisateur d'interagir avec l'ordinateur : un clavier permet de saisir du texte sous dans un fichier, une souris enregistre des déplacements de la main en déplacement du curseur, un écran affiche des données d’images/vidéos, un haut-parleur émet du son, etc. Tout ce qui est branché sur un ordinateur est, formellement un périphérique.

L''''unité centrale''' est là où se trouvent tous les composants importants d'un ordinateur, ceux qui font des calculs, qui exécutent des logiciels, qui mémorisent vos données, etc. Voici ce à quoi ressemble l'intérieur de l'unité centrale. Trois sections sont visibles : l'alimentation électrique en haut à gauche, la carte mère en bas à gauche et en jaune/orange, les disques et lecteurs à droite des câbles. Et on voit aussi beaucoup de câbles.

[[File:Asus P5K-SEIntel E6320.jpg|centre|vignette|upright=2|Exemple d'unité centrale.]]

Tout en haut à gauche, se trouve l''''alimentation électrique''', qui convertit le courant de la prise électrique en un courant plus faible, utilisable par les autres composants. Elle émet de nombreux câbles assez gros, qui sont reliés au reste. Les PC actuels utilisent des alimentations électriques standardisées, qui fournissent trois tensions au reste de l'ordinateur : une tension de 12 Volts, une de 5 Volts, une de 3,3 Volts.

À droite, caché par la partie &quot;métallique&quot; du boitier, se trouvent les lecteurs de CD/DVD, et les disques durs. Les lecteurs CD-ROM ou DVD-ROM permettaient de lire des CD ou des DVD. Je parle au passé, car ils ont aujourd'hui disparu des ordinateurs modernes. Les '''disques durs''' sont des mémoires de stockage, qui mémorisent vos données de manière permanente. De nos jours, ils sont remplacés par des SSD, qui sont des disques durs électroniques, là où les disques durs proprement dit sont des mémoires magnétiques. Nous verrons la différence dans deux chapitres dédiés, un sur les disques durs, l'autre sur les SSD.

En bas à droite, se trouve la '''carte mère''' un support plat, en plastique ou en céramique, sur laquelle sont soudés/connectés les autres composants. Sur celle-ci, de nombreux composants sont soudés, d'autres sont branchés dessus avec des câbles, d'autres sont connectés dessus avec des connecteurs. Ils sont reliés entre eux par des fils conducteurs, le plus souvent du cuivre ou de l’aluminium, ce qui leur permet de s’échanger des données. Sur les cartes simples, ces fils sont intégrés dans la carte électronique, dans des creux du plastique. Ils portent le nom de pistes.

Avant, les disques durs, SSD et lecteurs de CD/DVD sont branchés dessus via des connecteurs dédiés, appelés des connecteurs S-ATA. De nos jours, ils sont branchés sur un autre connecteur, grâce à l'interface NVME. Toujours est-il qu'ils sont reliés à la carte mère par des câbles, ce qui montre que ce sont des sortes de périphériques interne. Ils sont placés dans le boitier, mais on aurait tout aussi bien pu les mettre à l'extérieur, vu qu'ils communiquent avec l'ordinateur par l'intermédiaire d'un câble ou d'un connecteur dédié.

Mais deux autres composants très importants sont eux placés sur la carte mère, directement. Ils ont chacun un connecteur dédié, sur lequel ils sont branchés directement, sans passer par l'intermédiaire d'un câble, mais sans être soudés non plus. Il s'agit du processeur et de la mémoire RAM, deux composants centraux des PC modernes.

[[File:Pentium III SL4CB.jpg|thumb|Processeur Pentium III.]]

Le '''processeur''' traite les données, les modifie, les manipule. Pour faire simple, il s’agit d’une grosse calculatrice hyper-puissante. Il comprend à la fois un circuit qui fait des calculs, et un circuit de contrôle qui s'occupe de séquencer les calculs dans l'ordre demandé. Il est souvent caché sous un radiateur, lui-même surmonté par un ventilateur. En effet, un processeur chauffe beaucoup, ce qui demande d'évacuer cette chaleur. Un chapitre entier expliquera pourquoi les processeurs chauffent, ainsi que les techniques utilisées pour limiter leur production de chaleur et leur consommation électrique.

La '''mémoire vive''' conserve des informations/données temporairement, tant que le processeur en a besoin. Elle prend la forme de barrettes de RAM, comme montré ci-dessous.

[[File:2 gb ddr2 667.jpg|centre|vignette|upright=2|Barrette de RAM.]]

Outre ces composants dits principaux, un ordinateur peut comprendre plusieurs composants moins importants, surtout présents sur les ordinateurs personnels. Ils sont techniquement facultatifs, mais sont très présents dans les ordinateurs personnels. Cependant, certains ordinateurs spécialisés s'en passent. Il s'agit des diverses '''cartes d'extension''' sont branchées sur la carte mère. Elles permettent d’accélérer certains calculs ou certaines applications, afin de décharger le processeur. Par exemple, la carte graphique s'occupe des calculs graphiques, qu'il s'agisse de graphismes 3D de jeux vidéos ou de l'affichage en 2D du bureau. Dans un autre registre, la carte son prend en charge le microphone et les haut-parleurs.

[[Fichier:Personal computer, exploded 4.svg|thumb|upright=1.0|Éclaté d'un ordinateur de type PC :&lt;br /&gt;
1 : Écran ;&lt;br /&gt;
2 : Carte mère ;&lt;br /&gt;
3 : Processeur ;&lt;br /&gt;
4 : Câble Parallel ATA ;&lt;br /&gt;
5 : Mémoire vive (RAM) ;&lt;br /&gt;
6 : Carte d'extension ;&lt;br /&gt;
7 : Alimentation électrique ;&lt;br /&gt;
8 : Lecteur de disque optique ;&lt;br /&gt;
9 : Disque dur ;&lt;br /&gt;
10 : Clavier ;&lt;br /&gt;
11 : Souris.]]

Si on regarde une carte mère de face, on voit un grand nombre de connecteurs, mais aussi des circuits électroniques soudés à la carte mère.

[[File:Architecture matérielle d'une carte mère.png|centre|vignette|upright=2.0|Architecture matérielle d'une carte mère]]

Les '''connecteurs''' sont là où on branche les périphériques, la carte graphique, le processeur, la mémoire, etc. Dans l'ensemble, toute carte mère contient les connecteurs suivants :
* Le processeur vient s’enchâsser dans la carte mère sur un connecteur particulier : le '''socket'''. Celui-ci varie suivant la carte mère et le processeur, ce qui est source d'incompatibilités.
* Les barrettes de mémoire RAM s’enchâssent dans un autre type de connecteurs: les '''slots mémoire'''.
* Les mémoires de masse disposent de leurs propres connecteurs : connecteurs P-ATA pour les anciens disques durs, et S-ATA pour les récents.
* Les périphériques (clavier, souris, USB, Firewire, ...) sont connectés sur un ensemble de connecteurs dédiés, localisés à l'arrière du boitier de l'unité centrale. 
* Les autres périphériques sont placés dans l'unité centrale et sont connectés via des connecteurs spécialisés. Ces périphériques sont des cartes imprimées, d'où leur nom de '''cartes filles'''. On peut notamment citer les cartes réseau, les cartes son, ou les cartes vidéo.

===Les ordinateurs portables===

[[File:Samsung QX-511 (2).JPG|vignette|Ordinateur portable Samsung QX-511 (2), pour illustration.]]

Un ordinateur portable est identique à un ordinateur de type PC. Si vous ouvrez votre ordinateur portable (attention à la garantie), vous retrouverez les mêmes composants qu'un PC à l'intérieur. Un point important est la présence d'une batterie à l'intérieur du PC portable, absente des PC fixes.

[[File:LG gram 14Z90Q mainboard with battery.jpg|centre|vignette|upright=2|LG gram 14Z90Q avec sa batterie.]]

Une fois la batterie et les circuits associés retiré, la seule différence notable est que tous les composants sont soudés sur la carte mère, au lieu d'être branchés sur des connecteurs, à part éventuellement la RAM et le disque dur.

[[File:LG gram 14Z90Q mainboard without battery.jpg|centre|vignette|upright=2|LG gram 14Z90Q sans sa batterie.]]

La RAM est parfois soudée sur la carte mère, d'autres fois sous la forme de barrettes de mémoire vive semblables à celles des PC. Dans le dernier cas, elle est connectée à des connecteurs spécifiques, ce qui permet de les changer/upgrader. Les PC portables sont parfois construits de manière à pouvoir changer la RAM facilement, en ouvrant un cache spécial, concu pour.

[[File:Lenovo G555 состав - Донор.JPG|centre|vignette|upright=2|Lenovo G555.]]

La conception d'un ordinateur portable est légèrement différente de celle d'un PC, pour des raisons thermiques. Un PC fixe a plus de place pour évacuer sa chaleur. Les ventilateurs peuvent plus facilement déplacer l'air dans le boitier, même si le flux d'air dans le boitier est éventuellement gêné par la carte graphique. Mais l'évacuation de la chaleur est assez efficace. Sur les PC portables, leur finesse fait que le trajet de l'air est beaucoup plus contraint. Évacuer la chaleur produite par l'ordinateur est plus complexe, ce qui demande d'utiliser des systèmes de refroidissement et de ventilation spécifiques.

Là où les PC fixes se débrouillent avec des radiateurs et des ventilateurs posés sur le processeur, les PC portables font autrement. Ils ne peuvent pas forcément mettre le ventilateur sur le processeur. A la place, ils mettent le ventilateur à côté, mais le processeur est surmonté par un mécanisme de transmission de la chaleur, qui transfère la chaleur du processeur vers le ventilateur.

[[File:Diagram - How a laptop cooling system works.png|centre|vignette|upright=2|Comment fonctionne le système de ventilation d'un ordinateur portable, en anglais.]]

Les difficultés pour dissiper la chaleur font que les ordinateurs portables utilisent souvent des composants peu performants, mais qui chauffent peu. En effet, nous verrons que plus un composant est puissant, plus il chauffe. La relation n'est pas parfaite, mais les processeurs haute performance chauffent plus que les modèles d'entrée ou milieu de gamme moins puissants. En conséquence, les PC portables sont souvent moins puissants que les PC fixes, même pour les modèles dit ''gaming''.

===Les serveurs et ''mainframes''===

Les grandes entreprises utilisent des ordinateurs de grande taille, très puissants, appelés des ''mainframes''. Ils sont souvent confondus avec les serveurs par le grand public, il y a une différence entre les deux. Un serveur est une fonction logicielle/réseau, pas un type d'ordinateur. Mais laissons cette différence de côté, ce qui est dit pour les ''mainframes'' sert pour les gros serveurs haute performance.

[[File:IBM Z15 mainframe.jpg|vignette|Exemple de ''mainframe''' de type IBM Z15.]]

Les anciens ''mainframes'' des années 50-80 avaient une taille pouvant être impressionnante, au point de prendre une pièce complète d'un bâtiment. Mais de nos jours, les ''mainframes'' tiennent dans une grosse armoire un peu haute. Les ''mainframes'' doivent rester allumé en permanence et ne doivent pas être éteint, sauf éventuellement quelques jours par an pour des opérations de maintenance. Ils utilisent pour cela des techniques spécifiques, avec beaucoup de redondance interne.

[[File:ACONIT hall grandes machines.jpg|centre|vignette|upright=2|''Mainframe'' ACONIT.]]

Les ''mainframes'' sont aussi conçus pour mutualiser au maximum leur utilisation, ils peuvent être utilisés par plusieurs utilisateurs à la suite, voire en même temps. Pour cela, les anciens ''mainframes'' étaient capables de faire tourner plusieurs applications distinctes l'une à la suite de l'autre, avec des commutations fréquentes entre logiciels. De nos jours, ils sont capables d'exécuter un grand nombre de tâches en même temps, grâce à la présence de plusieurs processeurs. Les ''mainframes'' modernes sont même capables de faire tourner plusieurs systèmes d'exploitation en même temps si besoin.

Les anciens ''mainframes'' étaient des ordinateurs assez simples, avec un processeur, de la mémoire RAM, un ou plusieurs disques durs, pas plus. Le ''mainframe'' était tellement énorme et cher que les entreprises n'en avaient qu'un seul pour toute l'entreprise. Les employés avaient sur leur bureau des terminaux, qui permettaient d'accéder à l'ordinateur central, mais n'étaient pas des ordinateurs. Les terminaux étaient des composants électroniques simples, avec un écran, un clavier et une souris, mais sans processeur. Ils envoyaient des données au ''mainframe'', ils en recevaient de sa part, mais tout traitement était réalisé sur le ''mainframe''. L'arrivée sur le marché des ordinateurs personnels, de type PC fixe/portable, a entrainé l'abandon de ce genre de pratique, tous les employés ont maintenant un ordinateur rien que pour eux.

{|
|-
! colspan=&quot;2&quot; | Exemples de terminaux
|-
|[[File:Terminal-in2-sm9400.jpg|centre|vignette|upright=1.5|Exemple de terminal. Notez la présence d'un écran et d'un clavier, mais l'asbence d'une unité centrale.]]
|[[File:Chromatics CT4100.jpg|vignette|upright=1.5|Autre exemple de terminal. Le clavier est couplé à un stylo CRT, qui remplacait la souris et agissait sur l'écran comme s'il était tactile.]]
|-
! colspan=&quot;2&quot; | Intérieur d'un terminal
|-
|[[File:CT1024 Monitor.jpg|vignette|upright=1.5|Terminal CT1024, sans le boitier extérieur.]]
|[[File:CT1024 Terminal System.jpg|vignette|upright=1.5|Terminal CT1024, description des composants interne.]]
|}

De nos jours, les ''mainframes'' contiennent en réalité plusieurs ordinateurs simples interconnectés via un réseau local. Un ''mainframe'' qui tient dans une armoire contient facilement une dizaine ou centaine de processeurs, plein de RAM, des disques durs séparés dans une armoire distincte, etc. Vu qu'ils communiquent uniquement via le réseau, ils n'ont pas d'interface, pas d'écran, 'entrée via clavier/souris. Le tout est commandé avec une console de commande, typiquement un ordinateur portable ou un terminal assez simple séparé de l'armoire, qui permet à un administrateur de faire des opérations de surveillance, configuration et maintenance. Il peut y avoir une console de commande pour plusieurs armoires séparées, la console peut même être dans un autre bâtiment et accéder au ''mainframe'' par le réseau.

[[File:IBM System Z9 (type 2094 inside).jpg|centre|vignette|upright=2|''Mainframe'' de type IBM System Z9. L'ordinateur portable sert de console pour qu'un administrateur fasse des opérations de surveillance, configuration et maintenance.]]

Les processeurs et la RAM sont typiquement installés sur des cartes amovibles, qui sont connectées au fond de l'armoire lors de l'installation. Il est même possible de retirer ou d'ajouter des cartes en fonctionnement, afin d'ajouter/retirer des processeurs, des disques durs, etc. Ce qui est très utile si un composant est en panne et qu'il faut le remplacer. 

[[File:IBM TotalStorage Exp400.jpg|centre|vignette|upright=2|IBM TotalStorage Exp400]]

==Un peu d'abstraction : qu'est-ce qu'un ordinateur ?==

Un ordinateur comprend donc un processeur, plusieurs mémoires, des cartes d'extension et une carte mère pour connecter le tout. Mais il s'agit là d'une description assez terre-à-terre de ce qu'est un ordinateur. Une autre description, plus abstraite, se base sur le fait qu'un ordinateur est une énorme calculatrice programmable. Elle permet d'expliquer pourquoi il y a une distinction entre processeur et mémoire, entre unité centrale et périphériques. Tout ce qui va suivre pourra vous paraitre assez abstrait, mais rassurez-vous : les prochains chapitres rendront tout cela plus concrets.

===La séparation entre entrées-sorties et traitement===

L'unité centrale peut être vue comme une énorme calculatrice ultra-puissante, qui exécute des commandes/opérations. Mais à elle seule, elle ne servirait à rien, il faut interagir avec par l'intermédiaire de plusieurs périphériques. Il existe deux types de périphériques, qui sont conceptuellement différents. Les périphériques comme le clavier ou la souris permettent d'envoyer des informations à l'ordinateur, d'agir sur celui-ci. A l'inverse, les écrans transmettent des informations dans le sens inverse : de l'ordinateur vers l'utilisateur. Les premiers sont appelés des '''entrées''', les seconds des '''sorties'''.

Dans un ordinateur, les informations sont représentées sous la forme de nombres. Toute donnée dans un ordinateur est codée avec un ou plusieurs nombres regroupés dans une donnée, un fichier, ou autre. Et la transmissions avec les entrées et sorties se fait là-encore avec des nombres. Par exemple, quand vous appuyez sur votre clavier, le clavier envoie un numéro de touche à l'unité centrale, qui indique quelle touche a été appuyée. L'image à afficher à l'écran est codée sous la forme d'une suite de nombres (un par pixel). L'image est envoyée à l'écran, qui traduit la suite de nombre en image à afficher. Les entrées traduisent des actions utilisateurs en nombres, on dit que les entrées encodent les actions utilisateur. Les sorties font la traduction inverse, elles transforment des suites de nombres en une action physique. On dit qu'elles décodent des informations.

Pour résumer, toute appareil électronique est composé par :
* Des '''entrées''' sur lesquelles l'utilisateur agit sur l'ordinateur. Les entrées transforment les actions de l'utilisateur en nombres, qui sont interprétés par l'ordinateur.
* Une '''unité de traitement''', qui manipule des nombres et fait des calculs/opérations dessus. Les nombres proviennent des entrées, du disque dur, ou d'autres sources, peu importe.
* Des '''sorties''', qui va récupèrent le résultat calculé par l'unité de traitement pour en faire quelque chose : écrire sur une imprimante ou sur un moniteur, émettre du son,...

[[File:Ordinateur théorique Simple 1.png|centre|vignette|upright=2|Ordinateur théorique Simple 1]]

L'unité de traitement proprement dite, celle qui fait les calculs, est couplée à une mémoire qui mémorise les opérandes et résultats des calculs. La séparation entre processeur et mémoire est nécessaire pour qu'un appareil électronique soit qualifié d'ordinateur. De nombreux appareils n'ont pas de séparation entre unité de traitement et mémoire, comme certaines vielles radios AM/FM.

[[File:Schéma de principe d'un ordinateur.png|centre|vignette|upright=2|Schéma de principe d'un ordinateur]]

===Un ordinateur est un appareil programmable===

Les appareils simples sont non-programmables, ce qui veut dire qu’ils sont conçus pour une utilisation particulière et qu’ils ne peuvent pas faire autre chose. Par exemple, les circuits électroniques d’un lecteur de DVD ne peuvent pas être transformé en lecteur audio ou en console de jeux... Les circuits non-programmables sont câblés une bonne fois pour toute, et on ne peut pas les modifier. On peut parfois reconfigurer le circuit, pour faire varier certains paramètres, via des interrupteurs ou des boutons, mais cela s’arrête là. Et cela pose un problème : à chaque problème qu'on veut résoudre en utilisant un automate, on doit recréer un nouveau circuit.

À l'inverse, un ordinateur n’est pas conçu pour une utilisation particulière, contrairement aux autres objets techniques. Il est possible de modifier leur fonction du jour au lendemain, on peut lui faire faire ce qu’on veut. On dit qu'ils sont '''programmables'''. Pour cela, il suffit d’utiliser un logiciel, une application, un programme (ces termes sont synonymes), qui fait ce que l'on souhaite. La totalité des logiciels présents sur un ordinateur sont des programmes comme les autres, même le système d'exploitation (Windows, Linux, ...) ne fait pas exception.

Un programme est une suite de d'instructions, chaque instruction effectuant une action dans l'ordinateur. Sur les ordinateurs modernes, la majorité de ces instructions effectuent une opération arithmétique, comme une addition, une multiplication, une soustraction, etc. Les ordinateurs modernes sont donc de grosses calculettes très puissantes, capables d'effectuer des millions d'opérations par secondes. Et qui dit opération dit nombres : un ordinateur gère nativement des nombres, qui sont codés en binaire sur la quasi-totalité des ordinateurs modernes.

Une instruction est représentée dans un ordinateur par une série de nombres : un nombre qui indique quelle opération/commande effectuer et des autres nombres pour coder les données (ou de quoi les retrouver dans l'ordinateur). L'ordinateur récupére les commandes une par une, les traduit en opération à effectuer, exécuter l'opération, et enregistre le résultat. Puis il recommence avec la commande suivante.

[[File:Ordinateur Théorique Complexe 1.png|centre|vignette|upright=3|Ordinateur Théorique Complexe. En jaune, le programme informatique, la liste de commande. Le rectangle gris est l'ordinateur proprement dit.]]

De nombreux appareils sont programmables, mais tous ne sont pas des ordinateurs. Par exemple, certains circuits programmables nommés FPGA n'en sont pas. Pour être qualifié d'ordinateur, un appareil programmable doit avoir un processeur séparé de la mémoire. De plus, il doit utiliser un '''codage numérique''', chose que nous allons aborder dans le chapitre suivant.

===Les ordinateurs à programme mémorisé ou programme externe===

Au tout début de l'informatique, on utilisait des cartes perforées en plastique, sur lesquelles on inscrivait le programme à exécuter, les données à traiter, bref : tout ce qu'on donnait à manger à l'ordinateur. Par la suite, les premiers ordinateurs grand public, comme les Amstrad ou les Commodore, utilisaient des cassettes audio magnétiques pour stocker les programmes. Dans le même style, les consoles de jeu utilisaient autrefois des cartouches de jeu, qui contenaient le programme du jeu à exécuter. Pour résumer, les anciens ordinateurs mémorisaient les programmes sur un support externe, lu par un périphérique. De tels ordinateurs sont dits à '''programme externe'''.

: D’anciens ordinateurs personnels, comme l’Amstrad ou le Commodore, permettaient de taper les programmes à exécuter à la main, au clavier, avant d’appuyer une touche pour les exécuter. Nul besoin de vous dire que les cassettes audio étaient plus pratiques.

Mais de nos jours, les programmes sont enregistrés sur le disque dur de l'ordinateur ou dans une mémoire intégrée à l'ordinateur. On dit qu'ils sont installés, ce qui est un mot bien compliqué pour dire que le programme est enregistré sur le disque dur de l’ordinateur. A défaut de disque dur, le programme/logiciel est enregistré dans une mémoire spécialisée pour le stockage. Par exemple, sur les cartes électroniques grand public de marque Arduino, les programmes sont envoyés à la carte via le port USB, mais les programmes sont enregistrés dans la carte Arduino, dans une mémoire FLASH dédiée. Disque dur ou non, le programme est mémorisé dans la mémoire de l'ordinateur. Il est possible d'installer ou de désinstaller les programmes en modifiant le contenu de la mémoire. Le terme utilisé est alors celui de '''programme stocké en mémoire'''.

Les programmes à installer sont disponibles soit sur un périphérique, comme un DVD ou une clé USB, soit sont téléchargés depuis internet. Les premiers PC fournissaient les logiciels sur des disquettes, qui contenaient un programme d'installation pour enregistrer le programme sur le disque dur de l'ordinateur. Par la suite, le support des logiciels a migré vers les CD et DVD, les logiciels devenant de plus en plus gros. De nos jours, la majorité des applications sont téléchargées depuis le net, l'usage de périphériques est devenu obsolète, même les consoles de jeu abandonnent cette méthode de distribution.

==Les générations d'ordinateurs : un historique rapide==

L'informatique a beaucoup évolué dans le temps. Et une bonne partie de cette évolution tient à l'évolution de l’électronique sous-jacente. Les ordinateurs actuels sont fabriqués avec des transistors, des petits composants électroniques qui servent d'interrupteur programmables, qu'on détaillera dans ce qui suit. Mais ça n'a pas toujours été le cas. Et cela permet de distinguer plusieurs '''générations d'ordinateurs'''.

===Les ordinateurs électro-mécaniques : les premiers ordinateurs===

Le tout premier ordinateur est le '''Z1''', un modèle unique inventé par Konrad Suze entre 1936 et 1938. Son processeur gérait non pas des nombres entiers, mais des nombres à virgule (des nombres dits flottants, pour être précis), encodés sur 22 bits. Le processeur du Z1 était capable de faire des additions et des soustractions, car il intégrait un circuit additionneur-soustracteur basique. Des circuits annexes permettaient de faire des multiplications et des divisions en enchainant des additions/soustractions successives. Il fonctionnait à une fréquence de 1 Hz, ce qui fait qu'il pouvait faire une addition/soustraction par seconde maximum.

[[File:Blue-punch-card-front.png|vignette|upright=0.5|Carte Perforée.]]

Niveau mémoire, la RAM de l'ordinateur était très limitée : seulement 16 nombres de 22 bits chacun. S'il s'agissait d'une mémoire électronique, les programmes étaient mémorisés sur une mémoire mécanique. Les programmes étaient enregistrés sur des cartes perforées, à savoir des cartes en papier dans lesquelles un 1 est codé par un trou dans le papier et un 0 par une absence de trou. Les programmes étaient exécutés par l'ordinateur quand on insérait la carte perforée dans le lecteur et qu'on appuyait sur un bouton.

Après sa destruction dans un bombardement lors de la seconde guerre mondiale, le Z1 a été remplacé par un modèle dit Z2, lui-même suivi par le Z3, qui n'étaient que des améliorations du Z1. Tous étaient des ordinateurs dit '''électro-mécaniques''', car ils mélangeaient des composants électroniques (des relais) et des composants mécaniques (tout ce qui a trait aux cartes perforées, notamment). Les ordinateur qui ont suivi, avant 1944, étaient tous de ce type.

[[File:German Museum of Technology, Berlin 2017 024.jpg|centre|vignette|upright=2|Réplique du Z1 au ''German Museum of Technology'' de Berlin, 2017.]]

===Les premières générations : des ordinateurs qui prenaient des pièces de bâtiment entières===

A partir de 1944, de nombreux ordinateurs plus puissants ont été mis sur le marché. Des grandes noms de l'histoire de l'informatique date de cette époque : le Harvard Mark I et le Colossus Mark 1 (UK) ont tous deux été mis en service en 1944, suivi par le Z4 l'année suivante. Ils ont servis pour les cryptanalystes pour casser les codes utilisés par les allemands pour leurs transmissions, pendant la seconde guerre mondiale.

Mais c'est l'arrivée de l'ENIAC en 1945 qui a changé la donne. Cet ordinateur a introduit plusieurs innovations majeures. La première est assez technique, il s'agit de la turing-complétude, et a trait aux programmes qui peuvent être écrit pour un ordinateur. Nous ne la détaillerons pas ici. La seconde innovation est que le programme n'était plus mémorisé sur des cartes perforée, mais dans une mémoire électronique dans l'ordinateur lui-même. En clair, l'ENIAC était le premier '''''Stored-program computer''''', ordinateur à programme enregistré en français. Enfin, l'ENIAC était composé non pas de relais et l'élèments mécaniques, mais uniquement de tubes à vides, des composants électroniques assez rudimentaires plus ou moins équivalents aux transistors modernes.

[[File:IBM 7070.jpg|vignette|Cartes imprimées de l'IBM 704, avec des transistors et résistances dessus.]]

Les ordinateurs qui ont suivi l'ENIAC sont regroupés dans la '''première génération d'ordinateur'''. Ils étaient conçus avec des tubes à vide, ce qui les place entre les premiers ordinateurs électro-mécaniques et les ordinateurs utilisant des transistors. Les ordinateurs de première génération étaient très simples, ils ne géraient que quelques opérations simples : l'addition, la soustraction, pas grand chose de plus. A quelques exceptions près, ils ne géraient pas la multiplication et encore moins la division, ils n'avaient pas assez de relais ou de tubes à vides à disposition pour cela.

La '''seconde génération''' est celle des ordinateurs fabriqués avec des '''transistors''' isolés, reliés entre avec des fils électriques. Les transistors en question possèdent trois broches, des pattes métalliques sur lesquelles on connecte des fils électriques. Le transistor s'utilise le plus souvent comme un interrupteur commandé par sa troisième broche. Le courant qui traverse les deux premières broches passe ou ne passe pas selon ce qu'on met sur la troisième.

[[File:Transistor basic flow.svg|centre|vignette|Un transistor est un morceau de conducteur, dont la conductivité est contrôlée par sa troisième broche/borne.]]

Les ordinateurs de seconde génération avaient entre 1000 et 500 000 transistors. Les capacités des ordinateurs étaient donc nettement supérieures à celles des ordinateurs de première génération. Une part non négligeable des ordinateurs de seconde génération supportait l'opération de multiplication, absente sur les ordinateurs de première génération. Néanmoins, cela variait beaucoup selon les ordinateurs.

Un exemple assez hors du commun est celui du premier modèle de l'IBM 1620. Le tout premier modèle n'avait aucun circuit de calcul, il n'était même pas capable de faire une addition ou une multiplication. A la place, il utilisait une table d'addition et une table de multiplication en mémoire RAM. Les deux tables devaient être initialisées par le logiciel lors du démarrage de la machine. La table d'addition faisait une centaine de chiffre, la table de multiplication faisait le double. Le processeur de l'ordinateur gérait des instructions pour faire des additions ou des multiplications, mais ces opérations lisaient le résultat dans la table d'addition. Les calculs étaient fait chiffre par chiffre, avec un encodage partiellement décimal, partiellement binaire (des chiffres décimaux étaient encodés en binaire, nous en reparlerons quand nous parlerons du BCD) !

[[File:KL CoreMemory.jpg|vignette|Mémoire à tore de ferrite.]]

Les transistors n'étaient utilisés que pour le processeur et les circuits annexes. La mémoire n'était pas faite en transistors, pas à cette époque. La mémoire était une mémoire aujourd'hui abandonnée, appelée une '''mémoire à tores de ferrite'''. Elle sera détaillée dans un chapitre ultérieur. Mais sachez pour le moment qu'il s'agit d'une mémoire au support magnétique, les données étant stockées sur un support magnétique.

Transistors comme tubes à vide prenaient beaucoup de place, ce qui fait que les ordinateurs étaient assez gros. Concrètement, ils prenaient une pièce de bâtiment entière dans le meilleur des cas. C'était l'époque des gros ''mainframes'', reliés à des terminaux, peu puissants comparé aux standards actuels. Seules les grandes entreprises et les grands instituts de recherche pouvaient se payer les services de ce genre d'ordinateurs. Seuls les professionnels avaient accès à ce genre d'équipement.

===La troisième génération : le circuit intégré===

[[File:D8259AC-2.jpg|vignette|Exemple de circuit intégré.]]

La troisième génération est toujours fabriquée avec des transistors, mais dont la taille a été réduite. Avec l'évolution de la technologie, les transistors ont diminué en taille, de plus en plus. Ils sont devenus tellement petits qu'ils ont finit par être regroupés dans des '''circuits intégrés''', des circuits regroupent plusieurs transistors sur la même puce de silicium. Les circuits intégrés se présentent le plus souvent sous la forme de boitiers rectangulaires, comme illustré ci-contre. D'autres ont des boitiers de forme carrées, comme ceux que l'on peut trouver sur les barrettes de mémoire RAM, ou à l'intérieur des clés USB/ disques SSD.

Lors de cette génération, les processeurs étaient fournis en pièces détachées qu'il fallait relier entre elles. Le processeur était composé de plusieurs circuits intégrés séparés, impossible de mettre un processeur dans un seul boitier. Un exemple de processeur conçu en kit est la série des Intel 3000. Elle regroupe plusieurs circuits séparés aux noms à coucher dehors, mais dont vous comprendrez ce qu'ils veulent dire dans les chapitres adéquats : l'Intel 3001 est un séquenceur, l'Intel 3002 regroupe unité de calcul et registres, le 3003 est un circuit d'anticipation de retenue complémentaire du 3002, le 3212 est une mémoire tampon, le 3214 est une unité de gestion des interruptions, les 3216/3226 sont des interfaces de bus mémoire. On pourrait aussi citer la famille de circuits intégrés AMD Am2900.

Même si le processeur était en pièce détachées, utiliser une dizaine de circuits intégrés était nettement mieux que d'utiliser plusieurs milliers de transistors individuels. En conséquence, les ordinateurs ont vu leur taille grandement réduite, passant de pièces entières à une simple armoire, voire à quelques cartes intégrées superposées. De plus, le prix des circuits intégré était abordable, du moins comparé aux ordinateurs d'avant. Le prix des ordinateurs a alors grandement décru, permettant à des entreprises et administrations de taille modeste de s'équiper d'ordinateurs.

===La quatrième génération : le microprocesseur===

[[File:MOS6502.svg|vignette|Microprocesseur, ici un processeur MOS6502, de la quatrième génération.]]

Lors de la troisième génération, les circuits intégrés regroupaient plusieurs dizaines ou centaines de transistors, mais sont rapidement montés en gamme. De centaines de transistors, ils sont passé au milliers de transistors, puis au millions et maintenant au-delà du milliard. Les transistors étaient devenus tellement petits, tellement miniaturisés, qu'il était devenu possible de mettre un processeur entier dans un circuit intégré. C'est ainsi qu'est né le microprocesseur, à savoir un processeur qui tient tout entier dans un seul circuit imprimé. La quatrième génération d’ordinateur est celle des ordinateurs basés autour d'un microprocesseur.

Les tout premiers microprocesseurs étaient des processeurs à application militaire, comme le processeur du F-14 CADC ou celui de l'Air data computer. Le tout premier microprocesseur commercialisé au grand public est le 4004 d'Intel, sorti en 1971. L'intel 4004 comprenait environ 2300 transistors, avait une fréquence de 740 MHz, pouvait faire 46 opérations différentes, et manipulait des entiers de 4 bits. Il était au départ un processeur de commande, prévu pour être intégré dans la calculatrice Busicom calculator 141-P, mais il fut utilisé pour d'autres applications quelque temps plus tard. Immédiatement après le 4004, les premiers microprocesseurs 8 bits furent commercialisés. Le 4004 fut suivi par le 8008 et quelques autres processeurs 8 bits extrêmement connus, comme le 8080 d'Intel, le 68000 de Motorola, le 6502 ou le Z80.

Les microprocesseurs permirent encore uen fois de réduire la taille des ordinateurs, qui pouvaient tenir dans un boitier de PC, ou un boitier de console de jeu. Le prix des ordinateurs a aussi chuté en même temps que les transistors était miniaturisés. C'est cette invention qui permis l'invention des consoles de jeux et des mini-ordinateurs, à savoir les ordinateurs personnels. Sans miniaturisation, on n'aurait pas d'ordinateur personnel, pas de PC fixe ou portable.

==L'organisation du cours : les différents niveaux d'explication==

Le fonctionnement d'un ordinateur est assez complexe à expliquer car les explications peuvent se faire sur plusieurs niveaux. Par plusieurs niveaux, on veut dire qu'un ordinateur est composé de composants très simples, qui sont assemblés pour donner des composants eux-même plus complexes, qui sont eux-même regrouper, etc. Étudier tout cela demande de voir plusieurs niveaux, allant de transistors très petits à des processeurs multicœurs. Les niveaux les plus bas sont de l'électronique pur et dure, alors que ceux plus haut sont à mi-chemin entre électronique et informatique.

===Les niveaux d'abstraction en architecture des ordinateurs===

Les trois premiers niveaux sont de l'électronique pur et dure. Ils correspondent aux premiers chapitres du cours, qui porteront sur les circuits électroniques en général.
* Le premier niveau est celui des '''transistors''', des circuits intégrés, des ''wafer'' et autres circuits de très petite taille.
* Le second niveau est celui des '''portes logiques''', des circuits très basiques, très simples, à la base de tous les autres.
* Le troisième niveau est celui dit de la '''''Register Transfer Level''''', où un circuit électronique est construit à partir de circuits basiques, dont des registres et autres circuits dits combinatoires.
Les deux niveaux suivants sont de l'informatique proprement dit. C'est dans ces deux niveaux qu'on étudie les ordinateurs proprement dit, les circuits qu'il y a dedans et non l'électronique en général.
* Le quatrième niveau est celui de la '''microarchitecture''', qui étudie ce qu'il y a à l'intérieur d'un processeur, d'une mémoire, des périphériques et autres.
* Le cinquième niveau est celui de l''''architecture externe''', qui décrit l'interface du processeur, de la mémoire, d'un périphérique ou autre. Par décrire l'interface, on veut dire : comment un programmeur voit le processeur et la mémoire, comment il peut les manipuler. Une architecture externe unique peut avoir plusieurs microarchitecture, ce qui fait qu'on sépare les deux. Tout cela sera plus clair quand on passera aux chapitres sur le processeur et les mémoires.

Nous n'allons pas voir les 5 niveaux dans l'ordre, des transistors vers l'architecture externe. En réalité, nous allons procéder autrement. La première partie du cours portera sur les trois premiers niveaux, le reste sur les deux autres. Les 5 niveaux seront vus dans des chapitres séparés, du moins le plus possible. Au niveau pédagogique, tout est plus simple si on scinde les 5 niveaux. Bien sûr, il y a quelques explications qui demandent de voir plusieurs niveaux à la fois. Par exemple, dans le chapitre sur les mémoires caches, nous auront des explications portant sur la RTL, la microarchitecture du cache et son architecture externe. Mais le gros du cours tentera de séparer le plus possible les 5 niveaux.

===Les trois parties principales du cours===

Nous allons commencer par parler du binaire, avant de voir les portes logiques. Avec ces portes logiques, nous allons voir comment fabriquer des circuits basiques qui reviendront très souvent dans la suite du cours. Nous verrons les registres, les décodeurs, les additionneurs et plein d'autres circuits. Puis, nous reviendrons au niveau des transistors pour finir la première partie. La raison est que c'est plus simple de faire comme cela. Tout ce qui a trait aux transistors sert à expliquer comment fabriquer des portes logiques, et il faut expliquer les portes logiques pour voir le niveau de la RTL.

Une fois la première partie finie, nous allons voir les différents composants d'un ordinateur. Une première partie expliquera ce qu'il y a dans un ordinateur, quels sont ses composants. Nous y parlerons de l'architecture de base, de la hiérarchie mémoire, des tendances technologiques, et d'autres généralités qui serviront de base pour la suite. Puis, nous verrons dans l'ordre les bus électroniques, les mémoires RAM/ROM, le processeur, les périphériques, les mémoires de stockage (SSD et disques durs) et les mémoires caches. Pour chaque composant, nous allons voir leur architecture externe, avant de voir leur microarchitecture. La raison est que la microarchitecture ne peut se comprendre que quand on sait quelle architecture externe elle implémente.

Enfin, dans une troisième partie, nous allons voir les optimisations majeures présentes dans tous les ordinateurs modernes, avec une partie sur le pipeline et le parallélisme d'instruction, et une autre sur les architectures parallèles. Pour finir, les annexes de fin parlerons de sujets un peu à part.

&lt;noinclude&gt;
{{NavChapitre | book=Fonctionnement d'un ordinateur
           | next=L'encodage des données
           | nextText=L'encodage des données
}}
&lt;/noinclude&gt;</text>
      <sha1>73yof63znezra7jthlx96bha2p2m7p4</sha1>
    </revision>
    <revision>
      <id>744106</id>
      <parentid>744105</parentid>
      <timestamp>2025-06-04T20:55:41Z</timestamp>
      <contributor>
        <username>Mewtow</username>
        <id>31375</id>
      </contributor>
      <minor />
      <comment>/* Les ordinateurs électro-mécaniques : les premiers ordinateurs */</comment>
      <origin>744106</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="41764" sha1="les8yl97rp9nuyzoaqmw4im1d52tj33" xml:space="preserve">Pour commencer, nous allons voir qu'il existe de nombreux types d'ordinateurs. Le plus connu est certainement le PC, l'ordinateur personnel, que vous avez sans doute dans votre salon. Les ordinateurs portables sont un deuxième type d'ordinateur assez intuitif, que vous avez peut-être. Mais il y a aussi d'autres types d'ordinateurs auxquels vous n'avez jamais été confrontés.

==Les différents types d'ordinateurs==

Dans cette section, nous allons décrire rapidement les ordinateurs les plus courant, mais surtout voir ce qu'il y a à l'intérieur d'un ordinateur.

===L'ordinateur de type PC fixe===

De l'extérieur, l'ordinateur est composé d'une unité centrale sur laquelle on branche des périphériques.

[[File:Typical computer architecture systems.jpg|vignette|upright=1.5|Exemples de périphériques, connectés à une unité centrale (ici appelée à tort ''operating system'').]]

Les '''périphériques''' regroupent l'écran, la souris, le clavier, l'imprimante, et bien d'autres choses. Ils permettent à l'utilisateur d'interagir avec l'ordinateur : un clavier permet de saisir du texte sous dans un fichier, une souris enregistre des déplacements de la main en déplacement du curseur, un écran affiche des données d’images/vidéos, un haut-parleur émet du son, etc. Tout ce qui est branché sur un ordinateur est, formellement un périphérique.

L''''unité centrale''' est là où se trouvent tous les composants importants d'un ordinateur, ceux qui font des calculs, qui exécutent des logiciels, qui mémorisent vos données, etc. Voici ce à quoi ressemble l'intérieur de l'unité centrale. Trois sections sont visibles : l'alimentation électrique en haut à gauche, la carte mère en bas à gauche et en jaune/orange, les disques et lecteurs à droite des câbles. Et on voit aussi beaucoup de câbles.

[[File:Asus P5K-SEIntel E6320.jpg|centre|vignette|upright=2|Exemple d'unité centrale.]]

Tout en haut à gauche, se trouve l''''alimentation électrique''', qui convertit le courant de la prise électrique en un courant plus faible, utilisable par les autres composants. Elle émet de nombreux câbles assez gros, qui sont reliés au reste. Les PC actuels utilisent des alimentations électriques standardisées, qui fournissent trois tensions au reste de l'ordinateur : une tension de 12 Volts, une de 5 Volts, une de 3,3 Volts.

À droite, caché par la partie &quot;métallique&quot; du boitier, se trouvent les lecteurs de CD/DVD, et les disques durs. Les lecteurs CD-ROM ou DVD-ROM permettaient de lire des CD ou des DVD. Je parle au passé, car ils ont aujourd'hui disparu des ordinateurs modernes. Les '''disques durs''' sont des mémoires de stockage, qui mémorisent vos données de manière permanente. De nos jours, ils sont remplacés par des SSD, qui sont des disques durs électroniques, là où les disques durs proprement dit sont des mémoires magnétiques. Nous verrons la différence dans deux chapitres dédiés, un sur les disques durs, l'autre sur les SSD.

En bas à droite, se trouve la '''carte mère''' un support plat, en plastique ou en céramique, sur laquelle sont soudés/connectés les autres composants. Sur celle-ci, de nombreux composants sont soudés, d'autres sont branchés dessus avec des câbles, d'autres sont connectés dessus avec des connecteurs. Ils sont reliés entre eux par des fils conducteurs, le plus souvent du cuivre ou de l’aluminium, ce qui leur permet de s’échanger des données. Sur les cartes simples, ces fils sont intégrés dans la carte électronique, dans des creux du plastique. Ils portent le nom de pistes.

Avant, les disques durs, SSD et lecteurs de CD/DVD sont branchés dessus via des connecteurs dédiés, appelés des connecteurs S-ATA. De nos jours, ils sont branchés sur un autre connecteur, grâce à l'interface NVME. Toujours est-il qu'ils sont reliés à la carte mère par des câbles, ce qui montre que ce sont des sortes de périphériques interne. Ils sont placés dans le boitier, mais on aurait tout aussi bien pu les mettre à l'extérieur, vu qu'ils communiquent avec l'ordinateur par l'intermédiaire d'un câble ou d'un connecteur dédié.

Mais deux autres composants très importants sont eux placés sur la carte mère, directement. Ils ont chacun un connecteur dédié, sur lequel ils sont branchés directement, sans passer par l'intermédiaire d'un câble, mais sans être soudés non plus. Il s'agit du processeur et de la mémoire RAM, deux composants centraux des PC modernes.

[[File:Pentium III SL4CB.jpg|thumb|Processeur Pentium III.]]

Le '''processeur''' traite les données, les modifie, les manipule. Pour faire simple, il s’agit d’une grosse calculatrice hyper-puissante. Il comprend à la fois un circuit qui fait des calculs, et un circuit de contrôle qui s'occupe de séquencer les calculs dans l'ordre demandé. Il est souvent caché sous un radiateur, lui-même surmonté par un ventilateur. En effet, un processeur chauffe beaucoup, ce qui demande d'évacuer cette chaleur. Un chapitre entier expliquera pourquoi les processeurs chauffent, ainsi que les techniques utilisées pour limiter leur production de chaleur et leur consommation électrique.

La '''mémoire vive''' conserve des informations/données temporairement, tant que le processeur en a besoin. Elle prend la forme de barrettes de RAM, comme montré ci-dessous.

[[File:2 gb ddr2 667.jpg|centre|vignette|upright=2|Barrette de RAM.]]

Outre ces composants dits principaux, un ordinateur peut comprendre plusieurs composants moins importants, surtout présents sur les ordinateurs personnels. Ils sont techniquement facultatifs, mais sont très présents dans les ordinateurs personnels. Cependant, certains ordinateurs spécialisés s'en passent. Il s'agit des diverses '''cartes d'extension''' sont branchées sur la carte mère. Elles permettent d’accélérer certains calculs ou certaines applications, afin de décharger le processeur. Par exemple, la carte graphique s'occupe des calculs graphiques, qu'il s'agisse de graphismes 3D de jeux vidéos ou de l'affichage en 2D du bureau. Dans un autre registre, la carte son prend en charge le microphone et les haut-parleurs.

[[Fichier:Personal computer, exploded 4.svg|thumb|upright=1.0|Éclaté d'un ordinateur de type PC :&lt;br /&gt;
1 : Écran ;&lt;br /&gt;
2 : Carte mère ;&lt;br /&gt;
3 : Processeur ;&lt;br /&gt;
4 : Câble Parallel ATA ;&lt;br /&gt;
5 : Mémoire vive (RAM) ;&lt;br /&gt;
6 : Carte d'extension ;&lt;br /&gt;
7 : Alimentation électrique ;&lt;br /&gt;
8 : Lecteur de disque optique ;&lt;br /&gt;
9 : Disque dur ;&lt;br /&gt;
10 : Clavier ;&lt;br /&gt;
11 : Souris.]]

Si on regarde une carte mère de face, on voit un grand nombre de connecteurs, mais aussi des circuits électroniques soudés à la carte mère.

[[File:Architecture matérielle d'une carte mère.png|centre|vignette|upright=2.0|Architecture matérielle d'une carte mère]]

Les '''connecteurs''' sont là où on branche les périphériques, la carte graphique, le processeur, la mémoire, etc. Dans l'ensemble, toute carte mère contient les connecteurs suivants :
* Le processeur vient s’enchâsser dans la carte mère sur un connecteur particulier : le '''socket'''. Celui-ci varie suivant la carte mère et le processeur, ce qui est source d'incompatibilités.
* Les barrettes de mémoire RAM s’enchâssent dans un autre type de connecteurs: les '''slots mémoire'''.
* Les mémoires de masse disposent de leurs propres connecteurs : connecteurs P-ATA pour les anciens disques durs, et S-ATA pour les récents.
* Les périphériques (clavier, souris, USB, Firewire, ...) sont connectés sur un ensemble de connecteurs dédiés, localisés à l'arrière du boitier de l'unité centrale. 
* Les autres périphériques sont placés dans l'unité centrale et sont connectés via des connecteurs spécialisés. Ces périphériques sont des cartes imprimées, d'où leur nom de '''cartes filles'''. On peut notamment citer les cartes réseau, les cartes son, ou les cartes vidéo.

===Les ordinateurs portables===

[[File:Samsung QX-511 (2).JPG|vignette|Ordinateur portable Samsung QX-511 (2), pour illustration.]]

Un ordinateur portable est identique à un ordinateur de type PC. Si vous ouvrez votre ordinateur portable (attention à la garantie), vous retrouverez les mêmes composants qu'un PC à l'intérieur. Un point important est la présence d'une batterie à l'intérieur du PC portable, absente des PC fixes.

[[File:LG gram 14Z90Q mainboard with battery.jpg|centre|vignette|upright=2|LG gram 14Z90Q avec sa batterie.]]

Une fois la batterie et les circuits associés retiré, la seule différence notable est que tous les composants sont soudés sur la carte mère, au lieu d'être branchés sur des connecteurs, à part éventuellement la RAM et le disque dur.

[[File:LG gram 14Z90Q mainboard without battery.jpg|centre|vignette|upright=2|LG gram 14Z90Q sans sa batterie.]]

La RAM est parfois soudée sur la carte mère, d'autres fois sous la forme de barrettes de mémoire vive semblables à celles des PC. Dans le dernier cas, elle est connectée à des connecteurs spécifiques, ce qui permet de les changer/upgrader. Les PC portables sont parfois construits de manière à pouvoir changer la RAM facilement, en ouvrant un cache spécial, concu pour.

[[File:Lenovo G555 состав - Донор.JPG|centre|vignette|upright=2|Lenovo G555.]]

La conception d'un ordinateur portable est légèrement différente de celle d'un PC, pour des raisons thermiques. Un PC fixe a plus de place pour évacuer sa chaleur. Les ventilateurs peuvent plus facilement déplacer l'air dans le boitier, même si le flux d'air dans le boitier est éventuellement gêné par la carte graphique. Mais l'évacuation de la chaleur est assez efficace. Sur les PC portables, leur finesse fait que le trajet de l'air est beaucoup plus contraint. Évacuer la chaleur produite par l'ordinateur est plus complexe, ce qui demande d'utiliser des systèmes de refroidissement et de ventilation spécifiques.

Là où les PC fixes se débrouillent avec des radiateurs et des ventilateurs posés sur le processeur, les PC portables font autrement. Ils ne peuvent pas forcément mettre le ventilateur sur le processeur. A la place, ils mettent le ventilateur à côté, mais le processeur est surmonté par un mécanisme de transmission de la chaleur, qui transfère la chaleur du processeur vers le ventilateur.

[[File:Diagram - How a laptop cooling system works.png|centre|vignette|upright=2|Comment fonctionne le système de ventilation d'un ordinateur portable, en anglais.]]

Les difficultés pour dissiper la chaleur font que les ordinateurs portables utilisent souvent des composants peu performants, mais qui chauffent peu. En effet, nous verrons que plus un composant est puissant, plus il chauffe. La relation n'est pas parfaite, mais les processeurs haute performance chauffent plus que les modèles d'entrée ou milieu de gamme moins puissants. En conséquence, les PC portables sont souvent moins puissants que les PC fixes, même pour les modèles dit ''gaming''.

===Les serveurs et ''mainframes''===

Les grandes entreprises utilisent des ordinateurs de grande taille, très puissants, appelés des ''mainframes''. Ils sont souvent confondus avec les serveurs par le grand public, il y a une différence entre les deux. Un serveur est une fonction logicielle/réseau, pas un type d'ordinateur. Mais laissons cette différence de côté, ce qui est dit pour les ''mainframes'' sert pour les gros serveurs haute performance.

[[File:IBM Z15 mainframe.jpg|vignette|Exemple de ''mainframe''' de type IBM Z15.]]

Les anciens ''mainframes'' des années 50-80 avaient une taille pouvant être impressionnante, au point de prendre une pièce complète d'un bâtiment. Mais de nos jours, les ''mainframes'' tiennent dans une grosse armoire un peu haute. Les ''mainframes'' doivent rester allumé en permanence et ne doivent pas être éteint, sauf éventuellement quelques jours par an pour des opérations de maintenance. Ils utilisent pour cela des techniques spécifiques, avec beaucoup de redondance interne.

[[File:ACONIT hall grandes machines.jpg|centre|vignette|upright=2|''Mainframe'' ACONIT.]]

Les ''mainframes'' sont aussi conçus pour mutualiser au maximum leur utilisation, ils peuvent être utilisés par plusieurs utilisateurs à la suite, voire en même temps. Pour cela, les anciens ''mainframes'' étaient capables de faire tourner plusieurs applications distinctes l'une à la suite de l'autre, avec des commutations fréquentes entre logiciels. De nos jours, ils sont capables d'exécuter un grand nombre de tâches en même temps, grâce à la présence de plusieurs processeurs. Les ''mainframes'' modernes sont même capables de faire tourner plusieurs systèmes d'exploitation en même temps si besoin.

Les anciens ''mainframes'' étaient des ordinateurs assez simples, avec un processeur, de la mémoire RAM, un ou plusieurs disques durs, pas plus. Le ''mainframe'' était tellement énorme et cher que les entreprises n'en avaient qu'un seul pour toute l'entreprise. Les employés avaient sur leur bureau des terminaux, qui permettaient d'accéder à l'ordinateur central, mais n'étaient pas des ordinateurs. Les terminaux étaient des composants électroniques simples, avec un écran, un clavier et une souris, mais sans processeur. Ils envoyaient des données au ''mainframe'', ils en recevaient de sa part, mais tout traitement était réalisé sur le ''mainframe''. L'arrivée sur le marché des ordinateurs personnels, de type PC fixe/portable, a entrainé l'abandon de ce genre de pratique, tous les employés ont maintenant un ordinateur rien que pour eux.

{|
|-
! colspan=&quot;2&quot; | Exemples de terminaux
|-
|[[File:Terminal-in2-sm9400.jpg|centre|vignette|upright=1.5|Exemple de terminal. Notez la présence d'un écran et d'un clavier, mais l'asbence d'une unité centrale.]]
|[[File:Chromatics CT4100.jpg|vignette|upright=1.5|Autre exemple de terminal. Le clavier est couplé à un stylo CRT, qui remplacait la souris et agissait sur l'écran comme s'il était tactile.]]
|-
! colspan=&quot;2&quot; | Intérieur d'un terminal
|-
|[[File:CT1024 Monitor.jpg|vignette|upright=1.5|Terminal CT1024, sans le boitier extérieur.]]
|[[File:CT1024 Terminal System.jpg|vignette|upright=1.5|Terminal CT1024, description des composants interne.]]
|}

De nos jours, les ''mainframes'' contiennent en réalité plusieurs ordinateurs simples interconnectés via un réseau local. Un ''mainframe'' qui tient dans une armoire contient facilement une dizaine ou centaine de processeurs, plein de RAM, des disques durs séparés dans une armoire distincte, etc. Vu qu'ils communiquent uniquement via le réseau, ils n'ont pas d'interface, pas d'écran, 'entrée via clavier/souris. Le tout est commandé avec une console de commande, typiquement un ordinateur portable ou un terminal assez simple séparé de l'armoire, qui permet à un administrateur de faire des opérations de surveillance, configuration et maintenance. Il peut y avoir une console de commande pour plusieurs armoires séparées, la console peut même être dans un autre bâtiment et accéder au ''mainframe'' par le réseau.

[[File:IBM System Z9 (type 2094 inside).jpg|centre|vignette|upright=2|''Mainframe'' de type IBM System Z9. L'ordinateur portable sert de console pour qu'un administrateur fasse des opérations de surveillance, configuration et maintenance.]]

Les processeurs et la RAM sont typiquement installés sur des cartes amovibles, qui sont connectées au fond de l'armoire lors de l'installation. Il est même possible de retirer ou d'ajouter des cartes en fonctionnement, afin d'ajouter/retirer des processeurs, des disques durs, etc. Ce qui est très utile si un composant est en panne et qu'il faut le remplacer. 

[[File:IBM TotalStorage Exp400.jpg|centre|vignette|upright=2|IBM TotalStorage Exp400]]

==Un peu d'abstraction : qu'est-ce qu'un ordinateur ?==

Un ordinateur comprend donc un processeur, plusieurs mémoires, des cartes d'extension et une carte mère pour connecter le tout. Mais il s'agit là d'une description assez terre-à-terre de ce qu'est un ordinateur. Une autre description, plus abstraite, se base sur le fait qu'un ordinateur est une énorme calculatrice programmable. Elle permet d'expliquer pourquoi il y a une distinction entre processeur et mémoire, entre unité centrale et périphériques. Tout ce qui va suivre pourra vous paraitre assez abstrait, mais rassurez-vous : les prochains chapitres rendront tout cela plus concrets.

===La séparation entre entrées-sorties et traitement===

L'unité centrale peut être vue comme une énorme calculatrice ultra-puissante, qui exécute des commandes/opérations. Mais à elle seule, elle ne servirait à rien, il faut interagir avec par l'intermédiaire de plusieurs périphériques. Il existe deux types de périphériques, qui sont conceptuellement différents. Les périphériques comme le clavier ou la souris permettent d'envoyer des informations à l'ordinateur, d'agir sur celui-ci. A l'inverse, les écrans transmettent des informations dans le sens inverse : de l'ordinateur vers l'utilisateur. Les premiers sont appelés des '''entrées''', les seconds des '''sorties'''.

Dans un ordinateur, les informations sont représentées sous la forme de nombres. Toute donnée dans un ordinateur est codée avec un ou plusieurs nombres regroupés dans une donnée, un fichier, ou autre. Et la transmissions avec les entrées et sorties se fait là-encore avec des nombres. Par exemple, quand vous appuyez sur votre clavier, le clavier envoie un numéro de touche à l'unité centrale, qui indique quelle touche a été appuyée. L'image à afficher à l'écran est codée sous la forme d'une suite de nombres (un par pixel). L'image est envoyée à l'écran, qui traduit la suite de nombre en image à afficher. Les entrées traduisent des actions utilisateurs en nombres, on dit que les entrées encodent les actions utilisateur. Les sorties font la traduction inverse, elles transforment des suites de nombres en une action physique. On dit qu'elles décodent des informations.

Pour résumer, toute appareil électronique est composé par :
* Des '''entrées''' sur lesquelles l'utilisateur agit sur l'ordinateur. Les entrées transforment les actions de l'utilisateur en nombres, qui sont interprétés par l'ordinateur.
* Une '''unité de traitement''', qui manipule des nombres et fait des calculs/opérations dessus. Les nombres proviennent des entrées, du disque dur, ou d'autres sources, peu importe.
* Des '''sorties''', qui va récupèrent le résultat calculé par l'unité de traitement pour en faire quelque chose : écrire sur une imprimante ou sur un moniteur, émettre du son,...

[[File:Ordinateur théorique Simple 1.png|centre|vignette|upright=2|Ordinateur théorique Simple 1]]

L'unité de traitement proprement dite, celle qui fait les calculs, est couplée à une mémoire qui mémorise les opérandes et résultats des calculs. La séparation entre processeur et mémoire est nécessaire pour qu'un appareil électronique soit qualifié d'ordinateur. De nombreux appareils n'ont pas de séparation entre unité de traitement et mémoire, comme certaines vielles radios AM/FM.

[[File:Schéma de principe d'un ordinateur.png|centre|vignette|upright=2|Schéma de principe d'un ordinateur]]

===Un ordinateur est un appareil programmable===

Les appareils simples sont non-programmables, ce qui veut dire qu’ils sont conçus pour une utilisation particulière et qu’ils ne peuvent pas faire autre chose. Par exemple, les circuits électroniques d’un lecteur de DVD ne peuvent pas être transformé en lecteur audio ou en console de jeux... Les circuits non-programmables sont câblés une bonne fois pour toute, et on ne peut pas les modifier. On peut parfois reconfigurer le circuit, pour faire varier certains paramètres, via des interrupteurs ou des boutons, mais cela s’arrête là. Et cela pose un problème : à chaque problème qu'on veut résoudre en utilisant un automate, on doit recréer un nouveau circuit.

À l'inverse, un ordinateur n’est pas conçu pour une utilisation particulière, contrairement aux autres objets techniques. Il est possible de modifier leur fonction du jour au lendemain, on peut lui faire faire ce qu’on veut. On dit qu'ils sont '''programmables'''. Pour cela, il suffit d’utiliser un logiciel, une application, un programme (ces termes sont synonymes), qui fait ce que l'on souhaite. La totalité des logiciels présents sur un ordinateur sont des programmes comme les autres, même le système d'exploitation (Windows, Linux, ...) ne fait pas exception.

Un programme est une suite de d'instructions, chaque instruction effectuant une action dans l'ordinateur. Sur les ordinateurs modernes, la majorité de ces instructions effectuent une opération arithmétique, comme une addition, une multiplication, une soustraction, etc. Les ordinateurs modernes sont donc de grosses calculettes très puissantes, capables d'effectuer des millions d'opérations par secondes. Et qui dit opération dit nombres : un ordinateur gère nativement des nombres, qui sont codés en binaire sur la quasi-totalité des ordinateurs modernes.

Une instruction est représentée dans un ordinateur par une série de nombres : un nombre qui indique quelle opération/commande effectuer et des autres nombres pour coder les données (ou de quoi les retrouver dans l'ordinateur). L'ordinateur récupére les commandes une par une, les traduit en opération à effectuer, exécuter l'opération, et enregistre le résultat. Puis il recommence avec la commande suivante.

[[File:Ordinateur Théorique Complexe 1.png|centre|vignette|upright=3|Ordinateur Théorique Complexe. En jaune, le programme informatique, la liste de commande. Le rectangle gris est l'ordinateur proprement dit.]]

De nombreux appareils sont programmables, mais tous ne sont pas des ordinateurs. Par exemple, certains circuits programmables nommés FPGA n'en sont pas. Pour être qualifié d'ordinateur, un appareil programmable doit avoir un processeur séparé de la mémoire. De plus, il doit utiliser un '''codage numérique''', chose que nous allons aborder dans le chapitre suivant.

===Les ordinateurs à programme mémorisé ou programme externe===

Au tout début de l'informatique, on utilisait des cartes perforées en plastique, sur lesquelles on inscrivait le programme à exécuter, les données à traiter, bref : tout ce qu'on donnait à manger à l'ordinateur. Par la suite, les premiers ordinateurs grand public, comme les Amstrad ou les Commodore, utilisaient des cassettes audio magnétiques pour stocker les programmes. Dans le même style, les consoles de jeu utilisaient autrefois des cartouches de jeu, qui contenaient le programme du jeu à exécuter. Pour résumer, les anciens ordinateurs mémorisaient les programmes sur un support externe, lu par un périphérique. De tels ordinateurs sont dits à '''programme externe'''.

: D’anciens ordinateurs personnels, comme l’Amstrad ou le Commodore, permettaient de taper les programmes à exécuter à la main, au clavier, avant d’appuyer une touche pour les exécuter. Nul besoin de vous dire que les cassettes audio étaient plus pratiques.

Mais de nos jours, les programmes sont enregistrés sur le disque dur de l'ordinateur ou dans une mémoire intégrée à l'ordinateur. On dit qu'ils sont installés, ce qui est un mot bien compliqué pour dire que le programme est enregistré sur le disque dur de l’ordinateur. A défaut de disque dur, le programme/logiciel est enregistré dans une mémoire spécialisée pour le stockage. Par exemple, sur les cartes électroniques grand public de marque Arduino, les programmes sont envoyés à la carte via le port USB, mais les programmes sont enregistrés dans la carte Arduino, dans une mémoire FLASH dédiée. Disque dur ou non, le programme est mémorisé dans la mémoire de l'ordinateur. Il est possible d'installer ou de désinstaller les programmes en modifiant le contenu de la mémoire. Le terme utilisé est alors celui de '''programme stocké en mémoire'''.

Les programmes à installer sont disponibles soit sur un périphérique, comme un DVD ou une clé USB, soit sont téléchargés depuis internet. Les premiers PC fournissaient les logiciels sur des disquettes, qui contenaient un programme d'installation pour enregistrer le programme sur le disque dur de l'ordinateur. Par la suite, le support des logiciels a migré vers les CD et DVD, les logiciels devenant de plus en plus gros. De nos jours, la majorité des applications sont téléchargées depuis le net, l'usage de périphériques est devenu obsolète, même les consoles de jeu abandonnent cette méthode de distribution.

==Les générations d'ordinateurs : un historique rapide==

L'informatique a beaucoup évolué dans le temps. Et une bonne partie de cette évolution tient à l'évolution de l’électronique sous-jacente. Les ordinateurs actuels sont fabriqués avec des transistors, des petits composants électroniques qui servent d'interrupteur programmables, qu'on détaillera dans ce qui suit. Mais ça n'a pas toujours été le cas. Et cela permet de distinguer plusieurs '''générations d'ordinateurs'''.

===Les ordinateurs électro-mécaniques : les premiers ordinateurs===

Le tout premier ordinateur est le '''Z1''', un modèle unique inventé par Konrad Suze entre 1936 et 1938. Son processeur gérait non pas des nombres entiers, mais des nombres à virgule (des nombres dits flottants, pour être précis), encodés sur 22 bits. Le processeur du Z1 était capable de faire des additions et des soustractions, car il intégrait un circuit additionneur-soustracteur basique. Des circuits annexes permettaient de faire des multiplications et des divisions en enchainant des additions/soustractions successives. Il fonctionnait à une fréquence de 1 Hz, ce qui fait qu'il pouvait faire une addition/soustraction par seconde maximum.

[[File:Blue-punch-card-front.png|vignette|upright=0.5|Carte Perforée.]]

Niveau mémoire, la RAM de l'ordinateur était très limitée : seulement 16 nombres de 22 bits chacun. S'il s'agissait d'une mémoire électronique, les programmes étaient mémorisés sur une mémoire mécanique. Les programmes étaient enregistrés sur des cartes perforées, à savoir des cartes en papier dans lesquelles un 1 est codé par un trou dans le papier et un 0 par une absence de trou. Les programmes étaient exécutés par l'ordinateur quand on insérait la carte perforée dans le lecteur et qu'on appuyait sur un bouton.

[[File:German Museum of Technology, Berlin 2017 024.jpg|centre|vignette|upright=2|Réplique du Z1 au ''German Museum of Technology'' de Berlin, 2017.]]

Après sa destruction dans un bombardement, le Z1 a été reconstruit et amélioré, ce qui donné les deux ordinateurs Z2 et Z3. Ils étaient tous des ordinateurs dit '''électro-mécaniques''', car ils mélangeaient des composants électroniques (des relais) et des composants mécaniques (tout ce qui a trait aux cartes perforées, notamment). Les ordinateurs d'avant l'année 1944, étaient tous de ce type. Quelques ordinateurs des années 50 étaient de ce type, mais ils ont rapidement laissé la place à des ordinateurs purement électroniques, que nous allons voir dans ce qui suit..

===Les premières générations : des ordinateurs qui prenaient des pièces de bâtiment entières===

A partir de 1944, de nombreux ordinateurs plus puissants ont été mis sur le marché. Des grandes noms de l'histoire de l'informatique date de cette époque : le Harvard Mark I et le Colossus Mark 1 (UK) ont tous deux été mis en service en 1944, suivi par le Z4 l'année suivante. Ils ont servis pour les cryptanalystes pour casser les codes utilisés par les allemands pour leurs transmissions, pendant la seconde guerre mondiale.

Mais c'est l'arrivée de l'ENIAC en 1945 qui a changé la donne. Cet ordinateur a introduit plusieurs innovations majeures. La première est assez technique, il s'agit de la turing-complétude, et a trait aux programmes qui peuvent être écrit pour un ordinateur. Nous ne la détaillerons pas ici. La seconde innovation est que le programme n'était plus mémorisé sur des cartes perforée, mais dans une mémoire électronique dans l'ordinateur lui-même. En clair, l'ENIAC était le premier '''''Stored-program computer''''', ordinateur à programme enregistré en français. Enfin, l'ENIAC était composé non pas de relais et l'élèments mécaniques, mais uniquement de tubes à vides, des composants électroniques assez rudimentaires plus ou moins équivalents aux transistors modernes.

[[File:IBM 7070.jpg|vignette|Cartes imprimées de l'IBM 704, avec des transistors et résistances dessus.]]

Les ordinateurs qui ont suivi l'ENIAC sont regroupés dans la '''première génération d'ordinateur'''. Ils étaient conçus avec des tubes à vide, ce qui les place entre les premiers ordinateurs électro-mécaniques et les ordinateurs utilisant des transistors. Les ordinateurs de première génération étaient très simples, ils ne géraient que quelques opérations simples : l'addition, la soustraction, pas grand chose de plus. A quelques exceptions près, ils ne géraient pas la multiplication et encore moins la division, ils n'avaient pas assez de relais ou de tubes à vides à disposition pour cela.

La '''seconde génération''' est celle des ordinateurs fabriqués avec des '''transistors''' isolés, reliés entre avec des fils électriques. Les transistors en question possèdent trois broches, des pattes métalliques sur lesquelles on connecte des fils électriques. Le transistor s'utilise le plus souvent comme un interrupteur commandé par sa troisième broche. Le courant qui traverse les deux premières broches passe ou ne passe pas selon ce qu'on met sur la troisième.

[[File:Transistor basic flow.svg|centre|vignette|Un transistor est un morceau de conducteur, dont la conductivité est contrôlée par sa troisième broche/borne.]]

Les ordinateurs de seconde génération avaient entre 1000 et 500 000 transistors. Les capacités des ordinateurs étaient donc nettement supérieures à celles des ordinateurs de première génération. Une part non négligeable des ordinateurs de seconde génération supportait l'opération de multiplication, absente sur les ordinateurs de première génération. Néanmoins, cela variait beaucoup selon les ordinateurs.

Un exemple assez hors du commun est celui du premier modèle de l'IBM 1620. Le tout premier modèle n'avait aucun circuit de calcul, il n'était même pas capable de faire une addition ou une multiplication. A la place, il utilisait une table d'addition et une table de multiplication en mémoire RAM. Les deux tables devaient être initialisées par le logiciel lors du démarrage de la machine. La table d'addition faisait une centaine de chiffre, la table de multiplication faisait le double. Le processeur de l'ordinateur gérait des instructions pour faire des additions ou des multiplications, mais ces opérations lisaient le résultat dans la table d'addition. Les calculs étaient fait chiffre par chiffre, avec un encodage partiellement décimal, partiellement binaire (des chiffres décimaux étaient encodés en binaire, nous en reparlerons quand nous parlerons du BCD) !

[[File:KL CoreMemory.jpg|vignette|Mémoire à tore de ferrite.]]

Les transistors n'étaient utilisés que pour le processeur et les circuits annexes. La mémoire n'était pas faite en transistors, pas à cette époque. La mémoire était une mémoire aujourd'hui abandonnée, appelée une '''mémoire à tores de ferrite'''. Elle sera détaillée dans un chapitre ultérieur. Mais sachez pour le moment qu'il s'agit d'une mémoire au support magnétique, les données étant stockées sur un support magnétique.

Transistors comme tubes à vide prenaient beaucoup de place, ce qui fait que les ordinateurs étaient assez gros. Concrètement, ils prenaient une pièce de bâtiment entière dans le meilleur des cas. C'était l'époque des gros ''mainframes'', reliés à des terminaux, peu puissants comparé aux standards actuels. Seules les grandes entreprises et les grands instituts de recherche pouvaient se payer les services de ce genre d'ordinateurs. Seuls les professionnels avaient accès à ce genre d'équipement.

===La troisième génération : le circuit intégré===

[[File:D8259AC-2.jpg|vignette|Exemple de circuit intégré.]]

La troisième génération est toujours fabriquée avec des transistors, mais dont la taille a été réduite. Avec l'évolution de la technologie, les transistors ont diminué en taille, de plus en plus. Ils sont devenus tellement petits qu'ils ont finit par être regroupés dans des '''circuits intégrés''', des circuits regroupent plusieurs transistors sur la même puce de silicium. Les circuits intégrés se présentent le plus souvent sous la forme de boitiers rectangulaires, comme illustré ci-contre. D'autres ont des boitiers de forme carrées, comme ceux que l'on peut trouver sur les barrettes de mémoire RAM, ou à l'intérieur des clés USB/ disques SSD.

Lors de cette génération, les processeurs étaient fournis en pièces détachées qu'il fallait relier entre elles. Le processeur était composé de plusieurs circuits intégrés séparés, impossible de mettre un processeur dans un seul boitier. Un exemple de processeur conçu en kit est la série des Intel 3000. Elle regroupe plusieurs circuits séparés aux noms à coucher dehors, mais dont vous comprendrez ce qu'ils veulent dire dans les chapitres adéquats : l'Intel 3001 est un séquenceur, l'Intel 3002 regroupe unité de calcul et registres, le 3003 est un circuit d'anticipation de retenue complémentaire du 3002, le 3212 est une mémoire tampon, le 3214 est une unité de gestion des interruptions, les 3216/3226 sont des interfaces de bus mémoire. On pourrait aussi citer la famille de circuits intégrés AMD Am2900.

Même si le processeur était en pièce détachées, utiliser une dizaine de circuits intégrés était nettement mieux que d'utiliser plusieurs milliers de transistors individuels. En conséquence, les ordinateurs ont vu leur taille grandement réduite, passant de pièces entières à une simple armoire, voire à quelques cartes intégrées superposées. De plus, le prix des circuits intégré était abordable, du moins comparé aux ordinateurs d'avant. Le prix des ordinateurs a alors grandement décru, permettant à des entreprises et administrations de taille modeste de s'équiper d'ordinateurs.

===La quatrième génération : le microprocesseur===

[[File:MOS6502.svg|vignette|Microprocesseur, ici un processeur MOS6502, de la quatrième génération.]]

Lors de la troisième génération, les circuits intégrés regroupaient plusieurs dizaines ou centaines de transistors, mais sont rapidement montés en gamme. De centaines de transistors, ils sont passé au milliers de transistors, puis au millions et maintenant au-delà du milliard. Les transistors étaient devenus tellement petits, tellement miniaturisés, qu'il était devenu possible de mettre un processeur entier dans un circuit intégré. C'est ainsi qu'est né le microprocesseur, à savoir un processeur qui tient tout entier dans un seul circuit imprimé. La quatrième génération d’ordinateur est celle des ordinateurs basés autour d'un microprocesseur.

Les tout premiers microprocesseurs étaient des processeurs à application militaire, comme le processeur du F-14 CADC ou celui de l'Air data computer. Le tout premier microprocesseur commercialisé au grand public est le 4004 d'Intel, sorti en 1971. L'intel 4004 comprenait environ 2300 transistors, avait une fréquence de 740 MHz, pouvait faire 46 opérations différentes, et manipulait des entiers de 4 bits. Il était au départ un processeur de commande, prévu pour être intégré dans la calculatrice Busicom calculator 141-P, mais il fut utilisé pour d'autres applications quelque temps plus tard. Immédiatement après le 4004, les premiers microprocesseurs 8 bits furent commercialisés. Le 4004 fut suivi par le 8008 et quelques autres processeurs 8 bits extrêmement connus, comme le 8080 d'Intel, le 68000 de Motorola, le 6502 ou le Z80.

Les microprocesseurs permirent encore uen fois de réduire la taille des ordinateurs, qui pouvaient tenir dans un boitier de PC, ou un boitier de console de jeu. Le prix des ordinateurs a aussi chuté en même temps que les transistors était miniaturisés. C'est cette invention qui permis l'invention des consoles de jeux et des mini-ordinateurs, à savoir les ordinateurs personnels. Sans miniaturisation, on n'aurait pas d'ordinateur personnel, pas de PC fixe ou portable.

==L'organisation du cours : les différents niveaux d'explication==

Le fonctionnement d'un ordinateur est assez complexe à expliquer car les explications peuvent se faire sur plusieurs niveaux. Par plusieurs niveaux, on veut dire qu'un ordinateur est composé de composants très simples, qui sont assemblés pour donner des composants eux-même plus complexes, qui sont eux-même regrouper, etc. Étudier tout cela demande de voir plusieurs niveaux, allant de transistors très petits à des processeurs multicœurs. Les niveaux les plus bas sont de l'électronique pur et dure, alors que ceux plus haut sont à mi-chemin entre électronique et informatique.

===Les niveaux d'abstraction en architecture des ordinateurs===

Les trois premiers niveaux sont de l'électronique pur et dure. Ils correspondent aux premiers chapitres du cours, qui porteront sur les circuits électroniques en général.
* Le premier niveau est celui des '''transistors''', des circuits intégrés, des ''wafer'' et autres circuits de très petite taille.
* Le second niveau est celui des '''portes logiques''', des circuits très basiques, très simples, à la base de tous les autres.
* Le troisième niveau est celui dit de la '''''Register Transfer Level''''', où un circuit électronique est construit à partir de circuits basiques, dont des registres et autres circuits dits combinatoires.
Les deux niveaux suivants sont de l'informatique proprement dit. C'est dans ces deux niveaux qu'on étudie les ordinateurs proprement dit, les circuits qu'il y a dedans et non l'électronique en général.
* Le quatrième niveau est celui de la '''microarchitecture''', qui étudie ce qu'il y a à l'intérieur d'un processeur, d'une mémoire, des périphériques et autres.
* Le cinquième niveau est celui de l''''architecture externe''', qui décrit l'interface du processeur, de la mémoire, d'un périphérique ou autre. Par décrire l'interface, on veut dire : comment un programmeur voit le processeur et la mémoire, comment il peut les manipuler. Une architecture externe unique peut avoir plusieurs microarchitecture, ce qui fait qu'on sépare les deux. Tout cela sera plus clair quand on passera aux chapitres sur le processeur et les mémoires.

Nous n'allons pas voir les 5 niveaux dans l'ordre, des transistors vers l'architecture externe. En réalité, nous allons procéder autrement. La première partie du cours portera sur les trois premiers niveaux, le reste sur les deux autres. Les 5 niveaux seront vus dans des chapitres séparés, du moins le plus possible. Au niveau pédagogique, tout est plus simple si on scinde les 5 niveaux. Bien sûr, il y a quelques explications qui demandent de voir plusieurs niveaux à la fois. Par exemple, dans le chapitre sur les mémoires caches, nous auront des explications portant sur la RTL, la microarchitecture du cache et son architecture externe. Mais le gros du cours tentera de séparer le plus possible les 5 niveaux.

===Les trois parties principales du cours===

Nous allons commencer par parler du binaire, avant de voir les portes logiques. Avec ces portes logiques, nous allons voir comment fabriquer des circuits basiques qui reviendront très souvent dans la suite du cours. Nous verrons les registres, les décodeurs, les additionneurs et plein d'autres circuits. Puis, nous reviendrons au niveau des transistors pour finir la première partie. La raison est que c'est plus simple de faire comme cela. Tout ce qui a trait aux transistors sert à expliquer comment fabriquer des portes logiques, et il faut expliquer les portes logiques pour voir le niveau de la RTL.

Une fois la première partie finie, nous allons voir les différents composants d'un ordinateur. Une première partie expliquera ce qu'il y a dans un ordinateur, quels sont ses composants. Nous y parlerons de l'architecture de base, de la hiérarchie mémoire, des tendances technologiques, et d'autres généralités qui serviront de base pour la suite. Puis, nous verrons dans l'ordre les bus électroniques, les mémoires RAM/ROM, le processeur, les périphériques, les mémoires de stockage (SSD et disques durs) et les mémoires caches. Pour chaque composant, nous allons voir leur architecture externe, avant de voir leur microarchitecture. La raison est que la microarchitecture ne peut se comprendre que quand on sait quelle architecture externe elle implémente.

Enfin, dans une troisième partie, nous allons voir les optimisations majeures présentes dans tous les ordinateurs modernes, avec une partie sur le pipeline et le parallélisme d'instruction, et une autre sur les architectures parallèles. Pour finir, les annexes de fin parlerons de sujets un peu à part.

&lt;noinclude&gt;
{{NavChapitre | book=Fonctionnement d'un ordinateur
           | next=L'encodage des données
           | nextText=L'encodage des données
}}
&lt;/noinclude&gt;</text>
      <sha1>les8yl97rp9nuyzoaqmw4im1d52tj33</sha1>
    </revision>
    <revision>
      <id>744107</id>
      <parentid>744106</parentid>
      <timestamp>2025-06-04T20:58:33Z</timestamp>
      <contributor>
        <username>Mewtow</username>
        <id>31375</id>
      </contributor>
      <minor />
      <comment>/* Les ordinateurs électro-mécaniques : les premiers ordinateurs */</comment>
      <origin>744107</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="41814" sha1="lmwjkd1q4pppdzdk0m6zctoz0f2d7br" xml:space="preserve">Pour commencer, nous allons voir qu'il existe de nombreux types d'ordinateurs. Le plus connu est certainement le PC, l'ordinateur personnel, que vous avez sans doute dans votre salon. Les ordinateurs portables sont un deuxième type d'ordinateur assez intuitif, que vous avez peut-être. Mais il y a aussi d'autres types d'ordinateurs auxquels vous n'avez jamais été confrontés.

==Les différents types d'ordinateurs==

Dans cette section, nous allons décrire rapidement les ordinateurs les plus courant, mais surtout voir ce qu'il y a à l'intérieur d'un ordinateur.

===L'ordinateur de type PC fixe===

De l'extérieur, l'ordinateur est composé d'une unité centrale sur laquelle on branche des périphériques.

[[File:Typical computer architecture systems.jpg|vignette|upright=1.5|Exemples de périphériques, connectés à une unité centrale (ici appelée à tort ''operating system'').]]

Les '''périphériques''' regroupent l'écran, la souris, le clavier, l'imprimante, et bien d'autres choses. Ils permettent à l'utilisateur d'interagir avec l'ordinateur : un clavier permet de saisir du texte sous dans un fichier, une souris enregistre des déplacements de la main en déplacement du curseur, un écran affiche des données d’images/vidéos, un haut-parleur émet du son, etc. Tout ce qui est branché sur un ordinateur est, formellement un périphérique.

L''''unité centrale''' est là où se trouvent tous les composants importants d'un ordinateur, ceux qui font des calculs, qui exécutent des logiciels, qui mémorisent vos données, etc. Voici ce à quoi ressemble l'intérieur de l'unité centrale. Trois sections sont visibles : l'alimentation électrique en haut à gauche, la carte mère en bas à gauche et en jaune/orange, les disques et lecteurs à droite des câbles. Et on voit aussi beaucoup de câbles.

[[File:Asus P5K-SEIntel E6320.jpg|centre|vignette|upright=2|Exemple d'unité centrale.]]

Tout en haut à gauche, se trouve l''''alimentation électrique''', qui convertit le courant de la prise électrique en un courant plus faible, utilisable par les autres composants. Elle émet de nombreux câbles assez gros, qui sont reliés au reste. Les PC actuels utilisent des alimentations électriques standardisées, qui fournissent trois tensions au reste de l'ordinateur : une tension de 12 Volts, une de 5 Volts, une de 3,3 Volts.

À droite, caché par la partie &quot;métallique&quot; du boitier, se trouvent les lecteurs de CD/DVD, et les disques durs. Les lecteurs CD-ROM ou DVD-ROM permettaient de lire des CD ou des DVD. Je parle au passé, car ils ont aujourd'hui disparu des ordinateurs modernes. Les '''disques durs''' sont des mémoires de stockage, qui mémorisent vos données de manière permanente. De nos jours, ils sont remplacés par des SSD, qui sont des disques durs électroniques, là où les disques durs proprement dit sont des mémoires magnétiques. Nous verrons la différence dans deux chapitres dédiés, un sur les disques durs, l'autre sur les SSD.

En bas à droite, se trouve la '''carte mère''' un support plat, en plastique ou en céramique, sur laquelle sont soudés/connectés les autres composants. Sur celle-ci, de nombreux composants sont soudés, d'autres sont branchés dessus avec des câbles, d'autres sont connectés dessus avec des connecteurs. Ils sont reliés entre eux par des fils conducteurs, le plus souvent du cuivre ou de l’aluminium, ce qui leur permet de s’échanger des données. Sur les cartes simples, ces fils sont intégrés dans la carte électronique, dans des creux du plastique. Ils portent le nom de pistes.

Avant, les disques durs, SSD et lecteurs de CD/DVD sont branchés dessus via des connecteurs dédiés, appelés des connecteurs S-ATA. De nos jours, ils sont branchés sur un autre connecteur, grâce à l'interface NVME. Toujours est-il qu'ils sont reliés à la carte mère par des câbles, ce qui montre que ce sont des sortes de périphériques interne. Ils sont placés dans le boitier, mais on aurait tout aussi bien pu les mettre à l'extérieur, vu qu'ils communiquent avec l'ordinateur par l'intermédiaire d'un câble ou d'un connecteur dédié.

Mais deux autres composants très importants sont eux placés sur la carte mère, directement. Ils ont chacun un connecteur dédié, sur lequel ils sont branchés directement, sans passer par l'intermédiaire d'un câble, mais sans être soudés non plus. Il s'agit du processeur et de la mémoire RAM, deux composants centraux des PC modernes.

[[File:Pentium III SL4CB.jpg|thumb|Processeur Pentium III.]]

Le '''processeur''' traite les données, les modifie, les manipule. Pour faire simple, il s’agit d’une grosse calculatrice hyper-puissante. Il comprend à la fois un circuit qui fait des calculs, et un circuit de contrôle qui s'occupe de séquencer les calculs dans l'ordre demandé. Il est souvent caché sous un radiateur, lui-même surmonté par un ventilateur. En effet, un processeur chauffe beaucoup, ce qui demande d'évacuer cette chaleur. Un chapitre entier expliquera pourquoi les processeurs chauffent, ainsi que les techniques utilisées pour limiter leur production de chaleur et leur consommation électrique.

La '''mémoire vive''' conserve des informations/données temporairement, tant que le processeur en a besoin. Elle prend la forme de barrettes de RAM, comme montré ci-dessous.

[[File:2 gb ddr2 667.jpg|centre|vignette|upright=2|Barrette de RAM.]]

Outre ces composants dits principaux, un ordinateur peut comprendre plusieurs composants moins importants, surtout présents sur les ordinateurs personnels. Ils sont techniquement facultatifs, mais sont très présents dans les ordinateurs personnels. Cependant, certains ordinateurs spécialisés s'en passent. Il s'agit des diverses '''cartes d'extension''' sont branchées sur la carte mère. Elles permettent d’accélérer certains calculs ou certaines applications, afin de décharger le processeur. Par exemple, la carte graphique s'occupe des calculs graphiques, qu'il s'agisse de graphismes 3D de jeux vidéos ou de l'affichage en 2D du bureau. Dans un autre registre, la carte son prend en charge le microphone et les haut-parleurs.

[[Fichier:Personal computer, exploded 4.svg|thumb|upright=1.0|Éclaté d'un ordinateur de type PC :&lt;br /&gt;
1 : Écran ;&lt;br /&gt;
2 : Carte mère ;&lt;br /&gt;
3 : Processeur ;&lt;br /&gt;
4 : Câble Parallel ATA ;&lt;br /&gt;
5 : Mémoire vive (RAM) ;&lt;br /&gt;
6 : Carte d'extension ;&lt;br /&gt;
7 : Alimentation électrique ;&lt;br /&gt;
8 : Lecteur de disque optique ;&lt;br /&gt;
9 : Disque dur ;&lt;br /&gt;
10 : Clavier ;&lt;br /&gt;
11 : Souris.]]

Si on regarde une carte mère de face, on voit un grand nombre de connecteurs, mais aussi des circuits électroniques soudés à la carte mère.

[[File:Architecture matérielle d'une carte mère.png|centre|vignette|upright=2.0|Architecture matérielle d'une carte mère]]

Les '''connecteurs''' sont là où on branche les périphériques, la carte graphique, le processeur, la mémoire, etc. Dans l'ensemble, toute carte mère contient les connecteurs suivants :
* Le processeur vient s’enchâsser dans la carte mère sur un connecteur particulier : le '''socket'''. Celui-ci varie suivant la carte mère et le processeur, ce qui est source d'incompatibilités.
* Les barrettes de mémoire RAM s’enchâssent dans un autre type de connecteurs: les '''slots mémoire'''.
* Les mémoires de masse disposent de leurs propres connecteurs : connecteurs P-ATA pour les anciens disques durs, et S-ATA pour les récents.
* Les périphériques (clavier, souris, USB, Firewire, ...) sont connectés sur un ensemble de connecteurs dédiés, localisés à l'arrière du boitier de l'unité centrale. 
* Les autres périphériques sont placés dans l'unité centrale et sont connectés via des connecteurs spécialisés. Ces périphériques sont des cartes imprimées, d'où leur nom de '''cartes filles'''. On peut notamment citer les cartes réseau, les cartes son, ou les cartes vidéo.

===Les ordinateurs portables===

[[File:Samsung QX-511 (2).JPG|vignette|Ordinateur portable Samsung QX-511 (2), pour illustration.]]

Un ordinateur portable est identique à un ordinateur de type PC. Si vous ouvrez votre ordinateur portable (attention à la garantie), vous retrouverez les mêmes composants qu'un PC à l'intérieur. Un point important est la présence d'une batterie à l'intérieur du PC portable, absente des PC fixes.

[[File:LG gram 14Z90Q mainboard with battery.jpg|centre|vignette|upright=2|LG gram 14Z90Q avec sa batterie.]]

Une fois la batterie et les circuits associés retiré, la seule différence notable est que tous les composants sont soudés sur la carte mère, au lieu d'être branchés sur des connecteurs, à part éventuellement la RAM et le disque dur.

[[File:LG gram 14Z90Q mainboard without battery.jpg|centre|vignette|upright=2|LG gram 14Z90Q sans sa batterie.]]

La RAM est parfois soudée sur la carte mère, d'autres fois sous la forme de barrettes de mémoire vive semblables à celles des PC. Dans le dernier cas, elle est connectée à des connecteurs spécifiques, ce qui permet de les changer/upgrader. Les PC portables sont parfois construits de manière à pouvoir changer la RAM facilement, en ouvrant un cache spécial, concu pour.

[[File:Lenovo G555 состав - Донор.JPG|centre|vignette|upright=2|Lenovo G555.]]

La conception d'un ordinateur portable est légèrement différente de celle d'un PC, pour des raisons thermiques. Un PC fixe a plus de place pour évacuer sa chaleur. Les ventilateurs peuvent plus facilement déplacer l'air dans le boitier, même si le flux d'air dans le boitier est éventuellement gêné par la carte graphique. Mais l'évacuation de la chaleur est assez efficace. Sur les PC portables, leur finesse fait que le trajet de l'air est beaucoup plus contraint. Évacuer la chaleur produite par l'ordinateur est plus complexe, ce qui demande d'utiliser des systèmes de refroidissement et de ventilation spécifiques.

Là où les PC fixes se débrouillent avec des radiateurs et des ventilateurs posés sur le processeur, les PC portables font autrement. Ils ne peuvent pas forcément mettre le ventilateur sur le processeur. A la place, ils mettent le ventilateur à côté, mais le processeur est surmonté par un mécanisme de transmission de la chaleur, qui transfère la chaleur du processeur vers le ventilateur.

[[File:Diagram - How a laptop cooling system works.png|centre|vignette|upright=2|Comment fonctionne le système de ventilation d'un ordinateur portable, en anglais.]]

Les difficultés pour dissiper la chaleur font que les ordinateurs portables utilisent souvent des composants peu performants, mais qui chauffent peu. En effet, nous verrons que plus un composant est puissant, plus il chauffe. La relation n'est pas parfaite, mais les processeurs haute performance chauffent plus que les modèles d'entrée ou milieu de gamme moins puissants. En conséquence, les PC portables sont souvent moins puissants que les PC fixes, même pour les modèles dit ''gaming''.

===Les serveurs et ''mainframes''===

Les grandes entreprises utilisent des ordinateurs de grande taille, très puissants, appelés des ''mainframes''. Ils sont souvent confondus avec les serveurs par le grand public, il y a une différence entre les deux. Un serveur est une fonction logicielle/réseau, pas un type d'ordinateur. Mais laissons cette différence de côté, ce qui est dit pour les ''mainframes'' sert pour les gros serveurs haute performance.

[[File:IBM Z15 mainframe.jpg|vignette|Exemple de ''mainframe''' de type IBM Z15.]]

Les anciens ''mainframes'' des années 50-80 avaient une taille pouvant être impressionnante, au point de prendre une pièce complète d'un bâtiment. Mais de nos jours, les ''mainframes'' tiennent dans une grosse armoire un peu haute. Les ''mainframes'' doivent rester allumé en permanence et ne doivent pas être éteint, sauf éventuellement quelques jours par an pour des opérations de maintenance. Ils utilisent pour cela des techniques spécifiques, avec beaucoup de redondance interne.

[[File:ACONIT hall grandes machines.jpg|centre|vignette|upright=2|''Mainframe'' ACONIT.]]

Les ''mainframes'' sont aussi conçus pour mutualiser au maximum leur utilisation, ils peuvent être utilisés par plusieurs utilisateurs à la suite, voire en même temps. Pour cela, les anciens ''mainframes'' étaient capables de faire tourner plusieurs applications distinctes l'une à la suite de l'autre, avec des commutations fréquentes entre logiciels. De nos jours, ils sont capables d'exécuter un grand nombre de tâches en même temps, grâce à la présence de plusieurs processeurs. Les ''mainframes'' modernes sont même capables de faire tourner plusieurs systèmes d'exploitation en même temps si besoin.

Les anciens ''mainframes'' étaient des ordinateurs assez simples, avec un processeur, de la mémoire RAM, un ou plusieurs disques durs, pas plus. Le ''mainframe'' était tellement énorme et cher que les entreprises n'en avaient qu'un seul pour toute l'entreprise. Les employés avaient sur leur bureau des terminaux, qui permettaient d'accéder à l'ordinateur central, mais n'étaient pas des ordinateurs. Les terminaux étaient des composants électroniques simples, avec un écran, un clavier et une souris, mais sans processeur. Ils envoyaient des données au ''mainframe'', ils en recevaient de sa part, mais tout traitement était réalisé sur le ''mainframe''. L'arrivée sur le marché des ordinateurs personnels, de type PC fixe/portable, a entrainé l'abandon de ce genre de pratique, tous les employés ont maintenant un ordinateur rien que pour eux.

{|
|-
! colspan=&quot;2&quot; | Exemples de terminaux
|-
|[[File:Terminal-in2-sm9400.jpg|centre|vignette|upright=1.5|Exemple de terminal. Notez la présence d'un écran et d'un clavier, mais l'asbence d'une unité centrale.]]
|[[File:Chromatics CT4100.jpg|vignette|upright=1.5|Autre exemple de terminal. Le clavier est couplé à un stylo CRT, qui remplacait la souris et agissait sur l'écran comme s'il était tactile.]]
|-
! colspan=&quot;2&quot; | Intérieur d'un terminal
|-
|[[File:CT1024 Monitor.jpg|vignette|upright=1.5|Terminal CT1024, sans le boitier extérieur.]]
|[[File:CT1024 Terminal System.jpg|vignette|upright=1.5|Terminal CT1024, description des composants interne.]]
|}

De nos jours, les ''mainframes'' contiennent en réalité plusieurs ordinateurs simples interconnectés via un réseau local. Un ''mainframe'' qui tient dans une armoire contient facilement une dizaine ou centaine de processeurs, plein de RAM, des disques durs séparés dans une armoire distincte, etc. Vu qu'ils communiquent uniquement via le réseau, ils n'ont pas d'interface, pas d'écran, 'entrée via clavier/souris. Le tout est commandé avec une console de commande, typiquement un ordinateur portable ou un terminal assez simple séparé de l'armoire, qui permet à un administrateur de faire des opérations de surveillance, configuration et maintenance. Il peut y avoir une console de commande pour plusieurs armoires séparées, la console peut même être dans un autre bâtiment et accéder au ''mainframe'' par le réseau.

[[File:IBM System Z9 (type 2094 inside).jpg|centre|vignette|upright=2|''Mainframe'' de type IBM System Z9. L'ordinateur portable sert de console pour qu'un administrateur fasse des opérations de surveillance, configuration et maintenance.]]

Les processeurs et la RAM sont typiquement installés sur des cartes amovibles, qui sont connectées au fond de l'armoire lors de l'installation. Il est même possible de retirer ou d'ajouter des cartes en fonctionnement, afin d'ajouter/retirer des processeurs, des disques durs, etc. Ce qui est très utile si un composant est en panne et qu'il faut le remplacer. 

[[File:IBM TotalStorage Exp400.jpg|centre|vignette|upright=2|IBM TotalStorage Exp400]]

==Un peu d'abstraction : qu'est-ce qu'un ordinateur ?==

Un ordinateur comprend donc un processeur, plusieurs mémoires, des cartes d'extension et une carte mère pour connecter le tout. Mais il s'agit là d'une description assez terre-à-terre de ce qu'est un ordinateur. Une autre description, plus abstraite, se base sur le fait qu'un ordinateur est une énorme calculatrice programmable. Elle permet d'expliquer pourquoi il y a une distinction entre processeur et mémoire, entre unité centrale et périphériques. Tout ce qui va suivre pourra vous paraitre assez abstrait, mais rassurez-vous : les prochains chapitres rendront tout cela plus concrets.

===La séparation entre entrées-sorties et traitement===

L'unité centrale peut être vue comme une énorme calculatrice ultra-puissante, qui exécute des commandes/opérations. Mais à elle seule, elle ne servirait à rien, il faut interagir avec par l'intermédiaire de plusieurs périphériques. Il existe deux types de périphériques, qui sont conceptuellement différents. Les périphériques comme le clavier ou la souris permettent d'envoyer des informations à l'ordinateur, d'agir sur celui-ci. A l'inverse, les écrans transmettent des informations dans le sens inverse : de l'ordinateur vers l'utilisateur. Les premiers sont appelés des '''entrées''', les seconds des '''sorties'''.

Dans un ordinateur, les informations sont représentées sous la forme de nombres. Toute donnée dans un ordinateur est codée avec un ou plusieurs nombres regroupés dans une donnée, un fichier, ou autre. Et la transmissions avec les entrées et sorties se fait là-encore avec des nombres. Par exemple, quand vous appuyez sur votre clavier, le clavier envoie un numéro de touche à l'unité centrale, qui indique quelle touche a été appuyée. L'image à afficher à l'écran est codée sous la forme d'une suite de nombres (un par pixel). L'image est envoyée à l'écran, qui traduit la suite de nombre en image à afficher. Les entrées traduisent des actions utilisateurs en nombres, on dit que les entrées encodent les actions utilisateur. Les sorties font la traduction inverse, elles transforment des suites de nombres en une action physique. On dit qu'elles décodent des informations.

Pour résumer, toute appareil électronique est composé par :
* Des '''entrées''' sur lesquelles l'utilisateur agit sur l'ordinateur. Les entrées transforment les actions de l'utilisateur en nombres, qui sont interprétés par l'ordinateur.
* Une '''unité de traitement''', qui manipule des nombres et fait des calculs/opérations dessus. Les nombres proviennent des entrées, du disque dur, ou d'autres sources, peu importe.
* Des '''sorties''', qui va récupèrent le résultat calculé par l'unité de traitement pour en faire quelque chose : écrire sur une imprimante ou sur un moniteur, émettre du son,...

[[File:Ordinateur théorique Simple 1.png|centre|vignette|upright=2|Ordinateur théorique Simple 1]]

L'unité de traitement proprement dite, celle qui fait les calculs, est couplée à une mémoire qui mémorise les opérandes et résultats des calculs. La séparation entre processeur et mémoire est nécessaire pour qu'un appareil électronique soit qualifié d'ordinateur. De nombreux appareils n'ont pas de séparation entre unité de traitement et mémoire, comme certaines vielles radios AM/FM.

[[File:Schéma de principe d'un ordinateur.png|centre|vignette|upright=2|Schéma de principe d'un ordinateur]]

===Un ordinateur est un appareil programmable===

Les appareils simples sont non-programmables, ce qui veut dire qu’ils sont conçus pour une utilisation particulière et qu’ils ne peuvent pas faire autre chose. Par exemple, les circuits électroniques d’un lecteur de DVD ne peuvent pas être transformé en lecteur audio ou en console de jeux... Les circuits non-programmables sont câblés une bonne fois pour toute, et on ne peut pas les modifier. On peut parfois reconfigurer le circuit, pour faire varier certains paramètres, via des interrupteurs ou des boutons, mais cela s’arrête là. Et cela pose un problème : à chaque problème qu'on veut résoudre en utilisant un automate, on doit recréer un nouveau circuit.

À l'inverse, un ordinateur n’est pas conçu pour une utilisation particulière, contrairement aux autres objets techniques. Il est possible de modifier leur fonction du jour au lendemain, on peut lui faire faire ce qu’on veut. On dit qu'ils sont '''programmables'''. Pour cela, il suffit d’utiliser un logiciel, une application, un programme (ces termes sont synonymes), qui fait ce que l'on souhaite. La totalité des logiciels présents sur un ordinateur sont des programmes comme les autres, même le système d'exploitation (Windows, Linux, ...) ne fait pas exception.

Un programme est une suite de d'instructions, chaque instruction effectuant une action dans l'ordinateur. Sur les ordinateurs modernes, la majorité de ces instructions effectuent une opération arithmétique, comme une addition, une multiplication, une soustraction, etc. Les ordinateurs modernes sont donc de grosses calculettes très puissantes, capables d'effectuer des millions d'opérations par secondes. Et qui dit opération dit nombres : un ordinateur gère nativement des nombres, qui sont codés en binaire sur la quasi-totalité des ordinateurs modernes.

Une instruction est représentée dans un ordinateur par une série de nombres : un nombre qui indique quelle opération/commande effectuer et des autres nombres pour coder les données (ou de quoi les retrouver dans l'ordinateur). L'ordinateur récupére les commandes une par une, les traduit en opération à effectuer, exécuter l'opération, et enregistre le résultat. Puis il recommence avec la commande suivante.

[[File:Ordinateur Théorique Complexe 1.png|centre|vignette|upright=3|Ordinateur Théorique Complexe. En jaune, le programme informatique, la liste de commande. Le rectangle gris est l'ordinateur proprement dit.]]

De nombreux appareils sont programmables, mais tous ne sont pas des ordinateurs. Par exemple, certains circuits programmables nommés FPGA n'en sont pas. Pour être qualifié d'ordinateur, un appareil programmable doit avoir un processeur séparé de la mémoire. De plus, il doit utiliser un '''codage numérique''', chose que nous allons aborder dans le chapitre suivant.

===Les ordinateurs à programme mémorisé ou programme externe===

Au tout début de l'informatique, on utilisait des cartes perforées en plastique, sur lesquelles on inscrivait le programme à exécuter, les données à traiter, bref : tout ce qu'on donnait à manger à l'ordinateur. Par la suite, les premiers ordinateurs grand public, comme les Amstrad ou les Commodore, utilisaient des cassettes audio magnétiques pour stocker les programmes. Dans le même style, les consoles de jeu utilisaient autrefois des cartouches de jeu, qui contenaient le programme du jeu à exécuter. Pour résumer, les anciens ordinateurs mémorisaient les programmes sur un support externe, lu par un périphérique. De tels ordinateurs sont dits à '''programme externe'''.

: D’anciens ordinateurs personnels, comme l’Amstrad ou le Commodore, permettaient de taper les programmes à exécuter à la main, au clavier, avant d’appuyer une touche pour les exécuter. Nul besoin de vous dire que les cassettes audio étaient plus pratiques.

Mais de nos jours, les programmes sont enregistrés sur le disque dur de l'ordinateur ou dans une mémoire intégrée à l'ordinateur. On dit qu'ils sont installés, ce qui est un mot bien compliqué pour dire que le programme est enregistré sur le disque dur de l’ordinateur. A défaut de disque dur, le programme/logiciel est enregistré dans une mémoire spécialisée pour le stockage. Par exemple, sur les cartes électroniques grand public de marque Arduino, les programmes sont envoyés à la carte via le port USB, mais les programmes sont enregistrés dans la carte Arduino, dans une mémoire FLASH dédiée. Disque dur ou non, le programme est mémorisé dans la mémoire de l'ordinateur. Il est possible d'installer ou de désinstaller les programmes en modifiant le contenu de la mémoire. Le terme utilisé est alors celui de '''programme stocké en mémoire'''.

Les programmes à installer sont disponibles soit sur un périphérique, comme un DVD ou une clé USB, soit sont téléchargés depuis internet. Les premiers PC fournissaient les logiciels sur des disquettes, qui contenaient un programme d'installation pour enregistrer le programme sur le disque dur de l'ordinateur. Par la suite, le support des logiciels a migré vers les CD et DVD, les logiciels devenant de plus en plus gros. De nos jours, la majorité des applications sont téléchargées depuis le net, l'usage de périphériques est devenu obsolète, même les consoles de jeu abandonnent cette méthode de distribution.

==Les générations d'ordinateurs : un historique rapide==

L'informatique a beaucoup évolué dans le temps. Et une bonne partie de cette évolution tient à l'évolution de l’électronique sous-jacente. Les ordinateurs actuels sont fabriqués avec des transistors, des petits composants électroniques qui servent d'interrupteur programmables, qu'on détaillera dans ce qui suit. Mais ça n'a pas toujours été le cas. Et cela permet de distinguer plusieurs '''générations d'ordinateurs'''.

===Les ordinateurs électro-mécaniques : les premiers ordinateurs===

Le tout premier ordinateur est le '''Z1''', un modèle unique inventé par Konrad Suze entre 1936 et 1938. Son processeur gérait non pas des nombres entiers, mais des nombres à virgule (des nombres dits flottants, pour être précis), encodés sur 22 bits. Le processeur du Z1 était capable de faire des additions et des soustractions, car il intégrait un circuit additionneur-soustracteur basique. Des circuits annexes permettaient de faire des multiplications et des divisions en enchainant des additions/soustractions successives. Il fonctionnait à une fréquence de 1 Hz, ce qui fait qu'il pouvait faire une addition/soustraction par seconde maximum.

[[File:Blue-punch-card-front.png|vignette|upright=0.5|Carte Perforée.]]

Niveau mémoire, la RAM de l'ordinateur était très limitée : seulement 16 nombres de 22 bits chacun. S'il s'agissait d'une mémoire électronique, les programmes étaient mémorisés sur une mémoire mécanique. Les programmes étaient enregistrés sur des cartes perforées, à savoir des cartes en papier dans lesquelles un 1 est codé par un trou dans le papier et un 0 par une absence de trou. Les programmes étaient exécutés par l'ordinateur quand on insérait la carte perforée dans le lecteur et qu'on appuyait sur un bouton.

[[File:German Museum of Technology, Berlin 2017 024.jpg|centre|vignette|upright=2|Réplique du Z1 au ''German Museum of Technology'' de Berlin, 2017.]]

Après sa destruction dans un bombardement, le Z1 a été reconstruit et amélioré, ce qui donné les deux ordinateurs Z2 et Z3. Ils étaient tous des ordinateurs dit '''électro-mécaniques''', car ils mélangeaient des composants électroniques (des relais) et des composants mécaniques (tout ce qui a trait aux cartes perforées, notamment). Les ordinateurs d'avant l'année 1944, étaient tous de ce type. Quelques ordinateurs des années 50 étaient de ce type, mais leur nombre n'a pas dépassé 30. Il faut dire qu'ils ont rapidement laissé la place à des ordinateurs purement électroniques, que nous allons voir dans ce qui suit..

===Les premières générations : des ordinateurs qui prenaient des pièces de bâtiment entières===

A partir de 1944, de nombreux ordinateurs plus puissants ont été mis sur le marché. Des grandes noms de l'histoire de l'informatique date de cette époque : le Harvard Mark I et le Colossus Mark 1 (UK) ont tous deux été mis en service en 1944, suivi par le Z4 l'année suivante. Ils ont servis pour les cryptanalystes pour casser les codes utilisés par les allemands pour leurs transmissions, pendant la seconde guerre mondiale.

Mais c'est l'arrivée de l'ENIAC en 1945 qui a changé la donne. Cet ordinateur a introduit plusieurs innovations majeures. La première est assez technique, il s'agit de la turing-complétude, et a trait aux programmes qui peuvent être écrit pour un ordinateur. Nous ne la détaillerons pas ici. La seconde innovation est que le programme n'était plus mémorisé sur des cartes perforée, mais dans une mémoire électronique dans l'ordinateur lui-même. En clair, l'ENIAC était le premier '''''Stored-program computer''''', ordinateur à programme enregistré en français. Enfin, l'ENIAC était composé non pas de relais et l'élèments mécaniques, mais uniquement de tubes à vides, des composants électroniques assez rudimentaires plus ou moins équivalents aux transistors modernes.

[[File:IBM 7070.jpg|vignette|Cartes imprimées de l'IBM 704, avec des transistors et résistances dessus.]]

Les ordinateurs qui ont suivi l'ENIAC sont regroupés dans la '''première génération d'ordinateur'''. Ils étaient conçus avec des tubes à vide, ce qui les place entre les premiers ordinateurs électro-mécaniques et les ordinateurs utilisant des transistors. Les ordinateurs de première génération étaient très simples, ils ne géraient que quelques opérations simples : l'addition, la soustraction, pas grand chose de plus. A quelques exceptions près, ils ne géraient pas la multiplication et encore moins la division, ils n'avaient pas assez de relais ou de tubes à vides à disposition pour cela.

La '''seconde génération''' est celle des ordinateurs fabriqués avec des '''transistors''' isolés, reliés entre avec des fils électriques. Les transistors en question possèdent trois broches, des pattes métalliques sur lesquelles on connecte des fils électriques. Le transistor s'utilise le plus souvent comme un interrupteur commandé par sa troisième broche. Le courant qui traverse les deux premières broches passe ou ne passe pas selon ce qu'on met sur la troisième.

[[File:Transistor basic flow.svg|centre|vignette|Un transistor est un morceau de conducteur, dont la conductivité est contrôlée par sa troisième broche/borne.]]

Les ordinateurs de seconde génération avaient entre 1000 et 500 000 transistors. Les capacités des ordinateurs étaient donc nettement supérieures à celles des ordinateurs de première génération. Une part non négligeable des ordinateurs de seconde génération supportait l'opération de multiplication, absente sur les ordinateurs de première génération. Néanmoins, cela variait beaucoup selon les ordinateurs.

Un exemple assez hors du commun est celui du premier modèle de l'IBM 1620. Le tout premier modèle n'avait aucun circuit de calcul, il n'était même pas capable de faire une addition ou une multiplication. A la place, il utilisait une table d'addition et une table de multiplication en mémoire RAM. Les deux tables devaient être initialisées par le logiciel lors du démarrage de la machine. La table d'addition faisait une centaine de chiffre, la table de multiplication faisait le double. Le processeur de l'ordinateur gérait des instructions pour faire des additions ou des multiplications, mais ces opérations lisaient le résultat dans la table d'addition. Les calculs étaient fait chiffre par chiffre, avec un encodage partiellement décimal, partiellement binaire (des chiffres décimaux étaient encodés en binaire, nous en reparlerons quand nous parlerons du BCD) !

[[File:KL CoreMemory.jpg|vignette|Mémoire à tore de ferrite.]]

Les transistors n'étaient utilisés que pour le processeur et les circuits annexes. La mémoire n'était pas faite en transistors, pas à cette époque. La mémoire était une mémoire aujourd'hui abandonnée, appelée une '''mémoire à tores de ferrite'''. Elle sera détaillée dans un chapitre ultérieur. Mais sachez pour le moment qu'il s'agit d'une mémoire au support magnétique, les données étant stockées sur un support magnétique.

Transistors comme tubes à vide prenaient beaucoup de place, ce qui fait que les ordinateurs étaient assez gros. Concrètement, ils prenaient une pièce de bâtiment entière dans le meilleur des cas. C'était l'époque des gros ''mainframes'', reliés à des terminaux, peu puissants comparé aux standards actuels. Seules les grandes entreprises et les grands instituts de recherche pouvaient se payer les services de ce genre d'ordinateurs. Seuls les professionnels avaient accès à ce genre d'équipement.

===La troisième génération : le circuit intégré===

[[File:D8259AC-2.jpg|vignette|Exemple de circuit intégré.]]

La troisième génération est toujours fabriquée avec des transistors, mais dont la taille a été réduite. Avec l'évolution de la technologie, les transistors ont diminué en taille, de plus en plus. Ils sont devenus tellement petits qu'ils ont finit par être regroupés dans des '''circuits intégrés''', des circuits regroupent plusieurs transistors sur la même puce de silicium. Les circuits intégrés se présentent le plus souvent sous la forme de boitiers rectangulaires, comme illustré ci-contre. D'autres ont des boitiers de forme carrées, comme ceux que l'on peut trouver sur les barrettes de mémoire RAM, ou à l'intérieur des clés USB/ disques SSD.

Lors de cette génération, les processeurs étaient fournis en pièces détachées qu'il fallait relier entre elles. Le processeur était composé de plusieurs circuits intégrés séparés, impossible de mettre un processeur dans un seul boitier. Un exemple de processeur conçu en kit est la série des Intel 3000. Elle regroupe plusieurs circuits séparés aux noms à coucher dehors, mais dont vous comprendrez ce qu'ils veulent dire dans les chapitres adéquats : l'Intel 3001 est un séquenceur, l'Intel 3002 regroupe unité de calcul et registres, le 3003 est un circuit d'anticipation de retenue complémentaire du 3002, le 3212 est une mémoire tampon, le 3214 est une unité de gestion des interruptions, les 3216/3226 sont des interfaces de bus mémoire. On pourrait aussi citer la famille de circuits intégrés AMD Am2900.

Même si le processeur était en pièce détachées, utiliser une dizaine de circuits intégrés était nettement mieux que d'utiliser plusieurs milliers de transistors individuels. En conséquence, les ordinateurs ont vu leur taille grandement réduite, passant de pièces entières à une simple armoire, voire à quelques cartes intégrées superposées. De plus, le prix des circuits intégré était abordable, du moins comparé aux ordinateurs d'avant. Le prix des ordinateurs a alors grandement décru, permettant à des entreprises et administrations de taille modeste de s'équiper d'ordinateurs.

===La quatrième génération : le microprocesseur===

[[File:MOS6502.svg|vignette|Microprocesseur, ici un processeur MOS6502, de la quatrième génération.]]

Lors de la troisième génération, les circuits intégrés regroupaient plusieurs dizaines ou centaines de transistors, mais sont rapidement montés en gamme. De centaines de transistors, ils sont passé au milliers de transistors, puis au millions et maintenant au-delà du milliard. Les transistors étaient devenus tellement petits, tellement miniaturisés, qu'il était devenu possible de mettre un processeur entier dans un circuit intégré. C'est ainsi qu'est né le microprocesseur, à savoir un processeur qui tient tout entier dans un seul circuit imprimé. La quatrième génération d’ordinateur est celle des ordinateurs basés autour d'un microprocesseur.

Les tout premiers microprocesseurs étaient des processeurs à application militaire, comme le processeur du F-14 CADC ou celui de l'Air data computer. Le tout premier microprocesseur commercialisé au grand public est le 4004 d'Intel, sorti en 1971. L'intel 4004 comprenait environ 2300 transistors, avait une fréquence de 740 MHz, pouvait faire 46 opérations différentes, et manipulait des entiers de 4 bits. Il était au départ un processeur de commande, prévu pour être intégré dans la calculatrice Busicom calculator 141-P, mais il fut utilisé pour d'autres applications quelque temps plus tard. Immédiatement après le 4004, les premiers microprocesseurs 8 bits furent commercialisés. Le 4004 fut suivi par le 8008 et quelques autres processeurs 8 bits extrêmement connus, comme le 8080 d'Intel, le 68000 de Motorola, le 6502 ou le Z80.

Les microprocesseurs permirent encore uen fois de réduire la taille des ordinateurs, qui pouvaient tenir dans un boitier de PC, ou un boitier de console de jeu. Le prix des ordinateurs a aussi chuté en même temps que les transistors était miniaturisés. C'est cette invention qui permis l'invention des consoles de jeux et des mini-ordinateurs, à savoir les ordinateurs personnels. Sans miniaturisation, on n'aurait pas d'ordinateur personnel, pas de PC fixe ou portable.

==L'organisation du cours : les différents niveaux d'explication==

Le fonctionnement d'un ordinateur est assez complexe à expliquer car les explications peuvent se faire sur plusieurs niveaux. Par plusieurs niveaux, on veut dire qu'un ordinateur est composé de composants très simples, qui sont assemblés pour donner des composants eux-même plus complexes, qui sont eux-même regrouper, etc. Étudier tout cela demande de voir plusieurs niveaux, allant de transistors très petits à des processeurs multicœurs. Les niveaux les plus bas sont de l'électronique pur et dure, alors que ceux plus haut sont à mi-chemin entre électronique et informatique.

===Les niveaux d'abstraction en architecture des ordinateurs===

Les trois premiers niveaux sont de l'électronique pur et dure. Ils correspondent aux premiers chapitres du cours, qui porteront sur les circuits électroniques en général.
* Le premier niveau est celui des '''transistors''', des circuits intégrés, des ''wafer'' et autres circuits de très petite taille.
* Le second niveau est celui des '''portes logiques''', des circuits très basiques, très simples, à la base de tous les autres.
* Le troisième niveau est celui dit de la '''''Register Transfer Level''''', où un circuit électronique est construit à partir de circuits basiques, dont des registres et autres circuits dits combinatoires.
Les deux niveaux suivants sont de l'informatique proprement dit. C'est dans ces deux niveaux qu'on étudie les ordinateurs proprement dit, les circuits qu'il y a dedans et non l'électronique en général.
* Le quatrième niveau est celui de la '''microarchitecture''', qui étudie ce qu'il y a à l'intérieur d'un processeur, d'une mémoire, des périphériques et autres.
* Le cinquième niveau est celui de l''''architecture externe''', qui décrit l'interface du processeur, de la mémoire, d'un périphérique ou autre. Par décrire l'interface, on veut dire : comment un programmeur voit le processeur et la mémoire, comment il peut les manipuler. Une architecture externe unique peut avoir plusieurs microarchitecture, ce qui fait qu'on sépare les deux. Tout cela sera plus clair quand on passera aux chapitres sur le processeur et les mémoires.

Nous n'allons pas voir les 5 niveaux dans l'ordre, des transistors vers l'architecture externe. En réalité, nous allons procéder autrement. La première partie du cours portera sur les trois premiers niveaux, le reste sur les deux autres. Les 5 niveaux seront vus dans des chapitres séparés, du moins le plus possible. Au niveau pédagogique, tout est plus simple si on scinde les 5 niveaux. Bien sûr, il y a quelques explications qui demandent de voir plusieurs niveaux à la fois. Par exemple, dans le chapitre sur les mémoires caches, nous auront des explications portant sur la RTL, la microarchitecture du cache et son architecture externe. Mais le gros du cours tentera de séparer le plus possible les 5 niveaux.

===Les trois parties principales du cours===

Nous allons commencer par parler du binaire, avant de voir les portes logiques. Avec ces portes logiques, nous allons voir comment fabriquer des circuits basiques qui reviendront très souvent dans la suite du cours. Nous verrons les registres, les décodeurs, les additionneurs et plein d'autres circuits. Puis, nous reviendrons au niveau des transistors pour finir la première partie. La raison est que c'est plus simple de faire comme cela. Tout ce qui a trait aux transistors sert à expliquer comment fabriquer des portes logiques, et il faut expliquer les portes logiques pour voir le niveau de la RTL.

Une fois la première partie finie, nous allons voir les différents composants d'un ordinateur. Une première partie expliquera ce qu'il y a dans un ordinateur, quels sont ses composants. Nous y parlerons de l'architecture de base, de la hiérarchie mémoire, des tendances technologiques, et d'autres généralités qui serviront de base pour la suite. Puis, nous verrons dans l'ordre les bus électroniques, les mémoires RAM/ROM, le processeur, les périphériques, les mémoires de stockage (SSD et disques durs) et les mémoires caches. Pour chaque composant, nous allons voir leur architecture externe, avant de voir leur microarchitecture. La raison est que la microarchitecture ne peut se comprendre que quand on sait quelle architecture externe elle implémente.

Enfin, dans une troisième partie, nous allons voir les optimisations majeures présentes dans tous les ordinateurs modernes, avec une partie sur le pipeline et le parallélisme d'instruction, et une autre sur les architectures parallèles. Pour finir, les annexes de fin parlerons de sujets un peu à part.

&lt;noinclude&gt;
{{NavChapitre | book=Fonctionnement d'un ordinateur
           | next=L'encodage des données
           | nextText=L'encodage des données
}}
&lt;/noinclude&gt;</text>
      <sha1>lmwjkd1q4pppdzdk0m6zctoz0f2d7br</sha1>
    </revision>
    <revision>
      <id>744108</id>
      <parentid>744107</parentid>
      <timestamp>2025-06-04T21:04:48Z</timestamp>
      <contributor>
        <username>Mewtow</username>
        <id>31375</id>
      </contributor>
      <minor />
      <comment>/* Les premières générations : des ordinateurs qui prenaient des pièces de bâtiment entières */</comment>
      <origin>744108</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="42056" sha1="sg5izlx1ksms3je5vs1uau2v4mp8huj" xml:space="preserve">Pour commencer, nous allons voir qu'il existe de nombreux types d'ordinateurs. Le plus connu est certainement le PC, l'ordinateur personnel, que vous avez sans doute dans votre salon. Les ordinateurs portables sont un deuxième type d'ordinateur assez intuitif, que vous avez peut-être. Mais il y a aussi d'autres types d'ordinateurs auxquels vous n'avez jamais été confrontés.

==Les différents types d'ordinateurs==

Dans cette section, nous allons décrire rapidement les ordinateurs les plus courant, mais surtout voir ce qu'il y a à l'intérieur d'un ordinateur.

===L'ordinateur de type PC fixe===

De l'extérieur, l'ordinateur est composé d'une unité centrale sur laquelle on branche des périphériques.

[[File:Typical computer architecture systems.jpg|vignette|upright=1.5|Exemples de périphériques, connectés à une unité centrale (ici appelée à tort ''operating system'').]]

Les '''périphériques''' regroupent l'écran, la souris, le clavier, l'imprimante, et bien d'autres choses. Ils permettent à l'utilisateur d'interagir avec l'ordinateur : un clavier permet de saisir du texte sous dans un fichier, une souris enregistre des déplacements de la main en déplacement du curseur, un écran affiche des données d’images/vidéos, un haut-parleur émet du son, etc. Tout ce qui est branché sur un ordinateur est, formellement un périphérique.

L''''unité centrale''' est là où se trouvent tous les composants importants d'un ordinateur, ceux qui font des calculs, qui exécutent des logiciels, qui mémorisent vos données, etc. Voici ce à quoi ressemble l'intérieur de l'unité centrale. Trois sections sont visibles : l'alimentation électrique en haut à gauche, la carte mère en bas à gauche et en jaune/orange, les disques et lecteurs à droite des câbles. Et on voit aussi beaucoup de câbles.

[[File:Asus P5K-SEIntel E6320.jpg|centre|vignette|upright=2|Exemple d'unité centrale.]]

Tout en haut à gauche, se trouve l''''alimentation électrique''', qui convertit le courant de la prise électrique en un courant plus faible, utilisable par les autres composants. Elle émet de nombreux câbles assez gros, qui sont reliés au reste. Les PC actuels utilisent des alimentations électriques standardisées, qui fournissent trois tensions au reste de l'ordinateur : une tension de 12 Volts, une de 5 Volts, une de 3,3 Volts.

À droite, caché par la partie &quot;métallique&quot; du boitier, se trouvent les lecteurs de CD/DVD, et les disques durs. Les lecteurs CD-ROM ou DVD-ROM permettaient de lire des CD ou des DVD. Je parle au passé, car ils ont aujourd'hui disparu des ordinateurs modernes. Les '''disques durs''' sont des mémoires de stockage, qui mémorisent vos données de manière permanente. De nos jours, ils sont remplacés par des SSD, qui sont des disques durs électroniques, là où les disques durs proprement dit sont des mémoires magnétiques. Nous verrons la différence dans deux chapitres dédiés, un sur les disques durs, l'autre sur les SSD.

En bas à droite, se trouve la '''carte mère''' un support plat, en plastique ou en céramique, sur laquelle sont soudés/connectés les autres composants. Sur celle-ci, de nombreux composants sont soudés, d'autres sont branchés dessus avec des câbles, d'autres sont connectés dessus avec des connecteurs. Ils sont reliés entre eux par des fils conducteurs, le plus souvent du cuivre ou de l’aluminium, ce qui leur permet de s’échanger des données. Sur les cartes simples, ces fils sont intégrés dans la carte électronique, dans des creux du plastique. Ils portent le nom de pistes.

Avant, les disques durs, SSD et lecteurs de CD/DVD sont branchés dessus via des connecteurs dédiés, appelés des connecteurs S-ATA. De nos jours, ils sont branchés sur un autre connecteur, grâce à l'interface NVME. Toujours est-il qu'ils sont reliés à la carte mère par des câbles, ce qui montre que ce sont des sortes de périphériques interne. Ils sont placés dans le boitier, mais on aurait tout aussi bien pu les mettre à l'extérieur, vu qu'ils communiquent avec l'ordinateur par l'intermédiaire d'un câble ou d'un connecteur dédié.

Mais deux autres composants très importants sont eux placés sur la carte mère, directement. Ils ont chacun un connecteur dédié, sur lequel ils sont branchés directement, sans passer par l'intermédiaire d'un câble, mais sans être soudés non plus. Il s'agit du processeur et de la mémoire RAM, deux composants centraux des PC modernes.

[[File:Pentium III SL4CB.jpg|thumb|Processeur Pentium III.]]

Le '''processeur''' traite les données, les modifie, les manipule. Pour faire simple, il s’agit d’une grosse calculatrice hyper-puissante. Il comprend à la fois un circuit qui fait des calculs, et un circuit de contrôle qui s'occupe de séquencer les calculs dans l'ordre demandé. Il est souvent caché sous un radiateur, lui-même surmonté par un ventilateur. En effet, un processeur chauffe beaucoup, ce qui demande d'évacuer cette chaleur. Un chapitre entier expliquera pourquoi les processeurs chauffent, ainsi que les techniques utilisées pour limiter leur production de chaleur et leur consommation électrique.

La '''mémoire vive''' conserve des informations/données temporairement, tant que le processeur en a besoin. Elle prend la forme de barrettes de RAM, comme montré ci-dessous.

[[File:2 gb ddr2 667.jpg|centre|vignette|upright=2|Barrette de RAM.]]

Outre ces composants dits principaux, un ordinateur peut comprendre plusieurs composants moins importants, surtout présents sur les ordinateurs personnels. Ils sont techniquement facultatifs, mais sont très présents dans les ordinateurs personnels. Cependant, certains ordinateurs spécialisés s'en passent. Il s'agit des diverses '''cartes d'extension''' sont branchées sur la carte mère. Elles permettent d’accélérer certains calculs ou certaines applications, afin de décharger le processeur. Par exemple, la carte graphique s'occupe des calculs graphiques, qu'il s'agisse de graphismes 3D de jeux vidéos ou de l'affichage en 2D du bureau. Dans un autre registre, la carte son prend en charge le microphone et les haut-parleurs.

[[Fichier:Personal computer, exploded 4.svg|thumb|upright=1.0|Éclaté d'un ordinateur de type PC :&lt;br /&gt;
1 : Écran ;&lt;br /&gt;
2 : Carte mère ;&lt;br /&gt;
3 : Processeur ;&lt;br /&gt;
4 : Câble Parallel ATA ;&lt;br /&gt;
5 : Mémoire vive (RAM) ;&lt;br /&gt;
6 : Carte d'extension ;&lt;br /&gt;
7 : Alimentation électrique ;&lt;br /&gt;
8 : Lecteur de disque optique ;&lt;br /&gt;
9 : Disque dur ;&lt;br /&gt;
10 : Clavier ;&lt;br /&gt;
11 : Souris.]]

Si on regarde une carte mère de face, on voit un grand nombre de connecteurs, mais aussi des circuits électroniques soudés à la carte mère.

[[File:Architecture matérielle d'une carte mère.png|centre|vignette|upright=2.0|Architecture matérielle d'une carte mère]]

Les '''connecteurs''' sont là où on branche les périphériques, la carte graphique, le processeur, la mémoire, etc. Dans l'ensemble, toute carte mère contient les connecteurs suivants :
* Le processeur vient s’enchâsser dans la carte mère sur un connecteur particulier : le '''socket'''. Celui-ci varie suivant la carte mère et le processeur, ce qui est source d'incompatibilités.
* Les barrettes de mémoire RAM s’enchâssent dans un autre type de connecteurs: les '''slots mémoire'''.
* Les mémoires de masse disposent de leurs propres connecteurs : connecteurs P-ATA pour les anciens disques durs, et S-ATA pour les récents.
* Les périphériques (clavier, souris, USB, Firewire, ...) sont connectés sur un ensemble de connecteurs dédiés, localisés à l'arrière du boitier de l'unité centrale. 
* Les autres périphériques sont placés dans l'unité centrale et sont connectés via des connecteurs spécialisés. Ces périphériques sont des cartes imprimées, d'où leur nom de '''cartes filles'''. On peut notamment citer les cartes réseau, les cartes son, ou les cartes vidéo.

===Les ordinateurs portables===

[[File:Samsung QX-511 (2).JPG|vignette|Ordinateur portable Samsung QX-511 (2), pour illustration.]]

Un ordinateur portable est identique à un ordinateur de type PC. Si vous ouvrez votre ordinateur portable (attention à la garantie), vous retrouverez les mêmes composants qu'un PC à l'intérieur. Un point important est la présence d'une batterie à l'intérieur du PC portable, absente des PC fixes.

[[File:LG gram 14Z90Q mainboard with battery.jpg|centre|vignette|upright=2|LG gram 14Z90Q avec sa batterie.]]

Une fois la batterie et les circuits associés retiré, la seule différence notable est que tous les composants sont soudés sur la carte mère, au lieu d'être branchés sur des connecteurs, à part éventuellement la RAM et le disque dur.

[[File:LG gram 14Z90Q mainboard without battery.jpg|centre|vignette|upright=2|LG gram 14Z90Q sans sa batterie.]]

La RAM est parfois soudée sur la carte mère, d'autres fois sous la forme de barrettes de mémoire vive semblables à celles des PC. Dans le dernier cas, elle est connectée à des connecteurs spécifiques, ce qui permet de les changer/upgrader. Les PC portables sont parfois construits de manière à pouvoir changer la RAM facilement, en ouvrant un cache spécial, concu pour.

[[File:Lenovo G555 состав - Донор.JPG|centre|vignette|upright=2|Lenovo G555.]]

La conception d'un ordinateur portable est légèrement différente de celle d'un PC, pour des raisons thermiques. Un PC fixe a plus de place pour évacuer sa chaleur. Les ventilateurs peuvent plus facilement déplacer l'air dans le boitier, même si le flux d'air dans le boitier est éventuellement gêné par la carte graphique. Mais l'évacuation de la chaleur est assez efficace. Sur les PC portables, leur finesse fait que le trajet de l'air est beaucoup plus contraint. Évacuer la chaleur produite par l'ordinateur est plus complexe, ce qui demande d'utiliser des systèmes de refroidissement et de ventilation spécifiques.

Là où les PC fixes se débrouillent avec des radiateurs et des ventilateurs posés sur le processeur, les PC portables font autrement. Ils ne peuvent pas forcément mettre le ventilateur sur le processeur. A la place, ils mettent le ventilateur à côté, mais le processeur est surmonté par un mécanisme de transmission de la chaleur, qui transfère la chaleur du processeur vers le ventilateur.

[[File:Diagram - How a laptop cooling system works.png|centre|vignette|upright=2|Comment fonctionne le système de ventilation d'un ordinateur portable, en anglais.]]

Les difficultés pour dissiper la chaleur font que les ordinateurs portables utilisent souvent des composants peu performants, mais qui chauffent peu. En effet, nous verrons que plus un composant est puissant, plus il chauffe. La relation n'est pas parfaite, mais les processeurs haute performance chauffent plus que les modèles d'entrée ou milieu de gamme moins puissants. En conséquence, les PC portables sont souvent moins puissants que les PC fixes, même pour les modèles dit ''gaming''.

===Les serveurs et ''mainframes''===

Les grandes entreprises utilisent des ordinateurs de grande taille, très puissants, appelés des ''mainframes''. Ils sont souvent confondus avec les serveurs par le grand public, il y a une différence entre les deux. Un serveur est une fonction logicielle/réseau, pas un type d'ordinateur. Mais laissons cette différence de côté, ce qui est dit pour les ''mainframes'' sert pour les gros serveurs haute performance.

[[File:IBM Z15 mainframe.jpg|vignette|Exemple de ''mainframe''' de type IBM Z15.]]

Les anciens ''mainframes'' des années 50-80 avaient une taille pouvant être impressionnante, au point de prendre une pièce complète d'un bâtiment. Mais de nos jours, les ''mainframes'' tiennent dans une grosse armoire un peu haute. Les ''mainframes'' doivent rester allumé en permanence et ne doivent pas être éteint, sauf éventuellement quelques jours par an pour des opérations de maintenance. Ils utilisent pour cela des techniques spécifiques, avec beaucoup de redondance interne.

[[File:ACONIT hall grandes machines.jpg|centre|vignette|upright=2|''Mainframe'' ACONIT.]]

Les ''mainframes'' sont aussi conçus pour mutualiser au maximum leur utilisation, ils peuvent être utilisés par plusieurs utilisateurs à la suite, voire en même temps. Pour cela, les anciens ''mainframes'' étaient capables de faire tourner plusieurs applications distinctes l'une à la suite de l'autre, avec des commutations fréquentes entre logiciels. De nos jours, ils sont capables d'exécuter un grand nombre de tâches en même temps, grâce à la présence de plusieurs processeurs. Les ''mainframes'' modernes sont même capables de faire tourner plusieurs systèmes d'exploitation en même temps si besoin.

Les anciens ''mainframes'' étaient des ordinateurs assez simples, avec un processeur, de la mémoire RAM, un ou plusieurs disques durs, pas plus. Le ''mainframe'' était tellement énorme et cher que les entreprises n'en avaient qu'un seul pour toute l'entreprise. Les employés avaient sur leur bureau des terminaux, qui permettaient d'accéder à l'ordinateur central, mais n'étaient pas des ordinateurs. Les terminaux étaient des composants électroniques simples, avec un écran, un clavier et une souris, mais sans processeur. Ils envoyaient des données au ''mainframe'', ils en recevaient de sa part, mais tout traitement était réalisé sur le ''mainframe''. L'arrivée sur le marché des ordinateurs personnels, de type PC fixe/portable, a entrainé l'abandon de ce genre de pratique, tous les employés ont maintenant un ordinateur rien que pour eux.

{|
|-
! colspan=&quot;2&quot; | Exemples de terminaux
|-
|[[File:Terminal-in2-sm9400.jpg|centre|vignette|upright=1.5|Exemple de terminal. Notez la présence d'un écran et d'un clavier, mais l'asbence d'une unité centrale.]]
|[[File:Chromatics CT4100.jpg|vignette|upright=1.5|Autre exemple de terminal. Le clavier est couplé à un stylo CRT, qui remplacait la souris et agissait sur l'écran comme s'il était tactile.]]
|-
! colspan=&quot;2&quot; | Intérieur d'un terminal
|-
|[[File:CT1024 Monitor.jpg|vignette|upright=1.5|Terminal CT1024, sans le boitier extérieur.]]
|[[File:CT1024 Terminal System.jpg|vignette|upright=1.5|Terminal CT1024, description des composants interne.]]
|}

De nos jours, les ''mainframes'' contiennent en réalité plusieurs ordinateurs simples interconnectés via un réseau local. Un ''mainframe'' qui tient dans une armoire contient facilement une dizaine ou centaine de processeurs, plein de RAM, des disques durs séparés dans une armoire distincte, etc. Vu qu'ils communiquent uniquement via le réseau, ils n'ont pas d'interface, pas d'écran, 'entrée via clavier/souris. Le tout est commandé avec une console de commande, typiquement un ordinateur portable ou un terminal assez simple séparé de l'armoire, qui permet à un administrateur de faire des opérations de surveillance, configuration et maintenance. Il peut y avoir une console de commande pour plusieurs armoires séparées, la console peut même être dans un autre bâtiment et accéder au ''mainframe'' par le réseau.

[[File:IBM System Z9 (type 2094 inside).jpg|centre|vignette|upright=2|''Mainframe'' de type IBM System Z9. L'ordinateur portable sert de console pour qu'un administrateur fasse des opérations de surveillance, configuration et maintenance.]]

Les processeurs et la RAM sont typiquement installés sur des cartes amovibles, qui sont connectées au fond de l'armoire lors de l'installation. Il est même possible de retirer ou d'ajouter des cartes en fonctionnement, afin d'ajouter/retirer des processeurs, des disques durs, etc. Ce qui est très utile si un composant est en panne et qu'il faut le remplacer. 

[[File:IBM TotalStorage Exp400.jpg|centre|vignette|upright=2|IBM TotalStorage Exp400]]

==Un peu d'abstraction : qu'est-ce qu'un ordinateur ?==

Un ordinateur comprend donc un processeur, plusieurs mémoires, des cartes d'extension et une carte mère pour connecter le tout. Mais il s'agit là d'une description assez terre-à-terre de ce qu'est un ordinateur. Une autre description, plus abstraite, se base sur le fait qu'un ordinateur est une énorme calculatrice programmable. Elle permet d'expliquer pourquoi il y a une distinction entre processeur et mémoire, entre unité centrale et périphériques. Tout ce qui va suivre pourra vous paraitre assez abstrait, mais rassurez-vous : les prochains chapitres rendront tout cela plus concrets.

===La séparation entre entrées-sorties et traitement===

L'unité centrale peut être vue comme une énorme calculatrice ultra-puissante, qui exécute des commandes/opérations. Mais à elle seule, elle ne servirait à rien, il faut interagir avec par l'intermédiaire de plusieurs périphériques. Il existe deux types de périphériques, qui sont conceptuellement différents. Les périphériques comme le clavier ou la souris permettent d'envoyer des informations à l'ordinateur, d'agir sur celui-ci. A l'inverse, les écrans transmettent des informations dans le sens inverse : de l'ordinateur vers l'utilisateur. Les premiers sont appelés des '''entrées''', les seconds des '''sorties'''.

Dans un ordinateur, les informations sont représentées sous la forme de nombres. Toute donnée dans un ordinateur est codée avec un ou plusieurs nombres regroupés dans une donnée, un fichier, ou autre. Et la transmissions avec les entrées et sorties se fait là-encore avec des nombres. Par exemple, quand vous appuyez sur votre clavier, le clavier envoie un numéro de touche à l'unité centrale, qui indique quelle touche a été appuyée. L'image à afficher à l'écran est codée sous la forme d'une suite de nombres (un par pixel). L'image est envoyée à l'écran, qui traduit la suite de nombre en image à afficher. Les entrées traduisent des actions utilisateurs en nombres, on dit que les entrées encodent les actions utilisateur. Les sorties font la traduction inverse, elles transforment des suites de nombres en une action physique. On dit qu'elles décodent des informations.

Pour résumer, toute appareil électronique est composé par :
* Des '''entrées''' sur lesquelles l'utilisateur agit sur l'ordinateur. Les entrées transforment les actions de l'utilisateur en nombres, qui sont interprétés par l'ordinateur.
* Une '''unité de traitement''', qui manipule des nombres et fait des calculs/opérations dessus. Les nombres proviennent des entrées, du disque dur, ou d'autres sources, peu importe.
* Des '''sorties''', qui va récupèrent le résultat calculé par l'unité de traitement pour en faire quelque chose : écrire sur une imprimante ou sur un moniteur, émettre du son,...

[[File:Ordinateur théorique Simple 1.png|centre|vignette|upright=2|Ordinateur théorique Simple 1]]

L'unité de traitement proprement dite, celle qui fait les calculs, est couplée à une mémoire qui mémorise les opérandes et résultats des calculs. La séparation entre processeur et mémoire est nécessaire pour qu'un appareil électronique soit qualifié d'ordinateur. De nombreux appareils n'ont pas de séparation entre unité de traitement et mémoire, comme certaines vielles radios AM/FM.

[[File:Schéma de principe d'un ordinateur.png|centre|vignette|upright=2|Schéma de principe d'un ordinateur]]

===Un ordinateur est un appareil programmable===

Les appareils simples sont non-programmables, ce qui veut dire qu’ils sont conçus pour une utilisation particulière et qu’ils ne peuvent pas faire autre chose. Par exemple, les circuits électroniques d’un lecteur de DVD ne peuvent pas être transformé en lecteur audio ou en console de jeux... Les circuits non-programmables sont câblés une bonne fois pour toute, et on ne peut pas les modifier. On peut parfois reconfigurer le circuit, pour faire varier certains paramètres, via des interrupteurs ou des boutons, mais cela s’arrête là. Et cela pose un problème : à chaque problème qu'on veut résoudre en utilisant un automate, on doit recréer un nouveau circuit.

À l'inverse, un ordinateur n’est pas conçu pour une utilisation particulière, contrairement aux autres objets techniques. Il est possible de modifier leur fonction du jour au lendemain, on peut lui faire faire ce qu’on veut. On dit qu'ils sont '''programmables'''. Pour cela, il suffit d’utiliser un logiciel, une application, un programme (ces termes sont synonymes), qui fait ce que l'on souhaite. La totalité des logiciels présents sur un ordinateur sont des programmes comme les autres, même le système d'exploitation (Windows, Linux, ...) ne fait pas exception.

Un programme est une suite de d'instructions, chaque instruction effectuant une action dans l'ordinateur. Sur les ordinateurs modernes, la majorité de ces instructions effectuent une opération arithmétique, comme une addition, une multiplication, une soustraction, etc. Les ordinateurs modernes sont donc de grosses calculettes très puissantes, capables d'effectuer des millions d'opérations par secondes. Et qui dit opération dit nombres : un ordinateur gère nativement des nombres, qui sont codés en binaire sur la quasi-totalité des ordinateurs modernes.

Une instruction est représentée dans un ordinateur par une série de nombres : un nombre qui indique quelle opération/commande effectuer et des autres nombres pour coder les données (ou de quoi les retrouver dans l'ordinateur). L'ordinateur récupére les commandes une par une, les traduit en opération à effectuer, exécuter l'opération, et enregistre le résultat. Puis il recommence avec la commande suivante.

[[File:Ordinateur Théorique Complexe 1.png|centre|vignette|upright=3|Ordinateur Théorique Complexe. En jaune, le programme informatique, la liste de commande. Le rectangle gris est l'ordinateur proprement dit.]]

De nombreux appareils sont programmables, mais tous ne sont pas des ordinateurs. Par exemple, certains circuits programmables nommés FPGA n'en sont pas. Pour être qualifié d'ordinateur, un appareil programmable doit avoir un processeur séparé de la mémoire. De plus, il doit utiliser un '''codage numérique''', chose que nous allons aborder dans le chapitre suivant.

===Les ordinateurs à programme mémorisé ou programme externe===

Au tout début de l'informatique, on utilisait des cartes perforées en plastique, sur lesquelles on inscrivait le programme à exécuter, les données à traiter, bref : tout ce qu'on donnait à manger à l'ordinateur. Par la suite, les premiers ordinateurs grand public, comme les Amstrad ou les Commodore, utilisaient des cassettes audio magnétiques pour stocker les programmes. Dans le même style, les consoles de jeu utilisaient autrefois des cartouches de jeu, qui contenaient le programme du jeu à exécuter. Pour résumer, les anciens ordinateurs mémorisaient les programmes sur un support externe, lu par un périphérique. De tels ordinateurs sont dits à '''programme externe'''.

: D’anciens ordinateurs personnels, comme l’Amstrad ou le Commodore, permettaient de taper les programmes à exécuter à la main, au clavier, avant d’appuyer une touche pour les exécuter. Nul besoin de vous dire que les cassettes audio étaient plus pratiques.

Mais de nos jours, les programmes sont enregistrés sur le disque dur de l'ordinateur ou dans une mémoire intégrée à l'ordinateur. On dit qu'ils sont installés, ce qui est un mot bien compliqué pour dire que le programme est enregistré sur le disque dur de l’ordinateur. A défaut de disque dur, le programme/logiciel est enregistré dans une mémoire spécialisée pour le stockage. Par exemple, sur les cartes électroniques grand public de marque Arduino, les programmes sont envoyés à la carte via le port USB, mais les programmes sont enregistrés dans la carte Arduino, dans une mémoire FLASH dédiée. Disque dur ou non, le programme est mémorisé dans la mémoire de l'ordinateur. Il est possible d'installer ou de désinstaller les programmes en modifiant le contenu de la mémoire. Le terme utilisé est alors celui de '''programme stocké en mémoire'''.

Les programmes à installer sont disponibles soit sur un périphérique, comme un DVD ou une clé USB, soit sont téléchargés depuis internet. Les premiers PC fournissaient les logiciels sur des disquettes, qui contenaient un programme d'installation pour enregistrer le programme sur le disque dur de l'ordinateur. Par la suite, le support des logiciels a migré vers les CD et DVD, les logiciels devenant de plus en plus gros. De nos jours, la majorité des applications sont téléchargées depuis le net, l'usage de périphériques est devenu obsolète, même les consoles de jeu abandonnent cette méthode de distribution.

==Les générations d'ordinateurs : un historique rapide==

L'informatique a beaucoup évolué dans le temps. Et une bonne partie de cette évolution tient à l'évolution de l’électronique sous-jacente. Les ordinateurs actuels sont fabriqués avec des transistors, des petits composants électroniques qui servent d'interrupteur programmables, qu'on détaillera dans ce qui suit. Mais ça n'a pas toujours été le cas. Et cela permet de distinguer plusieurs '''générations d'ordinateurs'''.

===Les ordinateurs électro-mécaniques : les premiers ordinateurs===

Le tout premier ordinateur est le '''Z1''', un modèle unique inventé par Konrad Suze entre 1936 et 1938. Son processeur gérait non pas des nombres entiers, mais des nombres à virgule (des nombres dits flottants, pour être précis), encodés sur 22 bits. Le processeur du Z1 était capable de faire des additions et des soustractions, car il intégrait un circuit additionneur-soustracteur basique. Des circuits annexes permettaient de faire des multiplications et des divisions en enchainant des additions/soustractions successives. Il fonctionnait à une fréquence de 1 Hz, ce qui fait qu'il pouvait faire une addition/soustraction par seconde maximum.

[[File:Blue-punch-card-front.png|vignette|upright=0.5|Carte Perforée.]]

Niveau mémoire, la RAM de l'ordinateur était très limitée : seulement 16 nombres de 22 bits chacun. S'il s'agissait d'une mémoire électronique, les programmes étaient mémorisés sur une mémoire mécanique. Les programmes étaient enregistrés sur des cartes perforées, à savoir des cartes en papier dans lesquelles un 1 est codé par un trou dans le papier et un 0 par une absence de trou. Les programmes étaient exécutés par l'ordinateur quand on insérait la carte perforée dans le lecteur et qu'on appuyait sur un bouton.

[[File:German Museum of Technology, Berlin 2017 024.jpg|centre|vignette|upright=2|Réplique du Z1 au ''German Museum of Technology'' de Berlin, 2017.]]

Après sa destruction dans un bombardement, le Z1 a été reconstruit et amélioré, ce qui donné les deux ordinateurs Z2 et Z3. Ils étaient tous des ordinateurs dit '''électro-mécaniques''', car ils mélangeaient des composants électroniques (des relais) et des composants mécaniques (tout ce qui a trait aux cartes perforées, notamment). Les ordinateurs d'avant l'année 1944, étaient tous de ce type. Quelques ordinateurs des années 50 étaient de ce type, mais leur nombre n'a pas dépassé 30. Il faut dire qu'ils ont rapidement laissé la place à des ordinateurs purement électroniques, que nous allons voir dans ce qui suit..

===Les premières générations : des ordinateurs qui prenaient des pièces de bâtiment entières===

A partir de 1944, de nombreux ordinateurs plus puissants ont été mis sur le marché. Des grandes noms de l'histoire de l'informatique date de cette époque : le Harvard Mark I et le Colossus Mark 1 (UK) ont tous deux été mis en service en 1944, suivi par le Z4 l'année suivante. Ils ont servis pour les cryptanalystes pour casser les codes utilisés par les allemands pour leurs transmissions, pendant la seconde guerre mondiale.

Mais c'est l'arrivée de l'ENIAC en 1945 qui a changé la donne. Cet ordinateur a introduit plusieurs innovations majeures. La première est assez technique, il s'agit de la turing-complétude, et a trait aux programmes qui peuvent être écrit pour un ordinateur. Nous ne la détaillerons pas ici. La seconde innovation est que l'ENIAC était composé non pas de relais et d'éléments mécaniques, mais uniquement de tubes à vides, des composants électroniques assez rudimentaires plus ou moins équivalents aux transistors modernes.

Le ''Manchester Baby'' a introduit une innovation extrêmement importante, au point où on considère que c'est le premier ordinateur à avoir tous les critères nécessaires pour être appelé un ordinateur. Son innovation est que le programme n'était plus mémorisé sur des cartes perforée, mais dans une mémoire électronique dans l'ordinateur lui-même. En clair, le ''Manchester Baby'' était le premier '''''Stored-program computer''''', ordinateur à programme enregistré en français. 

[[File:IBM 7070.jpg|vignette|Cartes imprimées de l'IBM 704, avec des transistors et résistances dessus.]]

Les ordinateurs qui ont suivi l'ENIAC sont regroupés dans la '''première génération d'ordinateur'''. Ils étaient conçus avec des tubes à vide, ce qui les place entre les premiers ordinateurs électro-mécaniques et les ordinateurs utilisant des transistors. Les ordinateurs de première génération étaient très simples, ils ne géraient que quelques opérations simples : l'addition, la soustraction, pas grand chose de plus. A quelques exceptions près, ils ne géraient pas la multiplication et encore moins la division, ils n'avaient pas assez de relais ou de tubes à vides à disposition pour cela.

La '''seconde génération''' est celle des ordinateurs fabriqués avec des '''transistors''' isolés, reliés entre avec des fils électriques. Les transistors en question possèdent trois broches, des pattes métalliques sur lesquelles on connecte des fils électriques. Le transistor s'utilise le plus souvent comme un interrupteur commandé par sa troisième broche. Le courant qui traverse les deux premières broches passe ou ne passe pas selon ce qu'on met sur la troisième.

[[File:Transistor basic flow.svg|centre|vignette|Un transistor est un morceau de conducteur, dont la conductivité est contrôlée par sa troisième broche/borne.]]

Les ordinateurs de seconde génération avaient entre 1000 et 500 000 transistors. Les capacités des ordinateurs étaient donc nettement supérieures à celles des ordinateurs de première génération. Une part non négligeable des ordinateurs de seconde génération supportait l'opération de multiplication, absente sur les ordinateurs de première génération. Néanmoins, cela variait beaucoup selon les ordinateurs.

Un exemple assez hors du commun est celui du premier modèle de l'IBM 1620. Le tout premier modèle n'avait aucun circuit de calcul, il n'était même pas capable de faire une addition ou une multiplication. A la place, il utilisait une table d'addition et une table de multiplication en mémoire RAM. Les deux tables devaient être initialisées par le logiciel lors du démarrage de la machine. La table d'addition faisait une centaine de chiffre, la table de multiplication faisait le double. Le processeur de l'ordinateur gérait des instructions pour faire des additions ou des multiplications, mais ces opérations lisaient le résultat dans la table d'addition. Les calculs étaient fait chiffre par chiffre, avec un encodage partiellement décimal, partiellement binaire (des chiffres décimaux étaient encodés en binaire, nous en reparlerons quand nous parlerons du BCD) !

[[File:KL CoreMemory.jpg|vignette|Mémoire à tore de ferrite.]]

Les transistors n'étaient utilisés que pour le processeur et les circuits annexes. La mémoire n'était pas faite en transistors, pas à cette époque. La mémoire était une mémoire aujourd'hui abandonnée, appelée une '''mémoire à tores de ferrite'''. Elle sera détaillée dans un chapitre ultérieur. Mais sachez pour le moment qu'il s'agit d'une mémoire au support magnétique, les données étant stockées sur un support magnétique.

Transistors comme tubes à vide prenaient beaucoup de place, ce qui fait que les ordinateurs étaient assez gros. Concrètement, ils prenaient une pièce de bâtiment entière dans le meilleur des cas. C'était l'époque des gros ''mainframes'', reliés à des terminaux, peu puissants comparé aux standards actuels. Seules les grandes entreprises et les grands instituts de recherche pouvaient se payer les services de ce genre d'ordinateurs. Seuls les professionnels avaient accès à ce genre d'équipement.

===La troisième génération : le circuit intégré===

[[File:D8259AC-2.jpg|vignette|Exemple de circuit intégré.]]

La troisième génération est toujours fabriquée avec des transistors, mais dont la taille a été réduite. Avec l'évolution de la technologie, les transistors ont diminué en taille, de plus en plus. Ils sont devenus tellement petits qu'ils ont finit par être regroupés dans des '''circuits intégrés''', des circuits regroupent plusieurs transistors sur la même puce de silicium. Les circuits intégrés se présentent le plus souvent sous la forme de boitiers rectangulaires, comme illustré ci-contre. D'autres ont des boitiers de forme carrées, comme ceux que l'on peut trouver sur les barrettes de mémoire RAM, ou à l'intérieur des clés USB/ disques SSD.

Lors de cette génération, les processeurs étaient fournis en pièces détachées qu'il fallait relier entre elles. Le processeur était composé de plusieurs circuits intégrés séparés, impossible de mettre un processeur dans un seul boitier. Un exemple de processeur conçu en kit est la série des Intel 3000. Elle regroupe plusieurs circuits séparés aux noms à coucher dehors, mais dont vous comprendrez ce qu'ils veulent dire dans les chapitres adéquats : l'Intel 3001 est un séquenceur, l'Intel 3002 regroupe unité de calcul et registres, le 3003 est un circuit d'anticipation de retenue complémentaire du 3002, le 3212 est une mémoire tampon, le 3214 est une unité de gestion des interruptions, les 3216/3226 sont des interfaces de bus mémoire. On pourrait aussi citer la famille de circuits intégrés AMD Am2900.

Même si le processeur était en pièce détachées, utiliser une dizaine de circuits intégrés était nettement mieux que d'utiliser plusieurs milliers de transistors individuels. En conséquence, les ordinateurs ont vu leur taille grandement réduite, passant de pièces entières à une simple armoire, voire à quelques cartes intégrées superposées. De plus, le prix des circuits intégré était abordable, du moins comparé aux ordinateurs d'avant. Le prix des ordinateurs a alors grandement décru, permettant à des entreprises et administrations de taille modeste de s'équiper d'ordinateurs.

===La quatrième génération : le microprocesseur===

[[File:MOS6502.svg|vignette|Microprocesseur, ici un processeur MOS6502, de la quatrième génération.]]

Lors de la troisième génération, les circuits intégrés regroupaient plusieurs dizaines ou centaines de transistors, mais sont rapidement montés en gamme. De centaines de transistors, ils sont passé au milliers de transistors, puis au millions et maintenant au-delà du milliard. Les transistors étaient devenus tellement petits, tellement miniaturisés, qu'il était devenu possible de mettre un processeur entier dans un circuit intégré. C'est ainsi qu'est né le microprocesseur, à savoir un processeur qui tient tout entier dans un seul circuit imprimé. La quatrième génération d’ordinateur est celle des ordinateurs basés autour d'un microprocesseur.

Les tout premiers microprocesseurs étaient des processeurs à application militaire, comme le processeur du F-14 CADC ou celui de l'Air data computer. Le tout premier microprocesseur commercialisé au grand public est le 4004 d'Intel, sorti en 1971. L'intel 4004 comprenait environ 2300 transistors, avait une fréquence de 740 MHz, pouvait faire 46 opérations différentes, et manipulait des entiers de 4 bits. Il était au départ un processeur de commande, prévu pour être intégré dans la calculatrice Busicom calculator 141-P, mais il fut utilisé pour d'autres applications quelque temps plus tard. Immédiatement après le 4004, les premiers microprocesseurs 8 bits furent commercialisés. Le 4004 fut suivi par le 8008 et quelques autres processeurs 8 bits extrêmement connus, comme le 8080 d'Intel, le 68000 de Motorola, le 6502 ou le Z80.

Les microprocesseurs permirent encore uen fois de réduire la taille des ordinateurs, qui pouvaient tenir dans un boitier de PC, ou un boitier de console de jeu. Le prix des ordinateurs a aussi chuté en même temps que les transistors était miniaturisés. C'est cette invention qui permis l'invention des consoles de jeux et des mini-ordinateurs, à savoir les ordinateurs personnels. Sans miniaturisation, on n'aurait pas d'ordinateur personnel, pas de PC fixe ou portable.

==L'organisation du cours : les différents niveaux d'explication==

Le fonctionnement d'un ordinateur est assez complexe à expliquer car les explications peuvent se faire sur plusieurs niveaux. Par plusieurs niveaux, on veut dire qu'un ordinateur est composé de composants très simples, qui sont assemblés pour donner des composants eux-même plus complexes, qui sont eux-même regrouper, etc. Étudier tout cela demande de voir plusieurs niveaux, allant de transistors très petits à des processeurs multicœurs. Les niveaux les plus bas sont de l'électronique pur et dure, alors que ceux plus haut sont à mi-chemin entre électronique et informatique.

===Les niveaux d'abstraction en architecture des ordinateurs===

Les trois premiers niveaux sont de l'électronique pur et dure. Ils correspondent aux premiers chapitres du cours, qui porteront sur les circuits électroniques en général.
* Le premier niveau est celui des '''transistors''', des circuits intégrés, des ''wafer'' et autres circuits de très petite taille.
* Le second niveau est celui des '''portes logiques''', des circuits très basiques, très simples, à la base de tous les autres.
* Le troisième niveau est celui dit de la '''''Register Transfer Level''''', où un circuit électronique est construit à partir de circuits basiques, dont des registres et autres circuits dits combinatoires.
Les deux niveaux suivants sont de l'informatique proprement dit. C'est dans ces deux niveaux qu'on étudie les ordinateurs proprement dit, les circuits qu'il y a dedans et non l'électronique en général.
* Le quatrième niveau est celui de la '''microarchitecture''', qui étudie ce qu'il y a à l'intérieur d'un processeur, d'une mémoire, des périphériques et autres.
* Le cinquième niveau est celui de l''''architecture externe''', qui décrit l'interface du processeur, de la mémoire, d'un périphérique ou autre. Par décrire l'interface, on veut dire : comment un programmeur voit le processeur et la mémoire, comment il peut les manipuler. Une architecture externe unique peut avoir plusieurs microarchitecture, ce qui fait qu'on sépare les deux. Tout cela sera plus clair quand on passera aux chapitres sur le processeur et les mémoires.

Nous n'allons pas voir les 5 niveaux dans l'ordre, des transistors vers l'architecture externe. En réalité, nous allons procéder autrement. La première partie du cours portera sur les trois premiers niveaux, le reste sur les deux autres. Les 5 niveaux seront vus dans des chapitres séparés, du moins le plus possible. Au niveau pédagogique, tout est plus simple si on scinde les 5 niveaux. Bien sûr, il y a quelques explications qui demandent de voir plusieurs niveaux à la fois. Par exemple, dans le chapitre sur les mémoires caches, nous auront des explications portant sur la RTL, la microarchitecture du cache et son architecture externe. Mais le gros du cours tentera de séparer le plus possible les 5 niveaux.

===Les trois parties principales du cours===

Nous allons commencer par parler du binaire, avant de voir les portes logiques. Avec ces portes logiques, nous allons voir comment fabriquer des circuits basiques qui reviendront très souvent dans la suite du cours. Nous verrons les registres, les décodeurs, les additionneurs et plein d'autres circuits. Puis, nous reviendrons au niveau des transistors pour finir la première partie. La raison est que c'est plus simple de faire comme cela. Tout ce qui a trait aux transistors sert à expliquer comment fabriquer des portes logiques, et il faut expliquer les portes logiques pour voir le niveau de la RTL.

Une fois la première partie finie, nous allons voir les différents composants d'un ordinateur. Une première partie expliquera ce qu'il y a dans un ordinateur, quels sont ses composants. Nous y parlerons de l'architecture de base, de la hiérarchie mémoire, des tendances technologiques, et d'autres généralités qui serviront de base pour la suite. Puis, nous verrons dans l'ordre les bus électroniques, les mémoires RAM/ROM, le processeur, les périphériques, les mémoires de stockage (SSD et disques durs) et les mémoires caches. Pour chaque composant, nous allons voir leur architecture externe, avant de voir leur microarchitecture. La raison est que la microarchitecture ne peut se comprendre que quand on sait quelle architecture externe elle implémente.

Enfin, dans une troisième partie, nous allons voir les optimisations majeures présentes dans tous les ordinateurs modernes, avec une partie sur le pipeline et le parallélisme d'instruction, et une autre sur les architectures parallèles. Pour finir, les annexes de fin parlerons de sujets un peu à part.

&lt;noinclude&gt;
{{NavChapitre | book=Fonctionnement d'un ordinateur
           | next=L'encodage des données
           | nextText=L'encodage des données
}}
&lt;/noinclude&gt;</text>
      <sha1>sg5izlx1ksms3je5vs1uau2v4mp8huj</sha1>
    </revision>
    <revision>
      <id>744109</id>
      <parentid>744108</parentid>
      <timestamp>2025-06-04T21:07:24Z</timestamp>
      <contributor>
        <username>Mewtow</username>
        <id>31375</id>
      </contributor>
      <minor />
      <comment>/* Les ordinateurs électro-mécaniques : les premiers ordinateurs */</comment>
      <origin>744109</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="42231" sha1="qc4ygdlg6sknjrf2derri76f2nvpabk" xml:space="preserve">Pour commencer, nous allons voir qu'il existe de nombreux types d'ordinateurs. Le plus connu est certainement le PC, l'ordinateur personnel, que vous avez sans doute dans votre salon. Les ordinateurs portables sont un deuxième type d'ordinateur assez intuitif, que vous avez peut-être. Mais il y a aussi d'autres types d'ordinateurs auxquels vous n'avez jamais été confrontés.

==Les différents types d'ordinateurs==

Dans cette section, nous allons décrire rapidement les ordinateurs les plus courant, mais surtout voir ce qu'il y a à l'intérieur d'un ordinateur.

===L'ordinateur de type PC fixe===

De l'extérieur, l'ordinateur est composé d'une unité centrale sur laquelle on branche des périphériques.

[[File:Typical computer architecture systems.jpg|vignette|upright=1.5|Exemples de périphériques, connectés à une unité centrale (ici appelée à tort ''operating system'').]]

Les '''périphériques''' regroupent l'écran, la souris, le clavier, l'imprimante, et bien d'autres choses. Ils permettent à l'utilisateur d'interagir avec l'ordinateur : un clavier permet de saisir du texte sous dans un fichier, une souris enregistre des déplacements de la main en déplacement du curseur, un écran affiche des données d’images/vidéos, un haut-parleur émet du son, etc. Tout ce qui est branché sur un ordinateur est, formellement un périphérique.

L''''unité centrale''' est là où se trouvent tous les composants importants d'un ordinateur, ceux qui font des calculs, qui exécutent des logiciels, qui mémorisent vos données, etc. Voici ce à quoi ressemble l'intérieur de l'unité centrale. Trois sections sont visibles : l'alimentation électrique en haut à gauche, la carte mère en bas à gauche et en jaune/orange, les disques et lecteurs à droite des câbles. Et on voit aussi beaucoup de câbles.

[[File:Asus P5K-SEIntel E6320.jpg|centre|vignette|upright=2|Exemple d'unité centrale.]]

Tout en haut à gauche, se trouve l''''alimentation électrique''', qui convertit le courant de la prise électrique en un courant plus faible, utilisable par les autres composants. Elle émet de nombreux câbles assez gros, qui sont reliés au reste. Les PC actuels utilisent des alimentations électriques standardisées, qui fournissent trois tensions au reste de l'ordinateur : une tension de 12 Volts, une de 5 Volts, une de 3,3 Volts.

À droite, caché par la partie &quot;métallique&quot; du boitier, se trouvent les lecteurs de CD/DVD, et les disques durs. Les lecteurs CD-ROM ou DVD-ROM permettaient de lire des CD ou des DVD. Je parle au passé, car ils ont aujourd'hui disparu des ordinateurs modernes. Les '''disques durs''' sont des mémoires de stockage, qui mémorisent vos données de manière permanente. De nos jours, ils sont remplacés par des SSD, qui sont des disques durs électroniques, là où les disques durs proprement dit sont des mémoires magnétiques. Nous verrons la différence dans deux chapitres dédiés, un sur les disques durs, l'autre sur les SSD.

En bas à droite, se trouve la '''carte mère''' un support plat, en plastique ou en céramique, sur laquelle sont soudés/connectés les autres composants. Sur celle-ci, de nombreux composants sont soudés, d'autres sont branchés dessus avec des câbles, d'autres sont connectés dessus avec des connecteurs. Ils sont reliés entre eux par des fils conducteurs, le plus souvent du cuivre ou de l’aluminium, ce qui leur permet de s’échanger des données. Sur les cartes simples, ces fils sont intégrés dans la carte électronique, dans des creux du plastique. Ils portent le nom de pistes.

Avant, les disques durs, SSD et lecteurs de CD/DVD sont branchés dessus via des connecteurs dédiés, appelés des connecteurs S-ATA. De nos jours, ils sont branchés sur un autre connecteur, grâce à l'interface NVME. Toujours est-il qu'ils sont reliés à la carte mère par des câbles, ce qui montre que ce sont des sortes de périphériques interne. Ils sont placés dans le boitier, mais on aurait tout aussi bien pu les mettre à l'extérieur, vu qu'ils communiquent avec l'ordinateur par l'intermédiaire d'un câble ou d'un connecteur dédié.

Mais deux autres composants très importants sont eux placés sur la carte mère, directement. Ils ont chacun un connecteur dédié, sur lequel ils sont branchés directement, sans passer par l'intermédiaire d'un câble, mais sans être soudés non plus. Il s'agit du processeur et de la mémoire RAM, deux composants centraux des PC modernes.

[[File:Pentium III SL4CB.jpg|thumb|Processeur Pentium III.]]

Le '''processeur''' traite les données, les modifie, les manipule. Pour faire simple, il s’agit d’une grosse calculatrice hyper-puissante. Il comprend à la fois un circuit qui fait des calculs, et un circuit de contrôle qui s'occupe de séquencer les calculs dans l'ordre demandé. Il est souvent caché sous un radiateur, lui-même surmonté par un ventilateur. En effet, un processeur chauffe beaucoup, ce qui demande d'évacuer cette chaleur. Un chapitre entier expliquera pourquoi les processeurs chauffent, ainsi que les techniques utilisées pour limiter leur production de chaleur et leur consommation électrique.

La '''mémoire vive''' conserve des informations/données temporairement, tant que le processeur en a besoin. Elle prend la forme de barrettes de RAM, comme montré ci-dessous.

[[File:2 gb ddr2 667.jpg|centre|vignette|upright=2|Barrette de RAM.]]

Outre ces composants dits principaux, un ordinateur peut comprendre plusieurs composants moins importants, surtout présents sur les ordinateurs personnels. Ils sont techniquement facultatifs, mais sont très présents dans les ordinateurs personnels. Cependant, certains ordinateurs spécialisés s'en passent. Il s'agit des diverses '''cartes d'extension''' sont branchées sur la carte mère. Elles permettent d’accélérer certains calculs ou certaines applications, afin de décharger le processeur. Par exemple, la carte graphique s'occupe des calculs graphiques, qu'il s'agisse de graphismes 3D de jeux vidéos ou de l'affichage en 2D du bureau. Dans un autre registre, la carte son prend en charge le microphone et les haut-parleurs.

[[Fichier:Personal computer, exploded 4.svg|thumb|upright=1.0|Éclaté d'un ordinateur de type PC :&lt;br /&gt;
1 : Écran ;&lt;br /&gt;
2 : Carte mère ;&lt;br /&gt;
3 : Processeur ;&lt;br /&gt;
4 : Câble Parallel ATA ;&lt;br /&gt;
5 : Mémoire vive (RAM) ;&lt;br /&gt;
6 : Carte d'extension ;&lt;br /&gt;
7 : Alimentation électrique ;&lt;br /&gt;
8 : Lecteur de disque optique ;&lt;br /&gt;
9 : Disque dur ;&lt;br /&gt;
10 : Clavier ;&lt;br /&gt;
11 : Souris.]]

Si on regarde une carte mère de face, on voit un grand nombre de connecteurs, mais aussi des circuits électroniques soudés à la carte mère.

[[File:Architecture matérielle d'une carte mère.png|centre|vignette|upright=2.0|Architecture matérielle d'une carte mère]]

Les '''connecteurs''' sont là où on branche les périphériques, la carte graphique, le processeur, la mémoire, etc. Dans l'ensemble, toute carte mère contient les connecteurs suivants :
* Le processeur vient s’enchâsser dans la carte mère sur un connecteur particulier : le '''socket'''. Celui-ci varie suivant la carte mère et le processeur, ce qui est source d'incompatibilités.
* Les barrettes de mémoire RAM s’enchâssent dans un autre type de connecteurs: les '''slots mémoire'''.
* Les mémoires de masse disposent de leurs propres connecteurs : connecteurs P-ATA pour les anciens disques durs, et S-ATA pour les récents.
* Les périphériques (clavier, souris, USB, Firewire, ...) sont connectés sur un ensemble de connecteurs dédiés, localisés à l'arrière du boitier de l'unité centrale. 
* Les autres périphériques sont placés dans l'unité centrale et sont connectés via des connecteurs spécialisés. Ces périphériques sont des cartes imprimées, d'où leur nom de '''cartes filles'''. On peut notamment citer les cartes réseau, les cartes son, ou les cartes vidéo.

===Les ordinateurs portables===

[[File:Samsung QX-511 (2).JPG|vignette|Ordinateur portable Samsung QX-511 (2), pour illustration.]]

Un ordinateur portable est identique à un ordinateur de type PC. Si vous ouvrez votre ordinateur portable (attention à la garantie), vous retrouverez les mêmes composants qu'un PC à l'intérieur. Un point important est la présence d'une batterie à l'intérieur du PC portable, absente des PC fixes.

[[File:LG gram 14Z90Q mainboard with battery.jpg|centre|vignette|upright=2|LG gram 14Z90Q avec sa batterie.]]

Une fois la batterie et les circuits associés retiré, la seule différence notable est que tous les composants sont soudés sur la carte mère, au lieu d'être branchés sur des connecteurs, à part éventuellement la RAM et le disque dur.

[[File:LG gram 14Z90Q mainboard without battery.jpg|centre|vignette|upright=2|LG gram 14Z90Q sans sa batterie.]]

La RAM est parfois soudée sur la carte mère, d'autres fois sous la forme de barrettes de mémoire vive semblables à celles des PC. Dans le dernier cas, elle est connectée à des connecteurs spécifiques, ce qui permet de les changer/upgrader. Les PC portables sont parfois construits de manière à pouvoir changer la RAM facilement, en ouvrant un cache spécial, concu pour.

[[File:Lenovo G555 состав - Донор.JPG|centre|vignette|upright=2|Lenovo G555.]]

La conception d'un ordinateur portable est légèrement différente de celle d'un PC, pour des raisons thermiques. Un PC fixe a plus de place pour évacuer sa chaleur. Les ventilateurs peuvent plus facilement déplacer l'air dans le boitier, même si le flux d'air dans le boitier est éventuellement gêné par la carte graphique. Mais l'évacuation de la chaleur est assez efficace. Sur les PC portables, leur finesse fait que le trajet de l'air est beaucoup plus contraint. Évacuer la chaleur produite par l'ordinateur est plus complexe, ce qui demande d'utiliser des systèmes de refroidissement et de ventilation spécifiques.

Là où les PC fixes se débrouillent avec des radiateurs et des ventilateurs posés sur le processeur, les PC portables font autrement. Ils ne peuvent pas forcément mettre le ventilateur sur le processeur. A la place, ils mettent le ventilateur à côté, mais le processeur est surmonté par un mécanisme de transmission de la chaleur, qui transfère la chaleur du processeur vers le ventilateur.

[[File:Diagram - How a laptop cooling system works.png|centre|vignette|upright=2|Comment fonctionne le système de ventilation d'un ordinateur portable, en anglais.]]

Les difficultés pour dissiper la chaleur font que les ordinateurs portables utilisent souvent des composants peu performants, mais qui chauffent peu. En effet, nous verrons que plus un composant est puissant, plus il chauffe. La relation n'est pas parfaite, mais les processeurs haute performance chauffent plus que les modèles d'entrée ou milieu de gamme moins puissants. En conséquence, les PC portables sont souvent moins puissants que les PC fixes, même pour les modèles dit ''gaming''.

===Les serveurs et ''mainframes''===

Les grandes entreprises utilisent des ordinateurs de grande taille, très puissants, appelés des ''mainframes''. Ils sont souvent confondus avec les serveurs par le grand public, il y a une différence entre les deux. Un serveur est une fonction logicielle/réseau, pas un type d'ordinateur. Mais laissons cette différence de côté, ce qui est dit pour les ''mainframes'' sert pour les gros serveurs haute performance.

[[File:IBM Z15 mainframe.jpg|vignette|Exemple de ''mainframe''' de type IBM Z15.]]

Les anciens ''mainframes'' des années 50-80 avaient une taille pouvant être impressionnante, au point de prendre une pièce complète d'un bâtiment. Mais de nos jours, les ''mainframes'' tiennent dans une grosse armoire un peu haute. Les ''mainframes'' doivent rester allumé en permanence et ne doivent pas être éteint, sauf éventuellement quelques jours par an pour des opérations de maintenance. Ils utilisent pour cela des techniques spécifiques, avec beaucoup de redondance interne.

[[File:ACONIT hall grandes machines.jpg|centre|vignette|upright=2|''Mainframe'' ACONIT.]]

Les ''mainframes'' sont aussi conçus pour mutualiser au maximum leur utilisation, ils peuvent être utilisés par plusieurs utilisateurs à la suite, voire en même temps. Pour cela, les anciens ''mainframes'' étaient capables de faire tourner plusieurs applications distinctes l'une à la suite de l'autre, avec des commutations fréquentes entre logiciels. De nos jours, ils sont capables d'exécuter un grand nombre de tâches en même temps, grâce à la présence de plusieurs processeurs. Les ''mainframes'' modernes sont même capables de faire tourner plusieurs systèmes d'exploitation en même temps si besoin.

Les anciens ''mainframes'' étaient des ordinateurs assez simples, avec un processeur, de la mémoire RAM, un ou plusieurs disques durs, pas plus. Le ''mainframe'' était tellement énorme et cher que les entreprises n'en avaient qu'un seul pour toute l'entreprise. Les employés avaient sur leur bureau des terminaux, qui permettaient d'accéder à l'ordinateur central, mais n'étaient pas des ordinateurs. Les terminaux étaient des composants électroniques simples, avec un écran, un clavier et une souris, mais sans processeur. Ils envoyaient des données au ''mainframe'', ils en recevaient de sa part, mais tout traitement était réalisé sur le ''mainframe''. L'arrivée sur le marché des ordinateurs personnels, de type PC fixe/portable, a entrainé l'abandon de ce genre de pratique, tous les employés ont maintenant un ordinateur rien que pour eux.

{|
|-
! colspan=&quot;2&quot; | Exemples de terminaux
|-
|[[File:Terminal-in2-sm9400.jpg|centre|vignette|upright=1.5|Exemple de terminal. Notez la présence d'un écran et d'un clavier, mais l'asbence d'une unité centrale.]]
|[[File:Chromatics CT4100.jpg|vignette|upright=1.5|Autre exemple de terminal. Le clavier est couplé à un stylo CRT, qui remplacait la souris et agissait sur l'écran comme s'il était tactile.]]
|-
! colspan=&quot;2&quot; | Intérieur d'un terminal
|-
|[[File:CT1024 Monitor.jpg|vignette|upright=1.5|Terminal CT1024, sans le boitier extérieur.]]
|[[File:CT1024 Terminal System.jpg|vignette|upright=1.5|Terminal CT1024, description des composants interne.]]
|}

De nos jours, les ''mainframes'' contiennent en réalité plusieurs ordinateurs simples interconnectés via un réseau local. Un ''mainframe'' qui tient dans une armoire contient facilement une dizaine ou centaine de processeurs, plein de RAM, des disques durs séparés dans une armoire distincte, etc. Vu qu'ils communiquent uniquement via le réseau, ils n'ont pas d'interface, pas d'écran, 'entrée via clavier/souris. Le tout est commandé avec une console de commande, typiquement un ordinateur portable ou un terminal assez simple séparé de l'armoire, qui permet à un administrateur de faire des opérations de surveillance, configuration et maintenance. Il peut y avoir une console de commande pour plusieurs armoires séparées, la console peut même être dans un autre bâtiment et accéder au ''mainframe'' par le réseau.

[[File:IBM System Z9 (type 2094 inside).jpg|centre|vignette|upright=2|''Mainframe'' de type IBM System Z9. L'ordinateur portable sert de console pour qu'un administrateur fasse des opérations de surveillance, configuration et maintenance.]]

Les processeurs et la RAM sont typiquement installés sur des cartes amovibles, qui sont connectées au fond de l'armoire lors de l'installation. Il est même possible de retirer ou d'ajouter des cartes en fonctionnement, afin d'ajouter/retirer des processeurs, des disques durs, etc. Ce qui est très utile si un composant est en panne et qu'il faut le remplacer. 

[[File:IBM TotalStorage Exp400.jpg|centre|vignette|upright=2|IBM TotalStorage Exp400]]

==Un peu d'abstraction : qu'est-ce qu'un ordinateur ?==

Un ordinateur comprend donc un processeur, plusieurs mémoires, des cartes d'extension et une carte mère pour connecter le tout. Mais il s'agit là d'une description assez terre-à-terre de ce qu'est un ordinateur. Une autre description, plus abstraite, se base sur le fait qu'un ordinateur est une énorme calculatrice programmable. Elle permet d'expliquer pourquoi il y a une distinction entre processeur et mémoire, entre unité centrale et périphériques. Tout ce qui va suivre pourra vous paraitre assez abstrait, mais rassurez-vous : les prochains chapitres rendront tout cela plus concrets.

===La séparation entre entrées-sorties et traitement===

L'unité centrale peut être vue comme une énorme calculatrice ultra-puissante, qui exécute des commandes/opérations. Mais à elle seule, elle ne servirait à rien, il faut interagir avec par l'intermédiaire de plusieurs périphériques. Il existe deux types de périphériques, qui sont conceptuellement différents. Les périphériques comme le clavier ou la souris permettent d'envoyer des informations à l'ordinateur, d'agir sur celui-ci. A l'inverse, les écrans transmettent des informations dans le sens inverse : de l'ordinateur vers l'utilisateur. Les premiers sont appelés des '''entrées''', les seconds des '''sorties'''.

Dans un ordinateur, les informations sont représentées sous la forme de nombres. Toute donnée dans un ordinateur est codée avec un ou plusieurs nombres regroupés dans une donnée, un fichier, ou autre. Et la transmissions avec les entrées et sorties se fait là-encore avec des nombres. Par exemple, quand vous appuyez sur votre clavier, le clavier envoie un numéro de touche à l'unité centrale, qui indique quelle touche a été appuyée. L'image à afficher à l'écran est codée sous la forme d'une suite de nombres (un par pixel). L'image est envoyée à l'écran, qui traduit la suite de nombre en image à afficher. Les entrées traduisent des actions utilisateurs en nombres, on dit que les entrées encodent les actions utilisateur. Les sorties font la traduction inverse, elles transforment des suites de nombres en une action physique. On dit qu'elles décodent des informations.

Pour résumer, toute appareil électronique est composé par :
* Des '''entrées''' sur lesquelles l'utilisateur agit sur l'ordinateur. Les entrées transforment les actions de l'utilisateur en nombres, qui sont interprétés par l'ordinateur.
* Une '''unité de traitement''', qui manipule des nombres et fait des calculs/opérations dessus. Les nombres proviennent des entrées, du disque dur, ou d'autres sources, peu importe.
* Des '''sorties''', qui va récupèrent le résultat calculé par l'unité de traitement pour en faire quelque chose : écrire sur une imprimante ou sur un moniteur, émettre du son,...

[[File:Ordinateur théorique Simple 1.png|centre|vignette|upright=2|Ordinateur théorique Simple 1]]

L'unité de traitement proprement dite, celle qui fait les calculs, est couplée à une mémoire qui mémorise les opérandes et résultats des calculs. La séparation entre processeur et mémoire est nécessaire pour qu'un appareil électronique soit qualifié d'ordinateur. De nombreux appareils n'ont pas de séparation entre unité de traitement et mémoire, comme certaines vielles radios AM/FM.

[[File:Schéma de principe d'un ordinateur.png|centre|vignette|upright=2|Schéma de principe d'un ordinateur]]

===Un ordinateur est un appareil programmable===

Les appareils simples sont non-programmables, ce qui veut dire qu’ils sont conçus pour une utilisation particulière et qu’ils ne peuvent pas faire autre chose. Par exemple, les circuits électroniques d’un lecteur de DVD ne peuvent pas être transformé en lecteur audio ou en console de jeux... Les circuits non-programmables sont câblés une bonne fois pour toute, et on ne peut pas les modifier. On peut parfois reconfigurer le circuit, pour faire varier certains paramètres, via des interrupteurs ou des boutons, mais cela s’arrête là. Et cela pose un problème : à chaque problème qu'on veut résoudre en utilisant un automate, on doit recréer un nouveau circuit.

À l'inverse, un ordinateur n’est pas conçu pour une utilisation particulière, contrairement aux autres objets techniques. Il est possible de modifier leur fonction du jour au lendemain, on peut lui faire faire ce qu’on veut. On dit qu'ils sont '''programmables'''. Pour cela, il suffit d’utiliser un logiciel, une application, un programme (ces termes sont synonymes), qui fait ce que l'on souhaite. La totalité des logiciels présents sur un ordinateur sont des programmes comme les autres, même le système d'exploitation (Windows, Linux, ...) ne fait pas exception.

Un programme est une suite de d'instructions, chaque instruction effectuant une action dans l'ordinateur. Sur les ordinateurs modernes, la majorité de ces instructions effectuent une opération arithmétique, comme une addition, une multiplication, une soustraction, etc. Les ordinateurs modernes sont donc de grosses calculettes très puissantes, capables d'effectuer des millions d'opérations par secondes. Et qui dit opération dit nombres : un ordinateur gère nativement des nombres, qui sont codés en binaire sur la quasi-totalité des ordinateurs modernes.

Une instruction est représentée dans un ordinateur par une série de nombres : un nombre qui indique quelle opération/commande effectuer et des autres nombres pour coder les données (ou de quoi les retrouver dans l'ordinateur). L'ordinateur récupére les commandes une par une, les traduit en opération à effectuer, exécuter l'opération, et enregistre le résultat. Puis il recommence avec la commande suivante.

[[File:Ordinateur Théorique Complexe 1.png|centre|vignette|upright=3|Ordinateur Théorique Complexe. En jaune, le programme informatique, la liste de commande. Le rectangle gris est l'ordinateur proprement dit.]]

De nombreux appareils sont programmables, mais tous ne sont pas des ordinateurs. Par exemple, certains circuits programmables nommés FPGA n'en sont pas. Pour être qualifié d'ordinateur, un appareil programmable doit avoir un processeur séparé de la mémoire. De plus, il doit utiliser un '''codage numérique''', chose que nous allons aborder dans le chapitre suivant.

===Les ordinateurs à programme mémorisé ou programme externe===

Au tout début de l'informatique, on utilisait des cartes perforées en plastique, sur lesquelles on inscrivait le programme à exécuter, les données à traiter, bref : tout ce qu'on donnait à manger à l'ordinateur. Par la suite, les premiers ordinateurs grand public, comme les Amstrad ou les Commodore, utilisaient des cassettes audio magnétiques pour stocker les programmes. Dans le même style, les consoles de jeu utilisaient autrefois des cartouches de jeu, qui contenaient le programme du jeu à exécuter. Pour résumer, les anciens ordinateurs mémorisaient les programmes sur un support externe, lu par un périphérique. De tels ordinateurs sont dits à '''programme externe'''.

: D’anciens ordinateurs personnels, comme l’Amstrad ou le Commodore, permettaient de taper les programmes à exécuter à la main, au clavier, avant d’appuyer une touche pour les exécuter. Nul besoin de vous dire que les cassettes audio étaient plus pratiques.

Mais de nos jours, les programmes sont enregistrés sur le disque dur de l'ordinateur ou dans une mémoire intégrée à l'ordinateur. On dit qu'ils sont installés, ce qui est un mot bien compliqué pour dire que le programme est enregistré sur le disque dur de l’ordinateur. A défaut de disque dur, le programme/logiciel est enregistré dans une mémoire spécialisée pour le stockage. Par exemple, sur les cartes électroniques grand public de marque Arduino, les programmes sont envoyés à la carte via le port USB, mais les programmes sont enregistrés dans la carte Arduino, dans une mémoire FLASH dédiée. Disque dur ou non, le programme est mémorisé dans la mémoire de l'ordinateur. Il est possible d'installer ou de désinstaller les programmes en modifiant le contenu de la mémoire. Le terme utilisé est alors celui de '''programme stocké en mémoire'''.

Les programmes à installer sont disponibles soit sur un périphérique, comme un DVD ou une clé USB, soit sont téléchargés depuis internet. Les premiers PC fournissaient les logiciels sur des disquettes, qui contenaient un programme d'installation pour enregistrer le programme sur le disque dur de l'ordinateur. Par la suite, le support des logiciels a migré vers les CD et DVD, les logiciels devenant de plus en plus gros. De nos jours, la majorité des applications sont téléchargées depuis le net, l'usage de périphériques est devenu obsolète, même les consoles de jeu abandonnent cette méthode de distribution.

==Les générations d'ordinateurs : un historique rapide==

L'informatique a beaucoup évolué dans le temps. Et une bonne partie de cette évolution tient à l'évolution de l’électronique sous-jacente. Les ordinateurs actuels sont fabriqués avec des transistors, des petits composants électroniques qui servent d'interrupteur programmables, qu'on détaillera dans ce qui suit. Mais ça n'a pas toujours été le cas. Et cela permet de distinguer plusieurs '''générations d'ordinateurs'''.

===Les ordinateurs électro-mécaniques : les premiers ordinateurs===

Le tout premier ordinateur est le '''Z1''', un modèle unique inventé par Konrad Suze entre 1936 et 1938. Son processeur gérait non pas des nombres entiers, mais des nombres à virgule (des nombres dits flottants, pour être précis), encodés sur 22 bits. Le processeur du Z1 était capable de faire des additions et des soustractions, car il intégrait un circuit additionneur-soustracteur basique. Des circuits annexes permettaient de faire des multiplications et des divisions en enchainant des additions/soustractions successives. Il fonctionnait à une fréquence de 1 Hz, ce qui fait qu'il pouvait faire une addition/soustraction par seconde maximum.

[[File:Blue-punch-card-front.png|vignette|upright=0.5|Carte Perforée.]]

Niveau mémoire, la RAM de l'ordinateur était très limitée : seulement 16 nombres de 22 bits chacun. S'il s'agissait d'une mémoire électronique, les programmes étaient mémorisés sur une mémoire mécanique. Les programmes étaient enregistrés sur des cartes perforées, à savoir des cartes en papier dans lesquelles un 1 est codé par un trou dans le papier et un 0 par une absence de trou. Les programmes étaient exécutés par l'ordinateur quand on insérait la carte perforée dans le lecteur et qu'on appuyait sur un bouton.

[[File:German Museum of Technology, Berlin 2017 024.jpg|centre|vignette|upright=2|Réplique du Z1 au ''German Museum of Technology'' de Berlin, 2017.]]

Après sa destruction dans un bombardement, le Z1 a été reconstruit et amélioré, ce qui donné les deux ordinateurs Z2 et Z3. Ils étaient tous des ordinateurs dit '''électro-mécaniques''', car ils mélangeaient des composants électroniques et des composants mécaniques (tout ce qui a trait aux cartes perforées, notamment). Les composants électroniques étaient soit des relais, soit des tubes à vides, les deux étant des interrupteurs commandables électriquement plus ou moins équivalents aux transistors. Les ordinateurs d'avant l'année 1944, étaient tous de ce type. Quelques ordinateurs des années 50 étaient de ce type, mais leur nombre n'a pas dépassé 30. Il faut dire qu'ils ont rapidement laissé la place à des ordinateurs purement électroniques, que nous allons voir dans ce qui suit..

===Les premières générations : des ordinateurs qui prenaient des pièces de bâtiment entières===

A partir de 1944, de nombreux ordinateurs plus puissants ont été mis sur le marché. Des grandes noms de l'histoire de l'informatique date de cette époque : le Harvard Mark I et le Colossus Mark 1 (UK) ont tous deux été mis en service en 1944, suivi par le Z4 l'année suivante. Ils ont servis pour les cryptanalystes pour casser les codes utilisés par les allemands pour leurs transmissions, pendant la seconde guerre mondiale.

Mais c'est l'arrivée de l'ENIAC en 1945 qui a changé la donne. Cet ordinateur a introduit plusieurs innovations majeures. La première est assez technique, il s'agit de la turing-complétude, et a trait aux programmes qui peuvent être écrit pour un ordinateur. Nous ne la détaillerons pas ici. La seconde innovation est que l'ENIAC était composé non pas de relais et d'éléments mécaniques, mais uniquement de tubes à vides, des composants électroniques assez rudimentaires plus ou moins équivalents aux transistors modernes.

Le ''Manchester Baby'' a introduit une innovation extrêmement importante, au point où on considère que c'est le premier ordinateur à avoir tous les critères nécessaires pour être appelé un ordinateur. Son innovation est que le programme n'était plus mémorisé sur des cartes perforée, mais dans une mémoire électronique dans l'ordinateur lui-même. En clair, le ''Manchester Baby'' était le premier '''''Stored-program computer''''', ordinateur à programme enregistré en français. 

[[File:IBM 7070.jpg|vignette|Cartes imprimées de l'IBM 704, avec des transistors et résistances dessus.]]

Les ordinateurs qui ont suivi l'ENIAC sont regroupés dans la '''première génération d'ordinateur'''. Ils étaient conçus avec des tubes à vide, ce qui les place entre les premiers ordinateurs électro-mécaniques et les ordinateurs utilisant des transistors. Les ordinateurs de première génération étaient très simples, ils ne géraient que quelques opérations simples : l'addition, la soustraction, pas grand chose de plus. A quelques exceptions près, ils ne géraient pas la multiplication et encore moins la division, ils n'avaient pas assez de relais ou de tubes à vides à disposition pour cela.

La '''seconde génération''' est celle des ordinateurs fabriqués avec des '''transistors''' isolés, reliés entre avec des fils électriques. Les transistors en question possèdent trois broches, des pattes métalliques sur lesquelles on connecte des fils électriques. Le transistor s'utilise le plus souvent comme un interrupteur commandé par sa troisième broche. Le courant qui traverse les deux premières broches passe ou ne passe pas selon ce qu'on met sur la troisième.

[[File:Transistor basic flow.svg|centre|vignette|Un transistor est un morceau de conducteur, dont la conductivité est contrôlée par sa troisième broche/borne.]]

Les ordinateurs de seconde génération avaient entre 1000 et 500 000 transistors. Les capacités des ordinateurs étaient donc nettement supérieures à celles des ordinateurs de première génération. Une part non négligeable des ordinateurs de seconde génération supportait l'opération de multiplication, absente sur les ordinateurs de première génération. Néanmoins, cela variait beaucoup selon les ordinateurs.

Un exemple assez hors du commun est celui du premier modèle de l'IBM 1620. Le tout premier modèle n'avait aucun circuit de calcul, il n'était même pas capable de faire une addition ou une multiplication. A la place, il utilisait une table d'addition et une table de multiplication en mémoire RAM. Les deux tables devaient être initialisées par le logiciel lors du démarrage de la machine. La table d'addition faisait une centaine de chiffre, la table de multiplication faisait le double. Le processeur de l'ordinateur gérait des instructions pour faire des additions ou des multiplications, mais ces opérations lisaient le résultat dans la table d'addition. Les calculs étaient fait chiffre par chiffre, avec un encodage partiellement décimal, partiellement binaire (des chiffres décimaux étaient encodés en binaire, nous en reparlerons quand nous parlerons du BCD) !

[[File:KL CoreMemory.jpg|vignette|Mémoire à tore de ferrite.]]

Les transistors n'étaient utilisés que pour le processeur et les circuits annexes. La mémoire n'était pas faite en transistors, pas à cette époque. La mémoire était une mémoire aujourd'hui abandonnée, appelée une '''mémoire à tores de ferrite'''. Elle sera détaillée dans un chapitre ultérieur. Mais sachez pour le moment qu'il s'agit d'une mémoire au support magnétique, les données étant stockées sur un support magnétique.

Transistors comme tubes à vide prenaient beaucoup de place, ce qui fait que les ordinateurs étaient assez gros. Concrètement, ils prenaient une pièce de bâtiment entière dans le meilleur des cas. C'était l'époque des gros ''mainframes'', reliés à des terminaux, peu puissants comparé aux standards actuels. Seules les grandes entreprises et les grands instituts de recherche pouvaient se payer les services de ce genre d'ordinateurs. Seuls les professionnels avaient accès à ce genre d'équipement.

===La troisième génération : le circuit intégré===

[[File:D8259AC-2.jpg|vignette|Exemple de circuit intégré.]]

La troisième génération est toujours fabriquée avec des transistors, mais dont la taille a été réduite. Avec l'évolution de la technologie, les transistors ont diminué en taille, de plus en plus. Ils sont devenus tellement petits qu'ils ont finit par être regroupés dans des '''circuits intégrés''', des circuits regroupent plusieurs transistors sur la même puce de silicium. Les circuits intégrés se présentent le plus souvent sous la forme de boitiers rectangulaires, comme illustré ci-contre. D'autres ont des boitiers de forme carrées, comme ceux que l'on peut trouver sur les barrettes de mémoire RAM, ou à l'intérieur des clés USB/ disques SSD.

Lors de cette génération, les processeurs étaient fournis en pièces détachées qu'il fallait relier entre elles. Le processeur était composé de plusieurs circuits intégrés séparés, impossible de mettre un processeur dans un seul boitier. Un exemple de processeur conçu en kit est la série des Intel 3000. Elle regroupe plusieurs circuits séparés aux noms à coucher dehors, mais dont vous comprendrez ce qu'ils veulent dire dans les chapitres adéquats : l'Intel 3001 est un séquenceur, l'Intel 3002 regroupe unité de calcul et registres, le 3003 est un circuit d'anticipation de retenue complémentaire du 3002, le 3212 est une mémoire tampon, le 3214 est une unité de gestion des interruptions, les 3216/3226 sont des interfaces de bus mémoire. On pourrait aussi citer la famille de circuits intégrés AMD Am2900.

Même si le processeur était en pièce détachées, utiliser une dizaine de circuits intégrés était nettement mieux que d'utiliser plusieurs milliers de transistors individuels. En conséquence, les ordinateurs ont vu leur taille grandement réduite, passant de pièces entières à une simple armoire, voire à quelques cartes intégrées superposées. De plus, le prix des circuits intégré était abordable, du moins comparé aux ordinateurs d'avant. Le prix des ordinateurs a alors grandement décru, permettant à des entreprises et administrations de taille modeste de s'équiper d'ordinateurs.

===La quatrième génération : le microprocesseur===

[[File:MOS6502.svg|vignette|Microprocesseur, ici un processeur MOS6502, de la quatrième génération.]]

Lors de la troisième génération, les circuits intégrés regroupaient plusieurs dizaines ou centaines de transistors, mais sont rapidement montés en gamme. De centaines de transistors, ils sont passé au milliers de transistors, puis au millions et maintenant au-delà du milliard. Les transistors étaient devenus tellement petits, tellement miniaturisés, qu'il était devenu possible de mettre un processeur entier dans un circuit intégré. C'est ainsi qu'est né le microprocesseur, à savoir un processeur qui tient tout entier dans un seul circuit imprimé. La quatrième génération d’ordinateur est celle des ordinateurs basés autour d'un microprocesseur.

Les tout premiers microprocesseurs étaient des processeurs à application militaire, comme le processeur du F-14 CADC ou celui de l'Air data computer. Le tout premier microprocesseur commercialisé au grand public est le 4004 d'Intel, sorti en 1971. L'intel 4004 comprenait environ 2300 transistors, avait une fréquence de 740 MHz, pouvait faire 46 opérations différentes, et manipulait des entiers de 4 bits. Il était au départ un processeur de commande, prévu pour être intégré dans la calculatrice Busicom calculator 141-P, mais il fut utilisé pour d'autres applications quelque temps plus tard. Immédiatement après le 4004, les premiers microprocesseurs 8 bits furent commercialisés. Le 4004 fut suivi par le 8008 et quelques autres processeurs 8 bits extrêmement connus, comme le 8080 d'Intel, le 68000 de Motorola, le 6502 ou le Z80.

Les microprocesseurs permirent encore uen fois de réduire la taille des ordinateurs, qui pouvaient tenir dans un boitier de PC, ou un boitier de console de jeu. Le prix des ordinateurs a aussi chuté en même temps que les transistors était miniaturisés. C'est cette invention qui permis l'invention des consoles de jeux et des mini-ordinateurs, à savoir les ordinateurs personnels. Sans miniaturisation, on n'aurait pas d'ordinateur personnel, pas de PC fixe ou portable.

==L'organisation du cours : les différents niveaux d'explication==

Le fonctionnement d'un ordinateur est assez complexe à expliquer car les explications peuvent se faire sur plusieurs niveaux. Par plusieurs niveaux, on veut dire qu'un ordinateur est composé de composants très simples, qui sont assemblés pour donner des composants eux-même plus complexes, qui sont eux-même regrouper, etc. Étudier tout cela demande de voir plusieurs niveaux, allant de transistors très petits à des processeurs multicœurs. Les niveaux les plus bas sont de l'électronique pur et dure, alors que ceux plus haut sont à mi-chemin entre électronique et informatique.

===Les niveaux d'abstraction en architecture des ordinateurs===

Les trois premiers niveaux sont de l'électronique pur et dure. Ils correspondent aux premiers chapitres du cours, qui porteront sur les circuits électroniques en général.
* Le premier niveau est celui des '''transistors''', des circuits intégrés, des ''wafer'' et autres circuits de très petite taille.
* Le second niveau est celui des '''portes logiques''', des circuits très basiques, très simples, à la base de tous les autres.
* Le troisième niveau est celui dit de la '''''Register Transfer Level''''', où un circuit électronique est construit à partir de circuits basiques, dont des registres et autres circuits dits combinatoires.
Les deux niveaux suivants sont de l'informatique proprement dit. C'est dans ces deux niveaux qu'on étudie les ordinateurs proprement dit, les circuits qu'il y a dedans et non l'électronique en général.
* Le quatrième niveau est celui de la '''microarchitecture''', qui étudie ce qu'il y a à l'intérieur d'un processeur, d'une mémoire, des périphériques et autres.
* Le cinquième niveau est celui de l''''architecture externe''', qui décrit l'interface du processeur, de la mémoire, d'un périphérique ou autre. Par décrire l'interface, on veut dire : comment un programmeur voit le processeur et la mémoire, comment il peut les manipuler. Une architecture externe unique peut avoir plusieurs microarchitecture, ce qui fait qu'on sépare les deux. Tout cela sera plus clair quand on passera aux chapitres sur le processeur et les mémoires.

Nous n'allons pas voir les 5 niveaux dans l'ordre, des transistors vers l'architecture externe. En réalité, nous allons procéder autrement. La première partie du cours portera sur les trois premiers niveaux, le reste sur les deux autres. Les 5 niveaux seront vus dans des chapitres séparés, du moins le plus possible. Au niveau pédagogique, tout est plus simple si on scinde les 5 niveaux. Bien sûr, il y a quelques explications qui demandent de voir plusieurs niveaux à la fois. Par exemple, dans le chapitre sur les mémoires caches, nous auront des explications portant sur la RTL, la microarchitecture du cache et son architecture externe. Mais le gros du cours tentera de séparer le plus possible les 5 niveaux.

===Les trois parties principales du cours===

Nous allons commencer par parler du binaire, avant de voir les portes logiques. Avec ces portes logiques, nous allons voir comment fabriquer des circuits basiques qui reviendront très souvent dans la suite du cours. Nous verrons les registres, les décodeurs, les additionneurs et plein d'autres circuits. Puis, nous reviendrons au niveau des transistors pour finir la première partie. La raison est que c'est plus simple de faire comme cela. Tout ce qui a trait aux transistors sert à expliquer comment fabriquer des portes logiques, et il faut expliquer les portes logiques pour voir le niveau de la RTL.

Une fois la première partie finie, nous allons voir les différents composants d'un ordinateur. Une première partie expliquera ce qu'il y a dans un ordinateur, quels sont ses composants. Nous y parlerons de l'architecture de base, de la hiérarchie mémoire, des tendances technologiques, et d'autres généralités qui serviront de base pour la suite. Puis, nous verrons dans l'ordre les bus électroniques, les mémoires RAM/ROM, le processeur, les périphériques, les mémoires de stockage (SSD et disques durs) et les mémoires caches. Pour chaque composant, nous allons voir leur architecture externe, avant de voir leur microarchitecture. La raison est que la microarchitecture ne peut se comprendre que quand on sait quelle architecture externe elle implémente.

Enfin, dans une troisième partie, nous allons voir les optimisations majeures présentes dans tous les ordinateurs modernes, avec une partie sur le pipeline et le parallélisme d'instruction, et une autre sur les architectures parallèles. Pour finir, les annexes de fin parlerons de sujets un peu à part.

&lt;noinclude&gt;
{{NavChapitre | book=Fonctionnement d'un ordinateur
           | next=L'encodage des données
           | nextText=L'encodage des données
}}
&lt;/noinclude&gt;</text>
      <sha1>qc4ygdlg6sknjrf2derri76f2nvpabk</sha1>
    </revision>
    <revision>
      <id>744110</id>
      <parentid>744109</parentid>
      <timestamp>2025-06-04T21:09:08Z</timestamp>
      <contributor>
        <username>Mewtow</username>
        <id>31375</id>
      </contributor>
      <minor />
      <comment>/* Les premières générations : des ordinateurs qui prenaient des pièces de bâtiment entières */</comment>
      <origin>744110</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="41823" sha1="esmvone9u7foaybfjvueoq2bv0ardel" xml:space="preserve">Pour commencer, nous allons voir qu'il existe de nombreux types d'ordinateurs. Le plus connu est certainement le PC, l'ordinateur personnel, que vous avez sans doute dans votre salon. Les ordinateurs portables sont un deuxième type d'ordinateur assez intuitif, que vous avez peut-être. Mais il y a aussi d'autres types d'ordinateurs auxquels vous n'avez jamais été confrontés.

==Les différents types d'ordinateurs==

Dans cette section, nous allons décrire rapidement les ordinateurs les plus courant, mais surtout voir ce qu'il y a à l'intérieur d'un ordinateur.

===L'ordinateur de type PC fixe===

De l'extérieur, l'ordinateur est composé d'une unité centrale sur laquelle on branche des périphériques.

[[File:Typical computer architecture systems.jpg|vignette|upright=1.5|Exemples de périphériques, connectés à une unité centrale (ici appelée à tort ''operating system'').]]

Les '''périphériques''' regroupent l'écran, la souris, le clavier, l'imprimante, et bien d'autres choses. Ils permettent à l'utilisateur d'interagir avec l'ordinateur : un clavier permet de saisir du texte sous dans un fichier, une souris enregistre des déplacements de la main en déplacement du curseur, un écran affiche des données d’images/vidéos, un haut-parleur émet du son, etc. Tout ce qui est branché sur un ordinateur est, formellement un périphérique.

L''''unité centrale''' est là où se trouvent tous les composants importants d'un ordinateur, ceux qui font des calculs, qui exécutent des logiciels, qui mémorisent vos données, etc. Voici ce à quoi ressemble l'intérieur de l'unité centrale. Trois sections sont visibles : l'alimentation électrique en haut à gauche, la carte mère en bas à gauche et en jaune/orange, les disques et lecteurs à droite des câbles. Et on voit aussi beaucoup de câbles.

[[File:Asus P5K-SEIntel E6320.jpg|centre|vignette|upright=2|Exemple d'unité centrale.]]

Tout en haut à gauche, se trouve l''''alimentation électrique''', qui convertit le courant de la prise électrique en un courant plus faible, utilisable par les autres composants. Elle émet de nombreux câbles assez gros, qui sont reliés au reste. Les PC actuels utilisent des alimentations électriques standardisées, qui fournissent trois tensions au reste de l'ordinateur : une tension de 12 Volts, une de 5 Volts, une de 3,3 Volts.

À droite, caché par la partie &quot;métallique&quot; du boitier, se trouvent les lecteurs de CD/DVD, et les disques durs. Les lecteurs CD-ROM ou DVD-ROM permettaient de lire des CD ou des DVD. Je parle au passé, car ils ont aujourd'hui disparu des ordinateurs modernes. Les '''disques durs''' sont des mémoires de stockage, qui mémorisent vos données de manière permanente. De nos jours, ils sont remplacés par des SSD, qui sont des disques durs électroniques, là où les disques durs proprement dit sont des mémoires magnétiques. Nous verrons la différence dans deux chapitres dédiés, un sur les disques durs, l'autre sur les SSD.

En bas à droite, se trouve la '''carte mère''' un support plat, en plastique ou en céramique, sur laquelle sont soudés/connectés les autres composants. Sur celle-ci, de nombreux composants sont soudés, d'autres sont branchés dessus avec des câbles, d'autres sont connectés dessus avec des connecteurs. Ils sont reliés entre eux par des fils conducteurs, le plus souvent du cuivre ou de l’aluminium, ce qui leur permet de s’échanger des données. Sur les cartes simples, ces fils sont intégrés dans la carte électronique, dans des creux du plastique. Ils portent le nom de pistes.

Avant, les disques durs, SSD et lecteurs de CD/DVD sont branchés dessus via des connecteurs dédiés, appelés des connecteurs S-ATA. De nos jours, ils sont branchés sur un autre connecteur, grâce à l'interface NVME. Toujours est-il qu'ils sont reliés à la carte mère par des câbles, ce qui montre que ce sont des sortes de périphériques interne. Ils sont placés dans le boitier, mais on aurait tout aussi bien pu les mettre à l'extérieur, vu qu'ils communiquent avec l'ordinateur par l'intermédiaire d'un câble ou d'un connecteur dédié.

Mais deux autres composants très importants sont eux placés sur la carte mère, directement. Ils ont chacun un connecteur dédié, sur lequel ils sont branchés directement, sans passer par l'intermédiaire d'un câble, mais sans être soudés non plus. Il s'agit du processeur et de la mémoire RAM, deux composants centraux des PC modernes.

[[File:Pentium III SL4CB.jpg|thumb|Processeur Pentium III.]]

Le '''processeur''' traite les données, les modifie, les manipule. Pour faire simple, il s’agit d’une grosse calculatrice hyper-puissante. Il comprend à la fois un circuit qui fait des calculs, et un circuit de contrôle qui s'occupe de séquencer les calculs dans l'ordre demandé. Il est souvent caché sous un radiateur, lui-même surmonté par un ventilateur. En effet, un processeur chauffe beaucoup, ce qui demande d'évacuer cette chaleur. Un chapitre entier expliquera pourquoi les processeurs chauffent, ainsi que les techniques utilisées pour limiter leur production de chaleur et leur consommation électrique.

La '''mémoire vive''' conserve des informations/données temporairement, tant que le processeur en a besoin. Elle prend la forme de barrettes de RAM, comme montré ci-dessous.

[[File:2 gb ddr2 667.jpg|centre|vignette|upright=2|Barrette de RAM.]]

Outre ces composants dits principaux, un ordinateur peut comprendre plusieurs composants moins importants, surtout présents sur les ordinateurs personnels. Ils sont techniquement facultatifs, mais sont très présents dans les ordinateurs personnels. Cependant, certains ordinateurs spécialisés s'en passent. Il s'agit des diverses '''cartes d'extension''' sont branchées sur la carte mère. Elles permettent d’accélérer certains calculs ou certaines applications, afin de décharger le processeur. Par exemple, la carte graphique s'occupe des calculs graphiques, qu'il s'agisse de graphismes 3D de jeux vidéos ou de l'affichage en 2D du bureau. Dans un autre registre, la carte son prend en charge le microphone et les haut-parleurs.

[[Fichier:Personal computer, exploded 4.svg|thumb|upright=1.0|Éclaté d'un ordinateur de type PC :&lt;br /&gt;
1 : Écran ;&lt;br /&gt;
2 : Carte mère ;&lt;br /&gt;
3 : Processeur ;&lt;br /&gt;
4 : Câble Parallel ATA ;&lt;br /&gt;
5 : Mémoire vive (RAM) ;&lt;br /&gt;
6 : Carte d'extension ;&lt;br /&gt;
7 : Alimentation électrique ;&lt;br /&gt;
8 : Lecteur de disque optique ;&lt;br /&gt;
9 : Disque dur ;&lt;br /&gt;
10 : Clavier ;&lt;br /&gt;
11 : Souris.]]

Si on regarde une carte mère de face, on voit un grand nombre de connecteurs, mais aussi des circuits électroniques soudés à la carte mère.

[[File:Architecture matérielle d'une carte mère.png|centre|vignette|upright=2.0|Architecture matérielle d'une carte mère]]

Les '''connecteurs''' sont là où on branche les périphériques, la carte graphique, le processeur, la mémoire, etc. Dans l'ensemble, toute carte mère contient les connecteurs suivants :
* Le processeur vient s’enchâsser dans la carte mère sur un connecteur particulier : le '''socket'''. Celui-ci varie suivant la carte mère et le processeur, ce qui est source d'incompatibilités.
* Les barrettes de mémoire RAM s’enchâssent dans un autre type de connecteurs: les '''slots mémoire'''.
* Les mémoires de masse disposent de leurs propres connecteurs : connecteurs P-ATA pour les anciens disques durs, et S-ATA pour les récents.
* Les périphériques (clavier, souris, USB, Firewire, ...) sont connectés sur un ensemble de connecteurs dédiés, localisés à l'arrière du boitier de l'unité centrale. 
* Les autres périphériques sont placés dans l'unité centrale et sont connectés via des connecteurs spécialisés. Ces périphériques sont des cartes imprimées, d'où leur nom de '''cartes filles'''. On peut notamment citer les cartes réseau, les cartes son, ou les cartes vidéo.

===Les ordinateurs portables===

[[File:Samsung QX-511 (2).JPG|vignette|Ordinateur portable Samsung QX-511 (2), pour illustration.]]

Un ordinateur portable est identique à un ordinateur de type PC. Si vous ouvrez votre ordinateur portable (attention à la garantie), vous retrouverez les mêmes composants qu'un PC à l'intérieur. Un point important est la présence d'une batterie à l'intérieur du PC portable, absente des PC fixes.

[[File:LG gram 14Z90Q mainboard with battery.jpg|centre|vignette|upright=2|LG gram 14Z90Q avec sa batterie.]]

Une fois la batterie et les circuits associés retiré, la seule différence notable est que tous les composants sont soudés sur la carte mère, au lieu d'être branchés sur des connecteurs, à part éventuellement la RAM et le disque dur.

[[File:LG gram 14Z90Q mainboard without battery.jpg|centre|vignette|upright=2|LG gram 14Z90Q sans sa batterie.]]

La RAM est parfois soudée sur la carte mère, d'autres fois sous la forme de barrettes de mémoire vive semblables à celles des PC. Dans le dernier cas, elle est connectée à des connecteurs spécifiques, ce qui permet de les changer/upgrader. Les PC portables sont parfois construits de manière à pouvoir changer la RAM facilement, en ouvrant un cache spécial, concu pour.

[[File:Lenovo G555 состав - Донор.JPG|centre|vignette|upright=2|Lenovo G555.]]

La conception d'un ordinateur portable est légèrement différente de celle d'un PC, pour des raisons thermiques. Un PC fixe a plus de place pour évacuer sa chaleur. Les ventilateurs peuvent plus facilement déplacer l'air dans le boitier, même si le flux d'air dans le boitier est éventuellement gêné par la carte graphique. Mais l'évacuation de la chaleur est assez efficace. Sur les PC portables, leur finesse fait que le trajet de l'air est beaucoup plus contraint. Évacuer la chaleur produite par l'ordinateur est plus complexe, ce qui demande d'utiliser des systèmes de refroidissement et de ventilation spécifiques.

Là où les PC fixes se débrouillent avec des radiateurs et des ventilateurs posés sur le processeur, les PC portables font autrement. Ils ne peuvent pas forcément mettre le ventilateur sur le processeur. A la place, ils mettent le ventilateur à côté, mais le processeur est surmonté par un mécanisme de transmission de la chaleur, qui transfère la chaleur du processeur vers le ventilateur.

[[File:Diagram - How a laptop cooling system works.png|centre|vignette|upright=2|Comment fonctionne le système de ventilation d'un ordinateur portable, en anglais.]]

Les difficultés pour dissiper la chaleur font que les ordinateurs portables utilisent souvent des composants peu performants, mais qui chauffent peu. En effet, nous verrons que plus un composant est puissant, plus il chauffe. La relation n'est pas parfaite, mais les processeurs haute performance chauffent plus que les modèles d'entrée ou milieu de gamme moins puissants. En conséquence, les PC portables sont souvent moins puissants que les PC fixes, même pour les modèles dit ''gaming''.

===Les serveurs et ''mainframes''===

Les grandes entreprises utilisent des ordinateurs de grande taille, très puissants, appelés des ''mainframes''. Ils sont souvent confondus avec les serveurs par le grand public, il y a une différence entre les deux. Un serveur est une fonction logicielle/réseau, pas un type d'ordinateur. Mais laissons cette différence de côté, ce qui est dit pour les ''mainframes'' sert pour les gros serveurs haute performance.

[[File:IBM Z15 mainframe.jpg|vignette|Exemple de ''mainframe''' de type IBM Z15.]]

Les anciens ''mainframes'' des années 50-80 avaient une taille pouvant être impressionnante, au point de prendre une pièce complète d'un bâtiment. Mais de nos jours, les ''mainframes'' tiennent dans une grosse armoire un peu haute. Les ''mainframes'' doivent rester allumé en permanence et ne doivent pas être éteint, sauf éventuellement quelques jours par an pour des opérations de maintenance. Ils utilisent pour cela des techniques spécifiques, avec beaucoup de redondance interne.

[[File:ACONIT hall grandes machines.jpg|centre|vignette|upright=2|''Mainframe'' ACONIT.]]

Les ''mainframes'' sont aussi conçus pour mutualiser au maximum leur utilisation, ils peuvent être utilisés par plusieurs utilisateurs à la suite, voire en même temps. Pour cela, les anciens ''mainframes'' étaient capables de faire tourner plusieurs applications distinctes l'une à la suite de l'autre, avec des commutations fréquentes entre logiciels. De nos jours, ils sont capables d'exécuter un grand nombre de tâches en même temps, grâce à la présence de plusieurs processeurs. Les ''mainframes'' modernes sont même capables de faire tourner plusieurs systèmes d'exploitation en même temps si besoin.

Les anciens ''mainframes'' étaient des ordinateurs assez simples, avec un processeur, de la mémoire RAM, un ou plusieurs disques durs, pas plus. Le ''mainframe'' était tellement énorme et cher que les entreprises n'en avaient qu'un seul pour toute l'entreprise. Les employés avaient sur leur bureau des terminaux, qui permettaient d'accéder à l'ordinateur central, mais n'étaient pas des ordinateurs. Les terminaux étaient des composants électroniques simples, avec un écran, un clavier et une souris, mais sans processeur. Ils envoyaient des données au ''mainframe'', ils en recevaient de sa part, mais tout traitement était réalisé sur le ''mainframe''. L'arrivée sur le marché des ordinateurs personnels, de type PC fixe/portable, a entrainé l'abandon de ce genre de pratique, tous les employés ont maintenant un ordinateur rien que pour eux.

{|
|-
! colspan=&quot;2&quot; | Exemples de terminaux
|-
|[[File:Terminal-in2-sm9400.jpg|centre|vignette|upright=1.5|Exemple de terminal. Notez la présence d'un écran et d'un clavier, mais l'asbence d'une unité centrale.]]
|[[File:Chromatics CT4100.jpg|vignette|upright=1.5|Autre exemple de terminal. Le clavier est couplé à un stylo CRT, qui remplacait la souris et agissait sur l'écran comme s'il était tactile.]]
|-
! colspan=&quot;2&quot; | Intérieur d'un terminal
|-
|[[File:CT1024 Monitor.jpg|vignette|upright=1.5|Terminal CT1024, sans le boitier extérieur.]]
|[[File:CT1024 Terminal System.jpg|vignette|upright=1.5|Terminal CT1024, description des composants interne.]]
|}

De nos jours, les ''mainframes'' contiennent en réalité plusieurs ordinateurs simples interconnectés via un réseau local. Un ''mainframe'' qui tient dans une armoire contient facilement une dizaine ou centaine de processeurs, plein de RAM, des disques durs séparés dans une armoire distincte, etc. Vu qu'ils communiquent uniquement via le réseau, ils n'ont pas d'interface, pas d'écran, 'entrée via clavier/souris. Le tout est commandé avec une console de commande, typiquement un ordinateur portable ou un terminal assez simple séparé de l'armoire, qui permet à un administrateur de faire des opérations de surveillance, configuration et maintenance. Il peut y avoir une console de commande pour plusieurs armoires séparées, la console peut même être dans un autre bâtiment et accéder au ''mainframe'' par le réseau.

[[File:IBM System Z9 (type 2094 inside).jpg|centre|vignette|upright=2|''Mainframe'' de type IBM System Z9. L'ordinateur portable sert de console pour qu'un administrateur fasse des opérations de surveillance, configuration et maintenance.]]

Les processeurs et la RAM sont typiquement installés sur des cartes amovibles, qui sont connectées au fond de l'armoire lors de l'installation. Il est même possible de retirer ou d'ajouter des cartes en fonctionnement, afin d'ajouter/retirer des processeurs, des disques durs, etc. Ce qui est très utile si un composant est en panne et qu'il faut le remplacer. 

[[File:IBM TotalStorage Exp400.jpg|centre|vignette|upright=2|IBM TotalStorage Exp400]]

==Un peu d'abstraction : qu'est-ce qu'un ordinateur ?==

Un ordinateur comprend donc un processeur, plusieurs mémoires, des cartes d'extension et une carte mère pour connecter le tout. Mais il s'agit là d'une description assez terre-à-terre de ce qu'est un ordinateur. Une autre description, plus abstraite, se base sur le fait qu'un ordinateur est une énorme calculatrice programmable. Elle permet d'expliquer pourquoi il y a une distinction entre processeur et mémoire, entre unité centrale et périphériques. Tout ce qui va suivre pourra vous paraitre assez abstrait, mais rassurez-vous : les prochains chapitres rendront tout cela plus concrets.

===La séparation entre entrées-sorties et traitement===

L'unité centrale peut être vue comme une énorme calculatrice ultra-puissante, qui exécute des commandes/opérations. Mais à elle seule, elle ne servirait à rien, il faut interagir avec par l'intermédiaire de plusieurs périphériques. Il existe deux types de périphériques, qui sont conceptuellement différents. Les périphériques comme le clavier ou la souris permettent d'envoyer des informations à l'ordinateur, d'agir sur celui-ci. A l'inverse, les écrans transmettent des informations dans le sens inverse : de l'ordinateur vers l'utilisateur. Les premiers sont appelés des '''entrées''', les seconds des '''sorties'''.

Dans un ordinateur, les informations sont représentées sous la forme de nombres. Toute donnée dans un ordinateur est codée avec un ou plusieurs nombres regroupés dans une donnée, un fichier, ou autre. Et la transmissions avec les entrées et sorties se fait là-encore avec des nombres. Par exemple, quand vous appuyez sur votre clavier, le clavier envoie un numéro de touche à l'unité centrale, qui indique quelle touche a été appuyée. L'image à afficher à l'écran est codée sous la forme d'une suite de nombres (un par pixel). L'image est envoyée à l'écran, qui traduit la suite de nombre en image à afficher. Les entrées traduisent des actions utilisateurs en nombres, on dit que les entrées encodent les actions utilisateur. Les sorties font la traduction inverse, elles transforment des suites de nombres en une action physique. On dit qu'elles décodent des informations.

Pour résumer, toute appareil électronique est composé par :
* Des '''entrées''' sur lesquelles l'utilisateur agit sur l'ordinateur. Les entrées transforment les actions de l'utilisateur en nombres, qui sont interprétés par l'ordinateur.
* Une '''unité de traitement''', qui manipule des nombres et fait des calculs/opérations dessus. Les nombres proviennent des entrées, du disque dur, ou d'autres sources, peu importe.
* Des '''sorties''', qui va récupèrent le résultat calculé par l'unité de traitement pour en faire quelque chose : écrire sur une imprimante ou sur un moniteur, émettre du son,...

[[File:Ordinateur théorique Simple 1.png|centre|vignette|upright=2|Ordinateur théorique Simple 1]]

L'unité de traitement proprement dite, celle qui fait les calculs, est couplée à une mémoire qui mémorise les opérandes et résultats des calculs. La séparation entre processeur et mémoire est nécessaire pour qu'un appareil électronique soit qualifié d'ordinateur. De nombreux appareils n'ont pas de séparation entre unité de traitement et mémoire, comme certaines vielles radios AM/FM.

[[File:Schéma de principe d'un ordinateur.png|centre|vignette|upright=2|Schéma de principe d'un ordinateur]]

===Un ordinateur est un appareil programmable===

Les appareils simples sont non-programmables, ce qui veut dire qu’ils sont conçus pour une utilisation particulière et qu’ils ne peuvent pas faire autre chose. Par exemple, les circuits électroniques d’un lecteur de DVD ne peuvent pas être transformé en lecteur audio ou en console de jeux... Les circuits non-programmables sont câblés une bonne fois pour toute, et on ne peut pas les modifier. On peut parfois reconfigurer le circuit, pour faire varier certains paramètres, via des interrupteurs ou des boutons, mais cela s’arrête là. Et cela pose un problème : à chaque problème qu'on veut résoudre en utilisant un automate, on doit recréer un nouveau circuit.

À l'inverse, un ordinateur n’est pas conçu pour une utilisation particulière, contrairement aux autres objets techniques. Il est possible de modifier leur fonction du jour au lendemain, on peut lui faire faire ce qu’on veut. On dit qu'ils sont '''programmables'''. Pour cela, il suffit d’utiliser un logiciel, une application, un programme (ces termes sont synonymes), qui fait ce que l'on souhaite. La totalité des logiciels présents sur un ordinateur sont des programmes comme les autres, même le système d'exploitation (Windows, Linux, ...) ne fait pas exception.

Un programme est une suite de d'instructions, chaque instruction effectuant une action dans l'ordinateur. Sur les ordinateurs modernes, la majorité de ces instructions effectuent une opération arithmétique, comme une addition, une multiplication, une soustraction, etc. Les ordinateurs modernes sont donc de grosses calculettes très puissantes, capables d'effectuer des millions d'opérations par secondes. Et qui dit opération dit nombres : un ordinateur gère nativement des nombres, qui sont codés en binaire sur la quasi-totalité des ordinateurs modernes.

Une instruction est représentée dans un ordinateur par une série de nombres : un nombre qui indique quelle opération/commande effectuer et des autres nombres pour coder les données (ou de quoi les retrouver dans l'ordinateur). L'ordinateur récupére les commandes une par une, les traduit en opération à effectuer, exécuter l'opération, et enregistre le résultat. Puis il recommence avec la commande suivante.

[[File:Ordinateur Théorique Complexe 1.png|centre|vignette|upright=3|Ordinateur Théorique Complexe. En jaune, le programme informatique, la liste de commande. Le rectangle gris est l'ordinateur proprement dit.]]

De nombreux appareils sont programmables, mais tous ne sont pas des ordinateurs. Par exemple, certains circuits programmables nommés FPGA n'en sont pas. Pour être qualifié d'ordinateur, un appareil programmable doit avoir un processeur séparé de la mémoire. De plus, il doit utiliser un '''codage numérique''', chose que nous allons aborder dans le chapitre suivant.

===Les ordinateurs à programme mémorisé ou programme externe===

Au tout début de l'informatique, on utilisait des cartes perforées en plastique, sur lesquelles on inscrivait le programme à exécuter, les données à traiter, bref : tout ce qu'on donnait à manger à l'ordinateur. Par la suite, les premiers ordinateurs grand public, comme les Amstrad ou les Commodore, utilisaient des cassettes audio magnétiques pour stocker les programmes. Dans le même style, les consoles de jeu utilisaient autrefois des cartouches de jeu, qui contenaient le programme du jeu à exécuter. Pour résumer, les anciens ordinateurs mémorisaient les programmes sur un support externe, lu par un périphérique. De tels ordinateurs sont dits à '''programme externe'''.

: D’anciens ordinateurs personnels, comme l’Amstrad ou le Commodore, permettaient de taper les programmes à exécuter à la main, au clavier, avant d’appuyer une touche pour les exécuter. Nul besoin de vous dire que les cassettes audio étaient plus pratiques.

Mais de nos jours, les programmes sont enregistrés sur le disque dur de l'ordinateur ou dans une mémoire intégrée à l'ordinateur. On dit qu'ils sont installés, ce qui est un mot bien compliqué pour dire que le programme est enregistré sur le disque dur de l’ordinateur. A défaut de disque dur, le programme/logiciel est enregistré dans une mémoire spécialisée pour le stockage. Par exemple, sur les cartes électroniques grand public de marque Arduino, les programmes sont envoyés à la carte via le port USB, mais les programmes sont enregistrés dans la carte Arduino, dans une mémoire FLASH dédiée. Disque dur ou non, le programme est mémorisé dans la mémoire de l'ordinateur. Il est possible d'installer ou de désinstaller les programmes en modifiant le contenu de la mémoire. Le terme utilisé est alors celui de '''programme stocké en mémoire'''.

Les programmes à installer sont disponibles soit sur un périphérique, comme un DVD ou une clé USB, soit sont téléchargés depuis internet. Les premiers PC fournissaient les logiciels sur des disquettes, qui contenaient un programme d'installation pour enregistrer le programme sur le disque dur de l'ordinateur. Par la suite, le support des logiciels a migré vers les CD et DVD, les logiciels devenant de plus en plus gros. De nos jours, la majorité des applications sont téléchargées depuis le net, l'usage de périphériques est devenu obsolète, même les consoles de jeu abandonnent cette méthode de distribution.

==Les générations d'ordinateurs : un historique rapide==

L'informatique a beaucoup évolué dans le temps. Et une bonne partie de cette évolution tient à l'évolution de l’électronique sous-jacente. Les ordinateurs actuels sont fabriqués avec des transistors, des petits composants électroniques qui servent d'interrupteur programmables, qu'on détaillera dans ce qui suit. Mais ça n'a pas toujours été le cas. Et cela permet de distinguer plusieurs '''générations d'ordinateurs'''.

===Les ordinateurs électro-mécaniques : les premiers ordinateurs===

Le tout premier ordinateur est le '''Z1''', un modèle unique inventé par Konrad Suze entre 1936 et 1938. Son processeur gérait non pas des nombres entiers, mais des nombres à virgule (des nombres dits flottants, pour être précis), encodés sur 22 bits. Le processeur du Z1 était capable de faire des additions et des soustractions, car il intégrait un circuit additionneur-soustracteur basique. Des circuits annexes permettaient de faire des multiplications et des divisions en enchainant des additions/soustractions successives. Il fonctionnait à une fréquence de 1 Hz, ce qui fait qu'il pouvait faire une addition/soustraction par seconde maximum.

[[File:Blue-punch-card-front.png|vignette|upright=0.5|Carte Perforée.]]

Niveau mémoire, la RAM de l'ordinateur était très limitée : seulement 16 nombres de 22 bits chacun. S'il s'agissait d'une mémoire électronique, les programmes étaient mémorisés sur une mémoire mécanique. Les programmes étaient enregistrés sur des cartes perforées, à savoir des cartes en papier dans lesquelles un 1 est codé par un trou dans le papier et un 0 par une absence de trou. Les programmes étaient exécutés par l'ordinateur quand on insérait la carte perforée dans le lecteur et qu'on appuyait sur un bouton.

[[File:German Museum of Technology, Berlin 2017 024.jpg|centre|vignette|upright=2|Réplique du Z1 au ''German Museum of Technology'' de Berlin, 2017.]]

Après sa destruction dans un bombardement, le Z1 a été reconstruit et amélioré, ce qui donné les deux ordinateurs Z2 et Z3. Ils étaient tous des ordinateurs dit '''électro-mécaniques''', car ils mélangeaient des composants électroniques et des composants mécaniques (tout ce qui a trait aux cartes perforées, notamment). Les composants électroniques étaient soit des relais, soit des tubes à vides, les deux étant des interrupteurs commandables électriquement plus ou moins équivalents aux transistors. Les ordinateurs d'avant l'année 1944, étaient tous de ce type. Quelques ordinateurs des années 50 étaient de ce type, mais leur nombre n'a pas dépassé 30. Il faut dire qu'ils ont rapidement laissé la place à des ordinateurs purement électroniques, que nous allons voir dans ce qui suit..

===Les premières générations : des ordinateurs qui prenaient des pièces de bâtiment entières===

Les ordinateurs qui ont suivi les ordinateurs électromécaniques sont regroupés dans la '''première génération d'ordinateur'''. Ils étaient conçus avec des tubes à vide, ce qui les place entre les premiers ordinateurs électro-mécaniques et les ordinateurs utilisant des transistors. Les ordinateurs de première génération étaient très simples, ils ne géraient que quelques opérations simples : l'addition, la soustraction, pas grand chose de plus. A quelques exceptions près, ils ne géraient pas la multiplication et encore moins la division, ils n'avaient pas assez de relais ou de tubes à vides à disposition pour cela.

Mais c'est l'arrivée de l'ENIAC en 1945 qui a changé la donne. Cet ordinateur a introduit plusieurs innovations majeures. La première est assez technique, il s'agit de la turing-complétude, et a trait aux programmes qui peuvent être écrit pour un ordinateur. Nous ne la détaillerons pas ici. La seconde innovation est que l'ENIAC était composé non pas de relais et d'éléments mécaniques, mais uniquement de tubes à vides, des composants électroniques assez rudimentaires plus ou moins équivalents aux transistors modernes.

Le ''Manchester Baby'' a introduit une innovation extrêmement importante, au point où on considère que c'est le premier ordinateur à avoir tous les critères nécessaires pour être appelé un ordinateur. Son innovation est que le programme n'était plus mémorisé sur des cartes perforée, mais dans une mémoire électronique dans l'ordinateur lui-même. En clair, le ''Manchester Baby'' était le premier '''''Stored-program computer''''', ordinateur à programme enregistré en français. 

[[File:IBM 7070.jpg|vignette|Cartes imprimées de l'IBM 704, avec des transistors et résistances dessus.]]

La '''seconde génération''' est celle des ordinateurs fabriqués avec des '''transistors''' isolés, reliés entre avec des fils électriques. Les transistors en question possèdent trois broches, des pattes métalliques sur lesquelles on connecte des fils électriques. Le transistor s'utilise le plus souvent comme un interrupteur commandé par sa troisième broche. Le courant qui traverse les deux premières broches passe ou ne passe pas selon ce qu'on met sur la troisième.

[[File:Transistor basic flow.svg|centre|vignette|Un transistor est un morceau de conducteur, dont la conductivité est contrôlée par sa troisième broche/borne.]]

Les ordinateurs de seconde génération avaient entre 1000 et 500 000 transistors. Les capacités des ordinateurs étaient donc nettement supérieures à celles des ordinateurs de première génération. Une part non négligeable des ordinateurs de seconde génération supportait l'opération de multiplication, absente sur les ordinateurs de première génération. Néanmoins, cela variait beaucoup selon les ordinateurs.

Un exemple assez hors du commun est celui du premier modèle de l'IBM 1620. Le tout premier modèle n'avait aucun circuit de calcul, il n'était même pas capable de faire une addition ou une multiplication. A la place, il utilisait une table d'addition et une table de multiplication en mémoire RAM. Les deux tables devaient être initialisées par le logiciel lors du démarrage de la machine. La table d'addition faisait une centaine de chiffre, la table de multiplication faisait le double. Le processeur de l'ordinateur gérait des instructions pour faire des additions ou des multiplications, mais ces opérations lisaient le résultat dans la table d'addition. Les calculs étaient fait chiffre par chiffre, avec un encodage partiellement décimal, partiellement binaire (des chiffres décimaux étaient encodés en binaire, nous en reparlerons quand nous parlerons du BCD) !

[[File:KL CoreMemory.jpg|vignette|Mémoire à tore de ferrite.]]

Les transistors n'étaient utilisés que pour le processeur et les circuits annexes. La mémoire n'était pas faite en transistors, pas à cette époque. La mémoire était une mémoire aujourd'hui abandonnée, appelée une '''mémoire à tores de ferrite'''. Elle sera détaillée dans un chapitre ultérieur. Mais sachez pour le moment qu'il s'agit d'une mémoire au support magnétique, les données étant stockées sur un support magnétique.

Transistors comme tubes à vide prenaient beaucoup de place, ce qui fait que les ordinateurs étaient assez gros. Concrètement, ils prenaient une pièce de bâtiment entière dans le meilleur des cas. C'était l'époque des gros ''mainframes'', reliés à des terminaux, peu puissants comparé aux standards actuels. Seules les grandes entreprises et les grands instituts de recherche pouvaient se payer les services de ce genre d'ordinateurs. Seuls les professionnels avaient accès à ce genre d'équipement.

===La troisième génération : le circuit intégré===

[[File:D8259AC-2.jpg|vignette|Exemple de circuit intégré.]]

La troisième génération est toujours fabriquée avec des transistors, mais dont la taille a été réduite. Avec l'évolution de la technologie, les transistors ont diminué en taille, de plus en plus. Ils sont devenus tellement petits qu'ils ont finit par être regroupés dans des '''circuits intégrés''', des circuits regroupent plusieurs transistors sur la même puce de silicium. Les circuits intégrés se présentent le plus souvent sous la forme de boitiers rectangulaires, comme illustré ci-contre. D'autres ont des boitiers de forme carrées, comme ceux que l'on peut trouver sur les barrettes de mémoire RAM, ou à l'intérieur des clés USB/ disques SSD.

Lors de cette génération, les processeurs étaient fournis en pièces détachées qu'il fallait relier entre elles. Le processeur était composé de plusieurs circuits intégrés séparés, impossible de mettre un processeur dans un seul boitier. Un exemple de processeur conçu en kit est la série des Intel 3000. Elle regroupe plusieurs circuits séparés aux noms à coucher dehors, mais dont vous comprendrez ce qu'ils veulent dire dans les chapitres adéquats : l'Intel 3001 est un séquenceur, l'Intel 3002 regroupe unité de calcul et registres, le 3003 est un circuit d'anticipation de retenue complémentaire du 3002, le 3212 est une mémoire tampon, le 3214 est une unité de gestion des interruptions, les 3216/3226 sont des interfaces de bus mémoire. On pourrait aussi citer la famille de circuits intégrés AMD Am2900.

Même si le processeur était en pièce détachées, utiliser une dizaine de circuits intégrés était nettement mieux que d'utiliser plusieurs milliers de transistors individuels. En conséquence, les ordinateurs ont vu leur taille grandement réduite, passant de pièces entières à une simple armoire, voire à quelques cartes intégrées superposées. De plus, le prix des circuits intégré était abordable, du moins comparé aux ordinateurs d'avant. Le prix des ordinateurs a alors grandement décru, permettant à des entreprises et administrations de taille modeste de s'équiper d'ordinateurs.

===La quatrième génération : le microprocesseur===

[[File:MOS6502.svg|vignette|Microprocesseur, ici un processeur MOS6502, de la quatrième génération.]]

Lors de la troisième génération, les circuits intégrés regroupaient plusieurs dizaines ou centaines de transistors, mais sont rapidement montés en gamme. De centaines de transistors, ils sont passé au milliers de transistors, puis au millions et maintenant au-delà du milliard. Les transistors étaient devenus tellement petits, tellement miniaturisés, qu'il était devenu possible de mettre un processeur entier dans un circuit intégré. C'est ainsi qu'est né le microprocesseur, à savoir un processeur qui tient tout entier dans un seul circuit imprimé. La quatrième génération d’ordinateur est celle des ordinateurs basés autour d'un microprocesseur.

Les tout premiers microprocesseurs étaient des processeurs à application militaire, comme le processeur du F-14 CADC ou celui de l'Air data computer. Le tout premier microprocesseur commercialisé au grand public est le 4004 d'Intel, sorti en 1971. L'intel 4004 comprenait environ 2300 transistors, avait une fréquence de 740 MHz, pouvait faire 46 opérations différentes, et manipulait des entiers de 4 bits. Il était au départ un processeur de commande, prévu pour être intégré dans la calculatrice Busicom calculator 141-P, mais il fut utilisé pour d'autres applications quelque temps plus tard. Immédiatement après le 4004, les premiers microprocesseurs 8 bits furent commercialisés. Le 4004 fut suivi par le 8008 et quelques autres processeurs 8 bits extrêmement connus, comme le 8080 d'Intel, le 68000 de Motorola, le 6502 ou le Z80.

Les microprocesseurs permirent encore uen fois de réduire la taille des ordinateurs, qui pouvaient tenir dans un boitier de PC, ou un boitier de console de jeu. Le prix des ordinateurs a aussi chuté en même temps que les transistors était miniaturisés. C'est cette invention qui permis l'invention des consoles de jeux et des mini-ordinateurs, à savoir les ordinateurs personnels. Sans miniaturisation, on n'aurait pas d'ordinateur personnel, pas de PC fixe ou portable.

==L'organisation du cours : les différents niveaux d'explication==

Le fonctionnement d'un ordinateur est assez complexe à expliquer car les explications peuvent se faire sur plusieurs niveaux. Par plusieurs niveaux, on veut dire qu'un ordinateur est composé de composants très simples, qui sont assemblés pour donner des composants eux-même plus complexes, qui sont eux-même regrouper, etc. Étudier tout cela demande de voir plusieurs niveaux, allant de transistors très petits à des processeurs multicœurs. Les niveaux les plus bas sont de l'électronique pur et dure, alors que ceux plus haut sont à mi-chemin entre électronique et informatique.

===Les niveaux d'abstraction en architecture des ordinateurs===

Les trois premiers niveaux sont de l'électronique pur et dure. Ils correspondent aux premiers chapitres du cours, qui porteront sur les circuits électroniques en général.
* Le premier niveau est celui des '''transistors''', des circuits intégrés, des ''wafer'' et autres circuits de très petite taille.
* Le second niveau est celui des '''portes logiques''', des circuits très basiques, très simples, à la base de tous les autres.
* Le troisième niveau est celui dit de la '''''Register Transfer Level''''', où un circuit électronique est construit à partir de circuits basiques, dont des registres et autres circuits dits combinatoires.
Les deux niveaux suivants sont de l'informatique proprement dit. C'est dans ces deux niveaux qu'on étudie les ordinateurs proprement dit, les circuits qu'il y a dedans et non l'électronique en général.
* Le quatrième niveau est celui de la '''microarchitecture''', qui étudie ce qu'il y a à l'intérieur d'un processeur, d'une mémoire, des périphériques et autres.
* Le cinquième niveau est celui de l''''architecture externe''', qui décrit l'interface du processeur, de la mémoire, d'un périphérique ou autre. Par décrire l'interface, on veut dire : comment un programmeur voit le processeur et la mémoire, comment il peut les manipuler. Une architecture externe unique peut avoir plusieurs microarchitecture, ce qui fait qu'on sépare les deux. Tout cela sera plus clair quand on passera aux chapitres sur le processeur et les mémoires.

Nous n'allons pas voir les 5 niveaux dans l'ordre, des transistors vers l'architecture externe. En réalité, nous allons procéder autrement. La première partie du cours portera sur les trois premiers niveaux, le reste sur les deux autres. Les 5 niveaux seront vus dans des chapitres séparés, du moins le plus possible. Au niveau pédagogique, tout est plus simple si on scinde les 5 niveaux. Bien sûr, il y a quelques explications qui demandent de voir plusieurs niveaux à la fois. Par exemple, dans le chapitre sur les mémoires caches, nous auront des explications portant sur la RTL, la microarchitecture du cache et son architecture externe. Mais le gros du cours tentera de séparer le plus possible les 5 niveaux.

===Les trois parties principales du cours===

Nous allons commencer par parler du binaire, avant de voir les portes logiques. Avec ces portes logiques, nous allons voir comment fabriquer des circuits basiques qui reviendront très souvent dans la suite du cours. Nous verrons les registres, les décodeurs, les additionneurs et plein d'autres circuits. Puis, nous reviendrons au niveau des transistors pour finir la première partie. La raison est que c'est plus simple de faire comme cela. Tout ce qui a trait aux transistors sert à expliquer comment fabriquer des portes logiques, et il faut expliquer les portes logiques pour voir le niveau de la RTL.

Une fois la première partie finie, nous allons voir les différents composants d'un ordinateur. Une première partie expliquera ce qu'il y a dans un ordinateur, quels sont ses composants. Nous y parlerons de l'architecture de base, de la hiérarchie mémoire, des tendances technologiques, et d'autres généralités qui serviront de base pour la suite. Puis, nous verrons dans l'ordre les bus électroniques, les mémoires RAM/ROM, le processeur, les périphériques, les mémoires de stockage (SSD et disques durs) et les mémoires caches. Pour chaque composant, nous allons voir leur architecture externe, avant de voir leur microarchitecture. La raison est que la microarchitecture ne peut se comprendre que quand on sait quelle architecture externe elle implémente.

Enfin, dans une troisième partie, nous allons voir les optimisations majeures présentes dans tous les ordinateurs modernes, avec une partie sur le pipeline et le parallélisme d'instruction, et une autre sur les architectures parallèles. Pour finir, les annexes de fin parlerons de sujets un peu à part.

&lt;noinclude&gt;
{{NavChapitre | book=Fonctionnement d'un ordinateur
           | next=L'encodage des données
           | nextText=L'encodage des données
}}
&lt;/noinclude&gt;</text>
      <sha1>esmvone9u7foaybfjvueoq2bv0ardel</sha1>
    </revision>
    <revision>
      <id>744111</id>
      <parentid>744110</parentid>
      <timestamp>2025-06-04T21:10:09Z</timestamp>
      <contributor>
        <username>Mewtow</username>
        <id>31375</id>
      </contributor>
      <minor />
      <comment>/* Les ordinateurs électro-mécaniques : les premiers ordinateurs */</comment>
      <origin>744111</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="42311" sha1="1y6u2mfmgf5zja24n2wef64qrucswxu" xml:space="preserve">Pour commencer, nous allons voir qu'il existe de nombreux types d'ordinateurs. Le plus connu est certainement le PC, l'ordinateur personnel, que vous avez sans doute dans votre salon. Les ordinateurs portables sont un deuxième type d'ordinateur assez intuitif, que vous avez peut-être. Mais il y a aussi d'autres types d'ordinateurs auxquels vous n'avez jamais été confrontés.

==Les différents types d'ordinateurs==

Dans cette section, nous allons décrire rapidement les ordinateurs les plus courant, mais surtout voir ce qu'il y a à l'intérieur d'un ordinateur.

===L'ordinateur de type PC fixe===

De l'extérieur, l'ordinateur est composé d'une unité centrale sur laquelle on branche des périphériques.

[[File:Typical computer architecture systems.jpg|vignette|upright=1.5|Exemples de périphériques, connectés à une unité centrale (ici appelée à tort ''operating system'').]]

Les '''périphériques''' regroupent l'écran, la souris, le clavier, l'imprimante, et bien d'autres choses. Ils permettent à l'utilisateur d'interagir avec l'ordinateur : un clavier permet de saisir du texte sous dans un fichier, une souris enregistre des déplacements de la main en déplacement du curseur, un écran affiche des données d’images/vidéos, un haut-parleur émet du son, etc. Tout ce qui est branché sur un ordinateur est, formellement un périphérique.

L''''unité centrale''' est là où se trouvent tous les composants importants d'un ordinateur, ceux qui font des calculs, qui exécutent des logiciels, qui mémorisent vos données, etc. Voici ce à quoi ressemble l'intérieur de l'unité centrale. Trois sections sont visibles : l'alimentation électrique en haut à gauche, la carte mère en bas à gauche et en jaune/orange, les disques et lecteurs à droite des câbles. Et on voit aussi beaucoup de câbles.

[[File:Asus P5K-SEIntel E6320.jpg|centre|vignette|upright=2|Exemple d'unité centrale.]]

Tout en haut à gauche, se trouve l''''alimentation électrique''', qui convertit le courant de la prise électrique en un courant plus faible, utilisable par les autres composants. Elle émet de nombreux câbles assez gros, qui sont reliés au reste. Les PC actuels utilisent des alimentations électriques standardisées, qui fournissent trois tensions au reste de l'ordinateur : une tension de 12 Volts, une de 5 Volts, une de 3,3 Volts.

À droite, caché par la partie &quot;métallique&quot; du boitier, se trouvent les lecteurs de CD/DVD, et les disques durs. Les lecteurs CD-ROM ou DVD-ROM permettaient de lire des CD ou des DVD. Je parle au passé, car ils ont aujourd'hui disparu des ordinateurs modernes. Les '''disques durs''' sont des mémoires de stockage, qui mémorisent vos données de manière permanente. De nos jours, ils sont remplacés par des SSD, qui sont des disques durs électroniques, là où les disques durs proprement dit sont des mémoires magnétiques. Nous verrons la différence dans deux chapitres dédiés, un sur les disques durs, l'autre sur les SSD.

En bas à droite, se trouve la '''carte mère''' un support plat, en plastique ou en céramique, sur laquelle sont soudés/connectés les autres composants. Sur celle-ci, de nombreux composants sont soudés, d'autres sont branchés dessus avec des câbles, d'autres sont connectés dessus avec des connecteurs. Ils sont reliés entre eux par des fils conducteurs, le plus souvent du cuivre ou de l’aluminium, ce qui leur permet de s’échanger des données. Sur les cartes simples, ces fils sont intégrés dans la carte électronique, dans des creux du plastique. Ils portent le nom de pistes.

Avant, les disques durs, SSD et lecteurs de CD/DVD sont branchés dessus via des connecteurs dédiés, appelés des connecteurs S-ATA. De nos jours, ils sont branchés sur un autre connecteur, grâce à l'interface NVME. Toujours est-il qu'ils sont reliés à la carte mère par des câbles, ce qui montre que ce sont des sortes de périphériques interne. Ils sont placés dans le boitier, mais on aurait tout aussi bien pu les mettre à l'extérieur, vu qu'ils communiquent avec l'ordinateur par l'intermédiaire d'un câble ou d'un connecteur dédié.

Mais deux autres composants très importants sont eux placés sur la carte mère, directement. Ils ont chacun un connecteur dédié, sur lequel ils sont branchés directement, sans passer par l'intermédiaire d'un câble, mais sans être soudés non plus. Il s'agit du processeur et de la mémoire RAM, deux composants centraux des PC modernes.

[[File:Pentium III SL4CB.jpg|thumb|Processeur Pentium III.]]

Le '''processeur''' traite les données, les modifie, les manipule. Pour faire simple, il s’agit d’une grosse calculatrice hyper-puissante. Il comprend à la fois un circuit qui fait des calculs, et un circuit de contrôle qui s'occupe de séquencer les calculs dans l'ordre demandé. Il est souvent caché sous un radiateur, lui-même surmonté par un ventilateur. En effet, un processeur chauffe beaucoup, ce qui demande d'évacuer cette chaleur. Un chapitre entier expliquera pourquoi les processeurs chauffent, ainsi que les techniques utilisées pour limiter leur production de chaleur et leur consommation électrique.

La '''mémoire vive''' conserve des informations/données temporairement, tant que le processeur en a besoin. Elle prend la forme de barrettes de RAM, comme montré ci-dessous.

[[File:2 gb ddr2 667.jpg|centre|vignette|upright=2|Barrette de RAM.]]

Outre ces composants dits principaux, un ordinateur peut comprendre plusieurs composants moins importants, surtout présents sur les ordinateurs personnels. Ils sont techniquement facultatifs, mais sont très présents dans les ordinateurs personnels. Cependant, certains ordinateurs spécialisés s'en passent. Il s'agit des diverses '''cartes d'extension''' sont branchées sur la carte mère. Elles permettent d’accélérer certains calculs ou certaines applications, afin de décharger le processeur. Par exemple, la carte graphique s'occupe des calculs graphiques, qu'il s'agisse de graphismes 3D de jeux vidéos ou de l'affichage en 2D du bureau. Dans un autre registre, la carte son prend en charge le microphone et les haut-parleurs.

[[Fichier:Personal computer, exploded 4.svg|thumb|upright=1.0|Éclaté d'un ordinateur de type PC :&lt;br /&gt;
1 : Écran ;&lt;br /&gt;
2 : Carte mère ;&lt;br /&gt;
3 : Processeur ;&lt;br /&gt;
4 : Câble Parallel ATA ;&lt;br /&gt;
5 : Mémoire vive (RAM) ;&lt;br /&gt;
6 : Carte d'extension ;&lt;br /&gt;
7 : Alimentation électrique ;&lt;br /&gt;
8 : Lecteur de disque optique ;&lt;br /&gt;
9 : Disque dur ;&lt;br /&gt;
10 : Clavier ;&lt;br /&gt;
11 : Souris.]]

Si on regarde une carte mère de face, on voit un grand nombre de connecteurs, mais aussi des circuits électroniques soudés à la carte mère.

[[File:Architecture matérielle d'une carte mère.png|centre|vignette|upright=2.0|Architecture matérielle d'une carte mère]]

Les '''connecteurs''' sont là où on branche les périphériques, la carte graphique, le processeur, la mémoire, etc. Dans l'ensemble, toute carte mère contient les connecteurs suivants :
* Le processeur vient s’enchâsser dans la carte mère sur un connecteur particulier : le '''socket'''. Celui-ci varie suivant la carte mère et le processeur, ce qui est source d'incompatibilités.
* Les barrettes de mémoire RAM s’enchâssent dans un autre type de connecteurs: les '''slots mémoire'''.
* Les mémoires de masse disposent de leurs propres connecteurs : connecteurs P-ATA pour les anciens disques durs, et S-ATA pour les récents.
* Les périphériques (clavier, souris, USB, Firewire, ...) sont connectés sur un ensemble de connecteurs dédiés, localisés à l'arrière du boitier de l'unité centrale. 
* Les autres périphériques sont placés dans l'unité centrale et sont connectés via des connecteurs spécialisés. Ces périphériques sont des cartes imprimées, d'où leur nom de '''cartes filles'''. On peut notamment citer les cartes réseau, les cartes son, ou les cartes vidéo.

===Les ordinateurs portables===

[[File:Samsung QX-511 (2).JPG|vignette|Ordinateur portable Samsung QX-511 (2), pour illustration.]]

Un ordinateur portable est identique à un ordinateur de type PC. Si vous ouvrez votre ordinateur portable (attention à la garantie), vous retrouverez les mêmes composants qu'un PC à l'intérieur. Un point important est la présence d'une batterie à l'intérieur du PC portable, absente des PC fixes.

[[File:LG gram 14Z90Q mainboard with battery.jpg|centre|vignette|upright=2|LG gram 14Z90Q avec sa batterie.]]

Une fois la batterie et les circuits associés retiré, la seule différence notable est que tous les composants sont soudés sur la carte mère, au lieu d'être branchés sur des connecteurs, à part éventuellement la RAM et le disque dur.

[[File:LG gram 14Z90Q mainboard without battery.jpg|centre|vignette|upright=2|LG gram 14Z90Q sans sa batterie.]]

La RAM est parfois soudée sur la carte mère, d'autres fois sous la forme de barrettes de mémoire vive semblables à celles des PC. Dans le dernier cas, elle est connectée à des connecteurs spécifiques, ce qui permet de les changer/upgrader. Les PC portables sont parfois construits de manière à pouvoir changer la RAM facilement, en ouvrant un cache spécial, concu pour.

[[File:Lenovo G555 состав - Донор.JPG|centre|vignette|upright=2|Lenovo G555.]]

La conception d'un ordinateur portable est légèrement différente de celle d'un PC, pour des raisons thermiques. Un PC fixe a plus de place pour évacuer sa chaleur. Les ventilateurs peuvent plus facilement déplacer l'air dans le boitier, même si le flux d'air dans le boitier est éventuellement gêné par la carte graphique. Mais l'évacuation de la chaleur est assez efficace. Sur les PC portables, leur finesse fait que le trajet de l'air est beaucoup plus contraint. Évacuer la chaleur produite par l'ordinateur est plus complexe, ce qui demande d'utiliser des systèmes de refroidissement et de ventilation spécifiques.

Là où les PC fixes se débrouillent avec des radiateurs et des ventilateurs posés sur le processeur, les PC portables font autrement. Ils ne peuvent pas forcément mettre le ventilateur sur le processeur. A la place, ils mettent le ventilateur à côté, mais le processeur est surmonté par un mécanisme de transmission de la chaleur, qui transfère la chaleur du processeur vers le ventilateur.

[[File:Diagram - How a laptop cooling system works.png|centre|vignette|upright=2|Comment fonctionne le système de ventilation d'un ordinateur portable, en anglais.]]

Les difficultés pour dissiper la chaleur font que les ordinateurs portables utilisent souvent des composants peu performants, mais qui chauffent peu. En effet, nous verrons que plus un composant est puissant, plus il chauffe. La relation n'est pas parfaite, mais les processeurs haute performance chauffent plus que les modèles d'entrée ou milieu de gamme moins puissants. En conséquence, les PC portables sont souvent moins puissants que les PC fixes, même pour les modèles dit ''gaming''.

===Les serveurs et ''mainframes''===

Les grandes entreprises utilisent des ordinateurs de grande taille, très puissants, appelés des ''mainframes''. Ils sont souvent confondus avec les serveurs par le grand public, il y a une différence entre les deux. Un serveur est une fonction logicielle/réseau, pas un type d'ordinateur. Mais laissons cette différence de côté, ce qui est dit pour les ''mainframes'' sert pour les gros serveurs haute performance.

[[File:IBM Z15 mainframe.jpg|vignette|Exemple de ''mainframe''' de type IBM Z15.]]

Les anciens ''mainframes'' des années 50-80 avaient une taille pouvant être impressionnante, au point de prendre une pièce complète d'un bâtiment. Mais de nos jours, les ''mainframes'' tiennent dans une grosse armoire un peu haute. Les ''mainframes'' doivent rester allumé en permanence et ne doivent pas être éteint, sauf éventuellement quelques jours par an pour des opérations de maintenance. Ils utilisent pour cela des techniques spécifiques, avec beaucoup de redondance interne.

[[File:ACONIT hall grandes machines.jpg|centre|vignette|upright=2|''Mainframe'' ACONIT.]]

Les ''mainframes'' sont aussi conçus pour mutualiser au maximum leur utilisation, ils peuvent être utilisés par plusieurs utilisateurs à la suite, voire en même temps. Pour cela, les anciens ''mainframes'' étaient capables de faire tourner plusieurs applications distinctes l'une à la suite de l'autre, avec des commutations fréquentes entre logiciels. De nos jours, ils sont capables d'exécuter un grand nombre de tâches en même temps, grâce à la présence de plusieurs processeurs. Les ''mainframes'' modernes sont même capables de faire tourner plusieurs systèmes d'exploitation en même temps si besoin.

Les anciens ''mainframes'' étaient des ordinateurs assez simples, avec un processeur, de la mémoire RAM, un ou plusieurs disques durs, pas plus. Le ''mainframe'' était tellement énorme et cher que les entreprises n'en avaient qu'un seul pour toute l'entreprise. Les employés avaient sur leur bureau des terminaux, qui permettaient d'accéder à l'ordinateur central, mais n'étaient pas des ordinateurs. Les terminaux étaient des composants électroniques simples, avec un écran, un clavier et une souris, mais sans processeur. Ils envoyaient des données au ''mainframe'', ils en recevaient de sa part, mais tout traitement était réalisé sur le ''mainframe''. L'arrivée sur le marché des ordinateurs personnels, de type PC fixe/portable, a entrainé l'abandon de ce genre de pratique, tous les employés ont maintenant un ordinateur rien que pour eux.

{|
|-
! colspan=&quot;2&quot; | Exemples de terminaux
|-
|[[File:Terminal-in2-sm9400.jpg|centre|vignette|upright=1.5|Exemple de terminal. Notez la présence d'un écran et d'un clavier, mais l'asbence d'une unité centrale.]]
|[[File:Chromatics CT4100.jpg|vignette|upright=1.5|Autre exemple de terminal. Le clavier est couplé à un stylo CRT, qui remplacait la souris et agissait sur l'écran comme s'il était tactile.]]
|-
! colspan=&quot;2&quot; | Intérieur d'un terminal
|-
|[[File:CT1024 Monitor.jpg|vignette|upright=1.5|Terminal CT1024, sans le boitier extérieur.]]
|[[File:CT1024 Terminal System.jpg|vignette|upright=1.5|Terminal CT1024, description des composants interne.]]
|}

De nos jours, les ''mainframes'' contiennent en réalité plusieurs ordinateurs simples interconnectés via un réseau local. Un ''mainframe'' qui tient dans une armoire contient facilement une dizaine ou centaine de processeurs, plein de RAM, des disques durs séparés dans une armoire distincte, etc. Vu qu'ils communiquent uniquement via le réseau, ils n'ont pas d'interface, pas d'écran, 'entrée via clavier/souris. Le tout est commandé avec une console de commande, typiquement un ordinateur portable ou un terminal assez simple séparé de l'armoire, qui permet à un administrateur de faire des opérations de surveillance, configuration et maintenance. Il peut y avoir une console de commande pour plusieurs armoires séparées, la console peut même être dans un autre bâtiment et accéder au ''mainframe'' par le réseau.

[[File:IBM System Z9 (type 2094 inside).jpg|centre|vignette|upright=2|''Mainframe'' de type IBM System Z9. L'ordinateur portable sert de console pour qu'un administrateur fasse des opérations de surveillance, configuration et maintenance.]]

Les processeurs et la RAM sont typiquement installés sur des cartes amovibles, qui sont connectées au fond de l'armoire lors de l'installation. Il est même possible de retirer ou d'ajouter des cartes en fonctionnement, afin d'ajouter/retirer des processeurs, des disques durs, etc. Ce qui est très utile si un composant est en panne et qu'il faut le remplacer. 

[[File:IBM TotalStorage Exp400.jpg|centre|vignette|upright=2|IBM TotalStorage Exp400]]

==Un peu d'abstraction : qu'est-ce qu'un ordinateur ?==

Un ordinateur comprend donc un processeur, plusieurs mémoires, des cartes d'extension et une carte mère pour connecter le tout. Mais il s'agit là d'une description assez terre-à-terre de ce qu'est un ordinateur. Une autre description, plus abstraite, se base sur le fait qu'un ordinateur est une énorme calculatrice programmable. Elle permet d'expliquer pourquoi il y a une distinction entre processeur et mémoire, entre unité centrale et périphériques. Tout ce qui va suivre pourra vous paraitre assez abstrait, mais rassurez-vous : les prochains chapitres rendront tout cela plus concrets.

===La séparation entre entrées-sorties et traitement===

L'unité centrale peut être vue comme une énorme calculatrice ultra-puissante, qui exécute des commandes/opérations. Mais à elle seule, elle ne servirait à rien, il faut interagir avec par l'intermédiaire de plusieurs périphériques. Il existe deux types de périphériques, qui sont conceptuellement différents. Les périphériques comme le clavier ou la souris permettent d'envoyer des informations à l'ordinateur, d'agir sur celui-ci. A l'inverse, les écrans transmettent des informations dans le sens inverse : de l'ordinateur vers l'utilisateur. Les premiers sont appelés des '''entrées''', les seconds des '''sorties'''.

Dans un ordinateur, les informations sont représentées sous la forme de nombres. Toute donnée dans un ordinateur est codée avec un ou plusieurs nombres regroupés dans une donnée, un fichier, ou autre. Et la transmissions avec les entrées et sorties se fait là-encore avec des nombres. Par exemple, quand vous appuyez sur votre clavier, le clavier envoie un numéro de touche à l'unité centrale, qui indique quelle touche a été appuyée. L'image à afficher à l'écran est codée sous la forme d'une suite de nombres (un par pixel). L'image est envoyée à l'écran, qui traduit la suite de nombre en image à afficher. Les entrées traduisent des actions utilisateurs en nombres, on dit que les entrées encodent les actions utilisateur. Les sorties font la traduction inverse, elles transforment des suites de nombres en une action physique. On dit qu'elles décodent des informations.

Pour résumer, toute appareil électronique est composé par :
* Des '''entrées''' sur lesquelles l'utilisateur agit sur l'ordinateur. Les entrées transforment les actions de l'utilisateur en nombres, qui sont interprétés par l'ordinateur.
* Une '''unité de traitement''', qui manipule des nombres et fait des calculs/opérations dessus. Les nombres proviennent des entrées, du disque dur, ou d'autres sources, peu importe.
* Des '''sorties''', qui va récupèrent le résultat calculé par l'unité de traitement pour en faire quelque chose : écrire sur une imprimante ou sur un moniteur, émettre du son,...

[[File:Ordinateur théorique Simple 1.png|centre|vignette|upright=2|Ordinateur théorique Simple 1]]

L'unité de traitement proprement dite, celle qui fait les calculs, est couplée à une mémoire qui mémorise les opérandes et résultats des calculs. La séparation entre processeur et mémoire est nécessaire pour qu'un appareil électronique soit qualifié d'ordinateur. De nombreux appareils n'ont pas de séparation entre unité de traitement et mémoire, comme certaines vielles radios AM/FM.

[[File:Schéma de principe d'un ordinateur.png|centre|vignette|upright=2|Schéma de principe d'un ordinateur]]

===Un ordinateur est un appareil programmable===

Les appareils simples sont non-programmables, ce qui veut dire qu’ils sont conçus pour une utilisation particulière et qu’ils ne peuvent pas faire autre chose. Par exemple, les circuits électroniques d’un lecteur de DVD ne peuvent pas être transformé en lecteur audio ou en console de jeux... Les circuits non-programmables sont câblés une bonne fois pour toute, et on ne peut pas les modifier. On peut parfois reconfigurer le circuit, pour faire varier certains paramètres, via des interrupteurs ou des boutons, mais cela s’arrête là. Et cela pose un problème : à chaque problème qu'on veut résoudre en utilisant un automate, on doit recréer un nouveau circuit.

À l'inverse, un ordinateur n’est pas conçu pour une utilisation particulière, contrairement aux autres objets techniques. Il est possible de modifier leur fonction du jour au lendemain, on peut lui faire faire ce qu’on veut. On dit qu'ils sont '''programmables'''. Pour cela, il suffit d’utiliser un logiciel, une application, un programme (ces termes sont synonymes), qui fait ce que l'on souhaite. La totalité des logiciels présents sur un ordinateur sont des programmes comme les autres, même le système d'exploitation (Windows, Linux, ...) ne fait pas exception.

Un programme est une suite de d'instructions, chaque instruction effectuant une action dans l'ordinateur. Sur les ordinateurs modernes, la majorité de ces instructions effectuent une opération arithmétique, comme une addition, une multiplication, une soustraction, etc. Les ordinateurs modernes sont donc de grosses calculettes très puissantes, capables d'effectuer des millions d'opérations par secondes. Et qui dit opération dit nombres : un ordinateur gère nativement des nombres, qui sont codés en binaire sur la quasi-totalité des ordinateurs modernes.

Une instruction est représentée dans un ordinateur par une série de nombres : un nombre qui indique quelle opération/commande effectuer et des autres nombres pour coder les données (ou de quoi les retrouver dans l'ordinateur). L'ordinateur récupére les commandes une par une, les traduit en opération à effectuer, exécuter l'opération, et enregistre le résultat. Puis il recommence avec la commande suivante.

[[File:Ordinateur Théorique Complexe 1.png|centre|vignette|upright=3|Ordinateur Théorique Complexe. En jaune, le programme informatique, la liste de commande. Le rectangle gris est l'ordinateur proprement dit.]]

De nombreux appareils sont programmables, mais tous ne sont pas des ordinateurs. Par exemple, certains circuits programmables nommés FPGA n'en sont pas. Pour être qualifié d'ordinateur, un appareil programmable doit avoir un processeur séparé de la mémoire. De plus, il doit utiliser un '''codage numérique''', chose que nous allons aborder dans le chapitre suivant.

===Les ordinateurs à programme mémorisé ou programme externe===

Au tout début de l'informatique, on utilisait des cartes perforées en plastique, sur lesquelles on inscrivait le programme à exécuter, les données à traiter, bref : tout ce qu'on donnait à manger à l'ordinateur. Par la suite, les premiers ordinateurs grand public, comme les Amstrad ou les Commodore, utilisaient des cassettes audio magnétiques pour stocker les programmes. Dans le même style, les consoles de jeu utilisaient autrefois des cartouches de jeu, qui contenaient le programme du jeu à exécuter. Pour résumer, les anciens ordinateurs mémorisaient les programmes sur un support externe, lu par un périphérique. De tels ordinateurs sont dits à '''programme externe'''.

: D’anciens ordinateurs personnels, comme l’Amstrad ou le Commodore, permettaient de taper les programmes à exécuter à la main, au clavier, avant d’appuyer une touche pour les exécuter. Nul besoin de vous dire que les cassettes audio étaient plus pratiques.

Mais de nos jours, les programmes sont enregistrés sur le disque dur de l'ordinateur ou dans une mémoire intégrée à l'ordinateur. On dit qu'ils sont installés, ce qui est un mot bien compliqué pour dire que le programme est enregistré sur le disque dur de l’ordinateur. A défaut de disque dur, le programme/logiciel est enregistré dans une mémoire spécialisée pour le stockage. Par exemple, sur les cartes électroniques grand public de marque Arduino, les programmes sont envoyés à la carte via le port USB, mais les programmes sont enregistrés dans la carte Arduino, dans une mémoire FLASH dédiée. Disque dur ou non, le programme est mémorisé dans la mémoire de l'ordinateur. Il est possible d'installer ou de désinstaller les programmes en modifiant le contenu de la mémoire. Le terme utilisé est alors celui de '''programme stocké en mémoire'''.

Les programmes à installer sont disponibles soit sur un périphérique, comme un DVD ou une clé USB, soit sont téléchargés depuis internet. Les premiers PC fournissaient les logiciels sur des disquettes, qui contenaient un programme d'installation pour enregistrer le programme sur le disque dur de l'ordinateur. Par la suite, le support des logiciels a migré vers les CD et DVD, les logiciels devenant de plus en plus gros. De nos jours, la majorité des applications sont téléchargées depuis le net, l'usage de périphériques est devenu obsolète, même les consoles de jeu abandonnent cette méthode de distribution.

==Les générations d'ordinateurs : un historique rapide==

L'informatique a beaucoup évolué dans le temps. Et une bonne partie de cette évolution tient à l'évolution de l’électronique sous-jacente. Les ordinateurs actuels sont fabriqués avec des transistors, des petits composants électroniques qui servent d'interrupteur programmables, qu'on détaillera dans ce qui suit. Mais ça n'a pas toujours été le cas. Et cela permet de distinguer plusieurs '''générations d'ordinateurs'''.

===Les ordinateurs électro-mécaniques : les premiers ordinateurs===

Le tout premier ordinateur est le '''Z1''', un modèle unique inventé par Konrad Suze entre 1936 et 1938. Son processeur gérait non pas des nombres entiers, mais des nombres à virgule (des nombres dits flottants, pour être précis), encodés sur 22 bits. Le processeur du Z1 était capable de faire des additions et des soustractions, car il intégrait un circuit additionneur-soustracteur basique. Des circuits annexes permettaient de faire des multiplications et des divisions en enchainant des additions/soustractions successives. Il fonctionnait à une fréquence de 1 Hz, ce qui fait qu'il pouvait faire une addition/soustraction par seconde maximum.

[[File:Blue-punch-card-front.png|vignette|upright=0.5|Carte Perforée.]]

Niveau mémoire, la RAM de l'ordinateur était très limitée : seulement 16 nombres de 22 bits chacun. S'il s'agissait d'une mémoire électronique, les programmes étaient mémorisés sur une mémoire mécanique. Les programmes étaient enregistrés sur des cartes perforées, à savoir des cartes en papier dans lesquelles un 1 est codé par un trou dans le papier et un 0 par une absence de trou. Les programmes étaient exécutés par l'ordinateur quand on insérait la carte perforée dans le lecteur et qu'on appuyait sur un bouton.

[[File:German Museum of Technology, Berlin 2017 024.jpg|centre|vignette|upright=2|Réplique du Z1 au ''German Museum of Technology'' de Berlin, 2017.]]

Après sa destruction dans un bombardement, le Z1 a été reconstruit et amélioré, ce qui donné les deux ordinateurs Z2 et Z3. Quelques années plus tard, de nombreux ordinateurs ont été construits dans des laboratoires de recherche. Des grandes noms de l'histoire de l'informatique datent de cette époque : le Harvard Mark I et le Colossus Mark 1 (UK) ont tous deux été mis en service en 1944, par exemple. Ils ont servis pour les cryptanalystes pour casser les codes utilisés par les allemands pour leurs transmissions, pendant la seconde guerre mondiale.

Les ordinateurs cités dans le précédent paragraphe étaient tous des ordinateurs dit '''électro-mécaniques''', car ils mélangeaient des composants électroniques et des composants mécaniques (tout ce qui a trait aux cartes perforées, notamment). Les composants électroniques étaient soit des relais, soit des tubes à vides, les deux étant des interrupteurs commandables électriquement plus ou moins équivalents aux transistors. Les ordinateurs d'avant l'année 1944, étaient tous de ce type. Quelques ordinateurs des années 50 étaient de ce type, mais leur nombre n'a pas dépassé 30. Il faut dire qu'ils ont rapidement laissé la place à des ordinateurs purement électroniques, que nous allons voir dans ce qui suit..

===Les premières générations : des ordinateurs qui prenaient des pièces de bâtiment entières===

Les ordinateurs qui ont suivi les ordinateurs électromécaniques sont regroupés dans la '''première génération d'ordinateur'''. Ils étaient conçus avec des tubes à vide, ce qui les place entre les premiers ordinateurs électro-mécaniques et les ordinateurs utilisant des transistors. Les ordinateurs de première génération étaient très simples, ils ne géraient que quelques opérations simples : l'addition, la soustraction, pas grand chose de plus. A quelques exceptions près, ils ne géraient pas la multiplication et encore moins la division, ils n'avaient pas assez de relais ou de tubes à vides à disposition pour cela.

Mais c'est l'arrivée de l'ENIAC en 1945 qui a changé la donne. Cet ordinateur a introduit plusieurs innovations majeures. La première est assez technique, il s'agit de la turing-complétude, et a trait aux programmes qui peuvent être écrit pour un ordinateur. Nous ne la détaillerons pas ici. La seconde innovation est que l'ENIAC était composé non pas de relais et d'éléments mécaniques, mais uniquement de tubes à vides, des composants électroniques assez rudimentaires plus ou moins équivalents aux transistors modernes.

Le ''Manchester Baby'' a introduit une innovation extrêmement importante, au point où on considère que c'est le premier ordinateur à avoir tous les critères nécessaires pour être appelé un ordinateur. Son innovation est que le programme n'était plus mémorisé sur des cartes perforée, mais dans une mémoire électronique dans l'ordinateur lui-même. En clair, le ''Manchester Baby'' était le premier '''''Stored-program computer''''', ordinateur à programme enregistré en français. 

[[File:IBM 7070.jpg|vignette|Cartes imprimées de l'IBM 704, avec des transistors et résistances dessus.]]

La '''seconde génération''' est celle des ordinateurs fabriqués avec des '''transistors''' isolés, reliés entre avec des fils électriques. Les transistors en question possèdent trois broches, des pattes métalliques sur lesquelles on connecte des fils électriques. Le transistor s'utilise le plus souvent comme un interrupteur commandé par sa troisième broche. Le courant qui traverse les deux premières broches passe ou ne passe pas selon ce qu'on met sur la troisième.

[[File:Transistor basic flow.svg|centre|vignette|Un transistor est un morceau de conducteur, dont la conductivité est contrôlée par sa troisième broche/borne.]]

Les ordinateurs de seconde génération avaient entre 1000 et 500 000 transistors. Les capacités des ordinateurs étaient donc nettement supérieures à celles des ordinateurs de première génération. Une part non négligeable des ordinateurs de seconde génération supportait l'opération de multiplication, absente sur les ordinateurs de première génération. Néanmoins, cela variait beaucoup selon les ordinateurs.

Un exemple assez hors du commun est celui du premier modèle de l'IBM 1620. Le tout premier modèle n'avait aucun circuit de calcul, il n'était même pas capable de faire une addition ou une multiplication. A la place, il utilisait une table d'addition et une table de multiplication en mémoire RAM. Les deux tables devaient être initialisées par le logiciel lors du démarrage de la machine. La table d'addition faisait une centaine de chiffre, la table de multiplication faisait le double. Le processeur de l'ordinateur gérait des instructions pour faire des additions ou des multiplications, mais ces opérations lisaient le résultat dans la table d'addition. Les calculs étaient fait chiffre par chiffre, avec un encodage partiellement décimal, partiellement binaire (des chiffres décimaux étaient encodés en binaire, nous en reparlerons quand nous parlerons du BCD) !

[[File:KL CoreMemory.jpg|vignette|Mémoire à tore de ferrite.]]

Les transistors n'étaient utilisés que pour le processeur et les circuits annexes. La mémoire n'était pas faite en transistors, pas à cette époque. La mémoire était une mémoire aujourd'hui abandonnée, appelée une '''mémoire à tores de ferrite'''. Elle sera détaillée dans un chapitre ultérieur. Mais sachez pour le moment qu'il s'agit d'une mémoire au support magnétique, les données étant stockées sur un support magnétique.

Transistors comme tubes à vide prenaient beaucoup de place, ce qui fait que les ordinateurs étaient assez gros. Concrètement, ils prenaient une pièce de bâtiment entière dans le meilleur des cas. C'était l'époque des gros ''mainframes'', reliés à des terminaux, peu puissants comparé aux standards actuels. Seules les grandes entreprises et les grands instituts de recherche pouvaient se payer les services de ce genre d'ordinateurs. Seuls les professionnels avaient accès à ce genre d'équipement.

===La troisième génération : le circuit intégré===

[[File:D8259AC-2.jpg|vignette|Exemple de circuit intégré.]]

La troisième génération est toujours fabriquée avec des transistors, mais dont la taille a été réduite. Avec l'évolution de la technologie, les transistors ont diminué en taille, de plus en plus. Ils sont devenus tellement petits qu'ils ont finit par être regroupés dans des '''circuits intégrés''', des circuits regroupent plusieurs transistors sur la même puce de silicium. Les circuits intégrés se présentent le plus souvent sous la forme de boitiers rectangulaires, comme illustré ci-contre. D'autres ont des boitiers de forme carrées, comme ceux que l'on peut trouver sur les barrettes de mémoire RAM, ou à l'intérieur des clés USB/ disques SSD.

Lors de cette génération, les processeurs étaient fournis en pièces détachées qu'il fallait relier entre elles. Le processeur était composé de plusieurs circuits intégrés séparés, impossible de mettre un processeur dans un seul boitier. Un exemple de processeur conçu en kit est la série des Intel 3000. Elle regroupe plusieurs circuits séparés aux noms à coucher dehors, mais dont vous comprendrez ce qu'ils veulent dire dans les chapitres adéquats : l'Intel 3001 est un séquenceur, l'Intel 3002 regroupe unité de calcul et registres, le 3003 est un circuit d'anticipation de retenue complémentaire du 3002, le 3212 est une mémoire tampon, le 3214 est une unité de gestion des interruptions, les 3216/3226 sont des interfaces de bus mémoire. On pourrait aussi citer la famille de circuits intégrés AMD Am2900.

Même si le processeur était en pièce détachées, utiliser une dizaine de circuits intégrés était nettement mieux que d'utiliser plusieurs milliers de transistors individuels. En conséquence, les ordinateurs ont vu leur taille grandement réduite, passant de pièces entières à une simple armoire, voire à quelques cartes intégrées superposées. De plus, le prix des circuits intégré était abordable, du moins comparé aux ordinateurs d'avant. Le prix des ordinateurs a alors grandement décru, permettant à des entreprises et administrations de taille modeste de s'équiper d'ordinateurs.

===La quatrième génération : le microprocesseur===

[[File:MOS6502.svg|vignette|Microprocesseur, ici un processeur MOS6502, de la quatrième génération.]]

Lors de la troisième génération, les circuits intégrés regroupaient plusieurs dizaines ou centaines de transistors, mais sont rapidement montés en gamme. De centaines de transistors, ils sont passé au milliers de transistors, puis au millions et maintenant au-delà du milliard. Les transistors étaient devenus tellement petits, tellement miniaturisés, qu'il était devenu possible de mettre un processeur entier dans un circuit intégré. C'est ainsi qu'est né le microprocesseur, à savoir un processeur qui tient tout entier dans un seul circuit imprimé. La quatrième génération d’ordinateur est celle des ordinateurs basés autour d'un microprocesseur.

Les tout premiers microprocesseurs étaient des processeurs à application militaire, comme le processeur du F-14 CADC ou celui de l'Air data computer. Le tout premier microprocesseur commercialisé au grand public est le 4004 d'Intel, sorti en 1971. L'intel 4004 comprenait environ 2300 transistors, avait une fréquence de 740 MHz, pouvait faire 46 opérations différentes, et manipulait des entiers de 4 bits. Il était au départ un processeur de commande, prévu pour être intégré dans la calculatrice Busicom calculator 141-P, mais il fut utilisé pour d'autres applications quelque temps plus tard. Immédiatement après le 4004, les premiers microprocesseurs 8 bits furent commercialisés. Le 4004 fut suivi par le 8008 et quelques autres processeurs 8 bits extrêmement connus, comme le 8080 d'Intel, le 68000 de Motorola, le 6502 ou le Z80.

Les microprocesseurs permirent encore uen fois de réduire la taille des ordinateurs, qui pouvaient tenir dans un boitier de PC, ou un boitier de console de jeu. Le prix des ordinateurs a aussi chuté en même temps que les transistors était miniaturisés. C'est cette invention qui permis l'invention des consoles de jeux et des mini-ordinateurs, à savoir les ordinateurs personnels. Sans miniaturisation, on n'aurait pas d'ordinateur personnel, pas de PC fixe ou portable.

==L'organisation du cours : les différents niveaux d'explication==

Le fonctionnement d'un ordinateur est assez complexe à expliquer car les explications peuvent se faire sur plusieurs niveaux. Par plusieurs niveaux, on veut dire qu'un ordinateur est composé de composants très simples, qui sont assemblés pour donner des composants eux-même plus complexes, qui sont eux-même regrouper, etc. Étudier tout cela demande de voir plusieurs niveaux, allant de transistors très petits à des processeurs multicœurs. Les niveaux les plus bas sont de l'électronique pur et dure, alors que ceux plus haut sont à mi-chemin entre électronique et informatique.

===Les niveaux d'abstraction en architecture des ordinateurs===

Les trois premiers niveaux sont de l'électronique pur et dure. Ils correspondent aux premiers chapitres du cours, qui porteront sur les circuits électroniques en général.
* Le premier niveau est celui des '''transistors''', des circuits intégrés, des ''wafer'' et autres circuits de très petite taille.
* Le second niveau est celui des '''portes logiques''', des circuits très basiques, très simples, à la base de tous les autres.
* Le troisième niveau est celui dit de la '''''Register Transfer Level''''', où un circuit électronique est construit à partir de circuits basiques, dont des registres et autres circuits dits combinatoires.
Les deux niveaux suivants sont de l'informatique proprement dit. C'est dans ces deux niveaux qu'on étudie les ordinateurs proprement dit, les circuits qu'il y a dedans et non l'électronique en général.
* Le quatrième niveau est celui de la '''microarchitecture''', qui étudie ce qu'il y a à l'intérieur d'un processeur, d'une mémoire, des périphériques et autres.
* Le cinquième niveau est celui de l''''architecture externe''', qui décrit l'interface du processeur, de la mémoire, d'un périphérique ou autre. Par décrire l'interface, on veut dire : comment un programmeur voit le processeur et la mémoire, comment il peut les manipuler. Une architecture externe unique peut avoir plusieurs microarchitecture, ce qui fait qu'on sépare les deux. Tout cela sera plus clair quand on passera aux chapitres sur le processeur et les mémoires.

Nous n'allons pas voir les 5 niveaux dans l'ordre, des transistors vers l'architecture externe. En réalité, nous allons procéder autrement. La première partie du cours portera sur les trois premiers niveaux, le reste sur les deux autres. Les 5 niveaux seront vus dans des chapitres séparés, du moins le plus possible. Au niveau pédagogique, tout est plus simple si on scinde les 5 niveaux. Bien sûr, il y a quelques explications qui demandent de voir plusieurs niveaux à la fois. Par exemple, dans le chapitre sur les mémoires caches, nous auront des explications portant sur la RTL, la microarchitecture du cache et son architecture externe. Mais le gros du cours tentera de séparer le plus possible les 5 niveaux.

===Les trois parties principales du cours===

Nous allons commencer par parler du binaire, avant de voir les portes logiques. Avec ces portes logiques, nous allons voir comment fabriquer des circuits basiques qui reviendront très souvent dans la suite du cours. Nous verrons les registres, les décodeurs, les additionneurs et plein d'autres circuits. Puis, nous reviendrons au niveau des transistors pour finir la première partie. La raison est que c'est plus simple de faire comme cela. Tout ce qui a trait aux transistors sert à expliquer comment fabriquer des portes logiques, et il faut expliquer les portes logiques pour voir le niveau de la RTL.

Une fois la première partie finie, nous allons voir les différents composants d'un ordinateur. Une première partie expliquera ce qu'il y a dans un ordinateur, quels sont ses composants. Nous y parlerons de l'architecture de base, de la hiérarchie mémoire, des tendances technologiques, et d'autres généralités qui serviront de base pour la suite. Puis, nous verrons dans l'ordre les bus électroniques, les mémoires RAM/ROM, le processeur, les périphériques, les mémoires de stockage (SSD et disques durs) et les mémoires caches. Pour chaque composant, nous allons voir leur architecture externe, avant de voir leur microarchitecture. La raison est que la microarchitecture ne peut se comprendre que quand on sait quelle architecture externe elle implémente.

Enfin, dans une troisième partie, nous allons voir les optimisations majeures présentes dans tous les ordinateurs modernes, avec une partie sur le pipeline et le parallélisme d'instruction, et une autre sur les architectures parallèles. Pour finir, les annexes de fin parlerons de sujets un peu à part.

&lt;noinclude&gt;
{{NavChapitre | book=Fonctionnement d'un ordinateur
           | next=L'encodage des données
           | nextText=L'encodage des données
}}
&lt;/noinclude&gt;</text>
      <sha1>1y6u2mfmgf5zja24n2wef64qrucswxu</sha1>
    </revision>
    <revision>
      <id>744112</id>
      <parentid>744111</parentid>
      <timestamp>2025-06-04T21:18:03Z</timestamp>
      <contributor>
        <username>Mewtow</username>
        <id>31375</id>
      </contributor>
      <minor />
      <comment>/* Les premières générations : des ordinateurs qui prenaient des pièces de bâtiment entières */</comment>
      <origin>744112</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="43190" sha1="dk7clw4ufxg5vm6h9ty5z104w7zyi2i" xml:space="preserve">Pour commencer, nous allons voir qu'il existe de nombreux types d'ordinateurs. Le plus connu est certainement le PC, l'ordinateur personnel, que vous avez sans doute dans votre salon. Les ordinateurs portables sont un deuxième type d'ordinateur assez intuitif, que vous avez peut-être. Mais il y a aussi d'autres types d'ordinateurs auxquels vous n'avez jamais été confrontés.

==Les différents types d'ordinateurs==

Dans cette section, nous allons décrire rapidement les ordinateurs les plus courant, mais surtout voir ce qu'il y a à l'intérieur d'un ordinateur.

===L'ordinateur de type PC fixe===

De l'extérieur, l'ordinateur est composé d'une unité centrale sur laquelle on branche des périphériques.

[[File:Typical computer architecture systems.jpg|vignette|upright=1.5|Exemples de périphériques, connectés à une unité centrale (ici appelée à tort ''operating system'').]]

Les '''périphériques''' regroupent l'écran, la souris, le clavier, l'imprimante, et bien d'autres choses. Ils permettent à l'utilisateur d'interagir avec l'ordinateur : un clavier permet de saisir du texte sous dans un fichier, une souris enregistre des déplacements de la main en déplacement du curseur, un écran affiche des données d’images/vidéos, un haut-parleur émet du son, etc. Tout ce qui est branché sur un ordinateur est, formellement un périphérique.

L''''unité centrale''' est là où se trouvent tous les composants importants d'un ordinateur, ceux qui font des calculs, qui exécutent des logiciels, qui mémorisent vos données, etc. Voici ce à quoi ressemble l'intérieur de l'unité centrale. Trois sections sont visibles : l'alimentation électrique en haut à gauche, la carte mère en bas à gauche et en jaune/orange, les disques et lecteurs à droite des câbles. Et on voit aussi beaucoup de câbles.

[[File:Asus P5K-SEIntel E6320.jpg|centre|vignette|upright=2|Exemple d'unité centrale.]]

Tout en haut à gauche, se trouve l''''alimentation électrique''', qui convertit le courant de la prise électrique en un courant plus faible, utilisable par les autres composants. Elle émet de nombreux câbles assez gros, qui sont reliés au reste. Les PC actuels utilisent des alimentations électriques standardisées, qui fournissent trois tensions au reste de l'ordinateur : une tension de 12 Volts, une de 5 Volts, une de 3,3 Volts.

À droite, caché par la partie &quot;métallique&quot; du boitier, se trouvent les lecteurs de CD/DVD, et les disques durs. Les lecteurs CD-ROM ou DVD-ROM permettaient de lire des CD ou des DVD. Je parle au passé, car ils ont aujourd'hui disparu des ordinateurs modernes. Les '''disques durs''' sont des mémoires de stockage, qui mémorisent vos données de manière permanente. De nos jours, ils sont remplacés par des SSD, qui sont des disques durs électroniques, là où les disques durs proprement dit sont des mémoires magnétiques. Nous verrons la différence dans deux chapitres dédiés, un sur les disques durs, l'autre sur les SSD.

En bas à droite, se trouve la '''carte mère''' un support plat, en plastique ou en céramique, sur laquelle sont soudés/connectés les autres composants. Sur celle-ci, de nombreux composants sont soudés, d'autres sont branchés dessus avec des câbles, d'autres sont connectés dessus avec des connecteurs. Ils sont reliés entre eux par des fils conducteurs, le plus souvent du cuivre ou de l’aluminium, ce qui leur permet de s’échanger des données. Sur les cartes simples, ces fils sont intégrés dans la carte électronique, dans des creux du plastique. Ils portent le nom de pistes.

Avant, les disques durs, SSD et lecteurs de CD/DVD sont branchés dessus via des connecteurs dédiés, appelés des connecteurs S-ATA. De nos jours, ils sont branchés sur un autre connecteur, grâce à l'interface NVME. Toujours est-il qu'ils sont reliés à la carte mère par des câbles, ce qui montre que ce sont des sortes de périphériques interne. Ils sont placés dans le boitier, mais on aurait tout aussi bien pu les mettre à l'extérieur, vu qu'ils communiquent avec l'ordinateur par l'intermédiaire d'un câble ou d'un connecteur dédié.

Mais deux autres composants très importants sont eux placés sur la carte mère, directement. Ils ont chacun un connecteur dédié, sur lequel ils sont branchés directement, sans passer par l'intermédiaire d'un câble, mais sans être soudés non plus. Il s'agit du processeur et de la mémoire RAM, deux composants centraux des PC modernes.

[[File:Pentium III SL4CB.jpg|thumb|Processeur Pentium III.]]

Le '''processeur''' traite les données, les modifie, les manipule. Pour faire simple, il s’agit d’une grosse calculatrice hyper-puissante. Il comprend à la fois un circuit qui fait des calculs, et un circuit de contrôle qui s'occupe de séquencer les calculs dans l'ordre demandé. Il est souvent caché sous un radiateur, lui-même surmonté par un ventilateur. En effet, un processeur chauffe beaucoup, ce qui demande d'évacuer cette chaleur. Un chapitre entier expliquera pourquoi les processeurs chauffent, ainsi que les techniques utilisées pour limiter leur production de chaleur et leur consommation électrique.

La '''mémoire vive''' conserve des informations/données temporairement, tant que le processeur en a besoin. Elle prend la forme de barrettes de RAM, comme montré ci-dessous.

[[File:2 gb ddr2 667.jpg|centre|vignette|upright=2|Barrette de RAM.]]

Outre ces composants dits principaux, un ordinateur peut comprendre plusieurs composants moins importants, surtout présents sur les ordinateurs personnels. Ils sont techniquement facultatifs, mais sont très présents dans les ordinateurs personnels. Cependant, certains ordinateurs spécialisés s'en passent. Il s'agit des diverses '''cartes d'extension''' sont branchées sur la carte mère. Elles permettent d’accélérer certains calculs ou certaines applications, afin de décharger le processeur. Par exemple, la carte graphique s'occupe des calculs graphiques, qu'il s'agisse de graphismes 3D de jeux vidéos ou de l'affichage en 2D du bureau. Dans un autre registre, la carte son prend en charge le microphone et les haut-parleurs.

[[Fichier:Personal computer, exploded 4.svg|thumb|upright=1.0|Éclaté d'un ordinateur de type PC :&lt;br /&gt;
1 : Écran ;&lt;br /&gt;
2 : Carte mère ;&lt;br /&gt;
3 : Processeur ;&lt;br /&gt;
4 : Câble Parallel ATA ;&lt;br /&gt;
5 : Mémoire vive (RAM) ;&lt;br /&gt;
6 : Carte d'extension ;&lt;br /&gt;
7 : Alimentation électrique ;&lt;br /&gt;
8 : Lecteur de disque optique ;&lt;br /&gt;
9 : Disque dur ;&lt;br /&gt;
10 : Clavier ;&lt;br /&gt;
11 : Souris.]]

Si on regarde une carte mère de face, on voit un grand nombre de connecteurs, mais aussi des circuits électroniques soudés à la carte mère.

[[File:Architecture matérielle d'une carte mère.png|centre|vignette|upright=2.0|Architecture matérielle d'une carte mère]]

Les '''connecteurs''' sont là où on branche les périphériques, la carte graphique, le processeur, la mémoire, etc. Dans l'ensemble, toute carte mère contient les connecteurs suivants :
* Le processeur vient s’enchâsser dans la carte mère sur un connecteur particulier : le '''socket'''. Celui-ci varie suivant la carte mère et le processeur, ce qui est source d'incompatibilités.
* Les barrettes de mémoire RAM s’enchâssent dans un autre type de connecteurs: les '''slots mémoire'''.
* Les mémoires de masse disposent de leurs propres connecteurs : connecteurs P-ATA pour les anciens disques durs, et S-ATA pour les récents.
* Les périphériques (clavier, souris, USB, Firewire, ...) sont connectés sur un ensemble de connecteurs dédiés, localisés à l'arrière du boitier de l'unité centrale. 
* Les autres périphériques sont placés dans l'unité centrale et sont connectés via des connecteurs spécialisés. Ces périphériques sont des cartes imprimées, d'où leur nom de '''cartes filles'''. On peut notamment citer les cartes réseau, les cartes son, ou les cartes vidéo.

===Les ordinateurs portables===

[[File:Samsung QX-511 (2).JPG|vignette|Ordinateur portable Samsung QX-511 (2), pour illustration.]]

Un ordinateur portable est identique à un ordinateur de type PC. Si vous ouvrez votre ordinateur portable (attention à la garantie), vous retrouverez les mêmes composants qu'un PC à l'intérieur. Un point important est la présence d'une batterie à l'intérieur du PC portable, absente des PC fixes.

[[File:LG gram 14Z90Q mainboard with battery.jpg|centre|vignette|upright=2|LG gram 14Z90Q avec sa batterie.]]

Une fois la batterie et les circuits associés retiré, la seule différence notable est que tous les composants sont soudés sur la carte mère, au lieu d'être branchés sur des connecteurs, à part éventuellement la RAM et le disque dur.

[[File:LG gram 14Z90Q mainboard without battery.jpg|centre|vignette|upright=2|LG gram 14Z90Q sans sa batterie.]]

La RAM est parfois soudée sur la carte mère, d'autres fois sous la forme de barrettes de mémoire vive semblables à celles des PC. Dans le dernier cas, elle est connectée à des connecteurs spécifiques, ce qui permet de les changer/upgrader. Les PC portables sont parfois construits de manière à pouvoir changer la RAM facilement, en ouvrant un cache spécial, concu pour.

[[File:Lenovo G555 состав - Донор.JPG|centre|vignette|upright=2|Lenovo G555.]]

La conception d'un ordinateur portable est légèrement différente de celle d'un PC, pour des raisons thermiques. Un PC fixe a plus de place pour évacuer sa chaleur. Les ventilateurs peuvent plus facilement déplacer l'air dans le boitier, même si le flux d'air dans le boitier est éventuellement gêné par la carte graphique. Mais l'évacuation de la chaleur est assez efficace. Sur les PC portables, leur finesse fait que le trajet de l'air est beaucoup plus contraint. Évacuer la chaleur produite par l'ordinateur est plus complexe, ce qui demande d'utiliser des systèmes de refroidissement et de ventilation spécifiques.

Là où les PC fixes se débrouillent avec des radiateurs et des ventilateurs posés sur le processeur, les PC portables font autrement. Ils ne peuvent pas forcément mettre le ventilateur sur le processeur. A la place, ils mettent le ventilateur à côté, mais le processeur est surmonté par un mécanisme de transmission de la chaleur, qui transfère la chaleur du processeur vers le ventilateur.

[[File:Diagram - How a laptop cooling system works.png|centre|vignette|upright=2|Comment fonctionne le système de ventilation d'un ordinateur portable, en anglais.]]

Les difficultés pour dissiper la chaleur font que les ordinateurs portables utilisent souvent des composants peu performants, mais qui chauffent peu. En effet, nous verrons que plus un composant est puissant, plus il chauffe. La relation n'est pas parfaite, mais les processeurs haute performance chauffent plus que les modèles d'entrée ou milieu de gamme moins puissants. En conséquence, les PC portables sont souvent moins puissants que les PC fixes, même pour les modèles dit ''gaming''.

===Les serveurs et ''mainframes''===

Les grandes entreprises utilisent des ordinateurs de grande taille, très puissants, appelés des ''mainframes''. Ils sont souvent confondus avec les serveurs par le grand public, il y a une différence entre les deux. Un serveur est une fonction logicielle/réseau, pas un type d'ordinateur. Mais laissons cette différence de côté, ce qui est dit pour les ''mainframes'' sert pour les gros serveurs haute performance.

[[File:IBM Z15 mainframe.jpg|vignette|Exemple de ''mainframe''' de type IBM Z15.]]

Les anciens ''mainframes'' des années 50-80 avaient une taille pouvant être impressionnante, au point de prendre une pièce complète d'un bâtiment. Mais de nos jours, les ''mainframes'' tiennent dans une grosse armoire un peu haute. Les ''mainframes'' doivent rester allumé en permanence et ne doivent pas être éteint, sauf éventuellement quelques jours par an pour des opérations de maintenance. Ils utilisent pour cela des techniques spécifiques, avec beaucoup de redondance interne.

[[File:ACONIT hall grandes machines.jpg|centre|vignette|upright=2|''Mainframe'' ACONIT.]]

Les ''mainframes'' sont aussi conçus pour mutualiser au maximum leur utilisation, ils peuvent être utilisés par plusieurs utilisateurs à la suite, voire en même temps. Pour cela, les anciens ''mainframes'' étaient capables de faire tourner plusieurs applications distinctes l'une à la suite de l'autre, avec des commutations fréquentes entre logiciels. De nos jours, ils sont capables d'exécuter un grand nombre de tâches en même temps, grâce à la présence de plusieurs processeurs. Les ''mainframes'' modernes sont même capables de faire tourner plusieurs systèmes d'exploitation en même temps si besoin.

Les anciens ''mainframes'' étaient des ordinateurs assez simples, avec un processeur, de la mémoire RAM, un ou plusieurs disques durs, pas plus. Le ''mainframe'' était tellement énorme et cher que les entreprises n'en avaient qu'un seul pour toute l'entreprise. Les employés avaient sur leur bureau des terminaux, qui permettaient d'accéder à l'ordinateur central, mais n'étaient pas des ordinateurs. Les terminaux étaient des composants électroniques simples, avec un écran, un clavier et une souris, mais sans processeur. Ils envoyaient des données au ''mainframe'', ils en recevaient de sa part, mais tout traitement était réalisé sur le ''mainframe''. L'arrivée sur le marché des ordinateurs personnels, de type PC fixe/portable, a entrainé l'abandon de ce genre de pratique, tous les employés ont maintenant un ordinateur rien que pour eux.

{|
|-
! colspan=&quot;2&quot; | Exemples de terminaux
|-
|[[File:Terminal-in2-sm9400.jpg|centre|vignette|upright=1.5|Exemple de terminal. Notez la présence d'un écran et d'un clavier, mais l'asbence d'une unité centrale.]]
|[[File:Chromatics CT4100.jpg|vignette|upright=1.5|Autre exemple de terminal. Le clavier est couplé à un stylo CRT, qui remplacait la souris et agissait sur l'écran comme s'il était tactile.]]
|-
! colspan=&quot;2&quot; | Intérieur d'un terminal
|-
|[[File:CT1024 Monitor.jpg|vignette|upright=1.5|Terminal CT1024, sans le boitier extérieur.]]
|[[File:CT1024 Terminal System.jpg|vignette|upright=1.5|Terminal CT1024, description des composants interne.]]
|}

De nos jours, les ''mainframes'' contiennent en réalité plusieurs ordinateurs simples interconnectés via un réseau local. Un ''mainframe'' qui tient dans une armoire contient facilement une dizaine ou centaine de processeurs, plein de RAM, des disques durs séparés dans une armoire distincte, etc. Vu qu'ils communiquent uniquement via le réseau, ils n'ont pas d'interface, pas d'écran, 'entrée via clavier/souris. Le tout est commandé avec une console de commande, typiquement un ordinateur portable ou un terminal assez simple séparé de l'armoire, qui permet à un administrateur de faire des opérations de surveillance, configuration et maintenance. Il peut y avoir une console de commande pour plusieurs armoires séparées, la console peut même être dans un autre bâtiment et accéder au ''mainframe'' par le réseau.

[[File:IBM System Z9 (type 2094 inside).jpg|centre|vignette|upright=2|''Mainframe'' de type IBM System Z9. L'ordinateur portable sert de console pour qu'un administrateur fasse des opérations de surveillance, configuration et maintenance.]]

Les processeurs et la RAM sont typiquement installés sur des cartes amovibles, qui sont connectées au fond de l'armoire lors de l'installation. Il est même possible de retirer ou d'ajouter des cartes en fonctionnement, afin d'ajouter/retirer des processeurs, des disques durs, etc. Ce qui est très utile si un composant est en panne et qu'il faut le remplacer. 

[[File:IBM TotalStorage Exp400.jpg|centre|vignette|upright=2|IBM TotalStorage Exp400]]

==Un peu d'abstraction : qu'est-ce qu'un ordinateur ?==

Un ordinateur comprend donc un processeur, plusieurs mémoires, des cartes d'extension et une carte mère pour connecter le tout. Mais il s'agit là d'une description assez terre-à-terre de ce qu'est un ordinateur. Une autre description, plus abstraite, se base sur le fait qu'un ordinateur est une énorme calculatrice programmable. Elle permet d'expliquer pourquoi il y a une distinction entre processeur et mémoire, entre unité centrale et périphériques. Tout ce qui va suivre pourra vous paraitre assez abstrait, mais rassurez-vous : les prochains chapitres rendront tout cela plus concrets.

===La séparation entre entrées-sorties et traitement===

L'unité centrale peut être vue comme une énorme calculatrice ultra-puissante, qui exécute des commandes/opérations. Mais à elle seule, elle ne servirait à rien, il faut interagir avec par l'intermédiaire de plusieurs périphériques. Il existe deux types de périphériques, qui sont conceptuellement différents. Les périphériques comme le clavier ou la souris permettent d'envoyer des informations à l'ordinateur, d'agir sur celui-ci. A l'inverse, les écrans transmettent des informations dans le sens inverse : de l'ordinateur vers l'utilisateur. Les premiers sont appelés des '''entrées''', les seconds des '''sorties'''.

Dans un ordinateur, les informations sont représentées sous la forme de nombres. Toute donnée dans un ordinateur est codée avec un ou plusieurs nombres regroupés dans une donnée, un fichier, ou autre. Et la transmissions avec les entrées et sorties se fait là-encore avec des nombres. Par exemple, quand vous appuyez sur votre clavier, le clavier envoie un numéro de touche à l'unité centrale, qui indique quelle touche a été appuyée. L'image à afficher à l'écran est codée sous la forme d'une suite de nombres (un par pixel). L'image est envoyée à l'écran, qui traduit la suite de nombre en image à afficher. Les entrées traduisent des actions utilisateurs en nombres, on dit que les entrées encodent les actions utilisateur. Les sorties font la traduction inverse, elles transforment des suites de nombres en une action physique. On dit qu'elles décodent des informations.

Pour résumer, toute appareil électronique est composé par :
* Des '''entrées''' sur lesquelles l'utilisateur agit sur l'ordinateur. Les entrées transforment les actions de l'utilisateur en nombres, qui sont interprétés par l'ordinateur.
* Une '''unité de traitement''', qui manipule des nombres et fait des calculs/opérations dessus. Les nombres proviennent des entrées, du disque dur, ou d'autres sources, peu importe.
* Des '''sorties''', qui va récupèrent le résultat calculé par l'unité de traitement pour en faire quelque chose : écrire sur une imprimante ou sur un moniteur, émettre du son,...

[[File:Ordinateur théorique Simple 1.png|centre|vignette|upright=2|Ordinateur théorique Simple 1]]

L'unité de traitement proprement dite, celle qui fait les calculs, est couplée à une mémoire qui mémorise les opérandes et résultats des calculs. La séparation entre processeur et mémoire est nécessaire pour qu'un appareil électronique soit qualifié d'ordinateur. De nombreux appareils n'ont pas de séparation entre unité de traitement et mémoire, comme certaines vielles radios AM/FM.

[[File:Schéma de principe d'un ordinateur.png|centre|vignette|upright=2|Schéma de principe d'un ordinateur]]

===Un ordinateur est un appareil programmable===

Les appareils simples sont non-programmables, ce qui veut dire qu’ils sont conçus pour une utilisation particulière et qu’ils ne peuvent pas faire autre chose. Par exemple, les circuits électroniques d’un lecteur de DVD ne peuvent pas être transformé en lecteur audio ou en console de jeux... Les circuits non-programmables sont câblés une bonne fois pour toute, et on ne peut pas les modifier. On peut parfois reconfigurer le circuit, pour faire varier certains paramètres, via des interrupteurs ou des boutons, mais cela s’arrête là. Et cela pose un problème : à chaque problème qu'on veut résoudre en utilisant un automate, on doit recréer un nouveau circuit.

À l'inverse, un ordinateur n’est pas conçu pour une utilisation particulière, contrairement aux autres objets techniques. Il est possible de modifier leur fonction du jour au lendemain, on peut lui faire faire ce qu’on veut. On dit qu'ils sont '''programmables'''. Pour cela, il suffit d’utiliser un logiciel, une application, un programme (ces termes sont synonymes), qui fait ce que l'on souhaite. La totalité des logiciels présents sur un ordinateur sont des programmes comme les autres, même le système d'exploitation (Windows, Linux, ...) ne fait pas exception.

Un programme est une suite de d'instructions, chaque instruction effectuant une action dans l'ordinateur. Sur les ordinateurs modernes, la majorité de ces instructions effectuent une opération arithmétique, comme une addition, une multiplication, une soustraction, etc. Les ordinateurs modernes sont donc de grosses calculettes très puissantes, capables d'effectuer des millions d'opérations par secondes. Et qui dit opération dit nombres : un ordinateur gère nativement des nombres, qui sont codés en binaire sur la quasi-totalité des ordinateurs modernes.

Une instruction est représentée dans un ordinateur par une série de nombres : un nombre qui indique quelle opération/commande effectuer et des autres nombres pour coder les données (ou de quoi les retrouver dans l'ordinateur). L'ordinateur récupére les commandes une par une, les traduit en opération à effectuer, exécuter l'opération, et enregistre le résultat. Puis il recommence avec la commande suivante.

[[File:Ordinateur Théorique Complexe 1.png|centre|vignette|upright=3|Ordinateur Théorique Complexe. En jaune, le programme informatique, la liste de commande. Le rectangle gris est l'ordinateur proprement dit.]]

De nombreux appareils sont programmables, mais tous ne sont pas des ordinateurs. Par exemple, certains circuits programmables nommés FPGA n'en sont pas. Pour être qualifié d'ordinateur, un appareil programmable doit avoir un processeur séparé de la mémoire. De plus, il doit utiliser un '''codage numérique''', chose que nous allons aborder dans le chapitre suivant.

===Les ordinateurs à programme mémorisé ou programme externe===

Au tout début de l'informatique, on utilisait des cartes perforées en plastique, sur lesquelles on inscrivait le programme à exécuter, les données à traiter, bref : tout ce qu'on donnait à manger à l'ordinateur. Par la suite, les premiers ordinateurs grand public, comme les Amstrad ou les Commodore, utilisaient des cassettes audio magnétiques pour stocker les programmes. Dans le même style, les consoles de jeu utilisaient autrefois des cartouches de jeu, qui contenaient le programme du jeu à exécuter. Pour résumer, les anciens ordinateurs mémorisaient les programmes sur un support externe, lu par un périphérique. De tels ordinateurs sont dits à '''programme externe'''.

: D’anciens ordinateurs personnels, comme l’Amstrad ou le Commodore, permettaient de taper les programmes à exécuter à la main, au clavier, avant d’appuyer une touche pour les exécuter. Nul besoin de vous dire que les cassettes audio étaient plus pratiques.

Mais de nos jours, les programmes sont enregistrés sur le disque dur de l'ordinateur ou dans une mémoire intégrée à l'ordinateur. On dit qu'ils sont installés, ce qui est un mot bien compliqué pour dire que le programme est enregistré sur le disque dur de l’ordinateur. A défaut de disque dur, le programme/logiciel est enregistré dans une mémoire spécialisée pour le stockage. Par exemple, sur les cartes électroniques grand public de marque Arduino, les programmes sont envoyés à la carte via le port USB, mais les programmes sont enregistrés dans la carte Arduino, dans une mémoire FLASH dédiée. Disque dur ou non, le programme est mémorisé dans la mémoire de l'ordinateur. Il est possible d'installer ou de désinstaller les programmes en modifiant le contenu de la mémoire. Le terme utilisé est alors celui de '''programme stocké en mémoire'''.

Les programmes à installer sont disponibles soit sur un périphérique, comme un DVD ou une clé USB, soit sont téléchargés depuis internet. Les premiers PC fournissaient les logiciels sur des disquettes, qui contenaient un programme d'installation pour enregistrer le programme sur le disque dur de l'ordinateur. Par la suite, le support des logiciels a migré vers les CD et DVD, les logiciels devenant de plus en plus gros. De nos jours, la majorité des applications sont téléchargées depuis le net, l'usage de périphériques est devenu obsolète, même les consoles de jeu abandonnent cette méthode de distribution.

==Les générations d'ordinateurs : un historique rapide==

L'informatique a beaucoup évolué dans le temps. Et une bonne partie de cette évolution tient à l'évolution de l’électronique sous-jacente. Les ordinateurs actuels sont fabriqués avec des transistors, des petits composants électroniques qui servent d'interrupteur programmables, qu'on détaillera dans ce qui suit. Mais ça n'a pas toujours été le cas. Et cela permet de distinguer plusieurs '''générations d'ordinateurs'''.

===Les ordinateurs électro-mécaniques : les premiers ordinateurs===

Le tout premier ordinateur est le '''Z1''', un modèle unique inventé par Konrad Suze entre 1936 et 1938. Son processeur gérait non pas des nombres entiers, mais des nombres à virgule (des nombres dits flottants, pour être précis), encodés sur 22 bits. Le processeur du Z1 était capable de faire des additions et des soustractions, car il intégrait un circuit additionneur-soustracteur basique. Des circuits annexes permettaient de faire des multiplications et des divisions en enchainant des additions/soustractions successives. Il fonctionnait à une fréquence de 1 Hz, ce qui fait qu'il pouvait faire une addition/soustraction par seconde maximum.

[[File:Blue-punch-card-front.png|vignette|upright=0.5|Carte Perforée.]]

Niveau mémoire, la RAM de l'ordinateur était très limitée : seulement 16 nombres de 22 bits chacun. S'il s'agissait d'une mémoire électronique, les programmes étaient mémorisés sur une mémoire mécanique. Les programmes étaient enregistrés sur des cartes perforées, à savoir des cartes en papier dans lesquelles un 1 est codé par un trou dans le papier et un 0 par une absence de trou. Les programmes étaient exécutés par l'ordinateur quand on insérait la carte perforée dans le lecteur et qu'on appuyait sur un bouton.

[[File:German Museum of Technology, Berlin 2017 024.jpg|centre|vignette|upright=2|Réplique du Z1 au ''German Museum of Technology'' de Berlin, 2017.]]

Après sa destruction dans un bombardement, le Z1 a été reconstruit et amélioré, ce qui donné les deux ordinateurs Z2 et Z3. Quelques années plus tard, de nombreux ordinateurs ont été construits dans des laboratoires de recherche. Des grandes noms de l'histoire de l'informatique datent de cette époque : le Harvard Mark I et le Colossus Mark 1 (UK) ont tous deux été mis en service en 1944, par exemple. Ils ont servis pour les cryptanalystes pour casser les codes utilisés par les allemands pour leurs transmissions, pendant la seconde guerre mondiale.

Les ordinateurs cités dans le précédent paragraphe étaient tous des ordinateurs dit '''électro-mécaniques''', car ils mélangeaient des composants électroniques et des composants mécaniques (tout ce qui a trait aux cartes perforées, notamment). Les composants électroniques étaient soit des relais, soit des tubes à vides, les deux étant des interrupteurs commandables électriquement plus ou moins équivalents aux transistors. Les ordinateurs d'avant l'année 1944, étaient tous de ce type. Quelques ordinateurs des années 50 étaient de ce type, mais leur nombre n'a pas dépassé 30. Il faut dire qu'ils ont rapidement laissé la place à des ordinateurs purement électroniques, que nous allons voir dans ce qui suit..

===Les premières générations : des ordinateurs qui prenaient des pièces de bâtiment entières===

Les ordinateurs qui ont suivi les ordinateurs électromécaniques sont regroupés dans la '''première génération d'ordinateur'''. Ils étaient conçus avec des tubes à vide, ce qui les place entre les premiers ordinateurs électro-mécaniques et les ordinateurs utilisant des transistors. Les ordinateurs de première génération étaient très simples, ils ne géraient que quelques opérations simples : l'addition, la soustraction, pas grand chose de plus. A quelques exceptions près, ils ne géraient pas la multiplication et encore moins la division, ils n'avaient pas assez de relais ou de tubes à vides à disposition pour cela.

Une des toute première machine construite avec des tubes à vide était l'Atanasoff–Berry. Ce n'était pas un ordinateur, car elle ne pouvait pas exécuter de programme sans intervention humaine pour séquencer des opérations. Elle était construite pour résoudre des équations différentielles linéaires, donc pour des calculs très précis. Mais c'était la première machine de calcul purement électronique. Elle utilisait une mémoire RAM construite avec des condensateurs, des circuits de calcul construits avec des tubes à vide, aucune pièce mécanique. Les nombres étaient encodés sur 50 bits. Elle fonctionnait à une fréquence de 60 Hz et pouvait faire 30 additions/soustractions par seconde. Les calculs étaient réalisés un bit à la fois dans les circuits de calcul.

[[File:Atanasoff Berry Computer.gif|centre|vignette|upright=2|Atanasoff–Berry.]]

Mais c'est l'arrivée de l'ENIAC en 1945 qui a changé la donne. Cet ordinateur a introduit plusieurs innovations majeures. La première est assez technique, il s'agit de la turing-complétude, et a trait aux programmes qui peuvent être écrit pour un ordinateur. Nous ne la détaillerons pas ici. La seconde innovation est que l'ENIAC était composé non pas de relais et d'éléments mécaniques, mais uniquement de tubes à vides, des composants électroniques assez rudimentaires plus ou moins équivalents aux transistors modernes.

Le ''Manchester Baby'' a introduit une innovation extrêmement importante, au point où on considère que c'est le premier ordinateur à avoir tous les critères nécessaires pour être appelé un ordinateur. Son innovation est que le programme n'était plus mémorisé sur des cartes perforée, mais dans une mémoire électronique dans l'ordinateur lui-même. En clair, le ''Manchester Baby'' était le premier '''''Stored-program computer''''', ordinateur à programme enregistré en français. 

[[File:IBM 7070.jpg|vignette|Cartes imprimées de l'IBM 704, avec des transistors et résistances dessus.]]

La '''seconde génération''' est celle des ordinateurs fabriqués avec des '''transistors''' isolés, reliés entre avec des fils électriques. Les transistors en question possèdent trois broches, des pattes métalliques sur lesquelles on connecte des fils électriques. Le transistor s'utilise le plus souvent comme un interrupteur commandé par sa troisième broche. Le courant qui traverse les deux premières broches passe ou ne passe pas selon ce qu'on met sur la troisième.

[[File:Transistor basic flow.svg|centre|vignette|Un transistor est un morceau de conducteur, dont la conductivité est contrôlée par sa troisième broche/borne.]]

Les ordinateurs de seconde génération avaient entre 1000 et 500 000 transistors. Les capacités des ordinateurs étaient donc nettement supérieures à celles des ordinateurs de première génération. Une part non négligeable des ordinateurs de seconde génération supportait l'opération de multiplication, absente sur les ordinateurs de première génération. Néanmoins, cela variait beaucoup selon les ordinateurs.

Un exemple assez hors du commun est celui du premier modèle de l'IBM 1620. Le tout premier modèle n'avait aucun circuit de calcul, il n'était même pas capable de faire une addition ou une multiplication. A la place, il utilisait une table d'addition et une table de multiplication en mémoire RAM. Les deux tables devaient être initialisées par le logiciel lors du démarrage de la machine. La table d'addition faisait une centaine de chiffre, la table de multiplication faisait le double. Le processeur de l'ordinateur gérait des instructions pour faire des additions ou des multiplications, mais ces opérations lisaient le résultat dans la table d'addition. Les calculs étaient fait chiffre par chiffre, avec un encodage partiellement décimal, partiellement binaire (des chiffres décimaux étaient encodés en binaire, nous en reparlerons quand nous parlerons du BCD) !

[[File:KL CoreMemory.jpg|vignette|Mémoire à tore de ferrite.]]

Les transistors n'étaient utilisés que pour le processeur et les circuits annexes. La mémoire n'était pas faite en transistors, pas à cette époque. La mémoire était une mémoire aujourd'hui abandonnée, appelée une '''mémoire à tores de ferrite'''. Elle sera détaillée dans un chapitre ultérieur. Mais sachez pour le moment qu'il s'agit d'une mémoire au support magnétique, les données étant stockées sur un support magnétique.

Transistors comme tubes à vide prenaient beaucoup de place, ce qui fait que les ordinateurs étaient assez gros. Concrètement, ils prenaient une pièce de bâtiment entière dans le meilleur des cas. C'était l'époque des gros ''mainframes'', reliés à des terminaux, peu puissants comparé aux standards actuels. Seules les grandes entreprises et les grands instituts de recherche pouvaient se payer les services de ce genre d'ordinateurs. Seuls les professionnels avaient accès à ce genre d'équipement.

===La troisième génération : le circuit intégré===

[[File:D8259AC-2.jpg|vignette|Exemple de circuit intégré.]]

La troisième génération est toujours fabriquée avec des transistors, mais dont la taille a été réduite. Avec l'évolution de la technologie, les transistors ont diminué en taille, de plus en plus. Ils sont devenus tellement petits qu'ils ont finit par être regroupés dans des '''circuits intégrés''', des circuits regroupent plusieurs transistors sur la même puce de silicium. Les circuits intégrés se présentent le plus souvent sous la forme de boitiers rectangulaires, comme illustré ci-contre. D'autres ont des boitiers de forme carrées, comme ceux que l'on peut trouver sur les barrettes de mémoire RAM, ou à l'intérieur des clés USB/ disques SSD.

Lors de cette génération, les processeurs étaient fournis en pièces détachées qu'il fallait relier entre elles. Le processeur était composé de plusieurs circuits intégrés séparés, impossible de mettre un processeur dans un seul boitier. Un exemple de processeur conçu en kit est la série des Intel 3000. Elle regroupe plusieurs circuits séparés aux noms à coucher dehors, mais dont vous comprendrez ce qu'ils veulent dire dans les chapitres adéquats : l'Intel 3001 est un séquenceur, l'Intel 3002 regroupe unité de calcul et registres, le 3003 est un circuit d'anticipation de retenue complémentaire du 3002, le 3212 est une mémoire tampon, le 3214 est une unité de gestion des interruptions, les 3216/3226 sont des interfaces de bus mémoire. On pourrait aussi citer la famille de circuits intégrés AMD Am2900.

Même si le processeur était en pièce détachées, utiliser une dizaine de circuits intégrés était nettement mieux que d'utiliser plusieurs milliers de transistors individuels. En conséquence, les ordinateurs ont vu leur taille grandement réduite, passant de pièces entières à une simple armoire, voire à quelques cartes intégrées superposées. De plus, le prix des circuits intégré était abordable, du moins comparé aux ordinateurs d'avant. Le prix des ordinateurs a alors grandement décru, permettant à des entreprises et administrations de taille modeste de s'équiper d'ordinateurs.

===La quatrième génération : le microprocesseur===

[[File:MOS6502.svg|vignette|Microprocesseur, ici un processeur MOS6502, de la quatrième génération.]]

Lors de la troisième génération, les circuits intégrés regroupaient plusieurs dizaines ou centaines de transistors, mais sont rapidement montés en gamme. De centaines de transistors, ils sont passé au milliers de transistors, puis au millions et maintenant au-delà du milliard. Les transistors étaient devenus tellement petits, tellement miniaturisés, qu'il était devenu possible de mettre un processeur entier dans un circuit intégré. C'est ainsi qu'est né le microprocesseur, à savoir un processeur qui tient tout entier dans un seul circuit imprimé. La quatrième génération d’ordinateur est celle des ordinateurs basés autour d'un microprocesseur.

Les tout premiers microprocesseurs étaient des processeurs à application militaire, comme le processeur du F-14 CADC ou celui de l'Air data computer. Le tout premier microprocesseur commercialisé au grand public est le 4004 d'Intel, sorti en 1971. L'intel 4004 comprenait environ 2300 transistors, avait une fréquence de 740 MHz, pouvait faire 46 opérations différentes, et manipulait des entiers de 4 bits. Il était au départ un processeur de commande, prévu pour être intégré dans la calculatrice Busicom calculator 141-P, mais il fut utilisé pour d'autres applications quelque temps plus tard. Immédiatement après le 4004, les premiers microprocesseurs 8 bits furent commercialisés. Le 4004 fut suivi par le 8008 et quelques autres processeurs 8 bits extrêmement connus, comme le 8080 d'Intel, le 68000 de Motorola, le 6502 ou le Z80.

Les microprocesseurs permirent encore uen fois de réduire la taille des ordinateurs, qui pouvaient tenir dans un boitier de PC, ou un boitier de console de jeu. Le prix des ordinateurs a aussi chuté en même temps que les transistors était miniaturisés. C'est cette invention qui permis l'invention des consoles de jeux et des mini-ordinateurs, à savoir les ordinateurs personnels. Sans miniaturisation, on n'aurait pas d'ordinateur personnel, pas de PC fixe ou portable.

==L'organisation du cours : les différents niveaux d'explication==

Le fonctionnement d'un ordinateur est assez complexe à expliquer car les explications peuvent se faire sur plusieurs niveaux. Par plusieurs niveaux, on veut dire qu'un ordinateur est composé de composants très simples, qui sont assemblés pour donner des composants eux-même plus complexes, qui sont eux-même regrouper, etc. Étudier tout cela demande de voir plusieurs niveaux, allant de transistors très petits à des processeurs multicœurs. Les niveaux les plus bas sont de l'électronique pur et dure, alors que ceux plus haut sont à mi-chemin entre électronique et informatique.

===Les niveaux d'abstraction en architecture des ordinateurs===

Les trois premiers niveaux sont de l'électronique pur et dure. Ils correspondent aux premiers chapitres du cours, qui porteront sur les circuits électroniques en général.
* Le premier niveau est celui des '''transistors''', des circuits intégrés, des ''wafer'' et autres circuits de très petite taille.
* Le second niveau est celui des '''portes logiques''', des circuits très basiques, très simples, à la base de tous les autres.
* Le troisième niveau est celui dit de la '''''Register Transfer Level''''', où un circuit électronique est construit à partir de circuits basiques, dont des registres et autres circuits dits combinatoires.
Les deux niveaux suivants sont de l'informatique proprement dit. C'est dans ces deux niveaux qu'on étudie les ordinateurs proprement dit, les circuits qu'il y a dedans et non l'électronique en général.
* Le quatrième niveau est celui de la '''microarchitecture''', qui étudie ce qu'il y a à l'intérieur d'un processeur, d'une mémoire, des périphériques et autres.
* Le cinquième niveau est celui de l''''architecture externe''', qui décrit l'interface du processeur, de la mémoire, d'un périphérique ou autre. Par décrire l'interface, on veut dire : comment un programmeur voit le processeur et la mémoire, comment il peut les manipuler. Une architecture externe unique peut avoir plusieurs microarchitecture, ce qui fait qu'on sépare les deux. Tout cela sera plus clair quand on passera aux chapitres sur le processeur et les mémoires.

Nous n'allons pas voir les 5 niveaux dans l'ordre, des transistors vers l'architecture externe. En réalité, nous allons procéder autrement. La première partie du cours portera sur les trois premiers niveaux, le reste sur les deux autres. Les 5 niveaux seront vus dans des chapitres séparés, du moins le plus possible. Au niveau pédagogique, tout est plus simple si on scinde les 5 niveaux. Bien sûr, il y a quelques explications qui demandent de voir plusieurs niveaux à la fois. Par exemple, dans le chapitre sur les mémoires caches, nous auront des explications portant sur la RTL, la microarchitecture du cache et son architecture externe. Mais le gros du cours tentera de séparer le plus possible les 5 niveaux.

===Les trois parties principales du cours===

Nous allons commencer par parler du binaire, avant de voir les portes logiques. Avec ces portes logiques, nous allons voir comment fabriquer des circuits basiques qui reviendront très souvent dans la suite du cours. Nous verrons les registres, les décodeurs, les additionneurs et plein d'autres circuits. Puis, nous reviendrons au niveau des transistors pour finir la première partie. La raison est que c'est plus simple de faire comme cela. Tout ce qui a trait aux transistors sert à expliquer comment fabriquer des portes logiques, et il faut expliquer les portes logiques pour voir le niveau de la RTL.

Une fois la première partie finie, nous allons voir les différents composants d'un ordinateur. Une première partie expliquera ce qu'il y a dans un ordinateur, quels sont ses composants. Nous y parlerons de l'architecture de base, de la hiérarchie mémoire, des tendances technologiques, et d'autres généralités qui serviront de base pour la suite. Puis, nous verrons dans l'ordre les bus électroniques, les mémoires RAM/ROM, le processeur, les périphériques, les mémoires de stockage (SSD et disques durs) et les mémoires caches. Pour chaque composant, nous allons voir leur architecture externe, avant de voir leur microarchitecture. La raison est que la microarchitecture ne peut se comprendre que quand on sait quelle architecture externe elle implémente.

Enfin, dans une troisième partie, nous allons voir les optimisations majeures présentes dans tous les ordinateurs modernes, avec une partie sur le pipeline et le parallélisme d'instruction, et une autre sur les architectures parallèles. Pour finir, les annexes de fin parlerons de sujets un peu à part.

&lt;noinclude&gt;
{{NavChapitre | book=Fonctionnement d'un ordinateur
           | next=L'encodage des données
           | nextText=L'encodage des données
}}
&lt;/noinclude&gt;</text>
      <sha1>dk7clw4ufxg5vm6h9ty5z104w7zyi2i</sha1>
    </revision>
    <revision>
      <id>744113</id>
      <parentid>744112</parentid>
      <timestamp>2025-06-04T21:18:21Z</timestamp>
      <contributor>
        <username>Mewtow</username>
        <id>31375</id>
      </contributor>
      <minor />
      <comment>/* Les premières générations : des ordinateurs qui prenaient des pièces de bâtiment entières */</comment>
      <origin>744113</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="43192" sha1="ouuxzzcwk01ayaq6489eoq9htv0riqm" xml:space="preserve">Pour commencer, nous allons voir qu'il existe de nombreux types d'ordinateurs. Le plus connu est certainement le PC, l'ordinateur personnel, que vous avez sans doute dans votre salon. Les ordinateurs portables sont un deuxième type d'ordinateur assez intuitif, que vous avez peut-être. Mais il y a aussi d'autres types d'ordinateurs auxquels vous n'avez jamais été confrontés.

==Les différents types d'ordinateurs==

Dans cette section, nous allons décrire rapidement les ordinateurs les plus courant, mais surtout voir ce qu'il y a à l'intérieur d'un ordinateur.

===L'ordinateur de type PC fixe===

De l'extérieur, l'ordinateur est composé d'une unité centrale sur laquelle on branche des périphériques.

[[File:Typical computer architecture systems.jpg|vignette|upright=1.5|Exemples de périphériques, connectés à une unité centrale (ici appelée à tort ''operating system'').]]

Les '''périphériques''' regroupent l'écran, la souris, le clavier, l'imprimante, et bien d'autres choses. Ils permettent à l'utilisateur d'interagir avec l'ordinateur : un clavier permet de saisir du texte sous dans un fichier, une souris enregistre des déplacements de la main en déplacement du curseur, un écran affiche des données d’images/vidéos, un haut-parleur émet du son, etc. Tout ce qui est branché sur un ordinateur est, formellement un périphérique.

L''''unité centrale''' est là où se trouvent tous les composants importants d'un ordinateur, ceux qui font des calculs, qui exécutent des logiciels, qui mémorisent vos données, etc. Voici ce à quoi ressemble l'intérieur de l'unité centrale. Trois sections sont visibles : l'alimentation électrique en haut à gauche, la carte mère en bas à gauche et en jaune/orange, les disques et lecteurs à droite des câbles. Et on voit aussi beaucoup de câbles.

[[File:Asus P5K-SEIntel E6320.jpg|centre|vignette|upright=2|Exemple d'unité centrale.]]

Tout en haut à gauche, se trouve l''''alimentation électrique''', qui convertit le courant de la prise électrique en un courant plus faible, utilisable par les autres composants. Elle émet de nombreux câbles assez gros, qui sont reliés au reste. Les PC actuels utilisent des alimentations électriques standardisées, qui fournissent trois tensions au reste de l'ordinateur : une tension de 12 Volts, une de 5 Volts, une de 3,3 Volts.

À droite, caché par la partie &quot;métallique&quot; du boitier, se trouvent les lecteurs de CD/DVD, et les disques durs. Les lecteurs CD-ROM ou DVD-ROM permettaient de lire des CD ou des DVD. Je parle au passé, car ils ont aujourd'hui disparu des ordinateurs modernes. Les '''disques durs''' sont des mémoires de stockage, qui mémorisent vos données de manière permanente. De nos jours, ils sont remplacés par des SSD, qui sont des disques durs électroniques, là où les disques durs proprement dit sont des mémoires magnétiques. Nous verrons la différence dans deux chapitres dédiés, un sur les disques durs, l'autre sur les SSD.

En bas à droite, se trouve la '''carte mère''' un support plat, en plastique ou en céramique, sur laquelle sont soudés/connectés les autres composants. Sur celle-ci, de nombreux composants sont soudés, d'autres sont branchés dessus avec des câbles, d'autres sont connectés dessus avec des connecteurs. Ils sont reliés entre eux par des fils conducteurs, le plus souvent du cuivre ou de l’aluminium, ce qui leur permet de s’échanger des données. Sur les cartes simples, ces fils sont intégrés dans la carte électronique, dans des creux du plastique. Ils portent le nom de pistes.

Avant, les disques durs, SSD et lecteurs de CD/DVD sont branchés dessus via des connecteurs dédiés, appelés des connecteurs S-ATA. De nos jours, ils sont branchés sur un autre connecteur, grâce à l'interface NVME. Toujours est-il qu'ils sont reliés à la carte mère par des câbles, ce qui montre que ce sont des sortes de périphériques interne. Ils sont placés dans le boitier, mais on aurait tout aussi bien pu les mettre à l'extérieur, vu qu'ils communiquent avec l'ordinateur par l'intermédiaire d'un câble ou d'un connecteur dédié.

Mais deux autres composants très importants sont eux placés sur la carte mère, directement. Ils ont chacun un connecteur dédié, sur lequel ils sont branchés directement, sans passer par l'intermédiaire d'un câble, mais sans être soudés non plus. Il s'agit du processeur et de la mémoire RAM, deux composants centraux des PC modernes.

[[File:Pentium III SL4CB.jpg|thumb|Processeur Pentium III.]]

Le '''processeur''' traite les données, les modifie, les manipule. Pour faire simple, il s’agit d’une grosse calculatrice hyper-puissante. Il comprend à la fois un circuit qui fait des calculs, et un circuit de contrôle qui s'occupe de séquencer les calculs dans l'ordre demandé. Il est souvent caché sous un radiateur, lui-même surmonté par un ventilateur. En effet, un processeur chauffe beaucoup, ce qui demande d'évacuer cette chaleur. Un chapitre entier expliquera pourquoi les processeurs chauffent, ainsi que les techniques utilisées pour limiter leur production de chaleur et leur consommation électrique.

La '''mémoire vive''' conserve des informations/données temporairement, tant que le processeur en a besoin. Elle prend la forme de barrettes de RAM, comme montré ci-dessous.

[[File:2 gb ddr2 667.jpg|centre|vignette|upright=2|Barrette de RAM.]]

Outre ces composants dits principaux, un ordinateur peut comprendre plusieurs composants moins importants, surtout présents sur les ordinateurs personnels. Ils sont techniquement facultatifs, mais sont très présents dans les ordinateurs personnels. Cependant, certains ordinateurs spécialisés s'en passent. Il s'agit des diverses '''cartes d'extension''' sont branchées sur la carte mère. Elles permettent d’accélérer certains calculs ou certaines applications, afin de décharger le processeur. Par exemple, la carte graphique s'occupe des calculs graphiques, qu'il s'agisse de graphismes 3D de jeux vidéos ou de l'affichage en 2D du bureau. Dans un autre registre, la carte son prend en charge le microphone et les haut-parleurs.

[[Fichier:Personal computer, exploded 4.svg|thumb|upright=1.0|Éclaté d'un ordinateur de type PC :&lt;br /&gt;
1 : Écran ;&lt;br /&gt;
2 : Carte mère ;&lt;br /&gt;
3 : Processeur ;&lt;br /&gt;
4 : Câble Parallel ATA ;&lt;br /&gt;
5 : Mémoire vive (RAM) ;&lt;br /&gt;
6 : Carte d'extension ;&lt;br /&gt;
7 : Alimentation électrique ;&lt;br /&gt;
8 : Lecteur de disque optique ;&lt;br /&gt;
9 : Disque dur ;&lt;br /&gt;
10 : Clavier ;&lt;br /&gt;
11 : Souris.]]

Si on regarde une carte mère de face, on voit un grand nombre de connecteurs, mais aussi des circuits électroniques soudés à la carte mère.

[[File:Architecture matérielle d'une carte mère.png|centre|vignette|upright=2.0|Architecture matérielle d'une carte mère]]

Les '''connecteurs''' sont là où on branche les périphériques, la carte graphique, le processeur, la mémoire, etc. Dans l'ensemble, toute carte mère contient les connecteurs suivants :
* Le processeur vient s’enchâsser dans la carte mère sur un connecteur particulier : le '''socket'''. Celui-ci varie suivant la carte mère et le processeur, ce qui est source d'incompatibilités.
* Les barrettes de mémoire RAM s’enchâssent dans un autre type de connecteurs: les '''slots mémoire'''.
* Les mémoires de masse disposent de leurs propres connecteurs : connecteurs P-ATA pour les anciens disques durs, et S-ATA pour les récents.
* Les périphériques (clavier, souris, USB, Firewire, ...) sont connectés sur un ensemble de connecteurs dédiés, localisés à l'arrière du boitier de l'unité centrale. 
* Les autres périphériques sont placés dans l'unité centrale et sont connectés via des connecteurs spécialisés. Ces périphériques sont des cartes imprimées, d'où leur nom de '''cartes filles'''. On peut notamment citer les cartes réseau, les cartes son, ou les cartes vidéo.

===Les ordinateurs portables===

[[File:Samsung QX-511 (2).JPG|vignette|Ordinateur portable Samsung QX-511 (2), pour illustration.]]

Un ordinateur portable est identique à un ordinateur de type PC. Si vous ouvrez votre ordinateur portable (attention à la garantie), vous retrouverez les mêmes composants qu'un PC à l'intérieur. Un point important est la présence d'une batterie à l'intérieur du PC portable, absente des PC fixes.

[[File:LG gram 14Z90Q mainboard with battery.jpg|centre|vignette|upright=2|LG gram 14Z90Q avec sa batterie.]]

Une fois la batterie et les circuits associés retiré, la seule différence notable est que tous les composants sont soudés sur la carte mère, au lieu d'être branchés sur des connecteurs, à part éventuellement la RAM et le disque dur.

[[File:LG gram 14Z90Q mainboard without battery.jpg|centre|vignette|upright=2|LG gram 14Z90Q sans sa batterie.]]

La RAM est parfois soudée sur la carte mère, d'autres fois sous la forme de barrettes de mémoire vive semblables à celles des PC. Dans le dernier cas, elle est connectée à des connecteurs spécifiques, ce qui permet de les changer/upgrader. Les PC portables sont parfois construits de manière à pouvoir changer la RAM facilement, en ouvrant un cache spécial, concu pour.

[[File:Lenovo G555 состав - Донор.JPG|centre|vignette|upright=2|Lenovo G555.]]

La conception d'un ordinateur portable est légèrement différente de celle d'un PC, pour des raisons thermiques. Un PC fixe a plus de place pour évacuer sa chaleur. Les ventilateurs peuvent plus facilement déplacer l'air dans le boitier, même si le flux d'air dans le boitier est éventuellement gêné par la carte graphique. Mais l'évacuation de la chaleur est assez efficace. Sur les PC portables, leur finesse fait que le trajet de l'air est beaucoup plus contraint. Évacuer la chaleur produite par l'ordinateur est plus complexe, ce qui demande d'utiliser des systèmes de refroidissement et de ventilation spécifiques.

Là où les PC fixes se débrouillent avec des radiateurs et des ventilateurs posés sur le processeur, les PC portables font autrement. Ils ne peuvent pas forcément mettre le ventilateur sur le processeur. A la place, ils mettent le ventilateur à côté, mais le processeur est surmonté par un mécanisme de transmission de la chaleur, qui transfère la chaleur du processeur vers le ventilateur.

[[File:Diagram - How a laptop cooling system works.png|centre|vignette|upright=2|Comment fonctionne le système de ventilation d'un ordinateur portable, en anglais.]]

Les difficultés pour dissiper la chaleur font que les ordinateurs portables utilisent souvent des composants peu performants, mais qui chauffent peu. En effet, nous verrons que plus un composant est puissant, plus il chauffe. La relation n'est pas parfaite, mais les processeurs haute performance chauffent plus que les modèles d'entrée ou milieu de gamme moins puissants. En conséquence, les PC portables sont souvent moins puissants que les PC fixes, même pour les modèles dit ''gaming''.

===Les serveurs et ''mainframes''===

Les grandes entreprises utilisent des ordinateurs de grande taille, très puissants, appelés des ''mainframes''. Ils sont souvent confondus avec les serveurs par le grand public, il y a une différence entre les deux. Un serveur est une fonction logicielle/réseau, pas un type d'ordinateur. Mais laissons cette différence de côté, ce qui est dit pour les ''mainframes'' sert pour les gros serveurs haute performance.

[[File:IBM Z15 mainframe.jpg|vignette|Exemple de ''mainframe''' de type IBM Z15.]]

Les anciens ''mainframes'' des années 50-80 avaient une taille pouvant être impressionnante, au point de prendre une pièce complète d'un bâtiment. Mais de nos jours, les ''mainframes'' tiennent dans une grosse armoire un peu haute. Les ''mainframes'' doivent rester allumé en permanence et ne doivent pas être éteint, sauf éventuellement quelques jours par an pour des opérations de maintenance. Ils utilisent pour cela des techniques spécifiques, avec beaucoup de redondance interne.

[[File:ACONIT hall grandes machines.jpg|centre|vignette|upright=2|''Mainframe'' ACONIT.]]

Les ''mainframes'' sont aussi conçus pour mutualiser au maximum leur utilisation, ils peuvent être utilisés par plusieurs utilisateurs à la suite, voire en même temps. Pour cela, les anciens ''mainframes'' étaient capables de faire tourner plusieurs applications distinctes l'une à la suite de l'autre, avec des commutations fréquentes entre logiciels. De nos jours, ils sont capables d'exécuter un grand nombre de tâches en même temps, grâce à la présence de plusieurs processeurs. Les ''mainframes'' modernes sont même capables de faire tourner plusieurs systèmes d'exploitation en même temps si besoin.

Les anciens ''mainframes'' étaient des ordinateurs assez simples, avec un processeur, de la mémoire RAM, un ou plusieurs disques durs, pas plus. Le ''mainframe'' était tellement énorme et cher que les entreprises n'en avaient qu'un seul pour toute l'entreprise. Les employés avaient sur leur bureau des terminaux, qui permettaient d'accéder à l'ordinateur central, mais n'étaient pas des ordinateurs. Les terminaux étaient des composants électroniques simples, avec un écran, un clavier et une souris, mais sans processeur. Ils envoyaient des données au ''mainframe'', ils en recevaient de sa part, mais tout traitement était réalisé sur le ''mainframe''. L'arrivée sur le marché des ordinateurs personnels, de type PC fixe/portable, a entrainé l'abandon de ce genre de pratique, tous les employés ont maintenant un ordinateur rien que pour eux.

{|
|-
! colspan=&quot;2&quot; | Exemples de terminaux
|-
|[[File:Terminal-in2-sm9400.jpg|centre|vignette|upright=1.5|Exemple de terminal. Notez la présence d'un écran et d'un clavier, mais l'asbence d'une unité centrale.]]
|[[File:Chromatics CT4100.jpg|vignette|upright=1.5|Autre exemple de terminal. Le clavier est couplé à un stylo CRT, qui remplacait la souris et agissait sur l'écran comme s'il était tactile.]]
|-
! colspan=&quot;2&quot; | Intérieur d'un terminal
|-
|[[File:CT1024 Monitor.jpg|vignette|upright=1.5|Terminal CT1024, sans le boitier extérieur.]]
|[[File:CT1024 Terminal System.jpg|vignette|upright=1.5|Terminal CT1024, description des composants interne.]]
|}

De nos jours, les ''mainframes'' contiennent en réalité plusieurs ordinateurs simples interconnectés via un réseau local. Un ''mainframe'' qui tient dans une armoire contient facilement une dizaine ou centaine de processeurs, plein de RAM, des disques durs séparés dans une armoire distincte, etc. Vu qu'ils communiquent uniquement via le réseau, ils n'ont pas d'interface, pas d'écran, 'entrée via clavier/souris. Le tout est commandé avec une console de commande, typiquement un ordinateur portable ou un terminal assez simple séparé de l'armoire, qui permet à un administrateur de faire des opérations de surveillance, configuration et maintenance. Il peut y avoir une console de commande pour plusieurs armoires séparées, la console peut même être dans un autre bâtiment et accéder au ''mainframe'' par le réseau.

[[File:IBM System Z9 (type 2094 inside).jpg|centre|vignette|upright=2|''Mainframe'' de type IBM System Z9. L'ordinateur portable sert de console pour qu'un administrateur fasse des opérations de surveillance, configuration et maintenance.]]

Les processeurs et la RAM sont typiquement installés sur des cartes amovibles, qui sont connectées au fond de l'armoire lors de l'installation. Il est même possible de retirer ou d'ajouter des cartes en fonctionnement, afin d'ajouter/retirer des processeurs, des disques durs, etc. Ce qui est très utile si un composant est en panne et qu'il faut le remplacer. 

[[File:IBM TotalStorage Exp400.jpg|centre|vignette|upright=2|IBM TotalStorage Exp400]]

==Un peu d'abstraction : qu'est-ce qu'un ordinateur ?==

Un ordinateur comprend donc un processeur, plusieurs mémoires, des cartes d'extension et une carte mère pour connecter le tout. Mais il s'agit là d'une description assez terre-à-terre de ce qu'est un ordinateur. Une autre description, plus abstraite, se base sur le fait qu'un ordinateur est une énorme calculatrice programmable. Elle permet d'expliquer pourquoi il y a une distinction entre processeur et mémoire, entre unité centrale et périphériques. Tout ce qui va suivre pourra vous paraitre assez abstrait, mais rassurez-vous : les prochains chapitres rendront tout cela plus concrets.

===La séparation entre entrées-sorties et traitement===

L'unité centrale peut être vue comme une énorme calculatrice ultra-puissante, qui exécute des commandes/opérations. Mais à elle seule, elle ne servirait à rien, il faut interagir avec par l'intermédiaire de plusieurs périphériques. Il existe deux types de périphériques, qui sont conceptuellement différents. Les périphériques comme le clavier ou la souris permettent d'envoyer des informations à l'ordinateur, d'agir sur celui-ci. A l'inverse, les écrans transmettent des informations dans le sens inverse : de l'ordinateur vers l'utilisateur. Les premiers sont appelés des '''entrées''', les seconds des '''sorties'''.

Dans un ordinateur, les informations sont représentées sous la forme de nombres. Toute donnée dans un ordinateur est codée avec un ou plusieurs nombres regroupés dans une donnée, un fichier, ou autre. Et la transmissions avec les entrées et sorties se fait là-encore avec des nombres. Par exemple, quand vous appuyez sur votre clavier, le clavier envoie un numéro de touche à l'unité centrale, qui indique quelle touche a été appuyée. L'image à afficher à l'écran est codée sous la forme d'une suite de nombres (un par pixel). L'image est envoyée à l'écran, qui traduit la suite de nombre en image à afficher. Les entrées traduisent des actions utilisateurs en nombres, on dit que les entrées encodent les actions utilisateur. Les sorties font la traduction inverse, elles transforment des suites de nombres en une action physique. On dit qu'elles décodent des informations.

Pour résumer, toute appareil électronique est composé par :
* Des '''entrées''' sur lesquelles l'utilisateur agit sur l'ordinateur. Les entrées transforment les actions de l'utilisateur en nombres, qui sont interprétés par l'ordinateur.
* Une '''unité de traitement''', qui manipule des nombres et fait des calculs/opérations dessus. Les nombres proviennent des entrées, du disque dur, ou d'autres sources, peu importe.
* Des '''sorties''', qui va récupèrent le résultat calculé par l'unité de traitement pour en faire quelque chose : écrire sur une imprimante ou sur un moniteur, émettre du son,...

[[File:Ordinateur théorique Simple 1.png|centre|vignette|upright=2|Ordinateur théorique Simple 1]]

L'unité de traitement proprement dite, celle qui fait les calculs, est couplée à une mémoire qui mémorise les opérandes et résultats des calculs. La séparation entre processeur et mémoire est nécessaire pour qu'un appareil électronique soit qualifié d'ordinateur. De nombreux appareils n'ont pas de séparation entre unité de traitement et mémoire, comme certaines vielles radios AM/FM.

[[File:Schéma de principe d'un ordinateur.png|centre|vignette|upright=2|Schéma de principe d'un ordinateur]]

===Un ordinateur est un appareil programmable===

Les appareils simples sont non-programmables, ce qui veut dire qu’ils sont conçus pour une utilisation particulière et qu’ils ne peuvent pas faire autre chose. Par exemple, les circuits électroniques d’un lecteur de DVD ne peuvent pas être transformé en lecteur audio ou en console de jeux... Les circuits non-programmables sont câblés une bonne fois pour toute, et on ne peut pas les modifier. On peut parfois reconfigurer le circuit, pour faire varier certains paramètres, via des interrupteurs ou des boutons, mais cela s’arrête là. Et cela pose un problème : à chaque problème qu'on veut résoudre en utilisant un automate, on doit recréer un nouveau circuit.

À l'inverse, un ordinateur n’est pas conçu pour une utilisation particulière, contrairement aux autres objets techniques. Il est possible de modifier leur fonction du jour au lendemain, on peut lui faire faire ce qu’on veut. On dit qu'ils sont '''programmables'''. Pour cela, il suffit d’utiliser un logiciel, une application, un programme (ces termes sont synonymes), qui fait ce que l'on souhaite. La totalité des logiciels présents sur un ordinateur sont des programmes comme les autres, même le système d'exploitation (Windows, Linux, ...) ne fait pas exception.

Un programme est une suite de d'instructions, chaque instruction effectuant une action dans l'ordinateur. Sur les ordinateurs modernes, la majorité de ces instructions effectuent une opération arithmétique, comme une addition, une multiplication, une soustraction, etc. Les ordinateurs modernes sont donc de grosses calculettes très puissantes, capables d'effectuer des millions d'opérations par secondes. Et qui dit opération dit nombres : un ordinateur gère nativement des nombres, qui sont codés en binaire sur la quasi-totalité des ordinateurs modernes.

Une instruction est représentée dans un ordinateur par une série de nombres : un nombre qui indique quelle opération/commande effectuer et des autres nombres pour coder les données (ou de quoi les retrouver dans l'ordinateur). L'ordinateur récupére les commandes une par une, les traduit en opération à effectuer, exécuter l'opération, et enregistre le résultat. Puis il recommence avec la commande suivante.

[[File:Ordinateur Théorique Complexe 1.png|centre|vignette|upright=3|Ordinateur Théorique Complexe. En jaune, le programme informatique, la liste de commande. Le rectangle gris est l'ordinateur proprement dit.]]

De nombreux appareils sont programmables, mais tous ne sont pas des ordinateurs. Par exemple, certains circuits programmables nommés FPGA n'en sont pas. Pour être qualifié d'ordinateur, un appareil programmable doit avoir un processeur séparé de la mémoire. De plus, il doit utiliser un '''codage numérique''', chose que nous allons aborder dans le chapitre suivant.

===Les ordinateurs à programme mémorisé ou programme externe===

Au tout début de l'informatique, on utilisait des cartes perforées en plastique, sur lesquelles on inscrivait le programme à exécuter, les données à traiter, bref : tout ce qu'on donnait à manger à l'ordinateur. Par la suite, les premiers ordinateurs grand public, comme les Amstrad ou les Commodore, utilisaient des cassettes audio magnétiques pour stocker les programmes. Dans le même style, les consoles de jeu utilisaient autrefois des cartouches de jeu, qui contenaient le programme du jeu à exécuter. Pour résumer, les anciens ordinateurs mémorisaient les programmes sur un support externe, lu par un périphérique. De tels ordinateurs sont dits à '''programme externe'''.

: D’anciens ordinateurs personnels, comme l’Amstrad ou le Commodore, permettaient de taper les programmes à exécuter à la main, au clavier, avant d’appuyer une touche pour les exécuter. Nul besoin de vous dire que les cassettes audio étaient plus pratiques.

Mais de nos jours, les programmes sont enregistrés sur le disque dur de l'ordinateur ou dans une mémoire intégrée à l'ordinateur. On dit qu'ils sont installés, ce qui est un mot bien compliqué pour dire que le programme est enregistré sur le disque dur de l’ordinateur. A défaut de disque dur, le programme/logiciel est enregistré dans une mémoire spécialisée pour le stockage. Par exemple, sur les cartes électroniques grand public de marque Arduino, les programmes sont envoyés à la carte via le port USB, mais les programmes sont enregistrés dans la carte Arduino, dans une mémoire FLASH dédiée. Disque dur ou non, le programme est mémorisé dans la mémoire de l'ordinateur. Il est possible d'installer ou de désinstaller les programmes en modifiant le contenu de la mémoire. Le terme utilisé est alors celui de '''programme stocké en mémoire'''.

Les programmes à installer sont disponibles soit sur un périphérique, comme un DVD ou une clé USB, soit sont téléchargés depuis internet. Les premiers PC fournissaient les logiciels sur des disquettes, qui contenaient un programme d'installation pour enregistrer le programme sur le disque dur de l'ordinateur. Par la suite, le support des logiciels a migré vers les CD et DVD, les logiciels devenant de plus en plus gros. De nos jours, la majorité des applications sont téléchargées depuis le net, l'usage de périphériques est devenu obsolète, même les consoles de jeu abandonnent cette méthode de distribution.

==Les générations d'ordinateurs : un historique rapide==

L'informatique a beaucoup évolué dans le temps. Et une bonne partie de cette évolution tient à l'évolution de l’électronique sous-jacente. Les ordinateurs actuels sont fabriqués avec des transistors, des petits composants électroniques qui servent d'interrupteur programmables, qu'on détaillera dans ce qui suit. Mais ça n'a pas toujours été le cas. Et cela permet de distinguer plusieurs '''générations d'ordinateurs'''.

===Les ordinateurs électro-mécaniques : les premiers ordinateurs===

Le tout premier ordinateur est le '''Z1''', un modèle unique inventé par Konrad Suze entre 1936 et 1938. Son processeur gérait non pas des nombres entiers, mais des nombres à virgule (des nombres dits flottants, pour être précis), encodés sur 22 bits. Le processeur du Z1 était capable de faire des additions et des soustractions, car il intégrait un circuit additionneur-soustracteur basique. Des circuits annexes permettaient de faire des multiplications et des divisions en enchainant des additions/soustractions successives. Il fonctionnait à une fréquence de 1 Hz, ce qui fait qu'il pouvait faire une addition/soustraction par seconde maximum.

[[File:Blue-punch-card-front.png|vignette|upright=0.5|Carte Perforée.]]

Niveau mémoire, la RAM de l'ordinateur était très limitée : seulement 16 nombres de 22 bits chacun. S'il s'agissait d'une mémoire électronique, les programmes étaient mémorisés sur une mémoire mécanique. Les programmes étaient enregistrés sur des cartes perforées, à savoir des cartes en papier dans lesquelles un 1 est codé par un trou dans le papier et un 0 par une absence de trou. Les programmes étaient exécutés par l'ordinateur quand on insérait la carte perforée dans le lecteur et qu'on appuyait sur un bouton.

[[File:German Museum of Technology, Berlin 2017 024.jpg|centre|vignette|upright=2|Réplique du Z1 au ''German Museum of Technology'' de Berlin, 2017.]]

Après sa destruction dans un bombardement, le Z1 a été reconstruit et amélioré, ce qui donné les deux ordinateurs Z2 et Z3. Quelques années plus tard, de nombreux ordinateurs ont été construits dans des laboratoires de recherche. Des grandes noms de l'histoire de l'informatique datent de cette époque : le Harvard Mark I et le Colossus Mark 1 (UK) ont tous deux été mis en service en 1944, par exemple. Ils ont servis pour les cryptanalystes pour casser les codes utilisés par les allemands pour leurs transmissions, pendant la seconde guerre mondiale.

Les ordinateurs cités dans le précédent paragraphe étaient tous des ordinateurs dit '''électro-mécaniques''', car ils mélangeaient des composants électroniques et des composants mécaniques (tout ce qui a trait aux cartes perforées, notamment). Les composants électroniques étaient soit des relais, soit des tubes à vides, les deux étant des interrupteurs commandables électriquement plus ou moins équivalents aux transistors. Les ordinateurs d'avant l'année 1944, étaient tous de ce type. Quelques ordinateurs des années 50 étaient de ce type, mais leur nombre n'a pas dépassé 30. Il faut dire qu'ils ont rapidement laissé la place à des ordinateurs purement électroniques, que nous allons voir dans ce qui suit..

===Les premières générations : des ordinateurs qui prenaient des pièces de bâtiment entières===

Les ordinateurs qui ont suivi les ordinateurs électromécaniques sont regroupés dans la '''première génération d'ordinateur'''. Ils étaient conçus avec des tubes à vide, ce qui les place entre les premiers ordinateurs électro-mécaniques et les ordinateurs utilisant des transistors. Les ordinateurs de première génération étaient très simples, ils ne géraient que quelques opérations simples : l'addition, la soustraction, pas grand chose de plus. A quelques exceptions près, ils ne géraient pas la multiplication et encore moins la division, ils n'avaient pas assez de relais ou de tubes à vides à disposition pour cela.

Une des toute première machine construite avec des tubes à vide était l'Atanasoff–Berry. Ce n'était pas un ordinateur, car elle ne pouvait pas exécuter de programme sans intervention humaine pour séquencer des opérations. Elle était construite pour résoudre des équations différentielles linéaires, donc pour des calculs très précis. Mais c'était la première machine de calcul purement électronique. Elle utilisait une mémoire RAM construite avec des condensateurs, des circuits de calcul construits avec des tubes à vide, aucune pièce mécanique. Les nombres étaient encodés sur 50 bits. Elle fonctionnait à une fréquence de 60 Hz et pouvait faire 30 additions/soustractions par seconde. Les calculs étaient réalisés un bit à la fois dans les circuits de calcul.

[[File:Atanasoff Berry Computer.gif|centre|vignette|upright=2.5|Atanasoff–Berry.]]

Mais c'est l'arrivée de l'ENIAC en 1945 qui a changé la donne. Cet ordinateur a introduit plusieurs innovations majeures. La première est assez technique, il s'agit de la turing-complétude, et a trait aux programmes qui peuvent être écrit pour un ordinateur. Nous ne la détaillerons pas ici. La seconde innovation est que l'ENIAC était composé non pas de relais et d'éléments mécaniques, mais uniquement de tubes à vides, des composants électroniques assez rudimentaires plus ou moins équivalents aux transistors modernes.

Le ''Manchester Baby'' a introduit une innovation extrêmement importante, au point où on considère que c'est le premier ordinateur à avoir tous les critères nécessaires pour être appelé un ordinateur. Son innovation est que le programme n'était plus mémorisé sur des cartes perforée, mais dans une mémoire électronique dans l'ordinateur lui-même. En clair, le ''Manchester Baby'' était le premier '''''Stored-program computer''''', ordinateur à programme enregistré en français. 

[[File:IBM 7070.jpg|vignette|Cartes imprimées de l'IBM 704, avec des transistors et résistances dessus.]]

La '''seconde génération''' est celle des ordinateurs fabriqués avec des '''transistors''' isolés, reliés entre avec des fils électriques. Les transistors en question possèdent trois broches, des pattes métalliques sur lesquelles on connecte des fils électriques. Le transistor s'utilise le plus souvent comme un interrupteur commandé par sa troisième broche. Le courant qui traverse les deux premières broches passe ou ne passe pas selon ce qu'on met sur la troisième.

[[File:Transistor basic flow.svg|centre|vignette|Un transistor est un morceau de conducteur, dont la conductivité est contrôlée par sa troisième broche/borne.]]

Les ordinateurs de seconde génération avaient entre 1000 et 500 000 transistors. Les capacités des ordinateurs étaient donc nettement supérieures à celles des ordinateurs de première génération. Une part non négligeable des ordinateurs de seconde génération supportait l'opération de multiplication, absente sur les ordinateurs de première génération. Néanmoins, cela variait beaucoup selon les ordinateurs.

Un exemple assez hors du commun est celui du premier modèle de l'IBM 1620. Le tout premier modèle n'avait aucun circuit de calcul, il n'était même pas capable de faire une addition ou une multiplication. A la place, il utilisait une table d'addition et une table de multiplication en mémoire RAM. Les deux tables devaient être initialisées par le logiciel lors du démarrage de la machine. La table d'addition faisait une centaine de chiffre, la table de multiplication faisait le double. Le processeur de l'ordinateur gérait des instructions pour faire des additions ou des multiplications, mais ces opérations lisaient le résultat dans la table d'addition. Les calculs étaient fait chiffre par chiffre, avec un encodage partiellement décimal, partiellement binaire (des chiffres décimaux étaient encodés en binaire, nous en reparlerons quand nous parlerons du BCD) !

[[File:KL CoreMemory.jpg|vignette|Mémoire à tore de ferrite.]]

Les transistors n'étaient utilisés que pour le processeur et les circuits annexes. La mémoire n'était pas faite en transistors, pas à cette époque. La mémoire était une mémoire aujourd'hui abandonnée, appelée une '''mémoire à tores de ferrite'''. Elle sera détaillée dans un chapitre ultérieur. Mais sachez pour le moment qu'il s'agit d'une mémoire au support magnétique, les données étant stockées sur un support magnétique.

Transistors comme tubes à vide prenaient beaucoup de place, ce qui fait que les ordinateurs étaient assez gros. Concrètement, ils prenaient une pièce de bâtiment entière dans le meilleur des cas. C'était l'époque des gros ''mainframes'', reliés à des terminaux, peu puissants comparé aux standards actuels. Seules les grandes entreprises et les grands instituts de recherche pouvaient se payer les services de ce genre d'ordinateurs. Seuls les professionnels avaient accès à ce genre d'équipement.

===La troisième génération : le circuit intégré===

[[File:D8259AC-2.jpg|vignette|Exemple de circuit intégré.]]

La troisième génération est toujours fabriquée avec des transistors, mais dont la taille a été réduite. Avec l'évolution de la technologie, les transistors ont diminué en taille, de plus en plus. Ils sont devenus tellement petits qu'ils ont finit par être regroupés dans des '''circuits intégrés''', des circuits regroupent plusieurs transistors sur la même puce de silicium. Les circuits intégrés se présentent le plus souvent sous la forme de boitiers rectangulaires, comme illustré ci-contre. D'autres ont des boitiers de forme carrées, comme ceux que l'on peut trouver sur les barrettes de mémoire RAM, ou à l'intérieur des clés USB/ disques SSD.

Lors de cette génération, les processeurs étaient fournis en pièces détachées qu'il fallait relier entre elles. Le processeur était composé de plusieurs circuits intégrés séparés, impossible de mettre un processeur dans un seul boitier. Un exemple de processeur conçu en kit est la série des Intel 3000. Elle regroupe plusieurs circuits séparés aux noms à coucher dehors, mais dont vous comprendrez ce qu'ils veulent dire dans les chapitres adéquats : l'Intel 3001 est un séquenceur, l'Intel 3002 regroupe unité de calcul et registres, le 3003 est un circuit d'anticipation de retenue complémentaire du 3002, le 3212 est une mémoire tampon, le 3214 est une unité de gestion des interruptions, les 3216/3226 sont des interfaces de bus mémoire. On pourrait aussi citer la famille de circuits intégrés AMD Am2900.

Même si le processeur était en pièce détachées, utiliser une dizaine de circuits intégrés était nettement mieux que d'utiliser plusieurs milliers de transistors individuels. En conséquence, les ordinateurs ont vu leur taille grandement réduite, passant de pièces entières à une simple armoire, voire à quelques cartes intégrées superposées. De plus, le prix des circuits intégré était abordable, du moins comparé aux ordinateurs d'avant. Le prix des ordinateurs a alors grandement décru, permettant à des entreprises et administrations de taille modeste de s'équiper d'ordinateurs.

===La quatrième génération : le microprocesseur===

[[File:MOS6502.svg|vignette|Microprocesseur, ici un processeur MOS6502, de la quatrième génération.]]

Lors de la troisième génération, les circuits intégrés regroupaient plusieurs dizaines ou centaines de transistors, mais sont rapidement montés en gamme. De centaines de transistors, ils sont passé au milliers de transistors, puis au millions et maintenant au-delà du milliard. Les transistors étaient devenus tellement petits, tellement miniaturisés, qu'il était devenu possible de mettre un processeur entier dans un circuit intégré. C'est ainsi qu'est né le microprocesseur, à savoir un processeur qui tient tout entier dans un seul circuit imprimé. La quatrième génération d’ordinateur est celle des ordinateurs basés autour d'un microprocesseur.

Les tout premiers microprocesseurs étaient des processeurs à application militaire, comme le processeur du F-14 CADC ou celui de l'Air data computer. Le tout premier microprocesseur commercialisé au grand public est le 4004 d'Intel, sorti en 1971. L'intel 4004 comprenait environ 2300 transistors, avait une fréquence de 740 MHz, pouvait faire 46 opérations différentes, et manipulait des entiers de 4 bits. Il était au départ un processeur de commande, prévu pour être intégré dans la calculatrice Busicom calculator 141-P, mais il fut utilisé pour d'autres applications quelque temps plus tard. Immédiatement après le 4004, les premiers microprocesseurs 8 bits furent commercialisés. Le 4004 fut suivi par le 8008 et quelques autres processeurs 8 bits extrêmement connus, comme le 8080 d'Intel, le 68000 de Motorola, le 6502 ou le Z80.

Les microprocesseurs permirent encore uen fois de réduire la taille des ordinateurs, qui pouvaient tenir dans un boitier de PC, ou un boitier de console de jeu. Le prix des ordinateurs a aussi chuté en même temps que les transistors était miniaturisés. C'est cette invention qui permis l'invention des consoles de jeux et des mini-ordinateurs, à savoir les ordinateurs personnels. Sans miniaturisation, on n'aurait pas d'ordinateur personnel, pas de PC fixe ou portable.

==L'organisation du cours : les différents niveaux d'explication==

Le fonctionnement d'un ordinateur est assez complexe à expliquer car les explications peuvent se faire sur plusieurs niveaux. Par plusieurs niveaux, on veut dire qu'un ordinateur est composé de composants très simples, qui sont assemblés pour donner des composants eux-même plus complexes, qui sont eux-même regrouper, etc. Étudier tout cela demande de voir plusieurs niveaux, allant de transistors très petits à des processeurs multicœurs. Les niveaux les plus bas sont de l'électronique pur et dure, alors que ceux plus haut sont à mi-chemin entre électronique et informatique.

===Les niveaux d'abstraction en architecture des ordinateurs===

Les trois premiers niveaux sont de l'électronique pur et dure. Ils correspondent aux premiers chapitres du cours, qui porteront sur les circuits électroniques en général.
* Le premier niveau est celui des '''transistors''', des circuits intégrés, des ''wafer'' et autres circuits de très petite taille.
* Le second niveau est celui des '''portes logiques''', des circuits très basiques, très simples, à la base de tous les autres.
* Le troisième niveau est celui dit de la '''''Register Transfer Level''''', où un circuit électronique est construit à partir de circuits basiques, dont des registres et autres circuits dits combinatoires.
Les deux niveaux suivants sont de l'informatique proprement dit. C'est dans ces deux niveaux qu'on étudie les ordinateurs proprement dit, les circuits qu'il y a dedans et non l'électronique en général.
* Le quatrième niveau est celui de la '''microarchitecture''', qui étudie ce qu'il y a à l'intérieur d'un processeur, d'une mémoire, des périphériques et autres.
* Le cinquième niveau est celui de l''''architecture externe''', qui décrit l'interface du processeur, de la mémoire, d'un périphérique ou autre. Par décrire l'interface, on veut dire : comment un programmeur voit le processeur et la mémoire, comment il peut les manipuler. Une architecture externe unique peut avoir plusieurs microarchitecture, ce qui fait qu'on sépare les deux. Tout cela sera plus clair quand on passera aux chapitres sur le processeur et les mémoires.

Nous n'allons pas voir les 5 niveaux dans l'ordre, des transistors vers l'architecture externe. En réalité, nous allons procéder autrement. La première partie du cours portera sur les trois premiers niveaux, le reste sur les deux autres. Les 5 niveaux seront vus dans des chapitres séparés, du moins le plus possible. Au niveau pédagogique, tout est plus simple si on scinde les 5 niveaux. Bien sûr, il y a quelques explications qui demandent de voir plusieurs niveaux à la fois. Par exemple, dans le chapitre sur les mémoires caches, nous auront des explications portant sur la RTL, la microarchitecture du cache et son architecture externe. Mais le gros du cours tentera de séparer le plus possible les 5 niveaux.

===Les trois parties principales du cours===

Nous allons commencer par parler du binaire, avant de voir les portes logiques. Avec ces portes logiques, nous allons voir comment fabriquer des circuits basiques qui reviendront très souvent dans la suite du cours. Nous verrons les registres, les décodeurs, les additionneurs et plein d'autres circuits. Puis, nous reviendrons au niveau des transistors pour finir la première partie. La raison est que c'est plus simple de faire comme cela. Tout ce qui a trait aux transistors sert à expliquer comment fabriquer des portes logiques, et il faut expliquer les portes logiques pour voir le niveau de la RTL.

Une fois la première partie finie, nous allons voir les différents composants d'un ordinateur. Une première partie expliquera ce qu'il y a dans un ordinateur, quels sont ses composants. Nous y parlerons de l'architecture de base, de la hiérarchie mémoire, des tendances technologiques, et d'autres généralités qui serviront de base pour la suite. Puis, nous verrons dans l'ordre les bus électroniques, les mémoires RAM/ROM, le processeur, les périphériques, les mémoires de stockage (SSD et disques durs) et les mémoires caches. Pour chaque composant, nous allons voir leur architecture externe, avant de voir leur microarchitecture. La raison est que la microarchitecture ne peut se comprendre que quand on sait quelle architecture externe elle implémente.

Enfin, dans une troisième partie, nous allons voir les optimisations majeures présentes dans tous les ordinateurs modernes, avec une partie sur le pipeline et le parallélisme d'instruction, et une autre sur les architectures parallèles. Pour finir, les annexes de fin parlerons de sujets un peu à part.

&lt;noinclude&gt;
{{NavChapitre | book=Fonctionnement d'un ordinateur
           | next=L'encodage des données
           | nextText=L'encodage des données
}}
&lt;/noinclude&gt;</text>
      <sha1>ouuxzzcwk01ayaq6489eoq9htv0riqm</sha1>
    </revision>
    <revision>
      <id>744114</id>
      <parentid>744113</parentid>
      <timestamp>2025-06-04T21:25:19Z</timestamp>
      <contributor>
        <username>Mewtow</username>
        <id>31375</id>
      </contributor>
      <minor />
      <comment>/* Les premières générations : des ordinateurs qui prenaient des pièces de bâtiment entières */</comment>
      <origin>744114</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="42941" sha1="t6ptdzor6ix8eysnq6rbclu8q4akzni" xml:space="preserve">Pour commencer, nous allons voir qu'il existe de nombreux types d'ordinateurs. Le plus connu est certainement le PC, l'ordinateur personnel, que vous avez sans doute dans votre salon. Les ordinateurs portables sont un deuxième type d'ordinateur assez intuitif, que vous avez peut-être. Mais il y a aussi d'autres types d'ordinateurs auxquels vous n'avez jamais été confrontés.

==Les différents types d'ordinateurs==

Dans cette section, nous allons décrire rapidement les ordinateurs les plus courant, mais surtout voir ce qu'il y a à l'intérieur d'un ordinateur.

===L'ordinateur de type PC fixe===

De l'extérieur, l'ordinateur est composé d'une unité centrale sur laquelle on branche des périphériques.

[[File:Typical computer architecture systems.jpg|vignette|upright=1.5|Exemples de périphériques, connectés à une unité centrale (ici appelée à tort ''operating system'').]]

Les '''périphériques''' regroupent l'écran, la souris, le clavier, l'imprimante, et bien d'autres choses. Ils permettent à l'utilisateur d'interagir avec l'ordinateur : un clavier permet de saisir du texte sous dans un fichier, une souris enregistre des déplacements de la main en déplacement du curseur, un écran affiche des données d’images/vidéos, un haut-parleur émet du son, etc. Tout ce qui est branché sur un ordinateur est, formellement un périphérique.

L''''unité centrale''' est là où se trouvent tous les composants importants d'un ordinateur, ceux qui font des calculs, qui exécutent des logiciels, qui mémorisent vos données, etc. Voici ce à quoi ressemble l'intérieur de l'unité centrale. Trois sections sont visibles : l'alimentation électrique en haut à gauche, la carte mère en bas à gauche et en jaune/orange, les disques et lecteurs à droite des câbles. Et on voit aussi beaucoup de câbles.

[[File:Asus P5K-SEIntel E6320.jpg|centre|vignette|upright=2|Exemple d'unité centrale.]]

Tout en haut à gauche, se trouve l''''alimentation électrique''', qui convertit le courant de la prise électrique en un courant plus faible, utilisable par les autres composants. Elle émet de nombreux câbles assez gros, qui sont reliés au reste. Les PC actuels utilisent des alimentations électriques standardisées, qui fournissent trois tensions au reste de l'ordinateur : une tension de 12 Volts, une de 5 Volts, une de 3,3 Volts.

À droite, caché par la partie &quot;métallique&quot; du boitier, se trouvent les lecteurs de CD/DVD, et les disques durs. Les lecteurs CD-ROM ou DVD-ROM permettaient de lire des CD ou des DVD. Je parle au passé, car ils ont aujourd'hui disparu des ordinateurs modernes. Les '''disques durs''' sont des mémoires de stockage, qui mémorisent vos données de manière permanente. De nos jours, ils sont remplacés par des SSD, qui sont des disques durs électroniques, là où les disques durs proprement dit sont des mémoires magnétiques. Nous verrons la différence dans deux chapitres dédiés, un sur les disques durs, l'autre sur les SSD.

En bas à droite, se trouve la '''carte mère''' un support plat, en plastique ou en céramique, sur laquelle sont soudés/connectés les autres composants. Sur celle-ci, de nombreux composants sont soudés, d'autres sont branchés dessus avec des câbles, d'autres sont connectés dessus avec des connecteurs. Ils sont reliés entre eux par des fils conducteurs, le plus souvent du cuivre ou de l’aluminium, ce qui leur permet de s’échanger des données. Sur les cartes simples, ces fils sont intégrés dans la carte électronique, dans des creux du plastique. Ils portent le nom de pistes.

Avant, les disques durs, SSD et lecteurs de CD/DVD sont branchés dessus via des connecteurs dédiés, appelés des connecteurs S-ATA. De nos jours, ils sont branchés sur un autre connecteur, grâce à l'interface NVME. Toujours est-il qu'ils sont reliés à la carte mère par des câbles, ce qui montre que ce sont des sortes de périphériques interne. Ils sont placés dans le boitier, mais on aurait tout aussi bien pu les mettre à l'extérieur, vu qu'ils communiquent avec l'ordinateur par l'intermédiaire d'un câble ou d'un connecteur dédié.

Mais deux autres composants très importants sont eux placés sur la carte mère, directement. Ils ont chacun un connecteur dédié, sur lequel ils sont branchés directement, sans passer par l'intermédiaire d'un câble, mais sans être soudés non plus. Il s'agit du processeur et de la mémoire RAM, deux composants centraux des PC modernes.

[[File:Pentium III SL4CB.jpg|thumb|Processeur Pentium III.]]

Le '''processeur''' traite les données, les modifie, les manipule. Pour faire simple, il s’agit d’une grosse calculatrice hyper-puissante. Il comprend à la fois un circuit qui fait des calculs, et un circuit de contrôle qui s'occupe de séquencer les calculs dans l'ordre demandé. Il est souvent caché sous un radiateur, lui-même surmonté par un ventilateur. En effet, un processeur chauffe beaucoup, ce qui demande d'évacuer cette chaleur. Un chapitre entier expliquera pourquoi les processeurs chauffent, ainsi que les techniques utilisées pour limiter leur production de chaleur et leur consommation électrique.

La '''mémoire vive''' conserve des informations/données temporairement, tant que le processeur en a besoin. Elle prend la forme de barrettes de RAM, comme montré ci-dessous.

[[File:2 gb ddr2 667.jpg|centre|vignette|upright=2|Barrette de RAM.]]

Outre ces composants dits principaux, un ordinateur peut comprendre plusieurs composants moins importants, surtout présents sur les ordinateurs personnels. Ils sont techniquement facultatifs, mais sont très présents dans les ordinateurs personnels. Cependant, certains ordinateurs spécialisés s'en passent. Il s'agit des diverses '''cartes d'extension''' sont branchées sur la carte mère. Elles permettent d’accélérer certains calculs ou certaines applications, afin de décharger le processeur. Par exemple, la carte graphique s'occupe des calculs graphiques, qu'il s'agisse de graphismes 3D de jeux vidéos ou de l'affichage en 2D du bureau. Dans un autre registre, la carte son prend en charge le microphone et les haut-parleurs.

[[Fichier:Personal computer, exploded 4.svg|thumb|upright=1.0|Éclaté d'un ordinateur de type PC :&lt;br /&gt;
1 : Écran ;&lt;br /&gt;
2 : Carte mère ;&lt;br /&gt;
3 : Processeur ;&lt;br /&gt;
4 : Câble Parallel ATA ;&lt;br /&gt;
5 : Mémoire vive (RAM) ;&lt;br /&gt;
6 : Carte d'extension ;&lt;br /&gt;
7 : Alimentation électrique ;&lt;br /&gt;
8 : Lecteur de disque optique ;&lt;br /&gt;
9 : Disque dur ;&lt;br /&gt;
10 : Clavier ;&lt;br /&gt;
11 : Souris.]]

Si on regarde une carte mère de face, on voit un grand nombre de connecteurs, mais aussi des circuits électroniques soudés à la carte mère.

[[File:Architecture matérielle d'une carte mère.png|centre|vignette|upright=2.0|Architecture matérielle d'une carte mère]]

Les '''connecteurs''' sont là où on branche les périphériques, la carte graphique, le processeur, la mémoire, etc. Dans l'ensemble, toute carte mère contient les connecteurs suivants :
* Le processeur vient s’enchâsser dans la carte mère sur un connecteur particulier : le '''socket'''. Celui-ci varie suivant la carte mère et le processeur, ce qui est source d'incompatibilités.
* Les barrettes de mémoire RAM s’enchâssent dans un autre type de connecteurs: les '''slots mémoire'''.
* Les mémoires de masse disposent de leurs propres connecteurs : connecteurs P-ATA pour les anciens disques durs, et S-ATA pour les récents.
* Les périphériques (clavier, souris, USB, Firewire, ...) sont connectés sur un ensemble de connecteurs dédiés, localisés à l'arrière du boitier de l'unité centrale. 
* Les autres périphériques sont placés dans l'unité centrale et sont connectés via des connecteurs spécialisés. Ces périphériques sont des cartes imprimées, d'où leur nom de '''cartes filles'''. On peut notamment citer les cartes réseau, les cartes son, ou les cartes vidéo.

===Les ordinateurs portables===

[[File:Samsung QX-511 (2).JPG|vignette|Ordinateur portable Samsung QX-511 (2), pour illustration.]]

Un ordinateur portable est identique à un ordinateur de type PC. Si vous ouvrez votre ordinateur portable (attention à la garantie), vous retrouverez les mêmes composants qu'un PC à l'intérieur. Un point important est la présence d'une batterie à l'intérieur du PC portable, absente des PC fixes.

[[File:LG gram 14Z90Q mainboard with battery.jpg|centre|vignette|upright=2|LG gram 14Z90Q avec sa batterie.]]

Une fois la batterie et les circuits associés retiré, la seule différence notable est que tous les composants sont soudés sur la carte mère, au lieu d'être branchés sur des connecteurs, à part éventuellement la RAM et le disque dur.

[[File:LG gram 14Z90Q mainboard without battery.jpg|centre|vignette|upright=2|LG gram 14Z90Q sans sa batterie.]]

La RAM est parfois soudée sur la carte mère, d'autres fois sous la forme de barrettes de mémoire vive semblables à celles des PC. Dans le dernier cas, elle est connectée à des connecteurs spécifiques, ce qui permet de les changer/upgrader. Les PC portables sont parfois construits de manière à pouvoir changer la RAM facilement, en ouvrant un cache spécial, concu pour.

[[File:Lenovo G555 состав - Донор.JPG|centre|vignette|upright=2|Lenovo G555.]]

La conception d'un ordinateur portable est légèrement différente de celle d'un PC, pour des raisons thermiques. Un PC fixe a plus de place pour évacuer sa chaleur. Les ventilateurs peuvent plus facilement déplacer l'air dans le boitier, même si le flux d'air dans le boitier est éventuellement gêné par la carte graphique. Mais l'évacuation de la chaleur est assez efficace. Sur les PC portables, leur finesse fait que le trajet de l'air est beaucoup plus contraint. Évacuer la chaleur produite par l'ordinateur est plus complexe, ce qui demande d'utiliser des systèmes de refroidissement et de ventilation spécifiques.

Là où les PC fixes se débrouillent avec des radiateurs et des ventilateurs posés sur le processeur, les PC portables font autrement. Ils ne peuvent pas forcément mettre le ventilateur sur le processeur. A la place, ils mettent le ventilateur à côté, mais le processeur est surmonté par un mécanisme de transmission de la chaleur, qui transfère la chaleur du processeur vers le ventilateur.

[[File:Diagram - How a laptop cooling system works.png|centre|vignette|upright=2|Comment fonctionne le système de ventilation d'un ordinateur portable, en anglais.]]

Les difficultés pour dissiper la chaleur font que les ordinateurs portables utilisent souvent des composants peu performants, mais qui chauffent peu. En effet, nous verrons que plus un composant est puissant, plus il chauffe. La relation n'est pas parfaite, mais les processeurs haute performance chauffent plus que les modèles d'entrée ou milieu de gamme moins puissants. En conséquence, les PC portables sont souvent moins puissants que les PC fixes, même pour les modèles dit ''gaming''.

===Les serveurs et ''mainframes''===

Les grandes entreprises utilisent des ordinateurs de grande taille, très puissants, appelés des ''mainframes''. Ils sont souvent confondus avec les serveurs par le grand public, il y a une différence entre les deux. Un serveur est une fonction logicielle/réseau, pas un type d'ordinateur. Mais laissons cette différence de côté, ce qui est dit pour les ''mainframes'' sert pour les gros serveurs haute performance.

[[File:IBM Z15 mainframe.jpg|vignette|Exemple de ''mainframe''' de type IBM Z15.]]

Les anciens ''mainframes'' des années 50-80 avaient une taille pouvant être impressionnante, au point de prendre une pièce complète d'un bâtiment. Mais de nos jours, les ''mainframes'' tiennent dans une grosse armoire un peu haute. Les ''mainframes'' doivent rester allumé en permanence et ne doivent pas être éteint, sauf éventuellement quelques jours par an pour des opérations de maintenance. Ils utilisent pour cela des techniques spécifiques, avec beaucoup de redondance interne.

[[File:ACONIT hall grandes machines.jpg|centre|vignette|upright=2|''Mainframe'' ACONIT.]]

Les ''mainframes'' sont aussi conçus pour mutualiser au maximum leur utilisation, ils peuvent être utilisés par plusieurs utilisateurs à la suite, voire en même temps. Pour cela, les anciens ''mainframes'' étaient capables de faire tourner plusieurs applications distinctes l'une à la suite de l'autre, avec des commutations fréquentes entre logiciels. De nos jours, ils sont capables d'exécuter un grand nombre de tâches en même temps, grâce à la présence de plusieurs processeurs. Les ''mainframes'' modernes sont même capables de faire tourner plusieurs systèmes d'exploitation en même temps si besoin.

Les anciens ''mainframes'' étaient des ordinateurs assez simples, avec un processeur, de la mémoire RAM, un ou plusieurs disques durs, pas plus. Le ''mainframe'' était tellement énorme et cher que les entreprises n'en avaient qu'un seul pour toute l'entreprise. Les employés avaient sur leur bureau des terminaux, qui permettaient d'accéder à l'ordinateur central, mais n'étaient pas des ordinateurs. Les terminaux étaient des composants électroniques simples, avec un écran, un clavier et une souris, mais sans processeur. Ils envoyaient des données au ''mainframe'', ils en recevaient de sa part, mais tout traitement était réalisé sur le ''mainframe''. L'arrivée sur le marché des ordinateurs personnels, de type PC fixe/portable, a entrainé l'abandon de ce genre de pratique, tous les employés ont maintenant un ordinateur rien que pour eux.

{|
|-
! colspan=&quot;2&quot; | Exemples de terminaux
|-
|[[File:Terminal-in2-sm9400.jpg|centre|vignette|upright=1.5|Exemple de terminal. Notez la présence d'un écran et d'un clavier, mais l'asbence d'une unité centrale.]]
|[[File:Chromatics CT4100.jpg|vignette|upright=1.5|Autre exemple de terminal. Le clavier est couplé à un stylo CRT, qui remplacait la souris et agissait sur l'écran comme s'il était tactile.]]
|-
! colspan=&quot;2&quot; | Intérieur d'un terminal
|-
|[[File:CT1024 Monitor.jpg|vignette|upright=1.5|Terminal CT1024, sans le boitier extérieur.]]
|[[File:CT1024 Terminal System.jpg|vignette|upright=1.5|Terminal CT1024, description des composants interne.]]
|}

De nos jours, les ''mainframes'' contiennent en réalité plusieurs ordinateurs simples interconnectés via un réseau local. Un ''mainframe'' qui tient dans une armoire contient facilement une dizaine ou centaine de processeurs, plein de RAM, des disques durs séparés dans une armoire distincte, etc. Vu qu'ils communiquent uniquement via le réseau, ils n'ont pas d'interface, pas d'écran, 'entrée via clavier/souris. Le tout est commandé avec une console de commande, typiquement un ordinateur portable ou un terminal assez simple séparé de l'armoire, qui permet à un administrateur de faire des opérations de surveillance, configuration et maintenance. Il peut y avoir une console de commande pour plusieurs armoires séparées, la console peut même être dans un autre bâtiment et accéder au ''mainframe'' par le réseau.

[[File:IBM System Z9 (type 2094 inside).jpg|centre|vignette|upright=2|''Mainframe'' de type IBM System Z9. L'ordinateur portable sert de console pour qu'un administrateur fasse des opérations de surveillance, configuration et maintenance.]]

Les processeurs et la RAM sont typiquement installés sur des cartes amovibles, qui sont connectées au fond de l'armoire lors de l'installation. Il est même possible de retirer ou d'ajouter des cartes en fonctionnement, afin d'ajouter/retirer des processeurs, des disques durs, etc. Ce qui est très utile si un composant est en panne et qu'il faut le remplacer. 

[[File:IBM TotalStorage Exp400.jpg|centre|vignette|upright=2|IBM TotalStorage Exp400]]

==Un peu d'abstraction : qu'est-ce qu'un ordinateur ?==

Un ordinateur comprend donc un processeur, plusieurs mémoires, des cartes d'extension et une carte mère pour connecter le tout. Mais il s'agit là d'une description assez terre-à-terre de ce qu'est un ordinateur. Une autre description, plus abstraite, se base sur le fait qu'un ordinateur est une énorme calculatrice programmable. Elle permet d'expliquer pourquoi il y a une distinction entre processeur et mémoire, entre unité centrale et périphériques. Tout ce qui va suivre pourra vous paraitre assez abstrait, mais rassurez-vous : les prochains chapitres rendront tout cela plus concrets.

===La séparation entre entrées-sorties et traitement===

L'unité centrale peut être vue comme une énorme calculatrice ultra-puissante, qui exécute des commandes/opérations. Mais à elle seule, elle ne servirait à rien, il faut interagir avec par l'intermédiaire de plusieurs périphériques. Il existe deux types de périphériques, qui sont conceptuellement différents. Les périphériques comme le clavier ou la souris permettent d'envoyer des informations à l'ordinateur, d'agir sur celui-ci. A l'inverse, les écrans transmettent des informations dans le sens inverse : de l'ordinateur vers l'utilisateur. Les premiers sont appelés des '''entrées''', les seconds des '''sorties'''.

Dans un ordinateur, les informations sont représentées sous la forme de nombres. Toute donnée dans un ordinateur est codée avec un ou plusieurs nombres regroupés dans une donnée, un fichier, ou autre. Et la transmissions avec les entrées et sorties se fait là-encore avec des nombres. Par exemple, quand vous appuyez sur votre clavier, le clavier envoie un numéro de touche à l'unité centrale, qui indique quelle touche a été appuyée. L'image à afficher à l'écran est codée sous la forme d'une suite de nombres (un par pixel). L'image est envoyée à l'écran, qui traduit la suite de nombre en image à afficher. Les entrées traduisent des actions utilisateurs en nombres, on dit que les entrées encodent les actions utilisateur. Les sorties font la traduction inverse, elles transforment des suites de nombres en une action physique. On dit qu'elles décodent des informations.

Pour résumer, toute appareil électronique est composé par :
* Des '''entrées''' sur lesquelles l'utilisateur agit sur l'ordinateur. Les entrées transforment les actions de l'utilisateur en nombres, qui sont interprétés par l'ordinateur.
* Une '''unité de traitement''', qui manipule des nombres et fait des calculs/opérations dessus. Les nombres proviennent des entrées, du disque dur, ou d'autres sources, peu importe.
* Des '''sorties''', qui va récupèrent le résultat calculé par l'unité de traitement pour en faire quelque chose : écrire sur une imprimante ou sur un moniteur, émettre du son,...

[[File:Ordinateur théorique Simple 1.png|centre|vignette|upright=2|Ordinateur théorique Simple 1]]

L'unité de traitement proprement dite, celle qui fait les calculs, est couplée à une mémoire qui mémorise les opérandes et résultats des calculs. La séparation entre processeur et mémoire est nécessaire pour qu'un appareil électronique soit qualifié d'ordinateur. De nombreux appareils n'ont pas de séparation entre unité de traitement et mémoire, comme certaines vielles radios AM/FM.

[[File:Schéma de principe d'un ordinateur.png|centre|vignette|upright=2|Schéma de principe d'un ordinateur]]

===Un ordinateur est un appareil programmable===

Les appareils simples sont non-programmables, ce qui veut dire qu’ils sont conçus pour une utilisation particulière et qu’ils ne peuvent pas faire autre chose. Par exemple, les circuits électroniques d’un lecteur de DVD ne peuvent pas être transformé en lecteur audio ou en console de jeux... Les circuits non-programmables sont câblés une bonne fois pour toute, et on ne peut pas les modifier. On peut parfois reconfigurer le circuit, pour faire varier certains paramètres, via des interrupteurs ou des boutons, mais cela s’arrête là. Et cela pose un problème : à chaque problème qu'on veut résoudre en utilisant un automate, on doit recréer un nouveau circuit.

À l'inverse, un ordinateur n’est pas conçu pour une utilisation particulière, contrairement aux autres objets techniques. Il est possible de modifier leur fonction du jour au lendemain, on peut lui faire faire ce qu’on veut. On dit qu'ils sont '''programmables'''. Pour cela, il suffit d’utiliser un logiciel, une application, un programme (ces termes sont synonymes), qui fait ce que l'on souhaite. La totalité des logiciels présents sur un ordinateur sont des programmes comme les autres, même le système d'exploitation (Windows, Linux, ...) ne fait pas exception.

Un programme est une suite de d'instructions, chaque instruction effectuant une action dans l'ordinateur. Sur les ordinateurs modernes, la majorité de ces instructions effectuent une opération arithmétique, comme une addition, une multiplication, une soustraction, etc. Les ordinateurs modernes sont donc de grosses calculettes très puissantes, capables d'effectuer des millions d'opérations par secondes. Et qui dit opération dit nombres : un ordinateur gère nativement des nombres, qui sont codés en binaire sur la quasi-totalité des ordinateurs modernes.

Une instruction est représentée dans un ordinateur par une série de nombres : un nombre qui indique quelle opération/commande effectuer et des autres nombres pour coder les données (ou de quoi les retrouver dans l'ordinateur). L'ordinateur récupére les commandes une par une, les traduit en opération à effectuer, exécuter l'opération, et enregistre le résultat. Puis il recommence avec la commande suivante.

[[File:Ordinateur Théorique Complexe 1.png|centre|vignette|upright=3|Ordinateur Théorique Complexe. En jaune, le programme informatique, la liste de commande. Le rectangle gris est l'ordinateur proprement dit.]]

De nombreux appareils sont programmables, mais tous ne sont pas des ordinateurs. Par exemple, certains circuits programmables nommés FPGA n'en sont pas. Pour être qualifié d'ordinateur, un appareil programmable doit avoir un processeur séparé de la mémoire. De plus, il doit utiliser un '''codage numérique''', chose que nous allons aborder dans le chapitre suivant.

===Les ordinateurs à programme mémorisé ou programme externe===

Au tout début de l'informatique, on utilisait des cartes perforées en plastique, sur lesquelles on inscrivait le programme à exécuter, les données à traiter, bref : tout ce qu'on donnait à manger à l'ordinateur. Par la suite, les premiers ordinateurs grand public, comme les Amstrad ou les Commodore, utilisaient des cassettes audio magnétiques pour stocker les programmes. Dans le même style, les consoles de jeu utilisaient autrefois des cartouches de jeu, qui contenaient le programme du jeu à exécuter. Pour résumer, les anciens ordinateurs mémorisaient les programmes sur un support externe, lu par un périphérique. De tels ordinateurs sont dits à '''programme externe'''.

: D’anciens ordinateurs personnels, comme l’Amstrad ou le Commodore, permettaient de taper les programmes à exécuter à la main, au clavier, avant d’appuyer une touche pour les exécuter. Nul besoin de vous dire que les cassettes audio étaient plus pratiques.

Mais de nos jours, les programmes sont enregistrés sur le disque dur de l'ordinateur ou dans une mémoire intégrée à l'ordinateur. On dit qu'ils sont installés, ce qui est un mot bien compliqué pour dire que le programme est enregistré sur le disque dur de l’ordinateur. A défaut de disque dur, le programme/logiciel est enregistré dans une mémoire spécialisée pour le stockage. Par exemple, sur les cartes électroniques grand public de marque Arduino, les programmes sont envoyés à la carte via le port USB, mais les programmes sont enregistrés dans la carte Arduino, dans une mémoire FLASH dédiée. Disque dur ou non, le programme est mémorisé dans la mémoire de l'ordinateur. Il est possible d'installer ou de désinstaller les programmes en modifiant le contenu de la mémoire. Le terme utilisé est alors celui de '''programme stocké en mémoire'''.

Les programmes à installer sont disponibles soit sur un périphérique, comme un DVD ou une clé USB, soit sont téléchargés depuis internet. Les premiers PC fournissaient les logiciels sur des disquettes, qui contenaient un programme d'installation pour enregistrer le programme sur le disque dur de l'ordinateur. Par la suite, le support des logiciels a migré vers les CD et DVD, les logiciels devenant de plus en plus gros. De nos jours, la majorité des applications sont téléchargées depuis le net, l'usage de périphériques est devenu obsolète, même les consoles de jeu abandonnent cette méthode de distribution.

==Les générations d'ordinateurs : un historique rapide==

L'informatique a beaucoup évolué dans le temps. Et une bonne partie de cette évolution tient à l'évolution de l’électronique sous-jacente. Les ordinateurs actuels sont fabriqués avec des transistors, des petits composants électroniques qui servent d'interrupteur programmables, qu'on détaillera dans ce qui suit. Mais ça n'a pas toujours été le cas. Et cela permet de distinguer plusieurs '''générations d'ordinateurs'''.

===Les ordinateurs électro-mécaniques : les premiers ordinateurs===

Le tout premier ordinateur est le '''Z1''', un modèle unique inventé par Konrad Suze entre 1936 et 1938. Son processeur gérait non pas des nombres entiers, mais des nombres à virgule (des nombres dits flottants, pour être précis), encodés sur 22 bits. Le processeur du Z1 était capable de faire des additions et des soustractions, car il intégrait un circuit additionneur-soustracteur basique. Des circuits annexes permettaient de faire des multiplications et des divisions en enchainant des additions/soustractions successives. Il fonctionnait à une fréquence de 1 Hz, ce qui fait qu'il pouvait faire une addition/soustraction par seconde maximum.

[[File:Blue-punch-card-front.png|vignette|upright=0.5|Carte Perforée.]]

Niveau mémoire, la RAM de l'ordinateur était très limitée : seulement 16 nombres de 22 bits chacun. S'il s'agissait d'une mémoire électronique, les programmes étaient mémorisés sur une mémoire mécanique. Les programmes étaient enregistrés sur des cartes perforées, à savoir des cartes en papier dans lesquelles un 1 est codé par un trou dans le papier et un 0 par une absence de trou. Les programmes étaient exécutés par l'ordinateur quand on insérait la carte perforée dans le lecteur et qu'on appuyait sur un bouton.

[[File:German Museum of Technology, Berlin 2017 024.jpg|centre|vignette|upright=2|Réplique du Z1 au ''German Museum of Technology'' de Berlin, 2017.]]

Après sa destruction dans un bombardement, le Z1 a été reconstruit et amélioré, ce qui donné les deux ordinateurs Z2 et Z3. Quelques années plus tard, de nombreux ordinateurs ont été construits dans des laboratoires de recherche. Des grandes noms de l'histoire de l'informatique datent de cette époque : le Harvard Mark I et le Colossus Mark 1 (UK) ont tous deux été mis en service en 1944, par exemple. Ils ont servis pour les cryptanalystes pour casser les codes utilisés par les allemands pour leurs transmissions, pendant la seconde guerre mondiale.

Les ordinateurs cités dans le précédent paragraphe étaient tous des ordinateurs dit '''électro-mécaniques''', car ils mélangeaient des composants électroniques et des composants mécaniques (tout ce qui a trait aux cartes perforées, notamment). Les composants électroniques étaient soit des relais, soit des tubes à vides, les deux étant des interrupteurs commandables électriquement plus ou moins équivalents aux transistors. Les ordinateurs d'avant l'année 1944, étaient tous de ce type. Quelques ordinateurs des années 50 étaient de ce type, mais leur nombre n'a pas dépassé 30. Il faut dire qu'ils ont rapidement laissé la place à des ordinateurs purement électroniques, que nous allons voir dans ce qui suit..

===La première génération : des ordinateurs qui prenaient des pièces de bâtiment entières===

Les ordinateurs qui ont suivi les ordinateurs électromécaniques sont regroupés dans la '''première génération d'ordinateur'''. Ils étaient conçus avec des tubes à vide, ce qui les place entre les premiers ordinateurs électro-mécaniques et les ordinateurs utilisant des transistors. Les ordinateurs de première génération étaient très simples, ils ne géraient que quelques opérations simples : l'addition, la soustraction, pas grand chose de plus. A quelques exceptions près, ils ne géraient pas la multiplication et encore moins la division, ils n'avaient pas assez de relais ou de tubes à vides à disposition pour cela.

Une des toutes premières machines construite avec des tubes à vide était l'Atanasoff–Berry. Ce n'était pas un ordinateur, car elle ne pouvait pas exécuter de programme sans intervention humaine pour séquencer des opérations, mais c'était la première machine de calcul purement électronique, sans aucune pièce mécanique. Elle utilisait une mémoire RAM construite avec des condensateurs, ceux-ci étant placés sur des cylindres tournants. Les circuits de calcul étaient construits avec des tubes à vide et faisaient leur travail un bit à la fois. Elle fonctionnait à une fréquence de 60 Hz et pouvait faire 30 additions/soustractions par seconde. Les nombres étaient encodés sur 50 bits. 

[[File:Atanasoff Berry Computer.gif|centre|vignette|upright=2.5|Atanasoff–Berry.]]

L'arrivée de l'ENIAC en 1945 a changé la donne. Cet ordinateur a introduit plusieurs innovations majeures. La première est assez technique, il s'agit de la turing-complétude, elle a trait aux programmes qui peuvent être écrit pour un ordinateur, nous ne la détaillerons pas ici.

Le ''Manchester Baby'' a introduit une innovation extrêmement importante, au point où on considère que c'est le premier ordinateur à avoir tous les critères nécessaires pour être appelé un ordinateur. Son innovation est que le programme n'était plus mémorisé sur des cartes perforée, mais dans une mémoire électronique dans l'ordinateur lui-même. En clair, le ''Manchester Baby'' était le premier '''''Stored-program computer''''', ordinateur à programme enregistré en français. 

[[File:IBM 7070.jpg|vignette|Cartes imprimées de l'IBM 704, avec des transistors et résistances dessus.]]

===La seconde génération : le remplacement des tubes à vides par des transistors===

La '''seconde génération''' est celle des ordinateurs fabriqués avec des '''transistors''' isolés, reliés entre avec des fils électriques. Les transistors en question possèdent trois broches, des pattes métalliques sur lesquelles on connecte des fils électriques. Le transistor s'utilise le plus souvent comme un interrupteur commandé par sa troisième broche. Le courant qui traverse les deux premières broches passe ou ne passe pas selon ce qu'on met sur la troisième.

[[File:Transistor basic flow.svg|centre|vignette|Un transistor est un morceau de conducteur, dont la conductivité est contrôlée par sa troisième broche/borne.]]

Les ordinateurs de seconde génération avaient entre 1000 et 500 000 transistors. Les capacités des ordinateurs étaient donc nettement supérieures à celles des ordinateurs de première génération. Une part non négligeable des ordinateurs de seconde génération supportait l'opération de multiplication, absente sur les ordinateurs de première génération. Néanmoins, cela variait beaucoup selon les ordinateurs.

Un exemple assez hors du commun est celui du premier modèle de l'IBM 1620. Le tout premier modèle n'avait aucun circuit de calcul, il n'était même pas capable de faire une addition ou une multiplication. A la place, il utilisait une table d'addition et une table de multiplication en mémoire RAM. Les deux tables devaient être initialisées par le logiciel lors du démarrage de la machine. La table d'addition faisait une centaine de chiffre, la table de multiplication faisait le double. Le processeur de l'ordinateur gérait des instructions pour faire des additions ou des multiplications, mais ces opérations lisaient le résultat dans la table d'addition. Les calculs étaient fait chiffre par chiffre, avec un encodage partiellement décimal, partiellement binaire (des chiffres décimaux étaient encodés en binaire, nous en reparlerons quand nous parlerons du BCD) !

[[File:KL CoreMemory.jpg|vignette|Mémoire à tore de ferrite.]]

Les transistors n'étaient utilisés que pour le processeur et les circuits annexes. La mémoire n'était pas faite en transistors, pas à cette époque. La mémoire était une mémoire aujourd'hui abandonnée, appelée une '''mémoire à tores de ferrite'''. Elle sera détaillée dans un chapitre ultérieur. Mais sachez pour le moment qu'il s'agit d'une mémoire au support magnétique, les données étant stockées sur un support magnétique.

Transistors comme tubes à vide prenaient beaucoup de place, ce qui fait que les ordinateurs étaient assez gros. Concrètement, ils prenaient une pièce de bâtiment entière dans le meilleur des cas. C'était l'époque des gros ''mainframes'', reliés à des terminaux, peu puissants comparé aux standards actuels. Seules les grandes entreprises et les grands instituts de recherche pouvaient se payer les services de ce genre d'ordinateurs. Seuls les professionnels avaient accès à ce genre d'équipement.

===La troisième génération : le circuit intégré===

[[File:D8259AC-2.jpg|vignette|Exemple de circuit intégré.]]

La troisième génération est toujours fabriquée avec des transistors, mais dont la taille a été réduite. Avec l'évolution de la technologie, les transistors ont diminué en taille, de plus en plus. Ils sont devenus tellement petits qu'ils ont finit par être regroupés dans des '''circuits intégrés''', des circuits regroupent plusieurs transistors sur la même puce de silicium. Les circuits intégrés se présentent le plus souvent sous la forme de boitiers rectangulaires, comme illustré ci-contre. D'autres ont des boitiers de forme carrées, comme ceux que l'on peut trouver sur les barrettes de mémoire RAM, ou à l'intérieur des clés USB/ disques SSD.

Lors de cette génération, les processeurs étaient fournis en pièces détachées qu'il fallait relier entre elles. Le processeur était composé de plusieurs circuits intégrés séparés, impossible de mettre un processeur dans un seul boitier. Un exemple de processeur conçu en kit est la série des Intel 3000. Elle regroupe plusieurs circuits séparés aux noms à coucher dehors, mais dont vous comprendrez ce qu'ils veulent dire dans les chapitres adéquats : l'Intel 3001 est un séquenceur, l'Intel 3002 regroupe unité de calcul et registres, le 3003 est un circuit d'anticipation de retenue complémentaire du 3002, le 3212 est une mémoire tampon, le 3214 est une unité de gestion des interruptions, les 3216/3226 sont des interfaces de bus mémoire. On pourrait aussi citer la famille de circuits intégrés AMD Am2900.

Même si le processeur était en pièce détachées, utiliser une dizaine de circuits intégrés était nettement mieux que d'utiliser plusieurs milliers de transistors individuels. En conséquence, les ordinateurs ont vu leur taille grandement réduite, passant de pièces entières à une simple armoire, voire à quelques cartes intégrées superposées. De plus, le prix des circuits intégré était abordable, du moins comparé aux ordinateurs d'avant. Le prix des ordinateurs a alors grandement décru, permettant à des entreprises et administrations de taille modeste de s'équiper d'ordinateurs.

===La quatrième génération : le microprocesseur===

[[File:MOS6502.svg|vignette|Microprocesseur, ici un processeur MOS6502, de la quatrième génération.]]

Lors de la troisième génération, les circuits intégrés regroupaient plusieurs dizaines ou centaines de transistors, mais sont rapidement montés en gamme. De centaines de transistors, ils sont passé au milliers de transistors, puis au millions et maintenant au-delà du milliard. Les transistors étaient devenus tellement petits, tellement miniaturisés, qu'il était devenu possible de mettre un processeur entier dans un circuit intégré. C'est ainsi qu'est né le microprocesseur, à savoir un processeur qui tient tout entier dans un seul circuit imprimé. La quatrième génération d’ordinateur est celle des ordinateurs basés autour d'un microprocesseur.

Les tout premiers microprocesseurs étaient des processeurs à application militaire, comme le processeur du F-14 CADC ou celui de l'Air data computer. Le tout premier microprocesseur commercialisé au grand public est le 4004 d'Intel, sorti en 1971. L'intel 4004 comprenait environ 2300 transistors, avait une fréquence de 740 MHz, pouvait faire 46 opérations différentes, et manipulait des entiers de 4 bits. Il était au départ un processeur de commande, prévu pour être intégré dans la calculatrice Busicom calculator 141-P, mais il fut utilisé pour d'autres applications quelque temps plus tard. Immédiatement après le 4004, les premiers microprocesseurs 8 bits furent commercialisés. Le 4004 fut suivi par le 8008 et quelques autres processeurs 8 bits extrêmement connus, comme le 8080 d'Intel, le 68000 de Motorola, le 6502 ou le Z80.

Les microprocesseurs permirent encore uen fois de réduire la taille des ordinateurs, qui pouvaient tenir dans un boitier de PC, ou un boitier de console de jeu. Le prix des ordinateurs a aussi chuté en même temps que les transistors était miniaturisés. C'est cette invention qui permis l'invention des consoles de jeux et des mini-ordinateurs, à savoir les ordinateurs personnels. Sans miniaturisation, on n'aurait pas d'ordinateur personnel, pas de PC fixe ou portable.

==L'organisation du cours : les différents niveaux d'explication==

Le fonctionnement d'un ordinateur est assez complexe à expliquer car les explications peuvent se faire sur plusieurs niveaux. Par plusieurs niveaux, on veut dire qu'un ordinateur est composé de composants très simples, qui sont assemblés pour donner des composants eux-même plus complexes, qui sont eux-même regrouper, etc. Étudier tout cela demande de voir plusieurs niveaux, allant de transistors très petits à des processeurs multicœurs. Les niveaux les plus bas sont de l'électronique pur et dure, alors que ceux plus haut sont à mi-chemin entre électronique et informatique.

===Les niveaux d'abstraction en architecture des ordinateurs===

Les trois premiers niveaux sont de l'électronique pur et dure. Ils correspondent aux premiers chapitres du cours, qui porteront sur les circuits électroniques en général.
* Le premier niveau est celui des '''transistors''', des circuits intégrés, des ''wafer'' et autres circuits de très petite taille.
* Le second niveau est celui des '''portes logiques''', des circuits très basiques, très simples, à la base de tous les autres.
* Le troisième niveau est celui dit de la '''''Register Transfer Level''''', où un circuit électronique est construit à partir de circuits basiques, dont des registres et autres circuits dits combinatoires.
Les deux niveaux suivants sont de l'informatique proprement dit. C'est dans ces deux niveaux qu'on étudie les ordinateurs proprement dit, les circuits qu'il y a dedans et non l'électronique en général.
* Le quatrième niveau est celui de la '''microarchitecture''', qui étudie ce qu'il y a à l'intérieur d'un processeur, d'une mémoire, des périphériques et autres.
* Le cinquième niveau est celui de l''''architecture externe''', qui décrit l'interface du processeur, de la mémoire, d'un périphérique ou autre. Par décrire l'interface, on veut dire : comment un programmeur voit le processeur et la mémoire, comment il peut les manipuler. Une architecture externe unique peut avoir plusieurs microarchitecture, ce qui fait qu'on sépare les deux. Tout cela sera plus clair quand on passera aux chapitres sur le processeur et les mémoires.

Nous n'allons pas voir les 5 niveaux dans l'ordre, des transistors vers l'architecture externe. En réalité, nous allons procéder autrement. La première partie du cours portera sur les trois premiers niveaux, le reste sur les deux autres. Les 5 niveaux seront vus dans des chapitres séparés, du moins le plus possible. Au niveau pédagogique, tout est plus simple si on scinde les 5 niveaux. Bien sûr, il y a quelques explications qui demandent de voir plusieurs niveaux à la fois. Par exemple, dans le chapitre sur les mémoires caches, nous auront des explications portant sur la RTL, la microarchitecture du cache et son architecture externe. Mais le gros du cours tentera de séparer le plus possible les 5 niveaux.

===Les trois parties principales du cours===

Nous allons commencer par parler du binaire, avant de voir les portes logiques. Avec ces portes logiques, nous allons voir comment fabriquer des circuits basiques qui reviendront très souvent dans la suite du cours. Nous verrons les registres, les décodeurs, les additionneurs et plein d'autres circuits. Puis, nous reviendrons au niveau des transistors pour finir la première partie. La raison est que c'est plus simple de faire comme cela. Tout ce qui a trait aux transistors sert à expliquer comment fabriquer des portes logiques, et il faut expliquer les portes logiques pour voir le niveau de la RTL.

Une fois la première partie finie, nous allons voir les différents composants d'un ordinateur. Une première partie expliquera ce qu'il y a dans un ordinateur, quels sont ses composants. Nous y parlerons de l'architecture de base, de la hiérarchie mémoire, des tendances technologiques, et d'autres généralités qui serviront de base pour la suite. Puis, nous verrons dans l'ordre les bus électroniques, les mémoires RAM/ROM, le processeur, les périphériques, les mémoires de stockage (SSD et disques durs) et les mémoires caches. Pour chaque composant, nous allons voir leur architecture externe, avant de voir leur microarchitecture. La raison est que la microarchitecture ne peut se comprendre que quand on sait quelle architecture externe elle implémente.

Enfin, dans une troisième partie, nous allons voir les optimisations majeures présentes dans tous les ordinateurs modernes, avec une partie sur le pipeline et le parallélisme d'instruction, et une autre sur les architectures parallèles. Pour finir, les annexes de fin parlerons de sujets un peu à part.

&lt;noinclude&gt;
{{NavChapitre | book=Fonctionnement d'un ordinateur
           | next=L'encodage des données
           | nextText=L'encodage des données
}}
&lt;/noinclude&gt;</text>
      <sha1>t6ptdzor6ix8eysnq6rbclu8q4akzni</sha1>
    </revision>
    <revision>
      <id>744115</id>
      <parentid>744114</parentid>
      <timestamp>2025-06-04T23:22:44Z</timestamp>
      <contributor>
        <username>Mewtow</username>
        <id>31375</id>
      </contributor>
      <minor />
      <comment>/* La première génération : des ordinateurs qui prenaient des pièces de bâtiment entières */</comment>
      <origin>744115</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="42894" sha1="pl7cnkh9tunsubzcjwyxersmm7n6uks" xml:space="preserve">Pour commencer, nous allons voir qu'il existe de nombreux types d'ordinateurs. Le plus connu est certainement le PC, l'ordinateur personnel, que vous avez sans doute dans votre salon. Les ordinateurs portables sont un deuxième type d'ordinateur assez intuitif, que vous avez peut-être. Mais il y a aussi d'autres types d'ordinateurs auxquels vous n'avez jamais été confrontés.

==Les différents types d'ordinateurs==

Dans cette section, nous allons décrire rapidement les ordinateurs les plus courant, mais surtout voir ce qu'il y a à l'intérieur d'un ordinateur.

===L'ordinateur de type PC fixe===

De l'extérieur, l'ordinateur est composé d'une unité centrale sur laquelle on branche des périphériques.

[[File:Typical computer architecture systems.jpg|vignette|upright=1.5|Exemples de périphériques, connectés à une unité centrale (ici appelée à tort ''operating system'').]]

Les '''périphériques''' regroupent l'écran, la souris, le clavier, l'imprimante, et bien d'autres choses. Ils permettent à l'utilisateur d'interagir avec l'ordinateur : un clavier permet de saisir du texte sous dans un fichier, une souris enregistre des déplacements de la main en déplacement du curseur, un écran affiche des données d’images/vidéos, un haut-parleur émet du son, etc. Tout ce qui est branché sur un ordinateur est, formellement un périphérique.

L''''unité centrale''' est là où se trouvent tous les composants importants d'un ordinateur, ceux qui font des calculs, qui exécutent des logiciels, qui mémorisent vos données, etc. Voici ce à quoi ressemble l'intérieur de l'unité centrale. Trois sections sont visibles : l'alimentation électrique en haut à gauche, la carte mère en bas à gauche et en jaune/orange, les disques et lecteurs à droite des câbles. Et on voit aussi beaucoup de câbles.

[[File:Asus P5K-SEIntel E6320.jpg|centre|vignette|upright=2|Exemple d'unité centrale.]]

Tout en haut à gauche, se trouve l''''alimentation électrique''', qui convertit le courant de la prise électrique en un courant plus faible, utilisable par les autres composants. Elle émet de nombreux câbles assez gros, qui sont reliés au reste. Les PC actuels utilisent des alimentations électriques standardisées, qui fournissent trois tensions au reste de l'ordinateur : une tension de 12 Volts, une de 5 Volts, une de 3,3 Volts.

À droite, caché par la partie &quot;métallique&quot; du boitier, se trouvent les lecteurs de CD/DVD, et les disques durs. Les lecteurs CD-ROM ou DVD-ROM permettaient de lire des CD ou des DVD. Je parle au passé, car ils ont aujourd'hui disparu des ordinateurs modernes. Les '''disques durs''' sont des mémoires de stockage, qui mémorisent vos données de manière permanente. De nos jours, ils sont remplacés par des SSD, qui sont des disques durs électroniques, là où les disques durs proprement dit sont des mémoires magnétiques. Nous verrons la différence dans deux chapitres dédiés, un sur les disques durs, l'autre sur les SSD.

En bas à droite, se trouve la '''carte mère''' un support plat, en plastique ou en céramique, sur laquelle sont soudés/connectés les autres composants. Sur celle-ci, de nombreux composants sont soudés, d'autres sont branchés dessus avec des câbles, d'autres sont connectés dessus avec des connecteurs. Ils sont reliés entre eux par des fils conducteurs, le plus souvent du cuivre ou de l’aluminium, ce qui leur permet de s’échanger des données. Sur les cartes simples, ces fils sont intégrés dans la carte électronique, dans des creux du plastique. Ils portent le nom de pistes.

Avant, les disques durs, SSD et lecteurs de CD/DVD sont branchés dessus via des connecteurs dédiés, appelés des connecteurs S-ATA. De nos jours, ils sont branchés sur un autre connecteur, grâce à l'interface NVME. Toujours est-il qu'ils sont reliés à la carte mère par des câbles, ce qui montre que ce sont des sortes de périphériques interne. Ils sont placés dans le boitier, mais on aurait tout aussi bien pu les mettre à l'extérieur, vu qu'ils communiquent avec l'ordinateur par l'intermédiaire d'un câble ou d'un connecteur dédié.

Mais deux autres composants très importants sont eux placés sur la carte mère, directement. Ils ont chacun un connecteur dédié, sur lequel ils sont branchés directement, sans passer par l'intermédiaire d'un câble, mais sans être soudés non plus. Il s'agit du processeur et de la mémoire RAM, deux composants centraux des PC modernes.

[[File:Pentium III SL4CB.jpg|thumb|Processeur Pentium III.]]

Le '''processeur''' traite les données, les modifie, les manipule. Pour faire simple, il s’agit d’une grosse calculatrice hyper-puissante. Il comprend à la fois un circuit qui fait des calculs, et un circuit de contrôle qui s'occupe de séquencer les calculs dans l'ordre demandé. Il est souvent caché sous un radiateur, lui-même surmonté par un ventilateur. En effet, un processeur chauffe beaucoup, ce qui demande d'évacuer cette chaleur. Un chapitre entier expliquera pourquoi les processeurs chauffent, ainsi que les techniques utilisées pour limiter leur production de chaleur et leur consommation électrique.

La '''mémoire vive''' conserve des informations/données temporairement, tant que le processeur en a besoin. Elle prend la forme de barrettes de RAM, comme montré ci-dessous.

[[File:2 gb ddr2 667.jpg|centre|vignette|upright=2|Barrette de RAM.]]

Outre ces composants dits principaux, un ordinateur peut comprendre plusieurs composants moins importants, surtout présents sur les ordinateurs personnels. Ils sont techniquement facultatifs, mais sont très présents dans les ordinateurs personnels. Cependant, certains ordinateurs spécialisés s'en passent. Il s'agit des diverses '''cartes d'extension''' sont branchées sur la carte mère. Elles permettent d’accélérer certains calculs ou certaines applications, afin de décharger le processeur. Par exemple, la carte graphique s'occupe des calculs graphiques, qu'il s'agisse de graphismes 3D de jeux vidéos ou de l'affichage en 2D du bureau. Dans un autre registre, la carte son prend en charge le microphone et les haut-parleurs.

[[Fichier:Personal computer, exploded 4.svg|thumb|upright=1.0|Éclaté d'un ordinateur de type PC :&lt;br /&gt;
1 : Écran ;&lt;br /&gt;
2 : Carte mère ;&lt;br /&gt;
3 : Processeur ;&lt;br /&gt;
4 : Câble Parallel ATA ;&lt;br /&gt;
5 : Mémoire vive (RAM) ;&lt;br /&gt;
6 : Carte d'extension ;&lt;br /&gt;
7 : Alimentation électrique ;&lt;br /&gt;
8 : Lecteur de disque optique ;&lt;br /&gt;
9 : Disque dur ;&lt;br /&gt;
10 : Clavier ;&lt;br /&gt;
11 : Souris.]]

Si on regarde une carte mère de face, on voit un grand nombre de connecteurs, mais aussi des circuits électroniques soudés à la carte mère.

[[File:Architecture matérielle d'une carte mère.png|centre|vignette|upright=2.0|Architecture matérielle d'une carte mère]]

Les '''connecteurs''' sont là où on branche les périphériques, la carte graphique, le processeur, la mémoire, etc. Dans l'ensemble, toute carte mère contient les connecteurs suivants :
* Le processeur vient s’enchâsser dans la carte mère sur un connecteur particulier : le '''socket'''. Celui-ci varie suivant la carte mère et le processeur, ce qui est source d'incompatibilités.
* Les barrettes de mémoire RAM s’enchâssent dans un autre type de connecteurs: les '''slots mémoire'''.
* Les mémoires de masse disposent de leurs propres connecteurs : connecteurs P-ATA pour les anciens disques durs, et S-ATA pour les récents.
* Les périphériques (clavier, souris, USB, Firewire, ...) sont connectés sur un ensemble de connecteurs dédiés, localisés à l'arrière du boitier de l'unité centrale. 
* Les autres périphériques sont placés dans l'unité centrale et sont connectés via des connecteurs spécialisés. Ces périphériques sont des cartes imprimées, d'où leur nom de '''cartes filles'''. On peut notamment citer les cartes réseau, les cartes son, ou les cartes vidéo.

===Les ordinateurs portables===

[[File:Samsung QX-511 (2).JPG|vignette|Ordinateur portable Samsung QX-511 (2), pour illustration.]]

Un ordinateur portable est identique à un ordinateur de type PC. Si vous ouvrez votre ordinateur portable (attention à la garantie), vous retrouverez les mêmes composants qu'un PC à l'intérieur. Un point important est la présence d'une batterie à l'intérieur du PC portable, absente des PC fixes.

[[File:LG gram 14Z90Q mainboard with battery.jpg|centre|vignette|upright=2|LG gram 14Z90Q avec sa batterie.]]

Une fois la batterie et les circuits associés retiré, la seule différence notable est que tous les composants sont soudés sur la carte mère, au lieu d'être branchés sur des connecteurs, à part éventuellement la RAM et le disque dur.

[[File:LG gram 14Z90Q mainboard without battery.jpg|centre|vignette|upright=2|LG gram 14Z90Q sans sa batterie.]]

La RAM est parfois soudée sur la carte mère, d'autres fois sous la forme de barrettes de mémoire vive semblables à celles des PC. Dans le dernier cas, elle est connectée à des connecteurs spécifiques, ce qui permet de les changer/upgrader. Les PC portables sont parfois construits de manière à pouvoir changer la RAM facilement, en ouvrant un cache spécial, concu pour.

[[File:Lenovo G555 состав - Донор.JPG|centre|vignette|upright=2|Lenovo G555.]]

La conception d'un ordinateur portable est légèrement différente de celle d'un PC, pour des raisons thermiques. Un PC fixe a plus de place pour évacuer sa chaleur. Les ventilateurs peuvent plus facilement déplacer l'air dans le boitier, même si le flux d'air dans le boitier est éventuellement gêné par la carte graphique. Mais l'évacuation de la chaleur est assez efficace. Sur les PC portables, leur finesse fait que le trajet de l'air est beaucoup plus contraint. Évacuer la chaleur produite par l'ordinateur est plus complexe, ce qui demande d'utiliser des systèmes de refroidissement et de ventilation spécifiques.

Là où les PC fixes se débrouillent avec des radiateurs et des ventilateurs posés sur le processeur, les PC portables font autrement. Ils ne peuvent pas forcément mettre le ventilateur sur le processeur. A la place, ils mettent le ventilateur à côté, mais le processeur est surmonté par un mécanisme de transmission de la chaleur, qui transfère la chaleur du processeur vers le ventilateur.

[[File:Diagram - How a laptop cooling system works.png|centre|vignette|upright=2|Comment fonctionne le système de ventilation d'un ordinateur portable, en anglais.]]

Les difficultés pour dissiper la chaleur font que les ordinateurs portables utilisent souvent des composants peu performants, mais qui chauffent peu. En effet, nous verrons que plus un composant est puissant, plus il chauffe. La relation n'est pas parfaite, mais les processeurs haute performance chauffent plus que les modèles d'entrée ou milieu de gamme moins puissants. En conséquence, les PC portables sont souvent moins puissants que les PC fixes, même pour les modèles dit ''gaming''.

===Les serveurs et ''mainframes''===

Les grandes entreprises utilisent des ordinateurs de grande taille, très puissants, appelés des ''mainframes''. Ils sont souvent confondus avec les serveurs par le grand public, il y a une différence entre les deux. Un serveur est une fonction logicielle/réseau, pas un type d'ordinateur. Mais laissons cette différence de côté, ce qui est dit pour les ''mainframes'' sert pour les gros serveurs haute performance.

[[File:IBM Z15 mainframe.jpg|vignette|Exemple de ''mainframe''' de type IBM Z15.]]

Les anciens ''mainframes'' des années 50-80 avaient une taille pouvant être impressionnante, au point de prendre une pièce complète d'un bâtiment. Mais de nos jours, les ''mainframes'' tiennent dans une grosse armoire un peu haute. Les ''mainframes'' doivent rester allumé en permanence et ne doivent pas être éteint, sauf éventuellement quelques jours par an pour des opérations de maintenance. Ils utilisent pour cela des techniques spécifiques, avec beaucoup de redondance interne.

[[File:ACONIT hall grandes machines.jpg|centre|vignette|upright=2|''Mainframe'' ACONIT.]]

Les ''mainframes'' sont aussi conçus pour mutualiser au maximum leur utilisation, ils peuvent être utilisés par plusieurs utilisateurs à la suite, voire en même temps. Pour cela, les anciens ''mainframes'' étaient capables de faire tourner plusieurs applications distinctes l'une à la suite de l'autre, avec des commutations fréquentes entre logiciels. De nos jours, ils sont capables d'exécuter un grand nombre de tâches en même temps, grâce à la présence de plusieurs processeurs. Les ''mainframes'' modernes sont même capables de faire tourner plusieurs systèmes d'exploitation en même temps si besoin.

Les anciens ''mainframes'' étaient des ordinateurs assez simples, avec un processeur, de la mémoire RAM, un ou plusieurs disques durs, pas plus. Le ''mainframe'' était tellement énorme et cher que les entreprises n'en avaient qu'un seul pour toute l'entreprise. Les employés avaient sur leur bureau des terminaux, qui permettaient d'accéder à l'ordinateur central, mais n'étaient pas des ordinateurs. Les terminaux étaient des composants électroniques simples, avec un écran, un clavier et une souris, mais sans processeur. Ils envoyaient des données au ''mainframe'', ils en recevaient de sa part, mais tout traitement était réalisé sur le ''mainframe''. L'arrivée sur le marché des ordinateurs personnels, de type PC fixe/portable, a entrainé l'abandon de ce genre de pratique, tous les employés ont maintenant un ordinateur rien que pour eux.

{|
|-
! colspan=&quot;2&quot; | Exemples de terminaux
|-
|[[File:Terminal-in2-sm9400.jpg|centre|vignette|upright=1.5|Exemple de terminal. Notez la présence d'un écran et d'un clavier, mais l'asbence d'une unité centrale.]]
|[[File:Chromatics CT4100.jpg|vignette|upright=1.5|Autre exemple de terminal. Le clavier est couplé à un stylo CRT, qui remplacait la souris et agissait sur l'écran comme s'il était tactile.]]
|-
! colspan=&quot;2&quot; | Intérieur d'un terminal
|-
|[[File:CT1024 Monitor.jpg|vignette|upright=1.5|Terminal CT1024, sans le boitier extérieur.]]
|[[File:CT1024 Terminal System.jpg|vignette|upright=1.5|Terminal CT1024, description des composants interne.]]
|}

De nos jours, les ''mainframes'' contiennent en réalité plusieurs ordinateurs simples interconnectés via un réseau local. Un ''mainframe'' qui tient dans une armoire contient facilement une dizaine ou centaine de processeurs, plein de RAM, des disques durs séparés dans une armoire distincte, etc. Vu qu'ils communiquent uniquement via le réseau, ils n'ont pas d'interface, pas d'écran, 'entrée via clavier/souris. Le tout est commandé avec une console de commande, typiquement un ordinateur portable ou un terminal assez simple séparé de l'armoire, qui permet à un administrateur de faire des opérations de surveillance, configuration et maintenance. Il peut y avoir une console de commande pour plusieurs armoires séparées, la console peut même être dans un autre bâtiment et accéder au ''mainframe'' par le réseau.

[[File:IBM System Z9 (type 2094 inside).jpg|centre|vignette|upright=2|''Mainframe'' de type IBM System Z9. L'ordinateur portable sert de console pour qu'un administrateur fasse des opérations de surveillance, configuration et maintenance.]]

Les processeurs et la RAM sont typiquement installés sur des cartes amovibles, qui sont connectées au fond de l'armoire lors de l'installation. Il est même possible de retirer ou d'ajouter des cartes en fonctionnement, afin d'ajouter/retirer des processeurs, des disques durs, etc. Ce qui est très utile si un composant est en panne et qu'il faut le remplacer. 

[[File:IBM TotalStorage Exp400.jpg|centre|vignette|upright=2|IBM TotalStorage Exp400]]

==Un peu d'abstraction : qu'est-ce qu'un ordinateur ?==

Un ordinateur comprend donc un processeur, plusieurs mémoires, des cartes d'extension et une carte mère pour connecter le tout. Mais il s'agit là d'une description assez terre-à-terre de ce qu'est un ordinateur. Une autre description, plus abstraite, se base sur le fait qu'un ordinateur est une énorme calculatrice programmable. Elle permet d'expliquer pourquoi il y a une distinction entre processeur et mémoire, entre unité centrale et périphériques. Tout ce qui va suivre pourra vous paraitre assez abstrait, mais rassurez-vous : les prochains chapitres rendront tout cela plus concrets.

===La séparation entre entrées-sorties et traitement===

L'unité centrale peut être vue comme une énorme calculatrice ultra-puissante, qui exécute des commandes/opérations. Mais à elle seule, elle ne servirait à rien, il faut interagir avec par l'intermédiaire de plusieurs périphériques. Il existe deux types de périphériques, qui sont conceptuellement différents. Les périphériques comme le clavier ou la souris permettent d'envoyer des informations à l'ordinateur, d'agir sur celui-ci. A l'inverse, les écrans transmettent des informations dans le sens inverse : de l'ordinateur vers l'utilisateur. Les premiers sont appelés des '''entrées''', les seconds des '''sorties'''.

Dans un ordinateur, les informations sont représentées sous la forme de nombres. Toute donnée dans un ordinateur est codée avec un ou plusieurs nombres regroupés dans une donnée, un fichier, ou autre. Et la transmissions avec les entrées et sorties se fait là-encore avec des nombres. Par exemple, quand vous appuyez sur votre clavier, le clavier envoie un numéro de touche à l'unité centrale, qui indique quelle touche a été appuyée. L'image à afficher à l'écran est codée sous la forme d'une suite de nombres (un par pixel). L'image est envoyée à l'écran, qui traduit la suite de nombre en image à afficher. Les entrées traduisent des actions utilisateurs en nombres, on dit que les entrées encodent les actions utilisateur. Les sorties font la traduction inverse, elles transforment des suites de nombres en une action physique. On dit qu'elles décodent des informations.

Pour résumer, toute appareil électronique est composé par :
* Des '''entrées''' sur lesquelles l'utilisateur agit sur l'ordinateur. Les entrées transforment les actions de l'utilisateur en nombres, qui sont interprétés par l'ordinateur.
* Une '''unité de traitement''', qui manipule des nombres et fait des calculs/opérations dessus. Les nombres proviennent des entrées, du disque dur, ou d'autres sources, peu importe.
* Des '''sorties''', qui va récupèrent le résultat calculé par l'unité de traitement pour en faire quelque chose : écrire sur une imprimante ou sur un moniteur, émettre du son,...

[[File:Ordinateur théorique Simple 1.png|centre|vignette|upright=2|Ordinateur théorique Simple 1]]

L'unité de traitement proprement dite, celle qui fait les calculs, est couplée à une mémoire qui mémorise les opérandes et résultats des calculs. La séparation entre processeur et mémoire est nécessaire pour qu'un appareil électronique soit qualifié d'ordinateur. De nombreux appareils n'ont pas de séparation entre unité de traitement et mémoire, comme certaines vielles radios AM/FM.

[[File:Schéma de principe d'un ordinateur.png|centre|vignette|upright=2|Schéma de principe d'un ordinateur]]

===Un ordinateur est un appareil programmable===

Les appareils simples sont non-programmables, ce qui veut dire qu’ils sont conçus pour une utilisation particulière et qu’ils ne peuvent pas faire autre chose. Par exemple, les circuits électroniques d’un lecteur de DVD ne peuvent pas être transformé en lecteur audio ou en console de jeux... Les circuits non-programmables sont câblés une bonne fois pour toute, et on ne peut pas les modifier. On peut parfois reconfigurer le circuit, pour faire varier certains paramètres, via des interrupteurs ou des boutons, mais cela s’arrête là. Et cela pose un problème : à chaque problème qu'on veut résoudre en utilisant un automate, on doit recréer un nouveau circuit.

À l'inverse, un ordinateur n’est pas conçu pour une utilisation particulière, contrairement aux autres objets techniques. Il est possible de modifier leur fonction du jour au lendemain, on peut lui faire faire ce qu’on veut. On dit qu'ils sont '''programmables'''. Pour cela, il suffit d’utiliser un logiciel, une application, un programme (ces termes sont synonymes), qui fait ce que l'on souhaite. La totalité des logiciels présents sur un ordinateur sont des programmes comme les autres, même le système d'exploitation (Windows, Linux, ...) ne fait pas exception.

Un programme est une suite de d'instructions, chaque instruction effectuant une action dans l'ordinateur. Sur les ordinateurs modernes, la majorité de ces instructions effectuent une opération arithmétique, comme une addition, une multiplication, une soustraction, etc. Les ordinateurs modernes sont donc de grosses calculettes très puissantes, capables d'effectuer des millions d'opérations par secondes. Et qui dit opération dit nombres : un ordinateur gère nativement des nombres, qui sont codés en binaire sur la quasi-totalité des ordinateurs modernes.

Une instruction est représentée dans un ordinateur par une série de nombres : un nombre qui indique quelle opération/commande effectuer et des autres nombres pour coder les données (ou de quoi les retrouver dans l'ordinateur). L'ordinateur récupére les commandes une par une, les traduit en opération à effectuer, exécuter l'opération, et enregistre le résultat. Puis il recommence avec la commande suivante.

[[File:Ordinateur Théorique Complexe 1.png|centre|vignette|upright=3|Ordinateur Théorique Complexe. En jaune, le programme informatique, la liste de commande. Le rectangle gris est l'ordinateur proprement dit.]]

De nombreux appareils sont programmables, mais tous ne sont pas des ordinateurs. Par exemple, certains circuits programmables nommés FPGA n'en sont pas. Pour être qualifié d'ordinateur, un appareil programmable doit avoir un processeur séparé de la mémoire. De plus, il doit utiliser un '''codage numérique''', chose que nous allons aborder dans le chapitre suivant.

===Les ordinateurs à programme mémorisé ou programme externe===

Au tout début de l'informatique, on utilisait des cartes perforées en plastique, sur lesquelles on inscrivait le programme à exécuter, les données à traiter, bref : tout ce qu'on donnait à manger à l'ordinateur. Par la suite, les premiers ordinateurs grand public, comme les Amstrad ou les Commodore, utilisaient des cassettes audio magnétiques pour stocker les programmes. Dans le même style, les consoles de jeu utilisaient autrefois des cartouches de jeu, qui contenaient le programme du jeu à exécuter. Pour résumer, les anciens ordinateurs mémorisaient les programmes sur un support externe, lu par un périphérique. De tels ordinateurs sont dits à '''programme externe'''.

: D’anciens ordinateurs personnels, comme l’Amstrad ou le Commodore, permettaient de taper les programmes à exécuter à la main, au clavier, avant d’appuyer une touche pour les exécuter. Nul besoin de vous dire que les cassettes audio étaient plus pratiques.

Mais de nos jours, les programmes sont enregistrés sur le disque dur de l'ordinateur ou dans une mémoire intégrée à l'ordinateur. On dit qu'ils sont installés, ce qui est un mot bien compliqué pour dire que le programme est enregistré sur le disque dur de l’ordinateur. A défaut de disque dur, le programme/logiciel est enregistré dans une mémoire spécialisée pour le stockage. Par exemple, sur les cartes électroniques grand public de marque Arduino, les programmes sont envoyés à la carte via le port USB, mais les programmes sont enregistrés dans la carte Arduino, dans une mémoire FLASH dédiée. Disque dur ou non, le programme est mémorisé dans la mémoire de l'ordinateur. Il est possible d'installer ou de désinstaller les programmes en modifiant le contenu de la mémoire. Le terme utilisé est alors celui de '''programme stocké en mémoire'''.

Les programmes à installer sont disponibles soit sur un périphérique, comme un DVD ou une clé USB, soit sont téléchargés depuis internet. Les premiers PC fournissaient les logiciels sur des disquettes, qui contenaient un programme d'installation pour enregistrer le programme sur le disque dur de l'ordinateur. Par la suite, le support des logiciels a migré vers les CD et DVD, les logiciels devenant de plus en plus gros. De nos jours, la majorité des applications sont téléchargées depuis le net, l'usage de périphériques est devenu obsolète, même les consoles de jeu abandonnent cette méthode de distribution.

==Les générations d'ordinateurs : un historique rapide==

L'informatique a beaucoup évolué dans le temps. Et une bonne partie de cette évolution tient à l'évolution de l’électronique sous-jacente. Les ordinateurs actuels sont fabriqués avec des transistors, des petits composants électroniques qui servent d'interrupteur programmables, qu'on détaillera dans ce qui suit. Mais ça n'a pas toujours été le cas. Et cela permet de distinguer plusieurs '''générations d'ordinateurs'''.

===Les ordinateurs électro-mécaniques : les premiers ordinateurs===

Le tout premier ordinateur est le '''Z1''', un modèle unique inventé par Konrad Suze entre 1936 et 1938. Son processeur gérait non pas des nombres entiers, mais des nombres à virgule (des nombres dits flottants, pour être précis), encodés sur 22 bits. Le processeur du Z1 était capable de faire des additions et des soustractions, car il intégrait un circuit additionneur-soustracteur basique. Des circuits annexes permettaient de faire des multiplications et des divisions en enchainant des additions/soustractions successives. Il fonctionnait à une fréquence de 1 Hz, ce qui fait qu'il pouvait faire une addition/soustraction par seconde maximum.

[[File:Blue-punch-card-front.png|vignette|upright=0.5|Carte Perforée.]]

Niveau mémoire, la RAM de l'ordinateur était très limitée : seulement 16 nombres de 22 bits chacun. S'il s'agissait d'une mémoire électronique, les programmes étaient mémorisés sur une mémoire mécanique. Les programmes étaient enregistrés sur des cartes perforées, à savoir des cartes en papier dans lesquelles un 1 est codé par un trou dans le papier et un 0 par une absence de trou. Les programmes étaient exécutés par l'ordinateur quand on insérait la carte perforée dans le lecteur et qu'on appuyait sur un bouton.

[[File:German Museum of Technology, Berlin 2017 024.jpg|centre|vignette|upright=2|Réplique du Z1 au ''German Museum of Technology'' de Berlin, 2017.]]

Après sa destruction dans un bombardement, le Z1 a été reconstruit et amélioré, ce qui donné les deux ordinateurs Z2 et Z3. Quelques années plus tard, de nombreux ordinateurs ont été construits dans des laboratoires de recherche. Des grandes noms de l'histoire de l'informatique datent de cette époque : le Harvard Mark I et le Colossus Mark 1 (UK) ont tous deux été mis en service en 1944, par exemple. Ils ont servis pour les cryptanalystes pour casser les codes utilisés par les allemands pour leurs transmissions, pendant la seconde guerre mondiale.

Les ordinateurs cités dans le précédent paragraphe étaient tous des ordinateurs dit '''électro-mécaniques''', car ils mélangeaient des composants électroniques et des composants mécaniques (tout ce qui a trait aux cartes perforées, notamment). Les composants électroniques étaient soit des relais, soit des tubes à vides, les deux étant des interrupteurs commandables électriquement plus ou moins équivalents aux transistors. Les ordinateurs d'avant l'année 1944, étaient tous de ce type. Quelques ordinateurs des années 50 étaient de ce type, mais leur nombre n'a pas dépassé 30. Il faut dire qu'ils ont rapidement laissé la place à des ordinateurs purement électroniques, que nous allons voir dans ce qui suit..

===La première génération : les tubes à vide===

Les ordinateurs qui ont suivi les ordinateurs électromécaniques sont regroupés dans la '''première génération d'ordinateur'''. Ils étaient conçus avec des tubes à vide, ce qui les place entre les premiers ordinateurs électro-mécaniques et les ordinateurs utilisant des transistors. Les ordinateurs de première génération étaient très simples, ils ne géraient que quelques opérations simples : l'addition, la soustraction, pas grand chose de plus. A quelques exceptions près, ils ne géraient pas la multiplication et encore moins la division, ils n'avaient pas assez de relais ou de tubes à vides à disposition pour cela.

Une des toutes premières machines construite avec des tubes à vide était l'Atanasoff–Berry. Ce n'était pas un ordinateur, car elle ne pouvait pas exécuter de programme sans intervention humaine pour séquencer des opérations, mais c'était la première machine de calcul purement électronique, sans aucune pièce mécanique. Elle utilisait une mémoire RAM construite avec des condensateurs, ceux-ci étant placés sur des cylindres tournants. Les circuits de calcul étaient construits avec des tubes à vide et faisaient leur travail un bit à la fois. Elle fonctionnait à une fréquence de 60 Hz et pouvait faire 30 additions/soustractions par seconde. Les nombres étaient encodés sur 50 bits. 

[[File:Atanasoff Berry Computer.gif|centre|vignette|upright=2.5|Atanasoff–Berry.]]

L'arrivée de l'ENIAC en 1945 a changé la donne. Cet ordinateur a introduit plusieurs innovations majeures. La première est assez technique, il s'agit de la turing-complétude, elle a trait aux programmes qui peuvent être écrit pour un ordinateur, nous ne la détaillerons pas ici.

Le ''Manchester Baby'' a introduit une innovation extrêmement importante, au point où on considère que c'est le premier ordinateur à avoir tous les critères nécessaires pour être appelé un ordinateur. Son innovation est que le programme n'était plus mémorisé sur des cartes perforée, mais dans une mémoire électronique dans l'ordinateur lui-même. En clair, le ''Manchester Baby'' était le premier '''''Stored-program computer''''', ordinateur à programme enregistré en français. 

[[File:IBM 7070.jpg|vignette|Cartes imprimées de l'IBM 704, avec des transistors et résistances dessus.]]

===La seconde génération : le remplacement des tubes à vides par des transistors===

La '''seconde génération''' est celle des ordinateurs fabriqués avec des '''transistors''' isolés, reliés entre avec des fils électriques. Les transistors en question possèdent trois broches, des pattes métalliques sur lesquelles on connecte des fils électriques. Le transistor s'utilise le plus souvent comme un interrupteur commandé par sa troisième broche. Le courant qui traverse les deux premières broches passe ou ne passe pas selon ce qu'on met sur la troisième.

[[File:Transistor basic flow.svg|centre|vignette|Un transistor est un morceau de conducteur, dont la conductivité est contrôlée par sa troisième broche/borne.]]

Les ordinateurs de seconde génération avaient entre 1000 et 500 000 transistors. Les capacités des ordinateurs étaient donc nettement supérieures à celles des ordinateurs de première génération. Une part non négligeable des ordinateurs de seconde génération supportait l'opération de multiplication, absente sur les ordinateurs de première génération. Néanmoins, cela variait beaucoup selon les ordinateurs.

Un exemple assez hors du commun est celui du premier modèle de l'IBM 1620. Le tout premier modèle n'avait aucun circuit de calcul, il n'était même pas capable de faire une addition ou une multiplication. A la place, il utilisait une table d'addition et une table de multiplication en mémoire RAM. Les deux tables devaient être initialisées par le logiciel lors du démarrage de la machine. La table d'addition faisait une centaine de chiffre, la table de multiplication faisait le double. Le processeur de l'ordinateur gérait des instructions pour faire des additions ou des multiplications, mais ces opérations lisaient le résultat dans la table d'addition. Les calculs étaient fait chiffre par chiffre, avec un encodage partiellement décimal, partiellement binaire (des chiffres décimaux étaient encodés en binaire, nous en reparlerons quand nous parlerons du BCD) !

[[File:KL CoreMemory.jpg|vignette|Mémoire à tore de ferrite.]]

Les transistors n'étaient utilisés que pour le processeur et les circuits annexes. La mémoire n'était pas faite en transistors, pas à cette époque. La mémoire était une mémoire aujourd'hui abandonnée, appelée une '''mémoire à tores de ferrite'''. Elle sera détaillée dans un chapitre ultérieur. Mais sachez pour le moment qu'il s'agit d'une mémoire au support magnétique, les données étant stockées sur un support magnétique.

Transistors comme tubes à vide prenaient beaucoup de place, ce qui fait que les ordinateurs étaient assez gros. Concrètement, ils prenaient une pièce de bâtiment entière dans le meilleur des cas. C'était l'époque des gros ''mainframes'', reliés à des terminaux, peu puissants comparé aux standards actuels. Seules les grandes entreprises et les grands instituts de recherche pouvaient se payer les services de ce genre d'ordinateurs. Seuls les professionnels avaient accès à ce genre d'équipement.

===La troisième génération : le circuit intégré===

[[File:D8259AC-2.jpg|vignette|Exemple de circuit intégré.]]

La troisième génération est toujours fabriquée avec des transistors, mais dont la taille a été réduite. Avec l'évolution de la technologie, les transistors ont diminué en taille, de plus en plus. Ils sont devenus tellement petits qu'ils ont finit par être regroupés dans des '''circuits intégrés''', des circuits regroupent plusieurs transistors sur la même puce de silicium. Les circuits intégrés se présentent le plus souvent sous la forme de boitiers rectangulaires, comme illustré ci-contre. D'autres ont des boitiers de forme carrées, comme ceux que l'on peut trouver sur les barrettes de mémoire RAM, ou à l'intérieur des clés USB/ disques SSD.

Lors de cette génération, les processeurs étaient fournis en pièces détachées qu'il fallait relier entre elles. Le processeur était composé de plusieurs circuits intégrés séparés, impossible de mettre un processeur dans un seul boitier. Un exemple de processeur conçu en kit est la série des Intel 3000. Elle regroupe plusieurs circuits séparés aux noms à coucher dehors, mais dont vous comprendrez ce qu'ils veulent dire dans les chapitres adéquats : l'Intel 3001 est un séquenceur, l'Intel 3002 regroupe unité de calcul et registres, le 3003 est un circuit d'anticipation de retenue complémentaire du 3002, le 3212 est une mémoire tampon, le 3214 est une unité de gestion des interruptions, les 3216/3226 sont des interfaces de bus mémoire. On pourrait aussi citer la famille de circuits intégrés AMD Am2900.

Même si le processeur était en pièce détachées, utiliser une dizaine de circuits intégrés était nettement mieux que d'utiliser plusieurs milliers de transistors individuels. En conséquence, les ordinateurs ont vu leur taille grandement réduite, passant de pièces entières à une simple armoire, voire à quelques cartes intégrées superposées. De plus, le prix des circuits intégré était abordable, du moins comparé aux ordinateurs d'avant. Le prix des ordinateurs a alors grandement décru, permettant à des entreprises et administrations de taille modeste de s'équiper d'ordinateurs.

===La quatrième génération : le microprocesseur===

[[File:MOS6502.svg|vignette|Microprocesseur, ici un processeur MOS6502, de la quatrième génération.]]

Lors de la troisième génération, les circuits intégrés regroupaient plusieurs dizaines ou centaines de transistors, mais sont rapidement montés en gamme. De centaines de transistors, ils sont passé au milliers de transistors, puis au millions et maintenant au-delà du milliard. Les transistors étaient devenus tellement petits, tellement miniaturisés, qu'il était devenu possible de mettre un processeur entier dans un circuit intégré. C'est ainsi qu'est né le microprocesseur, à savoir un processeur qui tient tout entier dans un seul circuit imprimé. La quatrième génération d’ordinateur est celle des ordinateurs basés autour d'un microprocesseur.

Les tout premiers microprocesseurs étaient des processeurs à application militaire, comme le processeur du F-14 CADC ou celui de l'Air data computer. Le tout premier microprocesseur commercialisé au grand public est le 4004 d'Intel, sorti en 1971. L'intel 4004 comprenait environ 2300 transistors, avait une fréquence de 740 MHz, pouvait faire 46 opérations différentes, et manipulait des entiers de 4 bits. Il était au départ un processeur de commande, prévu pour être intégré dans la calculatrice Busicom calculator 141-P, mais il fut utilisé pour d'autres applications quelque temps plus tard. Immédiatement après le 4004, les premiers microprocesseurs 8 bits furent commercialisés. Le 4004 fut suivi par le 8008 et quelques autres processeurs 8 bits extrêmement connus, comme le 8080 d'Intel, le 68000 de Motorola, le 6502 ou le Z80.

Les microprocesseurs permirent encore uen fois de réduire la taille des ordinateurs, qui pouvaient tenir dans un boitier de PC, ou un boitier de console de jeu. Le prix des ordinateurs a aussi chuté en même temps que les transistors était miniaturisés. C'est cette invention qui permis l'invention des consoles de jeux et des mini-ordinateurs, à savoir les ordinateurs personnels. Sans miniaturisation, on n'aurait pas d'ordinateur personnel, pas de PC fixe ou portable.

==L'organisation du cours : les différents niveaux d'explication==

Le fonctionnement d'un ordinateur est assez complexe à expliquer car les explications peuvent se faire sur plusieurs niveaux. Par plusieurs niveaux, on veut dire qu'un ordinateur est composé de composants très simples, qui sont assemblés pour donner des composants eux-même plus complexes, qui sont eux-même regrouper, etc. Étudier tout cela demande de voir plusieurs niveaux, allant de transistors très petits à des processeurs multicœurs. Les niveaux les plus bas sont de l'électronique pur et dure, alors que ceux plus haut sont à mi-chemin entre électronique et informatique.

===Les niveaux d'abstraction en architecture des ordinateurs===

Les trois premiers niveaux sont de l'électronique pur et dure. Ils correspondent aux premiers chapitres du cours, qui porteront sur les circuits électroniques en général.
* Le premier niveau est celui des '''transistors''', des circuits intégrés, des ''wafer'' et autres circuits de très petite taille.
* Le second niveau est celui des '''portes logiques''', des circuits très basiques, très simples, à la base de tous les autres.
* Le troisième niveau est celui dit de la '''''Register Transfer Level''''', où un circuit électronique est construit à partir de circuits basiques, dont des registres et autres circuits dits combinatoires.
Les deux niveaux suivants sont de l'informatique proprement dit. C'est dans ces deux niveaux qu'on étudie les ordinateurs proprement dit, les circuits qu'il y a dedans et non l'électronique en général.
* Le quatrième niveau est celui de la '''microarchitecture''', qui étudie ce qu'il y a à l'intérieur d'un processeur, d'une mémoire, des périphériques et autres.
* Le cinquième niveau est celui de l''''architecture externe''', qui décrit l'interface du processeur, de la mémoire, d'un périphérique ou autre. Par décrire l'interface, on veut dire : comment un programmeur voit le processeur et la mémoire, comment il peut les manipuler. Une architecture externe unique peut avoir plusieurs microarchitecture, ce qui fait qu'on sépare les deux. Tout cela sera plus clair quand on passera aux chapitres sur le processeur et les mémoires.

Nous n'allons pas voir les 5 niveaux dans l'ordre, des transistors vers l'architecture externe. En réalité, nous allons procéder autrement. La première partie du cours portera sur les trois premiers niveaux, le reste sur les deux autres. Les 5 niveaux seront vus dans des chapitres séparés, du moins le plus possible. Au niveau pédagogique, tout est plus simple si on scinde les 5 niveaux. Bien sûr, il y a quelques explications qui demandent de voir plusieurs niveaux à la fois. Par exemple, dans le chapitre sur les mémoires caches, nous auront des explications portant sur la RTL, la microarchitecture du cache et son architecture externe. Mais le gros du cours tentera de séparer le plus possible les 5 niveaux.

===Les trois parties principales du cours===

Nous allons commencer par parler du binaire, avant de voir les portes logiques. Avec ces portes logiques, nous allons voir comment fabriquer des circuits basiques qui reviendront très souvent dans la suite du cours. Nous verrons les registres, les décodeurs, les additionneurs et plein d'autres circuits. Puis, nous reviendrons au niveau des transistors pour finir la première partie. La raison est que c'est plus simple de faire comme cela. Tout ce qui a trait aux transistors sert à expliquer comment fabriquer des portes logiques, et il faut expliquer les portes logiques pour voir le niveau de la RTL.

Une fois la première partie finie, nous allons voir les différents composants d'un ordinateur. Une première partie expliquera ce qu'il y a dans un ordinateur, quels sont ses composants. Nous y parlerons de l'architecture de base, de la hiérarchie mémoire, des tendances technologiques, et d'autres généralités qui serviront de base pour la suite. Puis, nous verrons dans l'ordre les bus électroniques, les mémoires RAM/ROM, le processeur, les périphériques, les mémoires de stockage (SSD et disques durs) et les mémoires caches. Pour chaque composant, nous allons voir leur architecture externe, avant de voir leur microarchitecture. La raison est que la microarchitecture ne peut se comprendre que quand on sait quelle architecture externe elle implémente.

Enfin, dans une troisième partie, nous allons voir les optimisations majeures présentes dans tous les ordinateurs modernes, avec une partie sur le pipeline et le parallélisme d'instruction, et une autre sur les architectures parallèles. Pour finir, les annexes de fin parlerons de sujets un peu à part.

&lt;noinclude&gt;
{{NavChapitre | book=Fonctionnement d'un ordinateur
           | next=L'encodage des données
           | nextText=L'encodage des données
}}
&lt;/noinclude&gt;</text>
      <sha1>pl7cnkh9tunsubzcjwyxersmm7n6uks</sha1>
    </revision>
    <revision>
      <id>744116</id>
      <parentid>744115</parentid>
      <timestamp>2025-06-04T23:49:25Z</timestamp>
      <contributor>
        <username>Mewtow</username>
        <id>31375</id>
      </contributor>
      <minor />
      <comment>/* La première génération : les tubes à vide */</comment>
      <origin>744116</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="43320" sha1="rfmlhd1k2kdds7yr238oo52ag6zn0jg" xml:space="preserve">Pour commencer, nous allons voir qu'il existe de nombreux types d'ordinateurs. Le plus connu est certainement le PC, l'ordinateur personnel, que vous avez sans doute dans votre salon. Les ordinateurs portables sont un deuxième type d'ordinateur assez intuitif, que vous avez peut-être. Mais il y a aussi d'autres types d'ordinateurs auxquels vous n'avez jamais été confrontés.

==Les différents types d'ordinateurs==

Dans cette section, nous allons décrire rapidement les ordinateurs les plus courant, mais surtout voir ce qu'il y a à l'intérieur d'un ordinateur.

===L'ordinateur de type PC fixe===

De l'extérieur, l'ordinateur est composé d'une unité centrale sur laquelle on branche des périphériques.

[[File:Typical computer architecture systems.jpg|vignette|upright=1.5|Exemples de périphériques, connectés à une unité centrale (ici appelée à tort ''operating system'').]]

Les '''périphériques''' regroupent l'écran, la souris, le clavier, l'imprimante, et bien d'autres choses. Ils permettent à l'utilisateur d'interagir avec l'ordinateur : un clavier permet de saisir du texte sous dans un fichier, une souris enregistre des déplacements de la main en déplacement du curseur, un écran affiche des données d’images/vidéos, un haut-parleur émet du son, etc. Tout ce qui est branché sur un ordinateur est, formellement un périphérique.

L''''unité centrale''' est là où se trouvent tous les composants importants d'un ordinateur, ceux qui font des calculs, qui exécutent des logiciels, qui mémorisent vos données, etc. Voici ce à quoi ressemble l'intérieur de l'unité centrale. Trois sections sont visibles : l'alimentation électrique en haut à gauche, la carte mère en bas à gauche et en jaune/orange, les disques et lecteurs à droite des câbles. Et on voit aussi beaucoup de câbles.

[[File:Asus P5K-SEIntel E6320.jpg|centre|vignette|upright=2|Exemple d'unité centrale.]]

Tout en haut à gauche, se trouve l''''alimentation électrique''', qui convertit le courant de la prise électrique en un courant plus faible, utilisable par les autres composants. Elle émet de nombreux câbles assez gros, qui sont reliés au reste. Les PC actuels utilisent des alimentations électriques standardisées, qui fournissent trois tensions au reste de l'ordinateur : une tension de 12 Volts, une de 5 Volts, une de 3,3 Volts.

À droite, caché par la partie &quot;métallique&quot; du boitier, se trouvent les lecteurs de CD/DVD, et les disques durs. Les lecteurs CD-ROM ou DVD-ROM permettaient de lire des CD ou des DVD. Je parle au passé, car ils ont aujourd'hui disparu des ordinateurs modernes. Les '''disques durs''' sont des mémoires de stockage, qui mémorisent vos données de manière permanente. De nos jours, ils sont remplacés par des SSD, qui sont des disques durs électroniques, là où les disques durs proprement dit sont des mémoires magnétiques. Nous verrons la différence dans deux chapitres dédiés, un sur les disques durs, l'autre sur les SSD.

En bas à droite, se trouve la '''carte mère''' un support plat, en plastique ou en céramique, sur laquelle sont soudés/connectés les autres composants. Sur celle-ci, de nombreux composants sont soudés, d'autres sont branchés dessus avec des câbles, d'autres sont connectés dessus avec des connecteurs. Ils sont reliés entre eux par des fils conducteurs, le plus souvent du cuivre ou de l’aluminium, ce qui leur permet de s’échanger des données. Sur les cartes simples, ces fils sont intégrés dans la carte électronique, dans des creux du plastique. Ils portent le nom de pistes.

Avant, les disques durs, SSD et lecteurs de CD/DVD sont branchés dessus via des connecteurs dédiés, appelés des connecteurs S-ATA. De nos jours, ils sont branchés sur un autre connecteur, grâce à l'interface NVME. Toujours est-il qu'ils sont reliés à la carte mère par des câbles, ce qui montre que ce sont des sortes de périphériques interne. Ils sont placés dans le boitier, mais on aurait tout aussi bien pu les mettre à l'extérieur, vu qu'ils communiquent avec l'ordinateur par l'intermédiaire d'un câble ou d'un connecteur dédié.

Mais deux autres composants très importants sont eux placés sur la carte mère, directement. Ils ont chacun un connecteur dédié, sur lequel ils sont branchés directement, sans passer par l'intermédiaire d'un câble, mais sans être soudés non plus. Il s'agit du processeur et de la mémoire RAM, deux composants centraux des PC modernes.

[[File:Pentium III SL4CB.jpg|thumb|Processeur Pentium III.]]

Le '''processeur''' traite les données, les modifie, les manipule. Pour faire simple, il s’agit d’une grosse calculatrice hyper-puissante. Il comprend à la fois un circuit qui fait des calculs, et un circuit de contrôle qui s'occupe de séquencer les calculs dans l'ordre demandé. Il est souvent caché sous un radiateur, lui-même surmonté par un ventilateur. En effet, un processeur chauffe beaucoup, ce qui demande d'évacuer cette chaleur. Un chapitre entier expliquera pourquoi les processeurs chauffent, ainsi que les techniques utilisées pour limiter leur production de chaleur et leur consommation électrique.

La '''mémoire vive''' conserve des informations/données temporairement, tant que le processeur en a besoin. Elle prend la forme de barrettes de RAM, comme montré ci-dessous.

[[File:2 gb ddr2 667.jpg|centre|vignette|upright=2|Barrette de RAM.]]

Outre ces composants dits principaux, un ordinateur peut comprendre plusieurs composants moins importants, surtout présents sur les ordinateurs personnels. Ils sont techniquement facultatifs, mais sont très présents dans les ordinateurs personnels. Cependant, certains ordinateurs spécialisés s'en passent. Il s'agit des diverses '''cartes d'extension''' sont branchées sur la carte mère. Elles permettent d’accélérer certains calculs ou certaines applications, afin de décharger le processeur. Par exemple, la carte graphique s'occupe des calculs graphiques, qu'il s'agisse de graphismes 3D de jeux vidéos ou de l'affichage en 2D du bureau. Dans un autre registre, la carte son prend en charge le microphone et les haut-parleurs.

[[Fichier:Personal computer, exploded 4.svg|thumb|upright=1.0|Éclaté d'un ordinateur de type PC :&lt;br /&gt;
1 : Écran ;&lt;br /&gt;
2 : Carte mère ;&lt;br /&gt;
3 : Processeur ;&lt;br /&gt;
4 : Câble Parallel ATA ;&lt;br /&gt;
5 : Mémoire vive (RAM) ;&lt;br /&gt;
6 : Carte d'extension ;&lt;br /&gt;
7 : Alimentation électrique ;&lt;br /&gt;
8 : Lecteur de disque optique ;&lt;br /&gt;
9 : Disque dur ;&lt;br /&gt;
10 : Clavier ;&lt;br /&gt;
11 : Souris.]]

Si on regarde une carte mère de face, on voit un grand nombre de connecteurs, mais aussi des circuits électroniques soudés à la carte mère.

[[File:Architecture matérielle d'une carte mère.png|centre|vignette|upright=2.0|Architecture matérielle d'une carte mère]]

Les '''connecteurs''' sont là où on branche les périphériques, la carte graphique, le processeur, la mémoire, etc. Dans l'ensemble, toute carte mère contient les connecteurs suivants :
* Le processeur vient s’enchâsser dans la carte mère sur un connecteur particulier : le '''socket'''. Celui-ci varie suivant la carte mère et le processeur, ce qui est source d'incompatibilités.
* Les barrettes de mémoire RAM s’enchâssent dans un autre type de connecteurs: les '''slots mémoire'''.
* Les mémoires de masse disposent de leurs propres connecteurs : connecteurs P-ATA pour les anciens disques durs, et S-ATA pour les récents.
* Les périphériques (clavier, souris, USB, Firewire, ...) sont connectés sur un ensemble de connecteurs dédiés, localisés à l'arrière du boitier de l'unité centrale. 
* Les autres périphériques sont placés dans l'unité centrale et sont connectés via des connecteurs spécialisés. Ces périphériques sont des cartes imprimées, d'où leur nom de '''cartes filles'''. On peut notamment citer les cartes réseau, les cartes son, ou les cartes vidéo.

===Les ordinateurs portables===

[[File:Samsung QX-511 (2).JPG|vignette|Ordinateur portable Samsung QX-511 (2), pour illustration.]]

Un ordinateur portable est identique à un ordinateur de type PC. Si vous ouvrez votre ordinateur portable (attention à la garantie), vous retrouverez les mêmes composants qu'un PC à l'intérieur. Un point important est la présence d'une batterie à l'intérieur du PC portable, absente des PC fixes.

[[File:LG gram 14Z90Q mainboard with battery.jpg|centre|vignette|upright=2|LG gram 14Z90Q avec sa batterie.]]

Une fois la batterie et les circuits associés retiré, la seule différence notable est que tous les composants sont soudés sur la carte mère, au lieu d'être branchés sur des connecteurs, à part éventuellement la RAM et le disque dur.

[[File:LG gram 14Z90Q mainboard without battery.jpg|centre|vignette|upright=2|LG gram 14Z90Q sans sa batterie.]]

La RAM est parfois soudée sur la carte mère, d'autres fois sous la forme de barrettes de mémoire vive semblables à celles des PC. Dans le dernier cas, elle est connectée à des connecteurs spécifiques, ce qui permet de les changer/upgrader. Les PC portables sont parfois construits de manière à pouvoir changer la RAM facilement, en ouvrant un cache spécial, concu pour.

[[File:Lenovo G555 состав - Донор.JPG|centre|vignette|upright=2|Lenovo G555.]]

La conception d'un ordinateur portable est légèrement différente de celle d'un PC, pour des raisons thermiques. Un PC fixe a plus de place pour évacuer sa chaleur. Les ventilateurs peuvent plus facilement déplacer l'air dans le boitier, même si le flux d'air dans le boitier est éventuellement gêné par la carte graphique. Mais l'évacuation de la chaleur est assez efficace. Sur les PC portables, leur finesse fait que le trajet de l'air est beaucoup plus contraint. Évacuer la chaleur produite par l'ordinateur est plus complexe, ce qui demande d'utiliser des systèmes de refroidissement et de ventilation spécifiques.

Là où les PC fixes se débrouillent avec des radiateurs et des ventilateurs posés sur le processeur, les PC portables font autrement. Ils ne peuvent pas forcément mettre le ventilateur sur le processeur. A la place, ils mettent le ventilateur à côté, mais le processeur est surmonté par un mécanisme de transmission de la chaleur, qui transfère la chaleur du processeur vers le ventilateur.

[[File:Diagram - How a laptop cooling system works.png|centre|vignette|upright=2|Comment fonctionne le système de ventilation d'un ordinateur portable, en anglais.]]

Les difficultés pour dissiper la chaleur font que les ordinateurs portables utilisent souvent des composants peu performants, mais qui chauffent peu. En effet, nous verrons que plus un composant est puissant, plus il chauffe. La relation n'est pas parfaite, mais les processeurs haute performance chauffent plus que les modèles d'entrée ou milieu de gamme moins puissants. En conséquence, les PC portables sont souvent moins puissants que les PC fixes, même pour les modèles dit ''gaming''.

===Les serveurs et ''mainframes''===

Les grandes entreprises utilisent des ordinateurs de grande taille, très puissants, appelés des ''mainframes''. Ils sont souvent confondus avec les serveurs par le grand public, il y a une différence entre les deux. Un serveur est une fonction logicielle/réseau, pas un type d'ordinateur. Mais laissons cette différence de côté, ce qui est dit pour les ''mainframes'' sert pour les gros serveurs haute performance.

[[File:IBM Z15 mainframe.jpg|vignette|Exemple de ''mainframe''' de type IBM Z15.]]

Les anciens ''mainframes'' des années 50-80 avaient une taille pouvant être impressionnante, au point de prendre une pièce complète d'un bâtiment. Mais de nos jours, les ''mainframes'' tiennent dans une grosse armoire un peu haute. Les ''mainframes'' doivent rester allumé en permanence et ne doivent pas être éteint, sauf éventuellement quelques jours par an pour des opérations de maintenance. Ils utilisent pour cela des techniques spécifiques, avec beaucoup de redondance interne.

[[File:ACONIT hall grandes machines.jpg|centre|vignette|upright=2|''Mainframe'' ACONIT.]]

Les ''mainframes'' sont aussi conçus pour mutualiser au maximum leur utilisation, ils peuvent être utilisés par plusieurs utilisateurs à la suite, voire en même temps. Pour cela, les anciens ''mainframes'' étaient capables de faire tourner plusieurs applications distinctes l'une à la suite de l'autre, avec des commutations fréquentes entre logiciels. De nos jours, ils sont capables d'exécuter un grand nombre de tâches en même temps, grâce à la présence de plusieurs processeurs. Les ''mainframes'' modernes sont même capables de faire tourner plusieurs systèmes d'exploitation en même temps si besoin.

Les anciens ''mainframes'' étaient des ordinateurs assez simples, avec un processeur, de la mémoire RAM, un ou plusieurs disques durs, pas plus. Le ''mainframe'' était tellement énorme et cher que les entreprises n'en avaient qu'un seul pour toute l'entreprise. Les employés avaient sur leur bureau des terminaux, qui permettaient d'accéder à l'ordinateur central, mais n'étaient pas des ordinateurs. Les terminaux étaient des composants électroniques simples, avec un écran, un clavier et une souris, mais sans processeur. Ils envoyaient des données au ''mainframe'', ils en recevaient de sa part, mais tout traitement était réalisé sur le ''mainframe''. L'arrivée sur le marché des ordinateurs personnels, de type PC fixe/portable, a entrainé l'abandon de ce genre de pratique, tous les employés ont maintenant un ordinateur rien que pour eux.

{|
|-
! colspan=&quot;2&quot; | Exemples de terminaux
|-
|[[File:Terminal-in2-sm9400.jpg|centre|vignette|upright=1.5|Exemple de terminal. Notez la présence d'un écran et d'un clavier, mais l'asbence d'une unité centrale.]]
|[[File:Chromatics CT4100.jpg|vignette|upright=1.5|Autre exemple de terminal. Le clavier est couplé à un stylo CRT, qui remplacait la souris et agissait sur l'écran comme s'il était tactile.]]
|-
! colspan=&quot;2&quot; | Intérieur d'un terminal
|-
|[[File:CT1024 Monitor.jpg|vignette|upright=1.5|Terminal CT1024, sans le boitier extérieur.]]
|[[File:CT1024 Terminal System.jpg|vignette|upright=1.5|Terminal CT1024, description des composants interne.]]
|}

De nos jours, les ''mainframes'' contiennent en réalité plusieurs ordinateurs simples interconnectés via un réseau local. Un ''mainframe'' qui tient dans une armoire contient facilement une dizaine ou centaine de processeurs, plein de RAM, des disques durs séparés dans une armoire distincte, etc. Vu qu'ils communiquent uniquement via le réseau, ils n'ont pas d'interface, pas d'écran, 'entrée via clavier/souris. Le tout est commandé avec une console de commande, typiquement un ordinateur portable ou un terminal assez simple séparé de l'armoire, qui permet à un administrateur de faire des opérations de surveillance, configuration et maintenance. Il peut y avoir une console de commande pour plusieurs armoires séparées, la console peut même être dans un autre bâtiment et accéder au ''mainframe'' par le réseau.

[[File:IBM System Z9 (type 2094 inside).jpg|centre|vignette|upright=2|''Mainframe'' de type IBM System Z9. L'ordinateur portable sert de console pour qu'un administrateur fasse des opérations de surveillance, configuration et maintenance.]]

Les processeurs et la RAM sont typiquement installés sur des cartes amovibles, qui sont connectées au fond de l'armoire lors de l'installation. Il est même possible de retirer ou d'ajouter des cartes en fonctionnement, afin d'ajouter/retirer des processeurs, des disques durs, etc. Ce qui est très utile si un composant est en panne et qu'il faut le remplacer. 

[[File:IBM TotalStorage Exp400.jpg|centre|vignette|upright=2|IBM TotalStorage Exp400]]

==Un peu d'abstraction : qu'est-ce qu'un ordinateur ?==

Un ordinateur comprend donc un processeur, plusieurs mémoires, des cartes d'extension et une carte mère pour connecter le tout. Mais il s'agit là d'une description assez terre-à-terre de ce qu'est un ordinateur. Une autre description, plus abstraite, se base sur le fait qu'un ordinateur est une énorme calculatrice programmable. Elle permet d'expliquer pourquoi il y a une distinction entre processeur et mémoire, entre unité centrale et périphériques. Tout ce qui va suivre pourra vous paraitre assez abstrait, mais rassurez-vous : les prochains chapitres rendront tout cela plus concrets.

===La séparation entre entrées-sorties et traitement===

L'unité centrale peut être vue comme une énorme calculatrice ultra-puissante, qui exécute des commandes/opérations. Mais à elle seule, elle ne servirait à rien, il faut interagir avec par l'intermédiaire de plusieurs périphériques. Il existe deux types de périphériques, qui sont conceptuellement différents. Les périphériques comme le clavier ou la souris permettent d'envoyer des informations à l'ordinateur, d'agir sur celui-ci. A l'inverse, les écrans transmettent des informations dans le sens inverse : de l'ordinateur vers l'utilisateur. Les premiers sont appelés des '''entrées''', les seconds des '''sorties'''.

Dans un ordinateur, les informations sont représentées sous la forme de nombres. Toute donnée dans un ordinateur est codée avec un ou plusieurs nombres regroupés dans une donnée, un fichier, ou autre. Et la transmissions avec les entrées et sorties se fait là-encore avec des nombres. Par exemple, quand vous appuyez sur votre clavier, le clavier envoie un numéro de touche à l'unité centrale, qui indique quelle touche a été appuyée. L'image à afficher à l'écran est codée sous la forme d'une suite de nombres (un par pixel). L'image est envoyée à l'écran, qui traduit la suite de nombre en image à afficher. Les entrées traduisent des actions utilisateurs en nombres, on dit que les entrées encodent les actions utilisateur. Les sorties font la traduction inverse, elles transforment des suites de nombres en une action physique. On dit qu'elles décodent des informations.

Pour résumer, toute appareil électronique est composé par :
* Des '''entrées''' sur lesquelles l'utilisateur agit sur l'ordinateur. Les entrées transforment les actions de l'utilisateur en nombres, qui sont interprétés par l'ordinateur.
* Une '''unité de traitement''', qui manipule des nombres et fait des calculs/opérations dessus. Les nombres proviennent des entrées, du disque dur, ou d'autres sources, peu importe.
* Des '''sorties''', qui va récupèrent le résultat calculé par l'unité de traitement pour en faire quelque chose : écrire sur une imprimante ou sur un moniteur, émettre du son,...

[[File:Ordinateur théorique Simple 1.png|centre|vignette|upright=2|Ordinateur théorique Simple 1]]

L'unité de traitement proprement dite, celle qui fait les calculs, est couplée à une mémoire qui mémorise les opérandes et résultats des calculs. La séparation entre processeur et mémoire est nécessaire pour qu'un appareil électronique soit qualifié d'ordinateur. De nombreux appareils n'ont pas de séparation entre unité de traitement et mémoire, comme certaines vielles radios AM/FM.

[[File:Schéma de principe d'un ordinateur.png|centre|vignette|upright=2|Schéma de principe d'un ordinateur]]

===Un ordinateur est un appareil programmable===

Les appareils simples sont non-programmables, ce qui veut dire qu’ils sont conçus pour une utilisation particulière et qu’ils ne peuvent pas faire autre chose. Par exemple, les circuits électroniques d’un lecteur de DVD ne peuvent pas être transformé en lecteur audio ou en console de jeux... Les circuits non-programmables sont câblés une bonne fois pour toute, et on ne peut pas les modifier. On peut parfois reconfigurer le circuit, pour faire varier certains paramètres, via des interrupteurs ou des boutons, mais cela s’arrête là. Et cela pose un problème : à chaque problème qu'on veut résoudre en utilisant un automate, on doit recréer un nouveau circuit.

À l'inverse, un ordinateur n’est pas conçu pour une utilisation particulière, contrairement aux autres objets techniques. Il est possible de modifier leur fonction du jour au lendemain, on peut lui faire faire ce qu’on veut. On dit qu'ils sont '''programmables'''. Pour cela, il suffit d’utiliser un logiciel, une application, un programme (ces termes sont synonymes), qui fait ce que l'on souhaite. La totalité des logiciels présents sur un ordinateur sont des programmes comme les autres, même le système d'exploitation (Windows, Linux, ...) ne fait pas exception.

Un programme est une suite de d'instructions, chaque instruction effectuant une action dans l'ordinateur. Sur les ordinateurs modernes, la majorité de ces instructions effectuent une opération arithmétique, comme une addition, une multiplication, une soustraction, etc. Les ordinateurs modernes sont donc de grosses calculettes très puissantes, capables d'effectuer des millions d'opérations par secondes. Et qui dit opération dit nombres : un ordinateur gère nativement des nombres, qui sont codés en binaire sur la quasi-totalité des ordinateurs modernes.

Une instruction est représentée dans un ordinateur par une série de nombres : un nombre qui indique quelle opération/commande effectuer et des autres nombres pour coder les données (ou de quoi les retrouver dans l'ordinateur). L'ordinateur récupére les commandes une par une, les traduit en opération à effectuer, exécuter l'opération, et enregistre le résultat. Puis il recommence avec la commande suivante.

[[File:Ordinateur Théorique Complexe 1.png|centre|vignette|upright=3|Ordinateur Théorique Complexe. En jaune, le programme informatique, la liste de commande. Le rectangle gris est l'ordinateur proprement dit.]]

De nombreux appareils sont programmables, mais tous ne sont pas des ordinateurs. Par exemple, certains circuits programmables nommés FPGA n'en sont pas. Pour être qualifié d'ordinateur, un appareil programmable doit avoir un processeur séparé de la mémoire. De plus, il doit utiliser un '''codage numérique''', chose que nous allons aborder dans le chapitre suivant.

===Les ordinateurs à programme mémorisé ou programme externe===

Au tout début de l'informatique, on utilisait des cartes perforées en plastique, sur lesquelles on inscrivait le programme à exécuter, les données à traiter, bref : tout ce qu'on donnait à manger à l'ordinateur. Par la suite, les premiers ordinateurs grand public, comme les Amstrad ou les Commodore, utilisaient des cassettes audio magnétiques pour stocker les programmes. Dans le même style, les consoles de jeu utilisaient autrefois des cartouches de jeu, qui contenaient le programme du jeu à exécuter. Pour résumer, les anciens ordinateurs mémorisaient les programmes sur un support externe, lu par un périphérique. De tels ordinateurs sont dits à '''programme externe'''.

: D’anciens ordinateurs personnels, comme l’Amstrad ou le Commodore, permettaient de taper les programmes à exécuter à la main, au clavier, avant d’appuyer une touche pour les exécuter. Nul besoin de vous dire que les cassettes audio étaient plus pratiques.

Mais de nos jours, les programmes sont enregistrés sur le disque dur de l'ordinateur ou dans une mémoire intégrée à l'ordinateur. On dit qu'ils sont installés, ce qui est un mot bien compliqué pour dire que le programme est enregistré sur le disque dur de l’ordinateur. A défaut de disque dur, le programme/logiciel est enregistré dans une mémoire spécialisée pour le stockage. Par exemple, sur les cartes électroniques grand public de marque Arduino, les programmes sont envoyés à la carte via le port USB, mais les programmes sont enregistrés dans la carte Arduino, dans une mémoire FLASH dédiée. Disque dur ou non, le programme est mémorisé dans la mémoire de l'ordinateur. Il est possible d'installer ou de désinstaller les programmes en modifiant le contenu de la mémoire. Le terme utilisé est alors celui de '''programme stocké en mémoire'''.

Les programmes à installer sont disponibles soit sur un périphérique, comme un DVD ou une clé USB, soit sont téléchargés depuis internet. Les premiers PC fournissaient les logiciels sur des disquettes, qui contenaient un programme d'installation pour enregistrer le programme sur le disque dur de l'ordinateur. Par la suite, le support des logiciels a migré vers les CD et DVD, les logiciels devenant de plus en plus gros. De nos jours, la majorité des applications sont téléchargées depuis le net, l'usage de périphériques est devenu obsolète, même les consoles de jeu abandonnent cette méthode de distribution.

==Les générations d'ordinateurs : un historique rapide==

L'informatique a beaucoup évolué dans le temps. Et une bonne partie de cette évolution tient à l'évolution de l’électronique sous-jacente. Les ordinateurs actuels sont fabriqués avec des transistors, des petits composants électroniques qui servent d'interrupteur programmables, qu'on détaillera dans ce qui suit. Mais ça n'a pas toujours été le cas. Et cela permet de distinguer plusieurs '''générations d'ordinateurs'''.

===Les ordinateurs électro-mécaniques : les premiers ordinateurs===

Le tout premier ordinateur est le '''Z1''', un modèle unique inventé par Konrad Suze entre 1936 et 1938. Son processeur gérait non pas des nombres entiers, mais des nombres à virgule (des nombres dits flottants, pour être précis), encodés sur 22 bits. Le processeur du Z1 était capable de faire des additions et des soustractions, car il intégrait un circuit additionneur-soustracteur basique. Des circuits annexes permettaient de faire des multiplications et des divisions en enchainant des additions/soustractions successives. Il fonctionnait à une fréquence de 1 Hz, ce qui fait qu'il pouvait faire une addition/soustraction par seconde maximum.

[[File:Blue-punch-card-front.png|vignette|upright=0.5|Carte Perforée.]]

Niveau mémoire, la RAM de l'ordinateur était très limitée : seulement 16 nombres de 22 bits chacun. S'il s'agissait d'une mémoire électronique, les programmes étaient mémorisés sur une mémoire mécanique. Les programmes étaient enregistrés sur des cartes perforées, à savoir des cartes en papier dans lesquelles un 1 est codé par un trou dans le papier et un 0 par une absence de trou. Les programmes étaient exécutés par l'ordinateur quand on insérait la carte perforée dans le lecteur et qu'on appuyait sur un bouton.

[[File:German Museum of Technology, Berlin 2017 024.jpg|centre|vignette|upright=2|Réplique du Z1 au ''German Museum of Technology'' de Berlin, 2017.]]

Après sa destruction dans un bombardement, le Z1 a été reconstruit et amélioré, ce qui donné les deux ordinateurs Z2 et Z3. Quelques années plus tard, de nombreux ordinateurs ont été construits dans des laboratoires de recherche. Des grandes noms de l'histoire de l'informatique datent de cette époque : le Harvard Mark I et le Colossus Mark 1 (UK) ont tous deux été mis en service en 1944, par exemple. Ils ont servis pour les cryptanalystes pour casser les codes utilisés par les allemands pour leurs transmissions, pendant la seconde guerre mondiale.

Les ordinateurs cités dans le précédent paragraphe étaient tous des ordinateurs dit '''électro-mécaniques''', car ils mélangeaient des composants électroniques et des composants mécaniques (tout ce qui a trait aux cartes perforées, notamment). Les composants électroniques étaient soit des relais, soit des tubes à vides, les deux étant des interrupteurs commandables électriquement plus ou moins équivalents aux transistors. Les ordinateurs d'avant l'année 1944, étaient tous de ce type. Quelques ordinateurs des années 50 étaient de ce type, mais leur nombre n'a pas dépassé 30. Il faut dire qu'ils ont rapidement laissé la place à des ordinateurs purement électroniques, que nous allons voir dans ce qui suit..

===La première génération : les tubes à vide===

[[File:IBM 7070.jpg|vignette|Cartes imprimées de l'IBM 704, avec des transistors et résistances dessus.]]

Les ordinateurs qui ont suivi les ordinateurs électromécaniques sont regroupés dans la '''première génération d'ordinateur'''. Ils étaient conçus avec des tubes à vide, ce qui les place entre les premiers ordinateurs électro-mécaniques et les ordinateurs utilisant des transistors. Les ordinateurs de première génération étaient très simples, ils ne géraient que quelques opérations simples : l'addition, la soustraction, pas grand chose de plus. A quelques exceptions près, ils ne géraient pas la multiplication et encore moins la division, ils n'avaient pas assez de relais ou de tubes à vides à disposition pour cela.

Une des toutes premières machines construite avec des tubes à vide était l'Atanasoff–Berry. Ce n'était pas un ordinateur, car elle ne pouvait pas exécuter de programme sans intervention humaine pour séquencer des opérations, mais c'était la première machine de calcul purement électronique, sans aucune pièce mécanique. Elle utilisait une mémoire RAM construite avec des condensateurs, ceux-ci étant placés sur des cylindres tournants. Les circuits de calcul étaient construits avec des tubes à vide et faisaient leur travail un bit à la fois. Elle fonctionnait à une fréquence de 60 Hz et pouvait faire 30 additions/soustractions par seconde. Les nombres étaient encodés sur 50 bits. 

[[File:Atanasoff Berry Computer.gif|centre|vignette|upright=2.5|Atanasoff–Berry.]]

L'arrivée de l'ENIAC en 1945 a changé la donne. Cet ordinateur a introduit plusieurs innovations majeures. La première est assez technique, il s'agit de la turing-complétude, elle a trait aux programmes qui peuvent être écrit pour un ordinateur, nous ne la détaillerons pas ici.

En 1948, le ''Manchester Baby'' a introduit une innovation extrêmement importante, au point où on considère que c'est le premier ordinateur à avoir tous les critères nécessaires pour être appelé un ordinateur. Son innovation est que le programme n'était plus mémorisé sur des cartes perforée, mais dans une mémoire électronique dans l'ordinateur lui-même. En clair, le ''Manchester Baby'' était le premier '''''Stored-program computer''''', ordinateur à programme enregistré en français. 

Le Manchester Baby avait une RAM de 32 nombres de 32 bits, fabriquées avec des tubes Willimas (abordés dans une annexe à la fin du cours). Il gérait 8 instructions en tout, mais ne gérait pas l'addition. Il gérait la soustraction, des instructions de branchement et d'accès mémoire, mais rien d'autre. Il pouvait cependant émuler l'addition à partir d'une soustraction et inversant l'opérande soustraite.

===La seconde génération : le remplacement des tubes à vides par des transistors===

La '''seconde génération''' est celle des ordinateurs fabriqués avec des '''transistors''' isolés, reliés entre avec des fils électriques. Les transistors en question possèdent trois broches, des pattes métalliques sur lesquelles on connecte des fils électriques. Le transistor s'utilise le plus souvent comme un interrupteur commandé par sa troisième broche. Le courant qui traverse les deux premières broches passe ou ne passe pas selon ce qu'on met sur la troisième.

[[File:Transistor basic flow.svg|centre|vignette|Un transistor est un morceau de conducteur, dont la conductivité est contrôlée par sa troisième broche/borne.]]

Les ordinateurs de seconde génération avaient entre 1000 et 500 000 transistors. Les capacités des ordinateurs étaient donc nettement supérieures à celles des ordinateurs de première génération. Une part non négligeable des ordinateurs de seconde génération supportait l'opération de multiplication, absente sur les ordinateurs de première génération. Néanmoins, cela variait beaucoup selon les ordinateurs.

Un exemple assez hors du commun est celui du premier modèle de l'IBM 1620. Le tout premier modèle n'avait aucun circuit de calcul, il n'était même pas capable de faire une addition ou une multiplication. A la place, il utilisait une table d'addition et une table de multiplication en mémoire RAM. Les deux tables devaient être initialisées par le logiciel lors du démarrage de la machine. La table d'addition faisait une centaine de chiffre, la table de multiplication faisait le double. Le processeur de l'ordinateur gérait des instructions pour faire des additions ou des multiplications, mais ces opérations lisaient le résultat dans la table d'addition. Les calculs étaient fait chiffre par chiffre, avec un encodage partiellement décimal, partiellement binaire (des chiffres décimaux étaient encodés en binaire, nous en reparlerons quand nous parlerons du BCD) !

[[File:KL CoreMemory.jpg|vignette|Mémoire à tore de ferrite.]]

Les transistors n'étaient utilisés que pour le processeur et les circuits annexes. La mémoire n'était pas faite en transistors, pas à cette époque. La mémoire était une mémoire aujourd'hui abandonnée, appelée une '''mémoire à tores de ferrite'''. Elle sera détaillée dans un chapitre ultérieur. Mais sachez pour le moment qu'il s'agit d'une mémoire au support magnétique, les données étant stockées sur un support magnétique.

Transistors comme tubes à vide prenaient beaucoup de place, ce qui fait que les ordinateurs étaient assez gros. Concrètement, ils prenaient une pièce de bâtiment entière dans le meilleur des cas. C'était l'époque des gros ''mainframes'', reliés à des terminaux, peu puissants comparé aux standards actuels. Seules les grandes entreprises et les grands instituts de recherche pouvaient se payer les services de ce genre d'ordinateurs. Seuls les professionnels avaient accès à ce genre d'équipement.

===La troisième génération : le circuit intégré===

[[File:D8259AC-2.jpg|vignette|Exemple de circuit intégré.]]

La troisième génération est toujours fabriquée avec des transistors, mais dont la taille a été réduite. Avec l'évolution de la technologie, les transistors ont diminué en taille, de plus en plus. Ils sont devenus tellement petits qu'ils ont finit par être regroupés dans des '''circuits intégrés''', des circuits regroupent plusieurs transistors sur la même puce de silicium. Les circuits intégrés se présentent le plus souvent sous la forme de boitiers rectangulaires, comme illustré ci-contre. D'autres ont des boitiers de forme carrées, comme ceux que l'on peut trouver sur les barrettes de mémoire RAM, ou à l'intérieur des clés USB/ disques SSD.

Lors de cette génération, les processeurs étaient fournis en pièces détachées qu'il fallait relier entre elles. Le processeur était composé de plusieurs circuits intégrés séparés, impossible de mettre un processeur dans un seul boitier. Un exemple de processeur conçu en kit est la série des Intel 3000. Elle regroupe plusieurs circuits séparés aux noms à coucher dehors, mais dont vous comprendrez ce qu'ils veulent dire dans les chapitres adéquats : l'Intel 3001 est un séquenceur, l'Intel 3002 regroupe unité de calcul et registres, le 3003 est un circuit d'anticipation de retenue complémentaire du 3002, le 3212 est une mémoire tampon, le 3214 est une unité de gestion des interruptions, les 3216/3226 sont des interfaces de bus mémoire. On pourrait aussi citer la famille de circuits intégrés AMD Am2900.

Même si le processeur était en pièce détachées, utiliser une dizaine de circuits intégrés était nettement mieux que d'utiliser plusieurs milliers de transistors individuels. En conséquence, les ordinateurs ont vu leur taille grandement réduite, passant de pièces entières à une simple armoire, voire à quelques cartes intégrées superposées. De plus, le prix des circuits intégré était abordable, du moins comparé aux ordinateurs d'avant. Le prix des ordinateurs a alors grandement décru, permettant à des entreprises et administrations de taille modeste de s'équiper d'ordinateurs.

===La quatrième génération : le microprocesseur===

[[File:MOS6502.svg|vignette|Microprocesseur, ici un processeur MOS6502, de la quatrième génération.]]

Lors de la troisième génération, les circuits intégrés regroupaient plusieurs dizaines ou centaines de transistors, mais sont rapidement montés en gamme. De centaines de transistors, ils sont passé au milliers de transistors, puis au millions et maintenant au-delà du milliard. Les transistors étaient devenus tellement petits, tellement miniaturisés, qu'il était devenu possible de mettre un processeur entier dans un circuit intégré. C'est ainsi qu'est né le microprocesseur, à savoir un processeur qui tient tout entier dans un seul circuit imprimé. La quatrième génération d’ordinateur est celle des ordinateurs basés autour d'un microprocesseur.

Les tout premiers microprocesseurs étaient des processeurs à application militaire, comme le processeur du F-14 CADC ou celui de l'Air data computer. Le tout premier microprocesseur commercialisé au grand public est le 4004 d'Intel, sorti en 1971. L'intel 4004 comprenait environ 2300 transistors, avait une fréquence de 740 MHz, pouvait faire 46 opérations différentes, et manipulait des entiers de 4 bits. Il était au départ un processeur de commande, prévu pour être intégré dans la calculatrice Busicom calculator 141-P, mais il fut utilisé pour d'autres applications quelque temps plus tard. Immédiatement après le 4004, les premiers microprocesseurs 8 bits furent commercialisés. Le 4004 fut suivi par le 8008 et quelques autres processeurs 8 bits extrêmement connus, comme le 8080 d'Intel, le 68000 de Motorola, le 6502 ou le Z80.

Les microprocesseurs permirent encore uen fois de réduire la taille des ordinateurs, qui pouvaient tenir dans un boitier de PC, ou un boitier de console de jeu. Le prix des ordinateurs a aussi chuté en même temps que les transistors était miniaturisés. C'est cette invention qui permis l'invention des consoles de jeux et des mini-ordinateurs, à savoir les ordinateurs personnels. Sans miniaturisation, on n'aurait pas d'ordinateur personnel, pas de PC fixe ou portable.

==L'organisation du cours : les différents niveaux d'explication==

Le fonctionnement d'un ordinateur est assez complexe à expliquer car les explications peuvent se faire sur plusieurs niveaux. Par plusieurs niveaux, on veut dire qu'un ordinateur est composé de composants très simples, qui sont assemblés pour donner des composants eux-même plus complexes, qui sont eux-même regrouper, etc. Étudier tout cela demande de voir plusieurs niveaux, allant de transistors très petits à des processeurs multicœurs. Les niveaux les plus bas sont de l'électronique pur et dure, alors que ceux plus haut sont à mi-chemin entre électronique et informatique.

===Les niveaux d'abstraction en architecture des ordinateurs===

Les trois premiers niveaux sont de l'électronique pur et dure. Ils correspondent aux premiers chapitres du cours, qui porteront sur les circuits électroniques en général.
* Le premier niveau est celui des '''transistors''', des circuits intégrés, des ''wafer'' et autres circuits de très petite taille.
* Le second niveau est celui des '''portes logiques''', des circuits très basiques, très simples, à la base de tous les autres.
* Le troisième niveau est celui dit de la '''''Register Transfer Level''''', où un circuit électronique est construit à partir de circuits basiques, dont des registres et autres circuits dits combinatoires.
Les deux niveaux suivants sont de l'informatique proprement dit. C'est dans ces deux niveaux qu'on étudie les ordinateurs proprement dit, les circuits qu'il y a dedans et non l'électronique en général.
* Le quatrième niveau est celui de la '''microarchitecture''', qui étudie ce qu'il y a à l'intérieur d'un processeur, d'une mémoire, des périphériques et autres.
* Le cinquième niveau est celui de l''''architecture externe''', qui décrit l'interface du processeur, de la mémoire, d'un périphérique ou autre. Par décrire l'interface, on veut dire : comment un programmeur voit le processeur et la mémoire, comment il peut les manipuler. Une architecture externe unique peut avoir plusieurs microarchitecture, ce qui fait qu'on sépare les deux. Tout cela sera plus clair quand on passera aux chapitres sur le processeur et les mémoires.

Nous n'allons pas voir les 5 niveaux dans l'ordre, des transistors vers l'architecture externe. En réalité, nous allons procéder autrement. La première partie du cours portera sur les trois premiers niveaux, le reste sur les deux autres. Les 5 niveaux seront vus dans des chapitres séparés, du moins le plus possible. Au niveau pédagogique, tout est plus simple si on scinde les 5 niveaux. Bien sûr, il y a quelques explications qui demandent de voir plusieurs niveaux à la fois. Par exemple, dans le chapitre sur les mémoires caches, nous auront des explications portant sur la RTL, la microarchitecture du cache et son architecture externe. Mais le gros du cours tentera de séparer le plus possible les 5 niveaux.

===Les trois parties principales du cours===

Nous allons commencer par parler du binaire, avant de voir les portes logiques. Avec ces portes logiques, nous allons voir comment fabriquer des circuits basiques qui reviendront très souvent dans la suite du cours. Nous verrons les registres, les décodeurs, les additionneurs et plein d'autres circuits. Puis, nous reviendrons au niveau des transistors pour finir la première partie. La raison est que c'est plus simple de faire comme cela. Tout ce qui a trait aux transistors sert à expliquer comment fabriquer des portes logiques, et il faut expliquer les portes logiques pour voir le niveau de la RTL.

Une fois la première partie finie, nous allons voir les différents composants d'un ordinateur. Une première partie expliquera ce qu'il y a dans un ordinateur, quels sont ses composants. Nous y parlerons de l'architecture de base, de la hiérarchie mémoire, des tendances technologiques, et d'autres généralités qui serviront de base pour la suite. Puis, nous verrons dans l'ordre les bus électroniques, les mémoires RAM/ROM, le processeur, les périphériques, les mémoires de stockage (SSD et disques durs) et les mémoires caches. Pour chaque composant, nous allons voir leur architecture externe, avant de voir leur microarchitecture. La raison est que la microarchitecture ne peut se comprendre que quand on sait quelle architecture externe elle implémente.

Enfin, dans une troisième partie, nous allons voir les optimisations majeures présentes dans tous les ordinateurs modernes, avec une partie sur le pipeline et le parallélisme d'instruction, et une autre sur les architectures parallèles. Pour finir, les annexes de fin parlerons de sujets un peu à part.

&lt;noinclude&gt;
{{NavChapitre | book=Fonctionnement d'un ordinateur
           | next=L'encodage des données
           | nextText=L'encodage des données
}}
&lt;/noinclude&gt;</text>
      <sha1>rfmlhd1k2kdds7yr238oo52ag6zn0jg</sha1>
    </revision>
    <revision>
      <id>744117</id>
      <parentid>744116</parentid>
      <timestamp>2025-06-04T23:49:33Z</timestamp>
      <contributor>
        <username>Mewtow</username>
        <id>31375</id>
      </contributor>
      <minor />
      <comment>/* La première génération : les tubes à vide */</comment>
      <origin>744117</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="43211" sha1="5bstp4bl48f1suqtfmn8r8j10bucuvn" xml:space="preserve">Pour commencer, nous allons voir qu'il existe de nombreux types d'ordinateurs. Le plus connu est certainement le PC, l'ordinateur personnel, que vous avez sans doute dans votre salon. Les ordinateurs portables sont un deuxième type d'ordinateur assez intuitif, que vous avez peut-être. Mais il y a aussi d'autres types d'ordinateurs auxquels vous n'avez jamais été confrontés.

==Les différents types d'ordinateurs==

Dans cette section, nous allons décrire rapidement les ordinateurs les plus courant, mais surtout voir ce qu'il y a à l'intérieur d'un ordinateur.

===L'ordinateur de type PC fixe===

De l'extérieur, l'ordinateur est composé d'une unité centrale sur laquelle on branche des périphériques.

[[File:Typical computer architecture systems.jpg|vignette|upright=1.5|Exemples de périphériques, connectés à une unité centrale (ici appelée à tort ''operating system'').]]

Les '''périphériques''' regroupent l'écran, la souris, le clavier, l'imprimante, et bien d'autres choses. Ils permettent à l'utilisateur d'interagir avec l'ordinateur : un clavier permet de saisir du texte sous dans un fichier, une souris enregistre des déplacements de la main en déplacement du curseur, un écran affiche des données d’images/vidéos, un haut-parleur émet du son, etc. Tout ce qui est branché sur un ordinateur est, formellement un périphérique.

L''''unité centrale''' est là où se trouvent tous les composants importants d'un ordinateur, ceux qui font des calculs, qui exécutent des logiciels, qui mémorisent vos données, etc. Voici ce à quoi ressemble l'intérieur de l'unité centrale. Trois sections sont visibles : l'alimentation électrique en haut à gauche, la carte mère en bas à gauche et en jaune/orange, les disques et lecteurs à droite des câbles. Et on voit aussi beaucoup de câbles.

[[File:Asus P5K-SEIntel E6320.jpg|centre|vignette|upright=2|Exemple d'unité centrale.]]

Tout en haut à gauche, se trouve l''''alimentation électrique''', qui convertit le courant de la prise électrique en un courant plus faible, utilisable par les autres composants. Elle émet de nombreux câbles assez gros, qui sont reliés au reste. Les PC actuels utilisent des alimentations électriques standardisées, qui fournissent trois tensions au reste de l'ordinateur : une tension de 12 Volts, une de 5 Volts, une de 3,3 Volts.

À droite, caché par la partie &quot;métallique&quot; du boitier, se trouvent les lecteurs de CD/DVD, et les disques durs. Les lecteurs CD-ROM ou DVD-ROM permettaient de lire des CD ou des DVD. Je parle au passé, car ils ont aujourd'hui disparu des ordinateurs modernes. Les '''disques durs''' sont des mémoires de stockage, qui mémorisent vos données de manière permanente. De nos jours, ils sont remplacés par des SSD, qui sont des disques durs électroniques, là où les disques durs proprement dit sont des mémoires magnétiques. Nous verrons la différence dans deux chapitres dédiés, un sur les disques durs, l'autre sur les SSD.

En bas à droite, se trouve la '''carte mère''' un support plat, en plastique ou en céramique, sur laquelle sont soudés/connectés les autres composants. Sur celle-ci, de nombreux composants sont soudés, d'autres sont branchés dessus avec des câbles, d'autres sont connectés dessus avec des connecteurs. Ils sont reliés entre eux par des fils conducteurs, le plus souvent du cuivre ou de l’aluminium, ce qui leur permet de s’échanger des données. Sur les cartes simples, ces fils sont intégrés dans la carte électronique, dans des creux du plastique. Ils portent le nom de pistes.

Avant, les disques durs, SSD et lecteurs de CD/DVD sont branchés dessus via des connecteurs dédiés, appelés des connecteurs S-ATA. De nos jours, ils sont branchés sur un autre connecteur, grâce à l'interface NVME. Toujours est-il qu'ils sont reliés à la carte mère par des câbles, ce qui montre que ce sont des sortes de périphériques interne. Ils sont placés dans le boitier, mais on aurait tout aussi bien pu les mettre à l'extérieur, vu qu'ils communiquent avec l'ordinateur par l'intermédiaire d'un câble ou d'un connecteur dédié.

Mais deux autres composants très importants sont eux placés sur la carte mère, directement. Ils ont chacun un connecteur dédié, sur lequel ils sont branchés directement, sans passer par l'intermédiaire d'un câble, mais sans être soudés non plus. Il s'agit du processeur et de la mémoire RAM, deux composants centraux des PC modernes.

[[File:Pentium III SL4CB.jpg|thumb|Processeur Pentium III.]]

Le '''processeur''' traite les données, les modifie, les manipule. Pour faire simple, il s’agit d’une grosse calculatrice hyper-puissante. Il comprend à la fois un circuit qui fait des calculs, et un circuit de contrôle qui s'occupe de séquencer les calculs dans l'ordre demandé. Il est souvent caché sous un radiateur, lui-même surmonté par un ventilateur. En effet, un processeur chauffe beaucoup, ce qui demande d'évacuer cette chaleur. Un chapitre entier expliquera pourquoi les processeurs chauffent, ainsi que les techniques utilisées pour limiter leur production de chaleur et leur consommation électrique.

La '''mémoire vive''' conserve des informations/données temporairement, tant que le processeur en a besoin. Elle prend la forme de barrettes de RAM, comme montré ci-dessous.

[[File:2 gb ddr2 667.jpg|centre|vignette|upright=2|Barrette de RAM.]]

Outre ces composants dits principaux, un ordinateur peut comprendre plusieurs composants moins importants, surtout présents sur les ordinateurs personnels. Ils sont techniquement facultatifs, mais sont très présents dans les ordinateurs personnels. Cependant, certains ordinateurs spécialisés s'en passent. Il s'agit des diverses '''cartes d'extension''' sont branchées sur la carte mère. Elles permettent d’accélérer certains calculs ou certaines applications, afin de décharger le processeur. Par exemple, la carte graphique s'occupe des calculs graphiques, qu'il s'agisse de graphismes 3D de jeux vidéos ou de l'affichage en 2D du bureau. Dans un autre registre, la carte son prend en charge le microphone et les haut-parleurs.

[[Fichier:Personal computer, exploded 4.svg|thumb|upright=1.0|Éclaté d'un ordinateur de type PC :&lt;br /&gt;
1 : Écran ;&lt;br /&gt;
2 : Carte mère ;&lt;br /&gt;
3 : Processeur ;&lt;br /&gt;
4 : Câble Parallel ATA ;&lt;br /&gt;
5 : Mémoire vive (RAM) ;&lt;br /&gt;
6 : Carte d'extension ;&lt;br /&gt;
7 : Alimentation électrique ;&lt;br /&gt;
8 : Lecteur de disque optique ;&lt;br /&gt;
9 : Disque dur ;&lt;br /&gt;
10 : Clavier ;&lt;br /&gt;
11 : Souris.]]

Si on regarde une carte mère de face, on voit un grand nombre de connecteurs, mais aussi des circuits électroniques soudés à la carte mère.

[[File:Architecture matérielle d'une carte mère.png|centre|vignette|upright=2.0|Architecture matérielle d'une carte mère]]

Les '''connecteurs''' sont là où on branche les périphériques, la carte graphique, le processeur, la mémoire, etc. Dans l'ensemble, toute carte mère contient les connecteurs suivants :
* Le processeur vient s’enchâsser dans la carte mère sur un connecteur particulier : le '''socket'''. Celui-ci varie suivant la carte mère et le processeur, ce qui est source d'incompatibilités.
* Les barrettes de mémoire RAM s’enchâssent dans un autre type de connecteurs: les '''slots mémoire'''.
* Les mémoires de masse disposent de leurs propres connecteurs : connecteurs P-ATA pour les anciens disques durs, et S-ATA pour les récents.
* Les périphériques (clavier, souris, USB, Firewire, ...) sont connectés sur un ensemble de connecteurs dédiés, localisés à l'arrière du boitier de l'unité centrale. 
* Les autres périphériques sont placés dans l'unité centrale et sont connectés via des connecteurs spécialisés. Ces périphériques sont des cartes imprimées, d'où leur nom de '''cartes filles'''. On peut notamment citer les cartes réseau, les cartes son, ou les cartes vidéo.

===Les ordinateurs portables===

[[File:Samsung QX-511 (2).JPG|vignette|Ordinateur portable Samsung QX-511 (2), pour illustration.]]

Un ordinateur portable est identique à un ordinateur de type PC. Si vous ouvrez votre ordinateur portable (attention à la garantie), vous retrouverez les mêmes composants qu'un PC à l'intérieur. Un point important est la présence d'une batterie à l'intérieur du PC portable, absente des PC fixes.

[[File:LG gram 14Z90Q mainboard with battery.jpg|centre|vignette|upright=2|LG gram 14Z90Q avec sa batterie.]]

Une fois la batterie et les circuits associés retiré, la seule différence notable est que tous les composants sont soudés sur la carte mère, au lieu d'être branchés sur des connecteurs, à part éventuellement la RAM et le disque dur.

[[File:LG gram 14Z90Q mainboard without battery.jpg|centre|vignette|upright=2|LG gram 14Z90Q sans sa batterie.]]

La RAM est parfois soudée sur la carte mère, d'autres fois sous la forme de barrettes de mémoire vive semblables à celles des PC. Dans le dernier cas, elle est connectée à des connecteurs spécifiques, ce qui permet de les changer/upgrader. Les PC portables sont parfois construits de manière à pouvoir changer la RAM facilement, en ouvrant un cache spécial, concu pour.

[[File:Lenovo G555 состав - Донор.JPG|centre|vignette|upright=2|Lenovo G555.]]

La conception d'un ordinateur portable est légèrement différente de celle d'un PC, pour des raisons thermiques. Un PC fixe a plus de place pour évacuer sa chaleur. Les ventilateurs peuvent plus facilement déplacer l'air dans le boitier, même si le flux d'air dans le boitier est éventuellement gêné par la carte graphique. Mais l'évacuation de la chaleur est assez efficace. Sur les PC portables, leur finesse fait que le trajet de l'air est beaucoup plus contraint. Évacuer la chaleur produite par l'ordinateur est plus complexe, ce qui demande d'utiliser des systèmes de refroidissement et de ventilation spécifiques.

Là où les PC fixes se débrouillent avec des radiateurs et des ventilateurs posés sur le processeur, les PC portables font autrement. Ils ne peuvent pas forcément mettre le ventilateur sur le processeur. A la place, ils mettent le ventilateur à côté, mais le processeur est surmonté par un mécanisme de transmission de la chaleur, qui transfère la chaleur du processeur vers le ventilateur.

[[File:Diagram - How a laptop cooling system works.png|centre|vignette|upright=2|Comment fonctionne le système de ventilation d'un ordinateur portable, en anglais.]]

Les difficultés pour dissiper la chaleur font que les ordinateurs portables utilisent souvent des composants peu performants, mais qui chauffent peu. En effet, nous verrons que plus un composant est puissant, plus il chauffe. La relation n'est pas parfaite, mais les processeurs haute performance chauffent plus que les modèles d'entrée ou milieu de gamme moins puissants. En conséquence, les PC portables sont souvent moins puissants que les PC fixes, même pour les modèles dit ''gaming''.

===Les serveurs et ''mainframes''===

Les grandes entreprises utilisent des ordinateurs de grande taille, très puissants, appelés des ''mainframes''. Ils sont souvent confondus avec les serveurs par le grand public, il y a une différence entre les deux. Un serveur est une fonction logicielle/réseau, pas un type d'ordinateur. Mais laissons cette différence de côté, ce qui est dit pour les ''mainframes'' sert pour les gros serveurs haute performance.

[[File:IBM Z15 mainframe.jpg|vignette|Exemple de ''mainframe''' de type IBM Z15.]]

Les anciens ''mainframes'' des années 50-80 avaient une taille pouvant être impressionnante, au point de prendre une pièce complète d'un bâtiment. Mais de nos jours, les ''mainframes'' tiennent dans une grosse armoire un peu haute. Les ''mainframes'' doivent rester allumé en permanence et ne doivent pas être éteint, sauf éventuellement quelques jours par an pour des opérations de maintenance. Ils utilisent pour cela des techniques spécifiques, avec beaucoup de redondance interne.

[[File:ACONIT hall grandes machines.jpg|centre|vignette|upright=2|''Mainframe'' ACONIT.]]

Les ''mainframes'' sont aussi conçus pour mutualiser au maximum leur utilisation, ils peuvent être utilisés par plusieurs utilisateurs à la suite, voire en même temps. Pour cela, les anciens ''mainframes'' étaient capables de faire tourner plusieurs applications distinctes l'une à la suite de l'autre, avec des commutations fréquentes entre logiciels. De nos jours, ils sont capables d'exécuter un grand nombre de tâches en même temps, grâce à la présence de plusieurs processeurs. Les ''mainframes'' modernes sont même capables de faire tourner plusieurs systèmes d'exploitation en même temps si besoin.

Les anciens ''mainframes'' étaient des ordinateurs assez simples, avec un processeur, de la mémoire RAM, un ou plusieurs disques durs, pas plus. Le ''mainframe'' était tellement énorme et cher que les entreprises n'en avaient qu'un seul pour toute l'entreprise. Les employés avaient sur leur bureau des terminaux, qui permettaient d'accéder à l'ordinateur central, mais n'étaient pas des ordinateurs. Les terminaux étaient des composants électroniques simples, avec un écran, un clavier et une souris, mais sans processeur. Ils envoyaient des données au ''mainframe'', ils en recevaient de sa part, mais tout traitement était réalisé sur le ''mainframe''. L'arrivée sur le marché des ordinateurs personnels, de type PC fixe/portable, a entrainé l'abandon de ce genre de pratique, tous les employés ont maintenant un ordinateur rien que pour eux.

{|
|-
! colspan=&quot;2&quot; | Exemples de terminaux
|-
|[[File:Terminal-in2-sm9400.jpg|centre|vignette|upright=1.5|Exemple de terminal. Notez la présence d'un écran et d'un clavier, mais l'asbence d'une unité centrale.]]
|[[File:Chromatics CT4100.jpg|vignette|upright=1.5|Autre exemple de terminal. Le clavier est couplé à un stylo CRT, qui remplacait la souris et agissait sur l'écran comme s'il était tactile.]]
|-
! colspan=&quot;2&quot; | Intérieur d'un terminal
|-
|[[File:CT1024 Monitor.jpg|vignette|upright=1.5|Terminal CT1024, sans le boitier extérieur.]]
|[[File:CT1024 Terminal System.jpg|vignette|upright=1.5|Terminal CT1024, description des composants interne.]]
|}

De nos jours, les ''mainframes'' contiennent en réalité plusieurs ordinateurs simples interconnectés via un réseau local. Un ''mainframe'' qui tient dans une armoire contient facilement une dizaine ou centaine de processeurs, plein de RAM, des disques durs séparés dans une armoire distincte, etc. Vu qu'ils communiquent uniquement via le réseau, ils n'ont pas d'interface, pas d'écran, 'entrée via clavier/souris. Le tout est commandé avec une console de commande, typiquement un ordinateur portable ou un terminal assez simple séparé de l'armoire, qui permet à un administrateur de faire des opérations de surveillance, configuration et maintenance. Il peut y avoir une console de commande pour plusieurs armoires séparées, la console peut même être dans un autre bâtiment et accéder au ''mainframe'' par le réseau.

[[File:IBM System Z9 (type 2094 inside).jpg|centre|vignette|upright=2|''Mainframe'' de type IBM System Z9. L'ordinateur portable sert de console pour qu'un administrateur fasse des opérations de surveillance, configuration et maintenance.]]

Les processeurs et la RAM sont typiquement installés sur des cartes amovibles, qui sont connectées au fond de l'armoire lors de l'installation. Il est même possible de retirer ou d'ajouter des cartes en fonctionnement, afin d'ajouter/retirer des processeurs, des disques durs, etc. Ce qui est très utile si un composant est en panne et qu'il faut le remplacer. 

[[File:IBM TotalStorage Exp400.jpg|centre|vignette|upright=2|IBM TotalStorage Exp400]]

==Un peu d'abstraction : qu'est-ce qu'un ordinateur ?==

Un ordinateur comprend donc un processeur, plusieurs mémoires, des cartes d'extension et une carte mère pour connecter le tout. Mais il s'agit là d'une description assez terre-à-terre de ce qu'est un ordinateur. Une autre description, plus abstraite, se base sur le fait qu'un ordinateur est une énorme calculatrice programmable. Elle permet d'expliquer pourquoi il y a une distinction entre processeur et mémoire, entre unité centrale et périphériques. Tout ce qui va suivre pourra vous paraitre assez abstrait, mais rassurez-vous : les prochains chapitres rendront tout cela plus concrets.

===La séparation entre entrées-sorties et traitement===

L'unité centrale peut être vue comme une énorme calculatrice ultra-puissante, qui exécute des commandes/opérations. Mais à elle seule, elle ne servirait à rien, il faut interagir avec par l'intermédiaire de plusieurs périphériques. Il existe deux types de périphériques, qui sont conceptuellement différents. Les périphériques comme le clavier ou la souris permettent d'envoyer des informations à l'ordinateur, d'agir sur celui-ci. A l'inverse, les écrans transmettent des informations dans le sens inverse : de l'ordinateur vers l'utilisateur. Les premiers sont appelés des '''entrées''', les seconds des '''sorties'''.

Dans un ordinateur, les informations sont représentées sous la forme de nombres. Toute donnée dans un ordinateur est codée avec un ou plusieurs nombres regroupés dans une donnée, un fichier, ou autre. Et la transmissions avec les entrées et sorties se fait là-encore avec des nombres. Par exemple, quand vous appuyez sur votre clavier, le clavier envoie un numéro de touche à l'unité centrale, qui indique quelle touche a été appuyée. L'image à afficher à l'écran est codée sous la forme d'une suite de nombres (un par pixel). L'image est envoyée à l'écran, qui traduit la suite de nombre en image à afficher. Les entrées traduisent des actions utilisateurs en nombres, on dit que les entrées encodent les actions utilisateur. Les sorties font la traduction inverse, elles transforment des suites de nombres en une action physique. On dit qu'elles décodent des informations.

Pour résumer, toute appareil électronique est composé par :
* Des '''entrées''' sur lesquelles l'utilisateur agit sur l'ordinateur. Les entrées transforment les actions de l'utilisateur en nombres, qui sont interprétés par l'ordinateur.
* Une '''unité de traitement''', qui manipule des nombres et fait des calculs/opérations dessus. Les nombres proviennent des entrées, du disque dur, ou d'autres sources, peu importe.
* Des '''sorties''', qui va récupèrent le résultat calculé par l'unité de traitement pour en faire quelque chose : écrire sur une imprimante ou sur un moniteur, émettre du son,...

[[File:Ordinateur théorique Simple 1.png|centre|vignette|upright=2|Ordinateur théorique Simple 1]]

L'unité de traitement proprement dite, celle qui fait les calculs, est couplée à une mémoire qui mémorise les opérandes et résultats des calculs. La séparation entre processeur et mémoire est nécessaire pour qu'un appareil électronique soit qualifié d'ordinateur. De nombreux appareils n'ont pas de séparation entre unité de traitement et mémoire, comme certaines vielles radios AM/FM.

[[File:Schéma de principe d'un ordinateur.png|centre|vignette|upright=2|Schéma de principe d'un ordinateur]]

===Un ordinateur est un appareil programmable===

Les appareils simples sont non-programmables, ce qui veut dire qu’ils sont conçus pour une utilisation particulière et qu’ils ne peuvent pas faire autre chose. Par exemple, les circuits électroniques d’un lecteur de DVD ne peuvent pas être transformé en lecteur audio ou en console de jeux... Les circuits non-programmables sont câblés une bonne fois pour toute, et on ne peut pas les modifier. On peut parfois reconfigurer le circuit, pour faire varier certains paramètres, via des interrupteurs ou des boutons, mais cela s’arrête là. Et cela pose un problème : à chaque problème qu'on veut résoudre en utilisant un automate, on doit recréer un nouveau circuit.

À l'inverse, un ordinateur n’est pas conçu pour une utilisation particulière, contrairement aux autres objets techniques. Il est possible de modifier leur fonction du jour au lendemain, on peut lui faire faire ce qu’on veut. On dit qu'ils sont '''programmables'''. Pour cela, il suffit d’utiliser un logiciel, une application, un programme (ces termes sont synonymes), qui fait ce que l'on souhaite. La totalité des logiciels présents sur un ordinateur sont des programmes comme les autres, même le système d'exploitation (Windows, Linux, ...) ne fait pas exception.

Un programme est une suite de d'instructions, chaque instruction effectuant une action dans l'ordinateur. Sur les ordinateurs modernes, la majorité de ces instructions effectuent une opération arithmétique, comme une addition, une multiplication, une soustraction, etc. Les ordinateurs modernes sont donc de grosses calculettes très puissantes, capables d'effectuer des millions d'opérations par secondes. Et qui dit opération dit nombres : un ordinateur gère nativement des nombres, qui sont codés en binaire sur la quasi-totalité des ordinateurs modernes.

Une instruction est représentée dans un ordinateur par une série de nombres : un nombre qui indique quelle opération/commande effectuer et des autres nombres pour coder les données (ou de quoi les retrouver dans l'ordinateur). L'ordinateur récupére les commandes une par une, les traduit en opération à effectuer, exécuter l'opération, et enregistre le résultat. Puis il recommence avec la commande suivante.

[[File:Ordinateur Théorique Complexe 1.png|centre|vignette|upright=3|Ordinateur Théorique Complexe. En jaune, le programme informatique, la liste de commande. Le rectangle gris est l'ordinateur proprement dit.]]

De nombreux appareils sont programmables, mais tous ne sont pas des ordinateurs. Par exemple, certains circuits programmables nommés FPGA n'en sont pas. Pour être qualifié d'ordinateur, un appareil programmable doit avoir un processeur séparé de la mémoire. De plus, il doit utiliser un '''codage numérique''', chose que nous allons aborder dans le chapitre suivant.

===Les ordinateurs à programme mémorisé ou programme externe===

Au tout début de l'informatique, on utilisait des cartes perforées en plastique, sur lesquelles on inscrivait le programme à exécuter, les données à traiter, bref : tout ce qu'on donnait à manger à l'ordinateur. Par la suite, les premiers ordinateurs grand public, comme les Amstrad ou les Commodore, utilisaient des cassettes audio magnétiques pour stocker les programmes. Dans le même style, les consoles de jeu utilisaient autrefois des cartouches de jeu, qui contenaient le programme du jeu à exécuter. Pour résumer, les anciens ordinateurs mémorisaient les programmes sur un support externe, lu par un périphérique. De tels ordinateurs sont dits à '''programme externe'''.

: D’anciens ordinateurs personnels, comme l’Amstrad ou le Commodore, permettaient de taper les programmes à exécuter à la main, au clavier, avant d’appuyer une touche pour les exécuter. Nul besoin de vous dire que les cassettes audio étaient plus pratiques.

Mais de nos jours, les programmes sont enregistrés sur le disque dur de l'ordinateur ou dans une mémoire intégrée à l'ordinateur. On dit qu'ils sont installés, ce qui est un mot bien compliqué pour dire que le programme est enregistré sur le disque dur de l’ordinateur. A défaut de disque dur, le programme/logiciel est enregistré dans une mémoire spécialisée pour le stockage. Par exemple, sur les cartes électroniques grand public de marque Arduino, les programmes sont envoyés à la carte via le port USB, mais les programmes sont enregistrés dans la carte Arduino, dans une mémoire FLASH dédiée. Disque dur ou non, le programme est mémorisé dans la mémoire de l'ordinateur. Il est possible d'installer ou de désinstaller les programmes en modifiant le contenu de la mémoire. Le terme utilisé est alors celui de '''programme stocké en mémoire'''.

Les programmes à installer sont disponibles soit sur un périphérique, comme un DVD ou une clé USB, soit sont téléchargés depuis internet. Les premiers PC fournissaient les logiciels sur des disquettes, qui contenaient un programme d'installation pour enregistrer le programme sur le disque dur de l'ordinateur. Par la suite, le support des logiciels a migré vers les CD et DVD, les logiciels devenant de plus en plus gros. De nos jours, la majorité des applications sont téléchargées depuis le net, l'usage de périphériques est devenu obsolète, même les consoles de jeu abandonnent cette méthode de distribution.

==Les générations d'ordinateurs : un historique rapide==

L'informatique a beaucoup évolué dans le temps. Et une bonne partie de cette évolution tient à l'évolution de l’électronique sous-jacente. Les ordinateurs actuels sont fabriqués avec des transistors, des petits composants électroniques qui servent d'interrupteur programmables, qu'on détaillera dans ce qui suit. Mais ça n'a pas toujours été le cas. Et cela permet de distinguer plusieurs '''générations d'ordinateurs'''.

===Les ordinateurs électro-mécaniques : les premiers ordinateurs===

Le tout premier ordinateur est le '''Z1''', un modèle unique inventé par Konrad Suze entre 1936 et 1938. Son processeur gérait non pas des nombres entiers, mais des nombres à virgule (des nombres dits flottants, pour être précis), encodés sur 22 bits. Le processeur du Z1 était capable de faire des additions et des soustractions, car il intégrait un circuit additionneur-soustracteur basique. Des circuits annexes permettaient de faire des multiplications et des divisions en enchainant des additions/soustractions successives. Il fonctionnait à une fréquence de 1 Hz, ce qui fait qu'il pouvait faire une addition/soustraction par seconde maximum.

[[File:Blue-punch-card-front.png|vignette|upright=0.5|Carte Perforée.]]

Niveau mémoire, la RAM de l'ordinateur était très limitée : seulement 16 nombres de 22 bits chacun. S'il s'agissait d'une mémoire électronique, les programmes étaient mémorisés sur une mémoire mécanique. Les programmes étaient enregistrés sur des cartes perforées, à savoir des cartes en papier dans lesquelles un 1 est codé par un trou dans le papier et un 0 par une absence de trou. Les programmes étaient exécutés par l'ordinateur quand on insérait la carte perforée dans le lecteur et qu'on appuyait sur un bouton.

[[File:German Museum of Technology, Berlin 2017 024.jpg|centre|vignette|upright=2|Réplique du Z1 au ''German Museum of Technology'' de Berlin, 2017.]]

Après sa destruction dans un bombardement, le Z1 a été reconstruit et amélioré, ce qui donné les deux ordinateurs Z2 et Z3. Quelques années plus tard, de nombreux ordinateurs ont été construits dans des laboratoires de recherche. Des grandes noms de l'histoire de l'informatique datent de cette époque : le Harvard Mark I et le Colossus Mark 1 (UK) ont tous deux été mis en service en 1944, par exemple. Ils ont servis pour les cryptanalystes pour casser les codes utilisés par les allemands pour leurs transmissions, pendant la seconde guerre mondiale.

Les ordinateurs cités dans le précédent paragraphe étaient tous des ordinateurs dit '''électro-mécaniques''', car ils mélangeaient des composants électroniques et des composants mécaniques (tout ce qui a trait aux cartes perforées, notamment). Les composants électroniques étaient soit des relais, soit des tubes à vides, les deux étant des interrupteurs commandables électriquement plus ou moins équivalents aux transistors. Les ordinateurs d'avant l'année 1944, étaient tous de ce type. Quelques ordinateurs des années 50 étaient de ce type, mais leur nombre n'a pas dépassé 30. Il faut dire qu'ils ont rapidement laissé la place à des ordinateurs purement électroniques, que nous allons voir dans ce qui suit..

===La première génération : les tubes à vide===

Les ordinateurs qui ont suivi les ordinateurs électromécaniques sont regroupés dans la '''première génération d'ordinateur'''. Ils étaient conçus avec des tubes à vide, ce qui les place entre les premiers ordinateurs électro-mécaniques et les ordinateurs utilisant des transistors. Les ordinateurs de première génération étaient très simples, ils ne géraient que quelques opérations simples : l'addition, la soustraction, pas grand chose de plus. A quelques exceptions près, ils ne géraient pas la multiplication et encore moins la division, ils n'avaient pas assez de relais ou de tubes à vides à disposition pour cela.

Une des toutes premières machines construite avec des tubes à vide était l'Atanasoff–Berry. Ce n'était pas un ordinateur, car elle ne pouvait pas exécuter de programme sans intervention humaine pour séquencer des opérations, mais c'était la première machine de calcul purement électronique, sans aucune pièce mécanique. Elle utilisait une mémoire RAM construite avec des condensateurs, ceux-ci étant placés sur des cylindres tournants. Les circuits de calcul étaient construits avec des tubes à vide et faisaient leur travail un bit à la fois. Elle fonctionnait à une fréquence de 60 Hz et pouvait faire 30 additions/soustractions par seconde. Les nombres étaient encodés sur 50 bits. 

[[File:Atanasoff Berry Computer.gif|centre|vignette|upright=2.5|Atanasoff–Berry.]]

L'arrivée de l'ENIAC en 1945 a changé la donne. Cet ordinateur a introduit plusieurs innovations majeures. La première est assez technique, il s'agit de la turing-complétude, elle a trait aux programmes qui peuvent être écrit pour un ordinateur, nous ne la détaillerons pas ici.

En 1948, le ''Manchester Baby'' a introduit une innovation extrêmement importante, au point où on considère que c'est le premier ordinateur à avoir tous les critères nécessaires pour être appelé un ordinateur. Son innovation est que le programme n'était plus mémorisé sur des cartes perforée, mais dans une mémoire électronique dans l'ordinateur lui-même. En clair, le ''Manchester Baby'' était le premier '''''Stored-program computer''''', ordinateur à programme enregistré en français. 

Le Manchester Baby avait une RAM de 32 nombres de 32 bits, fabriquées avec des tubes Willimas (abordés dans une annexe à la fin du cours). Il gérait 8 instructions en tout, mais ne gérait pas l'addition. Il gérait la soustraction, des instructions de branchement et d'accès mémoire, mais rien d'autre. Il pouvait cependant émuler l'addition à partir d'une soustraction et inversant l'opérande soustraite.

===La seconde génération : le remplacement des tubes à vides par des transistors===

La '''seconde génération''' est celle des ordinateurs fabriqués avec des '''transistors''' isolés, reliés entre avec des fils électriques. Les transistors en question possèdent trois broches, des pattes métalliques sur lesquelles on connecte des fils électriques. Le transistor s'utilise le plus souvent comme un interrupteur commandé par sa troisième broche. Le courant qui traverse les deux premières broches passe ou ne passe pas selon ce qu'on met sur la troisième.

[[File:Transistor basic flow.svg|centre|vignette|Un transistor est un morceau de conducteur, dont la conductivité est contrôlée par sa troisième broche/borne.]]

Les ordinateurs de seconde génération avaient entre 1000 et 500 000 transistors. Les capacités des ordinateurs étaient donc nettement supérieures à celles des ordinateurs de première génération. Une part non négligeable des ordinateurs de seconde génération supportait l'opération de multiplication, absente sur les ordinateurs de première génération. Néanmoins, cela variait beaucoup selon les ordinateurs.

Un exemple assez hors du commun est celui du premier modèle de l'IBM 1620. Le tout premier modèle n'avait aucun circuit de calcul, il n'était même pas capable de faire une addition ou une multiplication. A la place, il utilisait une table d'addition et une table de multiplication en mémoire RAM. Les deux tables devaient être initialisées par le logiciel lors du démarrage de la machine. La table d'addition faisait une centaine de chiffre, la table de multiplication faisait le double. Le processeur de l'ordinateur gérait des instructions pour faire des additions ou des multiplications, mais ces opérations lisaient le résultat dans la table d'addition. Les calculs étaient fait chiffre par chiffre, avec un encodage partiellement décimal, partiellement binaire (des chiffres décimaux étaient encodés en binaire, nous en reparlerons quand nous parlerons du BCD) !

[[File:KL CoreMemory.jpg|vignette|Mémoire à tore de ferrite.]]

Les transistors n'étaient utilisés que pour le processeur et les circuits annexes. La mémoire n'était pas faite en transistors, pas à cette époque. La mémoire était une mémoire aujourd'hui abandonnée, appelée une '''mémoire à tores de ferrite'''. Elle sera détaillée dans un chapitre ultérieur. Mais sachez pour le moment qu'il s'agit d'une mémoire au support magnétique, les données étant stockées sur un support magnétique.

Transistors comme tubes à vide prenaient beaucoup de place, ce qui fait que les ordinateurs étaient assez gros. Concrètement, ils prenaient une pièce de bâtiment entière dans le meilleur des cas. C'était l'époque des gros ''mainframes'', reliés à des terminaux, peu puissants comparé aux standards actuels. Seules les grandes entreprises et les grands instituts de recherche pouvaient se payer les services de ce genre d'ordinateurs. Seuls les professionnels avaient accès à ce genre d'équipement.

===La troisième génération : le circuit intégré===

[[File:D8259AC-2.jpg|vignette|Exemple de circuit intégré.]]

La troisième génération est toujours fabriquée avec des transistors, mais dont la taille a été réduite. Avec l'évolution de la technologie, les transistors ont diminué en taille, de plus en plus. Ils sont devenus tellement petits qu'ils ont finit par être regroupés dans des '''circuits intégrés''', des circuits regroupent plusieurs transistors sur la même puce de silicium. Les circuits intégrés se présentent le plus souvent sous la forme de boitiers rectangulaires, comme illustré ci-contre. D'autres ont des boitiers de forme carrées, comme ceux que l'on peut trouver sur les barrettes de mémoire RAM, ou à l'intérieur des clés USB/ disques SSD.

Lors de cette génération, les processeurs étaient fournis en pièces détachées qu'il fallait relier entre elles. Le processeur était composé de plusieurs circuits intégrés séparés, impossible de mettre un processeur dans un seul boitier. Un exemple de processeur conçu en kit est la série des Intel 3000. Elle regroupe plusieurs circuits séparés aux noms à coucher dehors, mais dont vous comprendrez ce qu'ils veulent dire dans les chapitres adéquats : l'Intel 3001 est un séquenceur, l'Intel 3002 regroupe unité de calcul et registres, le 3003 est un circuit d'anticipation de retenue complémentaire du 3002, le 3212 est une mémoire tampon, le 3214 est une unité de gestion des interruptions, les 3216/3226 sont des interfaces de bus mémoire. On pourrait aussi citer la famille de circuits intégrés AMD Am2900.

Même si le processeur était en pièce détachées, utiliser une dizaine de circuits intégrés était nettement mieux que d'utiliser plusieurs milliers de transistors individuels. En conséquence, les ordinateurs ont vu leur taille grandement réduite, passant de pièces entières à une simple armoire, voire à quelques cartes intégrées superposées. De plus, le prix des circuits intégré était abordable, du moins comparé aux ordinateurs d'avant. Le prix des ordinateurs a alors grandement décru, permettant à des entreprises et administrations de taille modeste de s'équiper d'ordinateurs.

===La quatrième génération : le microprocesseur===

[[File:MOS6502.svg|vignette|Microprocesseur, ici un processeur MOS6502, de la quatrième génération.]]

Lors de la troisième génération, les circuits intégrés regroupaient plusieurs dizaines ou centaines de transistors, mais sont rapidement montés en gamme. De centaines de transistors, ils sont passé au milliers de transistors, puis au millions et maintenant au-delà du milliard. Les transistors étaient devenus tellement petits, tellement miniaturisés, qu'il était devenu possible de mettre un processeur entier dans un circuit intégré. C'est ainsi qu'est né le microprocesseur, à savoir un processeur qui tient tout entier dans un seul circuit imprimé. La quatrième génération d’ordinateur est celle des ordinateurs basés autour d'un microprocesseur.

Les tout premiers microprocesseurs étaient des processeurs à application militaire, comme le processeur du F-14 CADC ou celui de l'Air data computer. Le tout premier microprocesseur commercialisé au grand public est le 4004 d'Intel, sorti en 1971. L'intel 4004 comprenait environ 2300 transistors, avait une fréquence de 740 MHz, pouvait faire 46 opérations différentes, et manipulait des entiers de 4 bits. Il était au départ un processeur de commande, prévu pour être intégré dans la calculatrice Busicom calculator 141-P, mais il fut utilisé pour d'autres applications quelque temps plus tard. Immédiatement après le 4004, les premiers microprocesseurs 8 bits furent commercialisés. Le 4004 fut suivi par le 8008 et quelques autres processeurs 8 bits extrêmement connus, comme le 8080 d'Intel, le 68000 de Motorola, le 6502 ou le Z80.

Les microprocesseurs permirent encore uen fois de réduire la taille des ordinateurs, qui pouvaient tenir dans un boitier de PC, ou un boitier de console de jeu. Le prix des ordinateurs a aussi chuté en même temps que les transistors était miniaturisés. C'est cette invention qui permis l'invention des consoles de jeux et des mini-ordinateurs, à savoir les ordinateurs personnels. Sans miniaturisation, on n'aurait pas d'ordinateur personnel, pas de PC fixe ou portable.

==L'organisation du cours : les différents niveaux d'explication==

Le fonctionnement d'un ordinateur est assez complexe à expliquer car les explications peuvent se faire sur plusieurs niveaux. Par plusieurs niveaux, on veut dire qu'un ordinateur est composé de composants très simples, qui sont assemblés pour donner des composants eux-même plus complexes, qui sont eux-même regrouper, etc. Étudier tout cela demande de voir plusieurs niveaux, allant de transistors très petits à des processeurs multicœurs. Les niveaux les plus bas sont de l'électronique pur et dure, alors que ceux plus haut sont à mi-chemin entre électronique et informatique.

===Les niveaux d'abstraction en architecture des ordinateurs===

Les trois premiers niveaux sont de l'électronique pur et dure. Ils correspondent aux premiers chapitres du cours, qui porteront sur les circuits électroniques en général.
* Le premier niveau est celui des '''transistors''', des circuits intégrés, des ''wafer'' et autres circuits de très petite taille.
* Le second niveau est celui des '''portes logiques''', des circuits très basiques, très simples, à la base de tous les autres.
* Le troisième niveau est celui dit de la '''''Register Transfer Level''''', où un circuit électronique est construit à partir de circuits basiques, dont des registres et autres circuits dits combinatoires.
Les deux niveaux suivants sont de l'informatique proprement dit. C'est dans ces deux niveaux qu'on étudie les ordinateurs proprement dit, les circuits qu'il y a dedans et non l'électronique en général.
* Le quatrième niveau est celui de la '''microarchitecture''', qui étudie ce qu'il y a à l'intérieur d'un processeur, d'une mémoire, des périphériques et autres.
* Le cinquième niveau est celui de l''''architecture externe''', qui décrit l'interface du processeur, de la mémoire, d'un périphérique ou autre. Par décrire l'interface, on veut dire : comment un programmeur voit le processeur et la mémoire, comment il peut les manipuler. Une architecture externe unique peut avoir plusieurs microarchitecture, ce qui fait qu'on sépare les deux. Tout cela sera plus clair quand on passera aux chapitres sur le processeur et les mémoires.

Nous n'allons pas voir les 5 niveaux dans l'ordre, des transistors vers l'architecture externe. En réalité, nous allons procéder autrement. La première partie du cours portera sur les trois premiers niveaux, le reste sur les deux autres. Les 5 niveaux seront vus dans des chapitres séparés, du moins le plus possible. Au niveau pédagogique, tout est plus simple si on scinde les 5 niveaux. Bien sûr, il y a quelques explications qui demandent de voir plusieurs niveaux à la fois. Par exemple, dans le chapitre sur les mémoires caches, nous auront des explications portant sur la RTL, la microarchitecture du cache et son architecture externe. Mais le gros du cours tentera de séparer le plus possible les 5 niveaux.

===Les trois parties principales du cours===

Nous allons commencer par parler du binaire, avant de voir les portes logiques. Avec ces portes logiques, nous allons voir comment fabriquer des circuits basiques qui reviendront très souvent dans la suite du cours. Nous verrons les registres, les décodeurs, les additionneurs et plein d'autres circuits. Puis, nous reviendrons au niveau des transistors pour finir la première partie. La raison est que c'est plus simple de faire comme cela. Tout ce qui a trait aux transistors sert à expliquer comment fabriquer des portes logiques, et il faut expliquer les portes logiques pour voir le niveau de la RTL.

Une fois la première partie finie, nous allons voir les différents composants d'un ordinateur. Une première partie expliquera ce qu'il y a dans un ordinateur, quels sont ses composants. Nous y parlerons de l'architecture de base, de la hiérarchie mémoire, des tendances technologiques, et d'autres généralités qui serviront de base pour la suite. Puis, nous verrons dans l'ordre les bus électroniques, les mémoires RAM/ROM, le processeur, les périphériques, les mémoires de stockage (SSD et disques durs) et les mémoires caches. Pour chaque composant, nous allons voir leur architecture externe, avant de voir leur microarchitecture. La raison est que la microarchitecture ne peut se comprendre que quand on sait quelle architecture externe elle implémente.

Enfin, dans une troisième partie, nous allons voir les optimisations majeures présentes dans tous les ordinateurs modernes, avec une partie sur le pipeline et le parallélisme d'instruction, et une autre sur les architectures parallèles. Pour finir, les annexes de fin parlerons de sujets un peu à part.

&lt;noinclude&gt;
{{NavChapitre | book=Fonctionnement d'un ordinateur
           | next=L'encodage des données
           | nextText=L'encodage des données
}}
&lt;/noinclude&gt;</text>
      <sha1>5bstp4bl48f1suqtfmn8r8j10bucuvn</sha1>
    </revision>
    <revision>
      <id>744118</id>
      <parentid>744117</parentid>
      <timestamp>2025-06-04T23:49:40Z</timestamp>
      <contributor>
        <username>Mewtow</username>
        <id>31375</id>
      </contributor>
      <minor />
      <comment>/* La seconde génération : le remplacement des tubes à vides par des transistors */</comment>
      <origin>744118</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="43320" sha1="73y7kymhk7r9xu17y6zpdc0hg8o1hof" xml:space="preserve">Pour commencer, nous allons voir qu'il existe de nombreux types d'ordinateurs. Le plus connu est certainement le PC, l'ordinateur personnel, que vous avez sans doute dans votre salon. Les ordinateurs portables sont un deuxième type d'ordinateur assez intuitif, que vous avez peut-être. Mais il y a aussi d'autres types d'ordinateurs auxquels vous n'avez jamais été confrontés.

==Les différents types d'ordinateurs==

Dans cette section, nous allons décrire rapidement les ordinateurs les plus courant, mais surtout voir ce qu'il y a à l'intérieur d'un ordinateur.

===L'ordinateur de type PC fixe===

De l'extérieur, l'ordinateur est composé d'une unité centrale sur laquelle on branche des périphériques.

[[File:Typical computer architecture systems.jpg|vignette|upright=1.5|Exemples de périphériques, connectés à une unité centrale (ici appelée à tort ''operating system'').]]

Les '''périphériques''' regroupent l'écran, la souris, le clavier, l'imprimante, et bien d'autres choses. Ils permettent à l'utilisateur d'interagir avec l'ordinateur : un clavier permet de saisir du texte sous dans un fichier, une souris enregistre des déplacements de la main en déplacement du curseur, un écran affiche des données d’images/vidéos, un haut-parleur émet du son, etc. Tout ce qui est branché sur un ordinateur est, formellement un périphérique.

L''''unité centrale''' est là où se trouvent tous les composants importants d'un ordinateur, ceux qui font des calculs, qui exécutent des logiciels, qui mémorisent vos données, etc. Voici ce à quoi ressemble l'intérieur de l'unité centrale. Trois sections sont visibles : l'alimentation électrique en haut à gauche, la carte mère en bas à gauche et en jaune/orange, les disques et lecteurs à droite des câbles. Et on voit aussi beaucoup de câbles.

[[File:Asus P5K-SEIntel E6320.jpg|centre|vignette|upright=2|Exemple d'unité centrale.]]

Tout en haut à gauche, se trouve l''''alimentation électrique''', qui convertit le courant de la prise électrique en un courant plus faible, utilisable par les autres composants. Elle émet de nombreux câbles assez gros, qui sont reliés au reste. Les PC actuels utilisent des alimentations électriques standardisées, qui fournissent trois tensions au reste de l'ordinateur : une tension de 12 Volts, une de 5 Volts, une de 3,3 Volts.

À droite, caché par la partie &quot;métallique&quot; du boitier, se trouvent les lecteurs de CD/DVD, et les disques durs. Les lecteurs CD-ROM ou DVD-ROM permettaient de lire des CD ou des DVD. Je parle au passé, car ils ont aujourd'hui disparu des ordinateurs modernes. Les '''disques durs''' sont des mémoires de stockage, qui mémorisent vos données de manière permanente. De nos jours, ils sont remplacés par des SSD, qui sont des disques durs électroniques, là où les disques durs proprement dit sont des mémoires magnétiques. Nous verrons la différence dans deux chapitres dédiés, un sur les disques durs, l'autre sur les SSD.

En bas à droite, se trouve la '''carte mère''' un support plat, en plastique ou en céramique, sur laquelle sont soudés/connectés les autres composants. Sur celle-ci, de nombreux composants sont soudés, d'autres sont branchés dessus avec des câbles, d'autres sont connectés dessus avec des connecteurs. Ils sont reliés entre eux par des fils conducteurs, le plus souvent du cuivre ou de l’aluminium, ce qui leur permet de s’échanger des données. Sur les cartes simples, ces fils sont intégrés dans la carte électronique, dans des creux du plastique. Ils portent le nom de pistes.

Avant, les disques durs, SSD et lecteurs de CD/DVD sont branchés dessus via des connecteurs dédiés, appelés des connecteurs S-ATA. De nos jours, ils sont branchés sur un autre connecteur, grâce à l'interface NVME. Toujours est-il qu'ils sont reliés à la carte mère par des câbles, ce qui montre que ce sont des sortes de périphériques interne. Ils sont placés dans le boitier, mais on aurait tout aussi bien pu les mettre à l'extérieur, vu qu'ils communiquent avec l'ordinateur par l'intermédiaire d'un câble ou d'un connecteur dédié.

Mais deux autres composants très importants sont eux placés sur la carte mère, directement. Ils ont chacun un connecteur dédié, sur lequel ils sont branchés directement, sans passer par l'intermédiaire d'un câble, mais sans être soudés non plus. Il s'agit du processeur et de la mémoire RAM, deux composants centraux des PC modernes.

[[File:Pentium III SL4CB.jpg|thumb|Processeur Pentium III.]]

Le '''processeur''' traite les données, les modifie, les manipule. Pour faire simple, il s’agit d’une grosse calculatrice hyper-puissante. Il comprend à la fois un circuit qui fait des calculs, et un circuit de contrôle qui s'occupe de séquencer les calculs dans l'ordre demandé. Il est souvent caché sous un radiateur, lui-même surmonté par un ventilateur. En effet, un processeur chauffe beaucoup, ce qui demande d'évacuer cette chaleur. Un chapitre entier expliquera pourquoi les processeurs chauffent, ainsi que les techniques utilisées pour limiter leur production de chaleur et leur consommation électrique.

La '''mémoire vive''' conserve des informations/données temporairement, tant que le processeur en a besoin. Elle prend la forme de barrettes de RAM, comme montré ci-dessous.

[[File:2 gb ddr2 667.jpg|centre|vignette|upright=2|Barrette de RAM.]]

Outre ces composants dits principaux, un ordinateur peut comprendre plusieurs composants moins importants, surtout présents sur les ordinateurs personnels. Ils sont techniquement facultatifs, mais sont très présents dans les ordinateurs personnels. Cependant, certains ordinateurs spécialisés s'en passent. Il s'agit des diverses '''cartes d'extension''' sont branchées sur la carte mère. Elles permettent d’accélérer certains calculs ou certaines applications, afin de décharger le processeur. Par exemple, la carte graphique s'occupe des calculs graphiques, qu'il s'agisse de graphismes 3D de jeux vidéos ou de l'affichage en 2D du bureau. Dans un autre registre, la carte son prend en charge le microphone et les haut-parleurs.

[[Fichier:Personal computer, exploded 4.svg|thumb|upright=1.0|Éclaté d'un ordinateur de type PC :&lt;br /&gt;
1 : Écran ;&lt;br /&gt;
2 : Carte mère ;&lt;br /&gt;
3 : Processeur ;&lt;br /&gt;
4 : Câble Parallel ATA ;&lt;br /&gt;
5 : Mémoire vive (RAM) ;&lt;br /&gt;
6 : Carte d'extension ;&lt;br /&gt;
7 : Alimentation électrique ;&lt;br /&gt;
8 : Lecteur de disque optique ;&lt;br /&gt;
9 : Disque dur ;&lt;br /&gt;
10 : Clavier ;&lt;br /&gt;
11 : Souris.]]

Si on regarde une carte mère de face, on voit un grand nombre de connecteurs, mais aussi des circuits électroniques soudés à la carte mère.

[[File:Architecture matérielle d'une carte mère.png|centre|vignette|upright=2.0|Architecture matérielle d'une carte mère]]

Les '''connecteurs''' sont là où on branche les périphériques, la carte graphique, le processeur, la mémoire, etc. Dans l'ensemble, toute carte mère contient les connecteurs suivants :
* Le processeur vient s’enchâsser dans la carte mère sur un connecteur particulier : le '''socket'''. Celui-ci varie suivant la carte mère et le processeur, ce qui est source d'incompatibilités.
* Les barrettes de mémoire RAM s’enchâssent dans un autre type de connecteurs: les '''slots mémoire'''.
* Les mémoires de masse disposent de leurs propres connecteurs : connecteurs P-ATA pour les anciens disques durs, et S-ATA pour les récents.
* Les périphériques (clavier, souris, USB, Firewire, ...) sont connectés sur un ensemble de connecteurs dédiés, localisés à l'arrière du boitier de l'unité centrale. 
* Les autres périphériques sont placés dans l'unité centrale et sont connectés via des connecteurs spécialisés. Ces périphériques sont des cartes imprimées, d'où leur nom de '''cartes filles'''. On peut notamment citer les cartes réseau, les cartes son, ou les cartes vidéo.

===Les ordinateurs portables===

[[File:Samsung QX-511 (2).JPG|vignette|Ordinateur portable Samsung QX-511 (2), pour illustration.]]

Un ordinateur portable est identique à un ordinateur de type PC. Si vous ouvrez votre ordinateur portable (attention à la garantie), vous retrouverez les mêmes composants qu'un PC à l'intérieur. Un point important est la présence d'une batterie à l'intérieur du PC portable, absente des PC fixes.

[[File:LG gram 14Z90Q mainboard with battery.jpg|centre|vignette|upright=2|LG gram 14Z90Q avec sa batterie.]]

Une fois la batterie et les circuits associés retiré, la seule différence notable est que tous les composants sont soudés sur la carte mère, au lieu d'être branchés sur des connecteurs, à part éventuellement la RAM et le disque dur.

[[File:LG gram 14Z90Q mainboard without battery.jpg|centre|vignette|upright=2|LG gram 14Z90Q sans sa batterie.]]

La RAM est parfois soudée sur la carte mère, d'autres fois sous la forme de barrettes de mémoire vive semblables à celles des PC. Dans le dernier cas, elle est connectée à des connecteurs spécifiques, ce qui permet de les changer/upgrader. Les PC portables sont parfois construits de manière à pouvoir changer la RAM facilement, en ouvrant un cache spécial, concu pour.

[[File:Lenovo G555 состав - Донор.JPG|centre|vignette|upright=2|Lenovo G555.]]

La conception d'un ordinateur portable est légèrement différente de celle d'un PC, pour des raisons thermiques. Un PC fixe a plus de place pour évacuer sa chaleur. Les ventilateurs peuvent plus facilement déplacer l'air dans le boitier, même si le flux d'air dans le boitier est éventuellement gêné par la carte graphique. Mais l'évacuation de la chaleur est assez efficace. Sur les PC portables, leur finesse fait que le trajet de l'air est beaucoup plus contraint. Évacuer la chaleur produite par l'ordinateur est plus complexe, ce qui demande d'utiliser des systèmes de refroidissement et de ventilation spécifiques.

Là où les PC fixes se débrouillent avec des radiateurs et des ventilateurs posés sur le processeur, les PC portables font autrement. Ils ne peuvent pas forcément mettre le ventilateur sur le processeur. A la place, ils mettent le ventilateur à côté, mais le processeur est surmonté par un mécanisme de transmission de la chaleur, qui transfère la chaleur du processeur vers le ventilateur.

[[File:Diagram - How a laptop cooling system works.png|centre|vignette|upright=2|Comment fonctionne le système de ventilation d'un ordinateur portable, en anglais.]]

Les difficultés pour dissiper la chaleur font que les ordinateurs portables utilisent souvent des composants peu performants, mais qui chauffent peu. En effet, nous verrons que plus un composant est puissant, plus il chauffe. La relation n'est pas parfaite, mais les processeurs haute performance chauffent plus que les modèles d'entrée ou milieu de gamme moins puissants. En conséquence, les PC portables sont souvent moins puissants que les PC fixes, même pour les modèles dit ''gaming''.

===Les serveurs et ''mainframes''===

Les grandes entreprises utilisent des ordinateurs de grande taille, très puissants, appelés des ''mainframes''. Ils sont souvent confondus avec les serveurs par le grand public, il y a une différence entre les deux. Un serveur est une fonction logicielle/réseau, pas un type d'ordinateur. Mais laissons cette différence de côté, ce qui est dit pour les ''mainframes'' sert pour les gros serveurs haute performance.

[[File:IBM Z15 mainframe.jpg|vignette|Exemple de ''mainframe''' de type IBM Z15.]]

Les anciens ''mainframes'' des années 50-80 avaient une taille pouvant être impressionnante, au point de prendre une pièce complète d'un bâtiment. Mais de nos jours, les ''mainframes'' tiennent dans une grosse armoire un peu haute. Les ''mainframes'' doivent rester allumé en permanence et ne doivent pas être éteint, sauf éventuellement quelques jours par an pour des opérations de maintenance. Ils utilisent pour cela des techniques spécifiques, avec beaucoup de redondance interne.

[[File:ACONIT hall grandes machines.jpg|centre|vignette|upright=2|''Mainframe'' ACONIT.]]

Les ''mainframes'' sont aussi conçus pour mutualiser au maximum leur utilisation, ils peuvent être utilisés par plusieurs utilisateurs à la suite, voire en même temps. Pour cela, les anciens ''mainframes'' étaient capables de faire tourner plusieurs applications distinctes l'une à la suite de l'autre, avec des commutations fréquentes entre logiciels. De nos jours, ils sont capables d'exécuter un grand nombre de tâches en même temps, grâce à la présence de plusieurs processeurs. Les ''mainframes'' modernes sont même capables de faire tourner plusieurs systèmes d'exploitation en même temps si besoin.

Les anciens ''mainframes'' étaient des ordinateurs assez simples, avec un processeur, de la mémoire RAM, un ou plusieurs disques durs, pas plus. Le ''mainframe'' était tellement énorme et cher que les entreprises n'en avaient qu'un seul pour toute l'entreprise. Les employés avaient sur leur bureau des terminaux, qui permettaient d'accéder à l'ordinateur central, mais n'étaient pas des ordinateurs. Les terminaux étaient des composants électroniques simples, avec un écran, un clavier et une souris, mais sans processeur. Ils envoyaient des données au ''mainframe'', ils en recevaient de sa part, mais tout traitement était réalisé sur le ''mainframe''. L'arrivée sur le marché des ordinateurs personnels, de type PC fixe/portable, a entrainé l'abandon de ce genre de pratique, tous les employés ont maintenant un ordinateur rien que pour eux.

{|
|-
! colspan=&quot;2&quot; | Exemples de terminaux
|-
|[[File:Terminal-in2-sm9400.jpg|centre|vignette|upright=1.5|Exemple de terminal. Notez la présence d'un écran et d'un clavier, mais l'asbence d'une unité centrale.]]
|[[File:Chromatics CT4100.jpg|vignette|upright=1.5|Autre exemple de terminal. Le clavier est couplé à un stylo CRT, qui remplacait la souris et agissait sur l'écran comme s'il était tactile.]]
|-
! colspan=&quot;2&quot; | Intérieur d'un terminal
|-
|[[File:CT1024 Monitor.jpg|vignette|upright=1.5|Terminal CT1024, sans le boitier extérieur.]]
|[[File:CT1024 Terminal System.jpg|vignette|upright=1.5|Terminal CT1024, description des composants interne.]]
|}

De nos jours, les ''mainframes'' contiennent en réalité plusieurs ordinateurs simples interconnectés via un réseau local. Un ''mainframe'' qui tient dans une armoire contient facilement une dizaine ou centaine de processeurs, plein de RAM, des disques durs séparés dans une armoire distincte, etc. Vu qu'ils communiquent uniquement via le réseau, ils n'ont pas d'interface, pas d'écran, 'entrée via clavier/souris. Le tout est commandé avec une console de commande, typiquement un ordinateur portable ou un terminal assez simple séparé de l'armoire, qui permet à un administrateur de faire des opérations de surveillance, configuration et maintenance. Il peut y avoir une console de commande pour plusieurs armoires séparées, la console peut même être dans un autre bâtiment et accéder au ''mainframe'' par le réseau.

[[File:IBM System Z9 (type 2094 inside).jpg|centre|vignette|upright=2|''Mainframe'' de type IBM System Z9. L'ordinateur portable sert de console pour qu'un administrateur fasse des opérations de surveillance, configuration et maintenance.]]

Les processeurs et la RAM sont typiquement installés sur des cartes amovibles, qui sont connectées au fond de l'armoire lors de l'installation. Il est même possible de retirer ou d'ajouter des cartes en fonctionnement, afin d'ajouter/retirer des processeurs, des disques durs, etc. Ce qui est très utile si un composant est en panne et qu'il faut le remplacer. 

[[File:IBM TotalStorage Exp400.jpg|centre|vignette|upright=2|IBM TotalStorage Exp400]]

==Un peu d'abstraction : qu'est-ce qu'un ordinateur ?==

Un ordinateur comprend donc un processeur, plusieurs mémoires, des cartes d'extension et une carte mère pour connecter le tout. Mais il s'agit là d'une description assez terre-à-terre de ce qu'est un ordinateur. Une autre description, plus abstraite, se base sur le fait qu'un ordinateur est une énorme calculatrice programmable. Elle permet d'expliquer pourquoi il y a une distinction entre processeur et mémoire, entre unité centrale et périphériques. Tout ce qui va suivre pourra vous paraitre assez abstrait, mais rassurez-vous : les prochains chapitres rendront tout cela plus concrets.

===La séparation entre entrées-sorties et traitement===

L'unité centrale peut être vue comme une énorme calculatrice ultra-puissante, qui exécute des commandes/opérations. Mais à elle seule, elle ne servirait à rien, il faut interagir avec par l'intermédiaire de plusieurs périphériques. Il existe deux types de périphériques, qui sont conceptuellement différents. Les périphériques comme le clavier ou la souris permettent d'envoyer des informations à l'ordinateur, d'agir sur celui-ci. A l'inverse, les écrans transmettent des informations dans le sens inverse : de l'ordinateur vers l'utilisateur. Les premiers sont appelés des '''entrées''', les seconds des '''sorties'''.

Dans un ordinateur, les informations sont représentées sous la forme de nombres. Toute donnée dans un ordinateur est codée avec un ou plusieurs nombres regroupés dans une donnée, un fichier, ou autre. Et la transmissions avec les entrées et sorties se fait là-encore avec des nombres. Par exemple, quand vous appuyez sur votre clavier, le clavier envoie un numéro de touche à l'unité centrale, qui indique quelle touche a été appuyée. L'image à afficher à l'écran est codée sous la forme d'une suite de nombres (un par pixel). L'image est envoyée à l'écran, qui traduit la suite de nombre en image à afficher. Les entrées traduisent des actions utilisateurs en nombres, on dit que les entrées encodent les actions utilisateur. Les sorties font la traduction inverse, elles transforment des suites de nombres en une action physique. On dit qu'elles décodent des informations.

Pour résumer, toute appareil électronique est composé par :
* Des '''entrées''' sur lesquelles l'utilisateur agit sur l'ordinateur. Les entrées transforment les actions de l'utilisateur en nombres, qui sont interprétés par l'ordinateur.
* Une '''unité de traitement''', qui manipule des nombres et fait des calculs/opérations dessus. Les nombres proviennent des entrées, du disque dur, ou d'autres sources, peu importe.
* Des '''sorties''', qui va récupèrent le résultat calculé par l'unité de traitement pour en faire quelque chose : écrire sur une imprimante ou sur un moniteur, émettre du son,...

[[File:Ordinateur théorique Simple 1.png|centre|vignette|upright=2|Ordinateur théorique Simple 1]]

L'unité de traitement proprement dite, celle qui fait les calculs, est couplée à une mémoire qui mémorise les opérandes et résultats des calculs. La séparation entre processeur et mémoire est nécessaire pour qu'un appareil électronique soit qualifié d'ordinateur. De nombreux appareils n'ont pas de séparation entre unité de traitement et mémoire, comme certaines vielles radios AM/FM.

[[File:Schéma de principe d'un ordinateur.png|centre|vignette|upright=2|Schéma de principe d'un ordinateur]]

===Un ordinateur est un appareil programmable===

Les appareils simples sont non-programmables, ce qui veut dire qu’ils sont conçus pour une utilisation particulière et qu’ils ne peuvent pas faire autre chose. Par exemple, les circuits électroniques d’un lecteur de DVD ne peuvent pas être transformé en lecteur audio ou en console de jeux... Les circuits non-programmables sont câblés une bonne fois pour toute, et on ne peut pas les modifier. On peut parfois reconfigurer le circuit, pour faire varier certains paramètres, via des interrupteurs ou des boutons, mais cela s’arrête là. Et cela pose un problème : à chaque problème qu'on veut résoudre en utilisant un automate, on doit recréer un nouveau circuit.

À l'inverse, un ordinateur n’est pas conçu pour une utilisation particulière, contrairement aux autres objets techniques. Il est possible de modifier leur fonction du jour au lendemain, on peut lui faire faire ce qu’on veut. On dit qu'ils sont '''programmables'''. Pour cela, il suffit d’utiliser un logiciel, une application, un programme (ces termes sont synonymes), qui fait ce que l'on souhaite. La totalité des logiciels présents sur un ordinateur sont des programmes comme les autres, même le système d'exploitation (Windows, Linux, ...) ne fait pas exception.

Un programme est une suite de d'instructions, chaque instruction effectuant une action dans l'ordinateur. Sur les ordinateurs modernes, la majorité de ces instructions effectuent une opération arithmétique, comme une addition, une multiplication, une soustraction, etc. Les ordinateurs modernes sont donc de grosses calculettes très puissantes, capables d'effectuer des millions d'opérations par secondes. Et qui dit opération dit nombres : un ordinateur gère nativement des nombres, qui sont codés en binaire sur la quasi-totalité des ordinateurs modernes.

Une instruction est représentée dans un ordinateur par une série de nombres : un nombre qui indique quelle opération/commande effectuer et des autres nombres pour coder les données (ou de quoi les retrouver dans l'ordinateur). L'ordinateur récupére les commandes une par une, les traduit en opération à effectuer, exécuter l'opération, et enregistre le résultat. Puis il recommence avec la commande suivante.

[[File:Ordinateur Théorique Complexe 1.png|centre|vignette|upright=3|Ordinateur Théorique Complexe. En jaune, le programme informatique, la liste de commande. Le rectangle gris est l'ordinateur proprement dit.]]

De nombreux appareils sont programmables, mais tous ne sont pas des ordinateurs. Par exemple, certains circuits programmables nommés FPGA n'en sont pas. Pour être qualifié d'ordinateur, un appareil programmable doit avoir un processeur séparé de la mémoire. De plus, il doit utiliser un '''codage numérique''', chose que nous allons aborder dans le chapitre suivant.

===Les ordinateurs à programme mémorisé ou programme externe===

Au tout début de l'informatique, on utilisait des cartes perforées en plastique, sur lesquelles on inscrivait le programme à exécuter, les données à traiter, bref : tout ce qu'on donnait à manger à l'ordinateur. Par la suite, les premiers ordinateurs grand public, comme les Amstrad ou les Commodore, utilisaient des cassettes audio magnétiques pour stocker les programmes. Dans le même style, les consoles de jeu utilisaient autrefois des cartouches de jeu, qui contenaient le programme du jeu à exécuter. Pour résumer, les anciens ordinateurs mémorisaient les programmes sur un support externe, lu par un périphérique. De tels ordinateurs sont dits à '''programme externe'''.

: D’anciens ordinateurs personnels, comme l’Amstrad ou le Commodore, permettaient de taper les programmes à exécuter à la main, au clavier, avant d’appuyer une touche pour les exécuter. Nul besoin de vous dire que les cassettes audio étaient plus pratiques.

Mais de nos jours, les programmes sont enregistrés sur le disque dur de l'ordinateur ou dans une mémoire intégrée à l'ordinateur. On dit qu'ils sont installés, ce qui est un mot bien compliqué pour dire que le programme est enregistré sur le disque dur de l’ordinateur. A défaut de disque dur, le programme/logiciel est enregistré dans une mémoire spécialisée pour le stockage. Par exemple, sur les cartes électroniques grand public de marque Arduino, les programmes sont envoyés à la carte via le port USB, mais les programmes sont enregistrés dans la carte Arduino, dans une mémoire FLASH dédiée. Disque dur ou non, le programme est mémorisé dans la mémoire de l'ordinateur. Il est possible d'installer ou de désinstaller les programmes en modifiant le contenu de la mémoire. Le terme utilisé est alors celui de '''programme stocké en mémoire'''.

Les programmes à installer sont disponibles soit sur un périphérique, comme un DVD ou une clé USB, soit sont téléchargés depuis internet. Les premiers PC fournissaient les logiciels sur des disquettes, qui contenaient un programme d'installation pour enregistrer le programme sur le disque dur de l'ordinateur. Par la suite, le support des logiciels a migré vers les CD et DVD, les logiciels devenant de plus en plus gros. De nos jours, la majorité des applications sont téléchargées depuis le net, l'usage de périphériques est devenu obsolète, même les consoles de jeu abandonnent cette méthode de distribution.

==Les générations d'ordinateurs : un historique rapide==

L'informatique a beaucoup évolué dans le temps. Et une bonne partie de cette évolution tient à l'évolution de l’électronique sous-jacente. Les ordinateurs actuels sont fabriqués avec des transistors, des petits composants électroniques qui servent d'interrupteur programmables, qu'on détaillera dans ce qui suit. Mais ça n'a pas toujours été le cas. Et cela permet de distinguer plusieurs '''générations d'ordinateurs'''.

===Les ordinateurs électro-mécaniques : les premiers ordinateurs===

Le tout premier ordinateur est le '''Z1''', un modèle unique inventé par Konrad Suze entre 1936 et 1938. Son processeur gérait non pas des nombres entiers, mais des nombres à virgule (des nombres dits flottants, pour être précis), encodés sur 22 bits. Le processeur du Z1 était capable de faire des additions et des soustractions, car il intégrait un circuit additionneur-soustracteur basique. Des circuits annexes permettaient de faire des multiplications et des divisions en enchainant des additions/soustractions successives. Il fonctionnait à une fréquence de 1 Hz, ce qui fait qu'il pouvait faire une addition/soustraction par seconde maximum.

[[File:Blue-punch-card-front.png|vignette|upright=0.5|Carte Perforée.]]

Niveau mémoire, la RAM de l'ordinateur était très limitée : seulement 16 nombres de 22 bits chacun. S'il s'agissait d'une mémoire électronique, les programmes étaient mémorisés sur une mémoire mécanique. Les programmes étaient enregistrés sur des cartes perforées, à savoir des cartes en papier dans lesquelles un 1 est codé par un trou dans le papier et un 0 par une absence de trou. Les programmes étaient exécutés par l'ordinateur quand on insérait la carte perforée dans le lecteur et qu'on appuyait sur un bouton.

[[File:German Museum of Technology, Berlin 2017 024.jpg|centre|vignette|upright=2|Réplique du Z1 au ''German Museum of Technology'' de Berlin, 2017.]]

Après sa destruction dans un bombardement, le Z1 a été reconstruit et amélioré, ce qui donné les deux ordinateurs Z2 et Z3. Quelques années plus tard, de nombreux ordinateurs ont été construits dans des laboratoires de recherche. Des grandes noms de l'histoire de l'informatique datent de cette époque : le Harvard Mark I et le Colossus Mark 1 (UK) ont tous deux été mis en service en 1944, par exemple. Ils ont servis pour les cryptanalystes pour casser les codes utilisés par les allemands pour leurs transmissions, pendant la seconde guerre mondiale.

Les ordinateurs cités dans le précédent paragraphe étaient tous des ordinateurs dit '''électro-mécaniques''', car ils mélangeaient des composants électroniques et des composants mécaniques (tout ce qui a trait aux cartes perforées, notamment). Les composants électroniques étaient soit des relais, soit des tubes à vides, les deux étant des interrupteurs commandables électriquement plus ou moins équivalents aux transistors. Les ordinateurs d'avant l'année 1944, étaient tous de ce type. Quelques ordinateurs des années 50 étaient de ce type, mais leur nombre n'a pas dépassé 30. Il faut dire qu'ils ont rapidement laissé la place à des ordinateurs purement électroniques, que nous allons voir dans ce qui suit..

===La première génération : les tubes à vide===

Les ordinateurs qui ont suivi les ordinateurs électromécaniques sont regroupés dans la '''première génération d'ordinateur'''. Ils étaient conçus avec des tubes à vide, ce qui les place entre les premiers ordinateurs électro-mécaniques et les ordinateurs utilisant des transistors. Les ordinateurs de première génération étaient très simples, ils ne géraient que quelques opérations simples : l'addition, la soustraction, pas grand chose de plus. A quelques exceptions près, ils ne géraient pas la multiplication et encore moins la division, ils n'avaient pas assez de relais ou de tubes à vides à disposition pour cela.

Une des toutes premières machines construite avec des tubes à vide était l'Atanasoff–Berry. Ce n'était pas un ordinateur, car elle ne pouvait pas exécuter de programme sans intervention humaine pour séquencer des opérations, mais c'était la première machine de calcul purement électronique, sans aucune pièce mécanique. Elle utilisait une mémoire RAM construite avec des condensateurs, ceux-ci étant placés sur des cylindres tournants. Les circuits de calcul étaient construits avec des tubes à vide et faisaient leur travail un bit à la fois. Elle fonctionnait à une fréquence de 60 Hz et pouvait faire 30 additions/soustractions par seconde. Les nombres étaient encodés sur 50 bits. 

[[File:Atanasoff Berry Computer.gif|centre|vignette|upright=2.5|Atanasoff–Berry.]]

L'arrivée de l'ENIAC en 1945 a changé la donne. Cet ordinateur a introduit plusieurs innovations majeures. La première est assez technique, il s'agit de la turing-complétude, elle a trait aux programmes qui peuvent être écrit pour un ordinateur, nous ne la détaillerons pas ici.

En 1948, le ''Manchester Baby'' a introduit une innovation extrêmement importante, au point où on considère que c'est le premier ordinateur à avoir tous les critères nécessaires pour être appelé un ordinateur. Son innovation est que le programme n'était plus mémorisé sur des cartes perforée, mais dans une mémoire électronique dans l'ordinateur lui-même. En clair, le ''Manchester Baby'' était le premier '''''Stored-program computer''''', ordinateur à programme enregistré en français. 

Le Manchester Baby avait une RAM de 32 nombres de 32 bits, fabriquées avec des tubes Willimas (abordés dans une annexe à la fin du cours). Il gérait 8 instructions en tout, mais ne gérait pas l'addition. Il gérait la soustraction, des instructions de branchement et d'accès mémoire, mais rien d'autre. Il pouvait cependant émuler l'addition à partir d'une soustraction et inversant l'opérande soustraite.

===La seconde génération : le remplacement des tubes à vides par des transistors===

[[File:IBM 7070.jpg|vignette|Cartes imprimées de l'IBM 704, avec des transistors et résistances dessus.]]

La '''seconde génération''' est celle des ordinateurs fabriqués avec des '''transistors''' isolés, reliés entre avec des fils électriques. Les transistors en question possèdent trois broches, des pattes métalliques sur lesquelles on connecte des fils électriques. Le transistor s'utilise le plus souvent comme un interrupteur commandé par sa troisième broche. Le courant qui traverse les deux premières broches passe ou ne passe pas selon ce qu'on met sur la troisième.

[[File:Transistor basic flow.svg|centre|vignette|Un transistor est un morceau de conducteur, dont la conductivité est contrôlée par sa troisième broche/borne.]]

Les ordinateurs de seconde génération avaient entre 1000 et 500 000 transistors. Les capacités des ordinateurs étaient donc nettement supérieures à celles des ordinateurs de première génération. Une part non négligeable des ordinateurs de seconde génération supportait l'opération de multiplication, absente sur les ordinateurs de première génération. Néanmoins, cela variait beaucoup selon les ordinateurs.

Un exemple assez hors du commun est celui du premier modèle de l'IBM 1620. Le tout premier modèle n'avait aucun circuit de calcul, il n'était même pas capable de faire une addition ou une multiplication. A la place, il utilisait une table d'addition et une table de multiplication en mémoire RAM. Les deux tables devaient être initialisées par le logiciel lors du démarrage de la machine. La table d'addition faisait une centaine de chiffre, la table de multiplication faisait le double. Le processeur de l'ordinateur gérait des instructions pour faire des additions ou des multiplications, mais ces opérations lisaient le résultat dans la table d'addition. Les calculs étaient fait chiffre par chiffre, avec un encodage partiellement décimal, partiellement binaire (des chiffres décimaux étaient encodés en binaire, nous en reparlerons quand nous parlerons du BCD) !

[[File:KL CoreMemory.jpg|vignette|Mémoire à tore de ferrite.]]

Les transistors n'étaient utilisés que pour le processeur et les circuits annexes. La mémoire n'était pas faite en transistors, pas à cette époque. La mémoire était une mémoire aujourd'hui abandonnée, appelée une '''mémoire à tores de ferrite'''. Elle sera détaillée dans un chapitre ultérieur. Mais sachez pour le moment qu'il s'agit d'une mémoire au support magnétique, les données étant stockées sur un support magnétique.

Transistors comme tubes à vide prenaient beaucoup de place, ce qui fait que les ordinateurs étaient assez gros. Concrètement, ils prenaient une pièce de bâtiment entière dans le meilleur des cas. C'était l'époque des gros ''mainframes'', reliés à des terminaux, peu puissants comparé aux standards actuels. Seules les grandes entreprises et les grands instituts de recherche pouvaient se payer les services de ce genre d'ordinateurs. Seuls les professionnels avaient accès à ce genre d'équipement.

===La troisième génération : le circuit intégré===

[[File:D8259AC-2.jpg|vignette|Exemple de circuit intégré.]]

La troisième génération est toujours fabriquée avec des transistors, mais dont la taille a été réduite. Avec l'évolution de la technologie, les transistors ont diminué en taille, de plus en plus. Ils sont devenus tellement petits qu'ils ont finit par être regroupés dans des '''circuits intégrés''', des circuits regroupent plusieurs transistors sur la même puce de silicium. Les circuits intégrés se présentent le plus souvent sous la forme de boitiers rectangulaires, comme illustré ci-contre. D'autres ont des boitiers de forme carrées, comme ceux que l'on peut trouver sur les barrettes de mémoire RAM, ou à l'intérieur des clés USB/ disques SSD.

Lors de cette génération, les processeurs étaient fournis en pièces détachées qu'il fallait relier entre elles. Le processeur était composé de plusieurs circuits intégrés séparés, impossible de mettre un processeur dans un seul boitier. Un exemple de processeur conçu en kit est la série des Intel 3000. Elle regroupe plusieurs circuits séparés aux noms à coucher dehors, mais dont vous comprendrez ce qu'ils veulent dire dans les chapitres adéquats : l'Intel 3001 est un séquenceur, l'Intel 3002 regroupe unité de calcul et registres, le 3003 est un circuit d'anticipation de retenue complémentaire du 3002, le 3212 est une mémoire tampon, le 3214 est une unité de gestion des interruptions, les 3216/3226 sont des interfaces de bus mémoire. On pourrait aussi citer la famille de circuits intégrés AMD Am2900.

Même si le processeur était en pièce détachées, utiliser une dizaine de circuits intégrés était nettement mieux que d'utiliser plusieurs milliers de transistors individuels. En conséquence, les ordinateurs ont vu leur taille grandement réduite, passant de pièces entières à une simple armoire, voire à quelques cartes intégrées superposées. De plus, le prix des circuits intégré était abordable, du moins comparé aux ordinateurs d'avant. Le prix des ordinateurs a alors grandement décru, permettant à des entreprises et administrations de taille modeste de s'équiper d'ordinateurs.

===La quatrième génération : le microprocesseur===

[[File:MOS6502.svg|vignette|Microprocesseur, ici un processeur MOS6502, de la quatrième génération.]]

Lors de la troisième génération, les circuits intégrés regroupaient plusieurs dizaines ou centaines de transistors, mais sont rapidement montés en gamme. De centaines de transistors, ils sont passé au milliers de transistors, puis au millions et maintenant au-delà du milliard. Les transistors étaient devenus tellement petits, tellement miniaturisés, qu'il était devenu possible de mettre un processeur entier dans un circuit intégré. C'est ainsi qu'est né le microprocesseur, à savoir un processeur qui tient tout entier dans un seul circuit imprimé. La quatrième génération d’ordinateur est celle des ordinateurs basés autour d'un microprocesseur.

Les tout premiers microprocesseurs étaient des processeurs à application militaire, comme le processeur du F-14 CADC ou celui de l'Air data computer. Le tout premier microprocesseur commercialisé au grand public est le 4004 d'Intel, sorti en 1971. L'intel 4004 comprenait environ 2300 transistors, avait une fréquence de 740 MHz, pouvait faire 46 opérations différentes, et manipulait des entiers de 4 bits. Il était au départ un processeur de commande, prévu pour être intégré dans la calculatrice Busicom calculator 141-P, mais il fut utilisé pour d'autres applications quelque temps plus tard. Immédiatement après le 4004, les premiers microprocesseurs 8 bits furent commercialisés. Le 4004 fut suivi par le 8008 et quelques autres processeurs 8 bits extrêmement connus, comme le 8080 d'Intel, le 68000 de Motorola, le 6502 ou le Z80.

Les microprocesseurs permirent encore uen fois de réduire la taille des ordinateurs, qui pouvaient tenir dans un boitier de PC, ou un boitier de console de jeu. Le prix des ordinateurs a aussi chuté en même temps que les transistors était miniaturisés. C'est cette invention qui permis l'invention des consoles de jeux et des mini-ordinateurs, à savoir les ordinateurs personnels. Sans miniaturisation, on n'aurait pas d'ordinateur personnel, pas de PC fixe ou portable.

==L'organisation du cours : les différents niveaux d'explication==

Le fonctionnement d'un ordinateur est assez complexe à expliquer car les explications peuvent se faire sur plusieurs niveaux. Par plusieurs niveaux, on veut dire qu'un ordinateur est composé de composants très simples, qui sont assemblés pour donner des composants eux-même plus complexes, qui sont eux-même regrouper, etc. Étudier tout cela demande de voir plusieurs niveaux, allant de transistors très petits à des processeurs multicœurs. Les niveaux les plus bas sont de l'électronique pur et dure, alors que ceux plus haut sont à mi-chemin entre électronique et informatique.

===Les niveaux d'abstraction en architecture des ordinateurs===

Les trois premiers niveaux sont de l'électronique pur et dure. Ils correspondent aux premiers chapitres du cours, qui porteront sur les circuits électroniques en général.
* Le premier niveau est celui des '''transistors''', des circuits intégrés, des ''wafer'' et autres circuits de très petite taille.
* Le second niveau est celui des '''portes logiques''', des circuits très basiques, très simples, à la base de tous les autres.
* Le troisième niveau est celui dit de la '''''Register Transfer Level''''', où un circuit électronique est construit à partir de circuits basiques, dont des registres et autres circuits dits combinatoires.
Les deux niveaux suivants sont de l'informatique proprement dit. C'est dans ces deux niveaux qu'on étudie les ordinateurs proprement dit, les circuits qu'il y a dedans et non l'électronique en général.
* Le quatrième niveau est celui de la '''microarchitecture''', qui étudie ce qu'il y a à l'intérieur d'un processeur, d'une mémoire, des périphériques et autres.
* Le cinquième niveau est celui de l''''architecture externe''', qui décrit l'interface du processeur, de la mémoire, d'un périphérique ou autre. Par décrire l'interface, on veut dire : comment un programmeur voit le processeur et la mémoire, comment il peut les manipuler. Une architecture externe unique peut avoir plusieurs microarchitecture, ce qui fait qu'on sépare les deux. Tout cela sera plus clair quand on passera aux chapitres sur le processeur et les mémoires.

Nous n'allons pas voir les 5 niveaux dans l'ordre, des transistors vers l'architecture externe. En réalité, nous allons procéder autrement. La première partie du cours portera sur les trois premiers niveaux, le reste sur les deux autres. Les 5 niveaux seront vus dans des chapitres séparés, du moins le plus possible. Au niveau pédagogique, tout est plus simple si on scinde les 5 niveaux. Bien sûr, il y a quelques explications qui demandent de voir plusieurs niveaux à la fois. Par exemple, dans le chapitre sur les mémoires caches, nous auront des explications portant sur la RTL, la microarchitecture du cache et son architecture externe. Mais le gros du cours tentera de séparer le plus possible les 5 niveaux.

===Les trois parties principales du cours===

Nous allons commencer par parler du binaire, avant de voir les portes logiques. Avec ces portes logiques, nous allons voir comment fabriquer des circuits basiques qui reviendront très souvent dans la suite du cours. Nous verrons les registres, les décodeurs, les additionneurs et plein d'autres circuits. Puis, nous reviendrons au niveau des transistors pour finir la première partie. La raison est que c'est plus simple de faire comme cela. Tout ce qui a trait aux transistors sert à expliquer comment fabriquer des portes logiques, et il faut expliquer les portes logiques pour voir le niveau de la RTL.

Une fois la première partie finie, nous allons voir les différents composants d'un ordinateur. Une première partie expliquera ce qu'il y a dans un ordinateur, quels sont ses composants. Nous y parlerons de l'architecture de base, de la hiérarchie mémoire, des tendances technologiques, et d'autres généralités qui serviront de base pour la suite. Puis, nous verrons dans l'ordre les bus électroniques, les mémoires RAM/ROM, le processeur, les périphériques, les mémoires de stockage (SSD et disques durs) et les mémoires caches. Pour chaque composant, nous allons voir leur architecture externe, avant de voir leur microarchitecture. La raison est que la microarchitecture ne peut se comprendre que quand on sait quelle architecture externe elle implémente.

Enfin, dans une troisième partie, nous allons voir les optimisations majeures présentes dans tous les ordinateurs modernes, avec une partie sur le pipeline et le parallélisme d'instruction, et une autre sur les architectures parallèles. Pour finir, les annexes de fin parlerons de sujets un peu à part.

&lt;noinclude&gt;
{{NavChapitre | book=Fonctionnement d'un ordinateur
           | next=L'encodage des données
           | nextText=L'encodage des données
}}
&lt;/noinclude&gt;</text>
      <sha1>73y7kymhk7r9xu17y6zpdc0hg8o1hof</sha1>
    </revision>
    <revision>
      <id>744119</id>
      <parentid>744118</parentid>
      <timestamp>2025-06-04T23:51:54Z</timestamp>
      <contributor>
        <username>Mewtow</username>
        <id>31375</id>
      </contributor>
      <minor />
      <comment>/* La première génération : les tubes à vide */</comment>
      <origin>744119</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="43887" sha1="6j9v78zf2smuaj1mkewss2508sb2hps" xml:space="preserve">Pour commencer, nous allons voir qu'il existe de nombreux types d'ordinateurs. Le plus connu est certainement le PC, l'ordinateur personnel, que vous avez sans doute dans votre salon. Les ordinateurs portables sont un deuxième type d'ordinateur assez intuitif, que vous avez peut-être. Mais il y a aussi d'autres types d'ordinateurs auxquels vous n'avez jamais été confrontés.

==Les différents types d'ordinateurs==

Dans cette section, nous allons décrire rapidement les ordinateurs les plus courant, mais surtout voir ce qu'il y a à l'intérieur d'un ordinateur.

===L'ordinateur de type PC fixe===

De l'extérieur, l'ordinateur est composé d'une unité centrale sur laquelle on branche des périphériques.

[[File:Typical computer architecture systems.jpg|vignette|upright=1.5|Exemples de périphériques, connectés à une unité centrale (ici appelée à tort ''operating system'').]]

Les '''périphériques''' regroupent l'écran, la souris, le clavier, l'imprimante, et bien d'autres choses. Ils permettent à l'utilisateur d'interagir avec l'ordinateur : un clavier permet de saisir du texte sous dans un fichier, une souris enregistre des déplacements de la main en déplacement du curseur, un écran affiche des données d’images/vidéos, un haut-parleur émet du son, etc. Tout ce qui est branché sur un ordinateur est, formellement un périphérique.

L''''unité centrale''' est là où se trouvent tous les composants importants d'un ordinateur, ceux qui font des calculs, qui exécutent des logiciels, qui mémorisent vos données, etc. Voici ce à quoi ressemble l'intérieur de l'unité centrale. Trois sections sont visibles : l'alimentation électrique en haut à gauche, la carte mère en bas à gauche et en jaune/orange, les disques et lecteurs à droite des câbles. Et on voit aussi beaucoup de câbles.

[[File:Asus P5K-SEIntel E6320.jpg|centre|vignette|upright=2|Exemple d'unité centrale.]]

Tout en haut à gauche, se trouve l''''alimentation électrique''', qui convertit le courant de la prise électrique en un courant plus faible, utilisable par les autres composants. Elle émet de nombreux câbles assez gros, qui sont reliés au reste. Les PC actuels utilisent des alimentations électriques standardisées, qui fournissent trois tensions au reste de l'ordinateur : une tension de 12 Volts, une de 5 Volts, une de 3,3 Volts.

À droite, caché par la partie &quot;métallique&quot; du boitier, se trouvent les lecteurs de CD/DVD, et les disques durs. Les lecteurs CD-ROM ou DVD-ROM permettaient de lire des CD ou des DVD. Je parle au passé, car ils ont aujourd'hui disparu des ordinateurs modernes. Les '''disques durs''' sont des mémoires de stockage, qui mémorisent vos données de manière permanente. De nos jours, ils sont remplacés par des SSD, qui sont des disques durs électroniques, là où les disques durs proprement dit sont des mémoires magnétiques. Nous verrons la différence dans deux chapitres dédiés, un sur les disques durs, l'autre sur les SSD.

En bas à droite, se trouve la '''carte mère''' un support plat, en plastique ou en céramique, sur laquelle sont soudés/connectés les autres composants. Sur celle-ci, de nombreux composants sont soudés, d'autres sont branchés dessus avec des câbles, d'autres sont connectés dessus avec des connecteurs. Ils sont reliés entre eux par des fils conducteurs, le plus souvent du cuivre ou de l’aluminium, ce qui leur permet de s’échanger des données. Sur les cartes simples, ces fils sont intégrés dans la carte électronique, dans des creux du plastique. Ils portent le nom de pistes.

Avant, les disques durs, SSD et lecteurs de CD/DVD sont branchés dessus via des connecteurs dédiés, appelés des connecteurs S-ATA. De nos jours, ils sont branchés sur un autre connecteur, grâce à l'interface NVME. Toujours est-il qu'ils sont reliés à la carte mère par des câbles, ce qui montre que ce sont des sortes de périphériques interne. Ils sont placés dans le boitier, mais on aurait tout aussi bien pu les mettre à l'extérieur, vu qu'ils communiquent avec l'ordinateur par l'intermédiaire d'un câble ou d'un connecteur dédié.

Mais deux autres composants très importants sont eux placés sur la carte mère, directement. Ils ont chacun un connecteur dédié, sur lequel ils sont branchés directement, sans passer par l'intermédiaire d'un câble, mais sans être soudés non plus. Il s'agit du processeur et de la mémoire RAM, deux composants centraux des PC modernes.

[[File:Pentium III SL4CB.jpg|thumb|Processeur Pentium III.]]

Le '''processeur''' traite les données, les modifie, les manipule. Pour faire simple, il s’agit d’une grosse calculatrice hyper-puissante. Il comprend à la fois un circuit qui fait des calculs, et un circuit de contrôle qui s'occupe de séquencer les calculs dans l'ordre demandé. Il est souvent caché sous un radiateur, lui-même surmonté par un ventilateur. En effet, un processeur chauffe beaucoup, ce qui demande d'évacuer cette chaleur. Un chapitre entier expliquera pourquoi les processeurs chauffent, ainsi que les techniques utilisées pour limiter leur production de chaleur et leur consommation électrique.

La '''mémoire vive''' conserve des informations/données temporairement, tant que le processeur en a besoin. Elle prend la forme de barrettes de RAM, comme montré ci-dessous.

[[File:2 gb ddr2 667.jpg|centre|vignette|upright=2|Barrette de RAM.]]

Outre ces composants dits principaux, un ordinateur peut comprendre plusieurs composants moins importants, surtout présents sur les ordinateurs personnels. Ils sont techniquement facultatifs, mais sont très présents dans les ordinateurs personnels. Cependant, certains ordinateurs spécialisés s'en passent. Il s'agit des diverses '''cartes d'extension''' sont branchées sur la carte mère. Elles permettent d’accélérer certains calculs ou certaines applications, afin de décharger le processeur. Par exemple, la carte graphique s'occupe des calculs graphiques, qu'il s'agisse de graphismes 3D de jeux vidéos ou de l'affichage en 2D du bureau. Dans un autre registre, la carte son prend en charge le microphone et les haut-parleurs.

[[Fichier:Personal computer, exploded 4.svg|thumb|upright=1.0|Éclaté d'un ordinateur de type PC :&lt;br /&gt;
1 : Écran ;&lt;br /&gt;
2 : Carte mère ;&lt;br /&gt;
3 : Processeur ;&lt;br /&gt;
4 : Câble Parallel ATA ;&lt;br /&gt;
5 : Mémoire vive (RAM) ;&lt;br /&gt;
6 : Carte d'extension ;&lt;br /&gt;
7 : Alimentation électrique ;&lt;br /&gt;
8 : Lecteur de disque optique ;&lt;br /&gt;
9 : Disque dur ;&lt;br /&gt;
10 : Clavier ;&lt;br /&gt;
11 : Souris.]]

Si on regarde une carte mère de face, on voit un grand nombre de connecteurs, mais aussi des circuits électroniques soudés à la carte mère.

[[File:Architecture matérielle d'une carte mère.png|centre|vignette|upright=2.0|Architecture matérielle d'une carte mère]]

Les '''connecteurs''' sont là où on branche les périphériques, la carte graphique, le processeur, la mémoire, etc. Dans l'ensemble, toute carte mère contient les connecteurs suivants :
* Le processeur vient s’enchâsser dans la carte mère sur un connecteur particulier : le '''socket'''. Celui-ci varie suivant la carte mère et le processeur, ce qui est source d'incompatibilités.
* Les barrettes de mémoire RAM s’enchâssent dans un autre type de connecteurs: les '''slots mémoire'''.
* Les mémoires de masse disposent de leurs propres connecteurs : connecteurs P-ATA pour les anciens disques durs, et S-ATA pour les récents.
* Les périphériques (clavier, souris, USB, Firewire, ...) sont connectés sur un ensemble de connecteurs dédiés, localisés à l'arrière du boitier de l'unité centrale. 
* Les autres périphériques sont placés dans l'unité centrale et sont connectés via des connecteurs spécialisés. Ces périphériques sont des cartes imprimées, d'où leur nom de '''cartes filles'''. On peut notamment citer les cartes réseau, les cartes son, ou les cartes vidéo.

===Les ordinateurs portables===

[[File:Samsung QX-511 (2).JPG|vignette|Ordinateur portable Samsung QX-511 (2), pour illustration.]]

Un ordinateur portable est identique à un ordinateur de type PC. Si vous ouvrez votre ordinateur portable (attention à la garantie), vous retrouverez les mêmes composants qu'un PC à l'intérieur. Un point important est la présence d'une batterie à l'intérieur du PC portable, absente des PC fixes.

[[File:LG gram 14Z90Q mainboard with battery.jpg|centre|vignette|upright=2|LG gram 14Z90Q avec sa batterie.]]

Une fois la batterie et les circuits associés retiré, la seule différence notable est que tous les composants sont soudés sur la carte mère, au lieu d'être branchés sur des connecteurs, à part éventuellement la RAM et le disque dur.

[[File:LG gram 14Z90Q mainboard without battery.jpg|centre|vignette|upright=2|LG gram 14Z90Q sans sa batterie.]]

La RAM est parfois soudée sur la carte mère, d'autres fois sous la forme de barrettes de mémoire vive semblables à celles des PC. Dans le dernier cas, elle est connectée à des connecteurs spécifiques, ce qui permet de les changer/upgrader. Les PC portables sont parfois construits de manière à pouvoir changer la RAM facilement, en ouvrant un cache spécial, concu pour.

[[File:Lenovo G555 состав - Донор.JPG|centre|vignette|upright=2|Lenovo G555.]]

La conception d'un ordinateur portable est légèrement différente de celle d'un PC, pour des raisons thermiques. Un PC fixe a plus de place pour évacuer sa chaleur. Les ventilateurs peuvent plus facilement déplacer l'air dans le boitier, même si le flux d'air dans le boitier est éventuellement gêné par la carte graphique. Mais l'évacuation de la chaleur est assez efficace. Sur les PC portables, leur finesse fait que le trajet de l'air est beaucoup plus contraint. Évacuer la chaleur produite par l'ordinateur est plus complexe, ce qui demande d'utiliser des systèmes de refroidissement et de ventilation spécifiques.

Là où les PC fixes se débrouillent avec des radiateurs et des ventilateurs posés sur le processeur, les PC portables font autrement. Ils ne peuvent pas forcément mettre le ventilateur sur le processeur. A la place, ils mettent le ventilateur à côté, mais le processeur est surmonté par un mécanisme de transmission de la chaleur, qui transfère la chaleur du processeur vers le ventilateur.

[[File:Diagram - How a laptop cooling system works.png|centre|vignette|upright=2|Comment fonctionne le système de ventilation d'un ordinateur portable, en anglais.]]

Les difficultés pour dissiper la chaleur font que les ordinateurs portables utilisent souvent des composants peu performants, mais qui chauffent peu. En effet, nous verrons que plus un composant est puissant, plus il chauffe. La relation n'est pas parfaite, mais les processeurs haute performance chauffent plus que les modèles d'entrée ou milieu de gamme moins puissants. En conséquence, les PC portables sont souvent moins puissants que les PC fixes, même pour les modèles dit ''gaming''.

===Les serveurs et ''mainframes''===

Les grandes entreprises utilisent des ordinateurs de grande taille, très puissants, appelés des ''mainframes''. Ils sont souvent confondus avec les serveurs par le grand public, il y a une différence entre les deux. Un serveur est une fonction logicielle/réseau, pas un type d'ordinateur. Mais laissons cette différence de côté, ce qui est dit pour les ''mainframes'' sert pour les gros serveurs haute performance.

[[File:IBM Z15 mainframe.jpg|vignette|Exemple de ''mainframe''' de type IBM Z15.]]

Les anciens ''mainframes'' des années 50-80 avaient une taille pouvant être impressionnante, au point de prendre une pièce complète d'un bâtiment. Mais de nos jours, les ''mainframes'' tiennent dans une grosse armoire un peu haute. Les ''mainframes'' doivent rester allumé en permanence et ne doivent pas être éteint, sauf éventuellement quelques jours par an pour des opérations de maintenance. Ils utilisent pour cela des techniques spécifiques, avec beaucoup de redondance interne.

[[File:ACONIT hall grandes machines.jpg|centre|vignette|upright=2|''Mainframe'' ACONIT.]]

Les ''mainframes'' sont aussi conçus pour mutualiser au maximum leur utilisation, ils peuvent être utilisés par plusieurs utilisateurs à la suite, voire en même temps. Pour cela, les anciens ''mainframes'' étaient capables de faire tourner plusieurs applications distinctes l'une à la suite de l'autre, avec des commutations fréquentes entre logiciels. De nos jours, ils sont capables d'exécuter un grand nombre de tâches en même temps, grâce à la présence de plusieurs processeurs. Les ''mainframes'' modernes sont même capables de faire tourner plusieurs systèmes d'exploitation en même temps si besoin.

Les anciens ''mainframes'' étaient des ordinateurs assez simples, avec un processeur, de la mémoire RAM, un ou plusieurs disques durs, pas plus. Le ''mainframe'' était tellement énorme et cher que les entreprises n'en avaient qu'un seul pour toute l'entreprise. Les employés avaient sur leur bureau des terminaux, qui permettaient d'accéder à l'ordinateur central, mais n'étaient pas des ordinateurs. Les terminaux étaient des composants électroniques simples, avec un écran, un clavier et une souris, mais sans processeur. Ils envoyaient des données au ''mainframe'', ils en recevaient de sa part, mais tout traitement était réalisé sur le ''mainframe''. L'arrivée sur le marché des ordinateurs personnels, de type PC fixe/portable, a entrainé l'abandon de ce genre de pratique, tous les employés ont maintenant un ordinateur rien que pour eux.

{|
|-
! colspan=&quot;2&quot; | Exemples de terminaux
|-
|[[File:Terminal-in2-sm9400.jpg|centre|vignette|upright=1.5|Exemple de terminal. Notez la présence d'un écran et d'un clavier, mais l'asbence d'une unité centrale.]]
|[[File:Chromatics CT4100.jpg|vignette|upright=1.5|Autre exemple de terminal. Le clavier est couplé à un stylo CRT, qui remplacait la souris et agissait sur l'écran comme s'il était tactile.]]
|-
! colspan=&quot;2&quot; | Intérieur d'un terminal
|-
|[[File:CT1024 Monitor.jpg|vignette|upright=1.5|Terminal CT1024, sans le boitier extérieur.]]
|[[File:CT1024 Terminal System.jpg|vignette|upright=1.5|Terminal CT1024, description des composants interne.]]
|}

De nos jours, les ''mainframes'' contiennent en réalité plusieurs ordinateurs simples interconnectés via un réseau local. Un ''mainframe'' qui tient dans une armoire contient facilement une dizaine ou centaine de processeurs, plein de RAM, des disques durs séparés dans une armoire distincte, etc. Vu qu'ils communiquent uniquement via le réseau, ils n'ont pas d'interface, pas d'écran, 'entrée via clavier/souris. Le tout est commandé avec une console de commande, typiquement un ordinateur portable ou un terminal assez simple séparé de l'armoire, qui permet à un administrateur de faire des opérations de surveillance, configuration et maintenance. Il peut y avoir une console de commande pour plusieurs armoires séparées, la console peut même être dans un autre bâtiment et accéder au ''mainframe'' par le réseau.

[[File:IBM System Z9 (type 2094 inside).jpg|centre|vignette|upright=2|''Mainframe'' de type IBM System Z9. L'ordinateur portable sert de console pour qu'un administrateur fasse des opérations de surveillance, configuration et maintenance.]]

Les processeurs et la RAM sont typiquement installés sur des cartes amovibles, qui sont connectées au fond de l'armoire lors de l'installation. Il est même possible de retirer ou d'ajouter des cartes en fonctionnement, afin d'ajouter/retirer des processeurs, des disques durs, etc. Ce qui est très utile si un composant est en panne et qu'il faut le remplacer. 

[[File:IBM TotalStorage Exp400.jpg|centre|vignette|upright=2|IBM TotalStorage Exp400]]

==Un peu d'abstraction : qu'est-ce qu'un ordinateur ?==

Un ordinateur comprend donc un processeur, plusieurs mémoires, des cartes d'extension et une carte mère pour connecter le tout. Mais il s'agit là d'une description assez terre-à-terre de ce qu'est un ordinateur. Une autre description, plus abstraite, se base sur le fait qu'un ordinateur est une énorme calculatrice programmable. Elle permet d'expliquer pourquoi il y a une distinction entre processeur et mémoire, entre unité centrale et périphériques. Tout ce qui va suivre pourra vous paraitre assez abstrait, mais rassurez-vous : les prochains chapitres rendront tout cela plus concrets.

===La séparation entre entrées-sorties et traitement===

L'unité centrale peut être vue comme une énorme calculatrice ultra-puissante, qui exécute des commandes/opérations. Mais à elle seule, elle ne servirait à rien, il faut interagir avec par l'intermédiaire de plusieurs périphériques. Il existe deux types de périphériques, qui sont conceptuellement différents. Les périphériques comme le clavier ou la souris permettent d'envoyer des informations à l'ordinateur, d'agir sur celui-ci. A l'inverse, les écrans transmettent des informations dans le sens inverse : de l'ordinateur vers l'utilisateur. Les premiers sont appelés des '''entrées''', les seconds des '''sorties'''.

Dans un ordinateur, les informations sont représentées sous la forme de nombres. Toute donnée dans un ordinateur est codée avec un ou plusieurs nombres regroupés dans une donnée, un fichier, ou autre. Et la transmissions avec les entrées et sorties se fait là-encore avec des nombres. Par exemple, quand vous appuyez sur votre clavier, le clavier envoie un numéro de touche à l'unité centrale, qui indique quelle touche a été appuyée. L'image à afficher à l'écran est codée sous la forme d'une suite de nombres (un par pixel). L'image est envoyée à l'écran, qui traduit la suite de nombre en image à afficher. Les entrées traduisent des actions utilisateurs en nombres, on dit que les entrées encodent les actions utilisateur. Les sorties font la traduction inverse, elles transforment des suites de nombres en une action physique. On dit qu'elles décodent des informations.

Pour résumer, toute appareil électronique est composé par :
* Des '''entrées''' sur lesquelles l'utilisateur agit sur l'ordinateur. Les entrées transforment les actions de l'utilisateur en nombres, qui sont interprétés par l'ordinateur.
* Une '''unité de traitement''', qui manipule des nombres et fait des calculs/opérations dessus. Les nombres proviennent des entrées, du disque dur, ou d'autres sources, peu importe.
* Des '''sorties''', qui va récupèrent le résultat calculé par l'unité de traitement pour en faire quelque chose : écrire sur une imprimante ou sur un moniteur, émettre du son,...

[[File:Ordinateur théorique Simple 1.png|centre|vignette|upright=2|Ordinateur théorique Simple 1]]

L'unité de traitement proprement dite, celle qui fait les calculs, est couplée à une mémoire qui mémorise les opérandes et résultats des calculs. La séparation entre processeur et mémoire est nécessaire pour qu'un appareil électronique soit qualifié d'ordinateur. De nombreux appareils n'ont pas de séparation entre unité de traitement et mémoire, comme certaines vielles radios AM/FM.

[[File:Schéma de principe d'un ordinateur.png|centre|vignette|upright=2|Schéma de principe d'un ordinateur]]

===Un ordinateur est un appareil programmable===

Les appareils simples sont non-programmables, ce qui veut dire qu’ils sont conçus pour une utilisation particulière et qu’ils ne peuvent pas faire autre chose. Par exemple, les circuits électroniques d’un lecteur de DVD ne peuvent pas être transformé en lecteur audio ou en console de jeux... Les circuits non-programmables sont câblés une bonne fois pour toute, et on ne peut pas les modifier. On peut parfois reconfigurer le circuit, pour faire varier certains paramètres, via des interrupteurs ou des boutons, mais cela s’arrête là. Et cela pose un problème : à chaque problème qu'on veut résoudre en utilisant un automate, on doit recréer un nouveau circuit.

À l'inverse, un ordinateur n’est pas conçu pour une utilisation particulière, contrairement aux autres objets techniques. Il est possible de modifier leur fonction du jour au lendemain, on peut lui faire faire ce qu’on veut. On dit qu'ils sont '''programmables'''. Pour cela, il suffit d’utiliser un logiciel, une application, un programme (ces termes sont synonymes), qui fait ce que l'on souhaite. La totalité des logiciels présents sur un ordinateur sont des programmes comme les autres, même le système d'exploitation (Windows, Linux, ...) ne fait pas exception.

Un programme est une suite de d'instructions, chaque instruction effectuant une action dans l'ordinateur. Sur les ordinateurs modernes, la majorité de ces instructions effectuent une opération arithmétique, comme une addition, une multiplication, une soustraction, etc. Les ordinateurs modernes sont donc de grosses calculettes très puissantes, capables d'effectuer des millions d'opérations par secondes. Et qui dit opération dit nombres : un ordinateur gère nativement des nombres, qui sont codés en binaire sur la quasi-totalité des ordinateurs modernes.

Une instruction est représentée dans un ordinateur par une série de nombres : un nombre qui indique quelle opération/commande effectuer et des autres nombres pour coder les données (ou de quoi les retrouver dans l'ordinateur). L'ordinateur récupére les commandes une par une, les traduit en opération à effectuer, exécuter l'opération, et enregistre le résultat. Puis il recommence avec la commande suivante.

[[File:Ordinateur Théorique Complexe 1.png|centre|vignette|upright=3|Ordinateur Théorique Complexe. En jaune, le programme informatique, la liste de commande. Le rectangle gris est l'ordinateur proprement dit.]]

De nombreux appareils sont programmables, mais tous ne sont pas des ordinateurs. Par exemple, certains circuits programmables nommés FPGA n'en sont pas. Pour être qualifié d'ordinateur, un appareil programmable doit avoir un processeur séparé de la mémoire. De plus, il doit utiliser un '''codage numérique''', chose que nous allons aborder dans le chapitre suivant.

===Les ordinateurs à programme mémorisé ou programme externe===

Au tout début de l'informatique, on utilisait des cartes perforées en plastique, sur lesquelles on inscrivait le programme à exécuter, les données à traiter, bref : tout ce qu'on donnait à manger à l'ordinateur. Par la suite, les premiers ordinateurs grand public, comme les Amstrad ou les Commodore, utilisaient des cassettes audio magnétiques pour stocker les programmes. Dans le même style, les consoles de jeu utilisaient autrefois des cartouches de jeu, qui contenaient le programme du jeu à exécuter. Pour résumer, les anciens ordinateurs mémorisaient les programmes sur un support externe, lu par un périphérique. De tels ordinateurs sont dits à '''programme externe'''.

: D’anciens ordinateurs personnels, comme l’Amstrad ou le Commodore, permettaient de taper les programmes à exécuter à la main, au clavier, avant d’appuyer une touche pour les exécuter. Nul besoin de vous dire que les cassettes audio étaient plus pratiques.

Mais de nos jours, les programmes sont enregistrés sur le disque dur de l'ordinateur ou dans une mémoire intégrée à l'ordinateur. On dit qu'ils sont installés, ce qui est un mot bien compliqué pour dire que le programme est enregistré sur le disque dur de l’ordinateur. A défaut de disque dur, le programme/logiciel est enregistré dans une mémoire spécialisée pour le stockage. Par exemple, sur les cartes électroniques grand public de marque Arduino, les programmes sont envoyés à la carte via le port USB, mais les programmes sont enregistrés dans la carte Arduino, dans une mémoire FLASH dédiée. Disque dur ou non, le programme est mémorisé dans la mémoire de l'ordinateur. Il est possible d'installer ou de désinstaller les programmes en modifiant le contenu de la mémoire. Le terme utilisé est alors celui de '''programme stocké en mémoire'''.

Les programmes à installer sont disponibles soit sur un périphérique, comme un DVD ou une clé USB, soit sont téléchargés depuis internet. Les premiers PC fournissaient les logiciels sur des disquettes, qui contenaient un programme d'installation pour enregistrer le programme sur le disque dur de l'ordinateur. Par la suite, le support des logiciels a migré vers les CD et DVD, les logiciels devenant de plus en plus gros. De nos jours, la majorité des applications sont téléchargées depuis le net, l'usage de périphériques est devenu obsolète, même les consoles de jeu abandonnent cette méthode de distribution.

==Les générations d'ordinateurs : un historique rapide==

L'informatique a beaucoup évolué dans le temps. Et une bonne partie de cette évolution tient à l'évolution de l’électronique sous-jacente. Les ordinateurs actuels sont fabriqués avec des transistors, des petits composants électroniques qui servent d'interrupteur programmables, qu'on détaillera dans ce qui suit. Mais ça n'a pas toujours été le cas. Et cela permet de distinguer plusieurs '''générations d'ordinateurs'''.

===Les ordinateurs électro-mécaniques : les premiers ordinateurs===

Le tout premier ordinateur est le '''Z1''', un modèle unique inventé par Konrad Suze entre 1936 et 1938. Son processeur gérait non pas des nombres entiers, mais des nombres à virgule (des nombres dits flottants, pour être précis), encodés sur 22 bits. Le processeur du Z1 était capable de faire des additions et des soustractions, car il intégrait un circuit additionneur-soustracteur basique. Des circuits annexes permettaient de faire des multiplications et des divisions en enchainant des additions/soustractions successives. Il fonctionnait à une fréquence de 1 Hz, ce qui fait qu'il pouvait faire une addition/soustraction par seconde maximum.

[[File:Blue-punch-card-front.png|vignette|upright=0.5|Carte Perforée.]]

Niveau mémoire, la RAM de l'ordinateur était très limitée : seulement 16 nombres de 22 bits chacun. S'il s'agissait d'une mémoire électronique, les programmes étaient mémorisés sur une mémoire mécanique. Les programmes étaient enregistrés sur des cartes perforées, à savoir des cartes en papier dans lesquelles un 1 est codé par un trou dans le papier et un 0 par une absence de trou. Les programmes étaient exécutés par l'ordinateur quand on insérait la carte perforée dans le lecteur et qu'on appuyait sur un bouton.

[[File:German Museum of Technology, Berlin 2017 024.jpg|centre|vignette|upright=2|Réplique du Z1 au ''German Museum of Technology'' de Berlin, 2017.]]

Après sa destruction dans un bombardement, le Z1 a été reconstruit et amélioré, ce qui donné les deux ordinateurs Z2 et Z3. Quelques années plus tard, de nombreux ordinateurs ont été construits dans des laboratoires de recherche. Des grandes noms de l'histoire de l'informatique datent de cette époque : le Harvard Mark I et le Colossus Mark 1 (UK) ont tous deux été mis en service en 1944, par exemple. Ils ont servis pour les cryptanalystes pour casser les codes utilisés par les allemands pour leurs transmissions, pendant la seconde guerre mondiale.

Les ordinateurs cités dans le précédent paragraphe étaient tous des ordinateurs dit '''électro-mécaniques''', car ils mélangeaient des composants électroniques et des composants mécaniques (tout ce qui a trait aux cartes perforées, notamment). Les composants électroniques étaient soit des relais, soit des tubes à vides, les deux étant des interrupteurs commandables électriquement plus ou moins équivalents aux transistors. Les ordinateurs d'avant l'année 1944, étaient tous de ce type. Quelques ordinateurs des années 50 étaient de ce type, mais leur nombre n'a pas dépassé 30. Il faut dire qu'ils ont rapidement laissé la place à des ordinateurs purement électroniques, que nous allons voir dans ce qui suit..

===La première génération : les tubes à vide===

Les ordinateurs qui ont suivi les ordinateurs électromécaniques sont regroupés dans la '''première génération d'ordinateur'''. Ils étaient conçus avec des tubes à vide, ce qui les place entre les premiers ordinateurs électro-mécaniques et les ordinateurs utilisant des transistors. Les tubes à vide étaient assez encombrants, surtout quand on sait que les ordinateurs de l'époque étaient composé de plusieurs milliers de ces tubes. Aussi, un ordinateur prenait facilement un étage de bâtiment entier, ou au moins plusieurs pièces. Et surtout, les tubes à vide consommaient beaucoup de courant, ils chauffaient et étaient assez peu fiables. Ils tombaient en panne assez souvent. Et ils étaient assez simple à fabriquer, mais restaient malgré tout chers.

[[File:Elektronenroehren-auswahl.jpg|centre|vignette|upright=2|Tubes à vides.]]

Les ordinateurs de première génération étaient très simples, ils ne géraient que quelques opérations simples : l'addition, la soustraction, pas grand chose de plus. A quelques exceptions près, ils ne géraient pas la multiplication et encore moins la division, ils n'avaient pas assez de relais ou de tubes à vides à disposition pour cela.

Une des toutes premières machines construite avec des tubes à vide était l'Atanasoff–Berry. Ce n'était pas un ordinateur, car elle ne pouvait pas exécuter de programme sans intervention humaine pour séquencer des opérations, mais c'était la première machine de calcul purement électronique, sans aucune pièce mécanique. Elle utilisait une mémoire RAM construite avec des condensateurs, ceux-ci étant placés sur des cylindres tournants. Les circuits de calcul étaient construits avec des tubes à vide et faisaient leur travail un bit à la fois. Elle fonctionnait à une fréquence de 60 Hz et pouvait faire 30 additions/soustractions par seconde. Les nombres étaient encodés sur 50 bits. 

[[File:Atanasoff Berry Computer.gif|centre|vignette|upright=2.5|Atanasoff–Berry.]]

L'arrivée de l'ENIAC en 1945 a changé la donne. Cet ordinateur a introduit plusieurs innovations majeures. La première est assez technique, il s'agit de la turing-complétude, elle a trait aux programmes qui peuvent être écrit pour un ordinateur, nous ne la détaillerons pas ici.

En 1948, le ''Manchester Baby'' a introduit une innovation extrêmement importante, au point où on considère que c'est le premier ordinateur à avoir tous les critères nécessaires pour être appelé un ordinateur. Son innovation est que le programme n'était plus mémorisé sur des cartes perforée, mais dans une mémoire électronique dans l'ordinateur lui-même. En clair, le ''Manchester Baby'' était le premier '''''Stored-program computer''''', ordinateur à programme enregistré en français. 

Le Manchester Baby avait une RAM de 32 nombres de 32 bits, fabriquées avec des tubes Willimas (abordés dans une annexe à la fin du cours). Il gérait 8 instructions en tout, mais ne gérait pas l'addition. Il gérait la soustraction, des instructions de branchement et d'accès mémoire, mais rien d'autre. Il pouvait cependant émuler l'addition à partir d'une soustraction et inversant l'opérande soustraite.

===La seconde génération : le remplacement des tubes à vides par des transistors===

[[File:IBM 7070.jpg|vignette|Cartes imprimées de l'IBM 704, avec des transistors et résistances dessus.]]

La '''seconde génération''' est celle des ordinateurs fabriqués avec des '''transistors''' isolés, reliés entre avec des fils électriques. Les transistors en question possèdent trois broches, des pattes métalliques sur lesquelles on connecte des fils électriques. Le transistor s'utilise le plus souvent comme un interrupteur commandé par sa troisième broche. Le courant qui traverse les deux premières broches passe ou ne passe pas selon ce qu'on met sur la troisième.

[[File:Transistor basic flow.svg|centre|vignette|Un transistor est un morceau de conducteur, dont la conductivité est contrôlée par sa troisième broche/borne.]]

Les ordinateurs de seconde génération avaient entre 1000 et 500 000 transistors. Les capacités des ordinateurs étaient donc nettement supérieures à celles des ordinateurs de première génération. Une part non négligeable des ordinateurs de seconde génération supportait l'opération de multiplication, absente sur les ordinateurs de première génération. Néanmoins, cela variait beaucoup selon les ordinateurs.

Un exemple assez hors du commun est celui du premier modèle de l'IBM 1620. Le tout premier modèle n'avait aucun circuit de calcul, il n'était même pas capable de faire une addition ou une multiplication. A la place, il utilisait une table d'addition et une table de multiplication en mémoire RAM. Les deux tables devaient être initialisées par le logiciel lors du démarrage de la machine. La table d'addition faisait une centaine de chiffre, la table de multiplication faisait le double. Le processeur de l'ordinateur gérait des instructions pour faire des additions ou des multiplications, mais ces opérations lisaient le résultat dans la table d'addition. Les calculs étaient fait chiffre par chiffre, avec un encodage partiellement décimal, partiellement binaire (des chiffres décimaux étaient encodés en binaire, nous en reparlerons quand nous parlerons du BCD) !

[[File:KL CoreMemory.jpg|vignette|Mémoire à tore de ferrite.]]

Les transistors n'étaient utilisés que pour le processeur et les circuits annexes. La mémoire n'était pas faite en transistors, pas à cette époque. La mémoire était une mémoire aujourd'hui abandonnée, appelée une '''mémoire à tores de ferrite'''. Elle sera détaillée dans un chapitre ultérieur. Mais sachez pour le moment qu'il s'agit d'une mémoire au support magnétique, les données étant stockées sur un support magnétique.

Transistors comme tubes à vide prenaient beaucoup de place, ce qui fait que les ordinateurs étaient assez gros. Concrètement, ils prenaient une pièce de bâtiment entière dans le meilleur des cas. C'était l'époque des gros ''mainframes'', reliés à des terminaux, peu puissants comparé aux standards actuels. Seules les grandes entreprises et les grands instituts de recherche pouvaient se payer les services de ce genre d'ordinateurs. Seuls les professionnels avaient accès à ce genre d'équipement.

===La troisième génération : le circuit intégré===

[[File:D8259AC-2.jpg|vignette|Exemple de circuit intégré.]]

La troisième génération est toujours fabriquée avec des transistors, mais dont la taille a été réduite. Avec l'évolution de la technologie, les transistors ont diminué en taille, de plus en plus. Ils sont devenus tellement petits qu'ils ont finit par être regroupés dans des '''circuits intégrés''', des circuits regroupent plusieurs transistors sur la même puce de silicium. Les circuits intégrés se présentent le plus souvent sous la forme de boitiers rectangulaires, comme illustré ci-contre. D'autres ont des boitiers de forme carrées, comme ceux que l'on peut trouver sur les barrettes de mémoire RAM, ou à l'intérieur des clés USB/ disques SSD.

Lors de cette génération, les processeurs étaient fournis en pièces détachées qu'il fallait relier entre elles. Le processeur était composé de plusieurs circuits intégrés séparés, impossible de mettre un processeur dans un seul boitier. Un exemple de processeur conçu en kit est la série des Intel 3000. Elle regroupe plusieurs circuits séparés aux noms à coucher dehors, mais dont vous comprendrez ce qu'ils veulent dire dans les chapitres adéquats : l'Intel 3001 est un séquenceur, l'Intel 3002 regroupe unité de calcul et registres, le 3003 est un circuit d'anticipation de retenue complémentaire du 3002, le 3212 est une mémoire tampon, le 3214 est une unité de gestion des interruptions, les 3216/3226 sont des interfaces de bus mémoire. On pourrait aussi citer la famille de circuits intégrés AMD Am2900.

Même si le processeur était en pièce détachées, utiliser une dizaine de circuits intégrés était nettement mieux que d'utiliser plusieurs milliers de transistors individuels. En conséquence, les ordinateurs ont vu leur taille grandement réduite, passant de pièces entières à une simple armoire, voire à quelques cartes intégrées superposées. De plus, le prix des circuits intégré était abordable, du moins comparé aux ordinateurs d'avant. Le prix des ordinateurs a alors grandement décru, permettant à des entreprises et administrations de taille modeste de s'équiper d'ordinateurs.

===La quatrième génération : le microprocesseur===

[[File:MOS6502.svg|vignette|Microprocesseur, ici un processeur MOS6502, de la quatrième génération.]]

Lors de la troisième génération, les circuits intégrés regroupaient plusieurs dizaines ou centaines de transistors, mais sont rapidement montés en gamme. De centaines de transistors, ils sont passé au milliers de transistors, puis au millions et maintenant au-delà du milliard. Les transistors étaient devenus tellement petits, tellement miniaturisés, qu'il était devenu possible de mettre un processeur entier dans un circuit intégré. C'est ainsi qu'est né le microprocesseur, à savoir un processeur qui tient tout entier dans un seul circuit imprimé. La quatrième génération d’ordinateur est celle des ordinateurs basés autour d'un microprocesseur.

Les tout premiers microprocesseurs étaient des processeurs à application militaire, comme le processeur du F-14 CADC ou celui de l'Air data computer. Le tout premier microprocesseur commercialisé au grand public est le 4004 d'Intel, sorti en 1971. L'intel 4004 comprenait environ 2300 transistors, avait une fréquence de 740 MHz, pouvait faire 46 opérations différentes, et manipulait des entiers de 4 bits. Il était au départ un processeur de commande, prévu pour être intégré dans la calculatrice Busicom calculator 141-P, mais il fut utilisé pour d'autres applications quelque temps plus tard. Immédiatement après le 4004, les premiers microprocesseurs 8 bits furent commercialisés. Le 4004 fut suivi par le 8008 et quelques autres processeurs 8 bits extrêmement connus, comme le 8080 d'Intel, le 68000 de Motorola, le 6502 ou le Z80.

Les microprocesseurs permirent encore uen fois de réduire la taille des ordinateurs, qui pouvaient tenir dans un boitier de PC, ou un boitier de console de jeu. Le prix des ordinateurs a aussi chuté en même temps que les transistors était miniaturisés. C'est cette invention qui permis l'invention des consoles de jeux et des mini-ordinateurs, à savoir les ordinateurs personnels. Sans miniaturisation, on n'aurait pas d'ordinateur personnel, pas de PC fixe ou portable.

==L'organisation du cours : les différents niveaux d'explication==

Le fonctionnement d'un ordinateur est assez complexe à expliquer car les explications peuvent se faire sur plusieurs niveaux. Par plusieurs niveaux, on veut dire qu'un ordinateur est composé de composants très simples, qui sont assemblés pour donner des composants eux-même plus complexes, qui sont eux-même regrouper, etc. Étudier tout cela demande de voir plusieurs niveaux, allant de transistors très petits à des processeurs multicœurs. Les niveaux les plus bas sont de l'électronique pur et dure, alors que ceux plus haut sont à mi-chemin entre électronique et informatique.

===Les niveaux d'abstraction en architecture des ordinateurs===

Les trois premiers niveaux sont de l'électronique pur et dure. Ils correspondent aux premiers chapitres du cours, qui porteront sur les circuits électroniques en général.
* Le premier niveau est celui des '''transistors''', des circuits intégrés, des ''wafer'' et autres circuits de très petite taille.
* Le second niveau est celui des '''portes logiques''', des circuits très basiques, très simples, à la base de tous les autres.
* Le troisième niveau est celui dit de la '''''Register Transfer Level''''', où un circuit électronique est construit à partir de circuits basiques, dont des registres et autres circuits dits combinatoires.
Les deux niveaux suivants sont de l'informatique proprement dit. C'est dans ces deux niveaux qu'on étudie les ordinateurs proprement dit, les circuits qu'il y a dedans et non l'électronique en général.
* Le quatrième niveau est celui de la '''microarchitecture''', qui étudie ce qu'il y a à l'intérieur d'un processeur, d'une mémoire, des périphériques et autres.
* Le cinquième niveau est celui de l''''architecture externe''', qui décrit l'interface du processeur, de la mémoire, d'un périphérique ou autre. Par décrire l'interface, on veut dire : comment un programmeur voit le processeur et la mémoire, comment il peut les manipuler. Une architecture externe unique peut avoir plusieurs microarchitecture, ce qui fait qu'on sépare les deux. Tout cela sera plus clair quand on passera aux chapitres sur le processeur et les mémoires.

Nous n'allons pas voir les 5 niveaux dans l'ordre, des transistors vers l'architecture externe. En réalité, nous allons procéder autrement. La première partie du cours portera sur les trois premiers niveaux, le reste sur les deux autres. Les 5 niveaux seront vus dans des chapitres séparés, du moins le plus possible. Au niveau pédagogique, tout est plus simple si on scinde les 5 niveaux. Bien sûr, il y a quelques explications qui demandent de voir plusieurs niveaux à la fois. Par exemple, dans le chapitre sur les mémoires caches, nous auront des explications portant sur la RTL, la microarchitecture du cache et son architecture externe. Mais le gros du cours tentera de séparer le plus possible les 5 niveaux.

===Les trois parties principales du cours===

Nous allons commencer par parler du binaire, avant de voir les portes logiques. Avec ces portes logiques, nous allons voir comment fabriquer des circuits basiques qui reviendront très souvent dans la suite du cours. Nous verrons les registres, les décodeurs, les additionneurs et plein d'autres circuits. Puis, nous reviendrons au niveau des transistors pour finir la première partie. La raison est que c'est plus simple de faire comme cela. Tout ce qui a trait aux transistors sert à expliquer comment fabriquer des portes logiques, et il faut expliquer les portes logiques pour voir le niveau de la RTL.

Une fois la première partie finie, nous allons voir les différents composants d'un ordinateur. Une première partie expliquera ce qu'il y a dans un ordinateur, quels sont ses composants. Nous y parlerons de l'architecture de base, de la hiérarchie mémoire, des tendances technologiques, et d'autres généralités qui serviront de base pour la suite. Puis, nous verrons dans l'ordre les bus électroniques, les mémoires RAM/ROM, le processeur, les périphériques, les mémoires de stockage (SSD et disques durs) et les mémoires caches. Pour chaque composant, nous allons voir leur architecture externe, avant de voir leur microarchitecture. La raison est que la microarchitecture ne peut se comprendre que quand on sait quelle architecture externe elle implémente.

Enfin, dans une troisième partie, nous allons voir les optimisations majeures présentes dans tous les ordinateurs modernes, avec une partie sur le pipeline et le parallélisme d'instruction, et une autre sur les architectures parallèles. Pour finir, les annexes de fin parlerons de sujets un peu à part.

&lt;noinclude&gt;
{{NavChapitre | book=Fonctionnement d'un ordinateur
           | next=L'encodage des données
           | nextText=L'encodage des données
}}
&lt;/noinclude&gt;</text>
      <sha1>6j9v78zf2smuaj1mkewss2508sb2hps</sha1>
    </revision>
    <revision>
      <id>744120</id>
      <parentid>744119</parentid>
      <timestamp>2025-06-04T23:56:02Z</timestamp>
      <contributor>
        <username>Mewtow</username>
        <id>31375</id>
      </contributor>
      <minor />
      <comment>/* La première génération : les tubes à vide */</comment>
      <origin>744120</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="43949" sha1="3c5ofvrq7d5mfb97yd36p51bm44p7nv" xml:space="preserve">Pour commencer, nous allons voir qu'il existe de nombreux types d'ordinateurs. Le plus connu est certainement le PC, l'ordinateur personnel, que vous avez sans doute dans votre salon. Les ordinateurs portables sont un deuxième type d'ordinateur assez intuitif, que vous avez peut-être. Mais il y a aussi d'autres types d'ordinateurs auxquels vous n'avez jamais été confrontés.

==Les différents types d'ordinateurs==

Dans cette section, nous allons décrire rapidement les ordinateurs les plus courant, mais surtout voir ce qu'il y a à l'intérieur d'un ordinateur.

===L'ordinateur de type PC fixe===

De l'extérieur, l'ordinateur est composé d'une unité centrale sur laquelle on branche des périphériques.

[[File:Typical computer architecture systems.jpg|vignette|upright=1.5|Exemples de périphériques, connectés à une unité centrale (ici appelée à tort ''operating system'').]]

Les '''périphériques''' regroupent l'écran, la souris, le clavier, l'imprimante, et bien d'autres choses. Ils permettent à l'utilisateur d'interagir avec l'ordinateur : un clavier permet de saisir du texte sous dans un fichier, une souris enregistre des déplacements de la main en déplacement du curseur, un écran affiche des données d’images/vidéos, un haut-parleur émet du son, etc. Tout ce qui est branché sur un ordinateur est, formellement un périphérique.

L''''unité centrale''' est là où se trouvent tous les composants importants d'un ordinateur, ceux qui font des calculs, qui exécutent des logiciels, qui mémorisent vos données, etc. Voici ce à quoi ressemble l'intérieur de l'unité centrale. Trois sections sont visibles : l'alimentation électrique en haut à gauche, la carte mère en bas à gauche et en jaune/orange, les disques et lecteurs à droite des câbles. Et on voit aussi beaucoup de câbles.

[[File:Asus P5K-SEIntel E6320.jpg|centre|vignette|upright=2|Exemple d'unité centrale.]]

Tout en haut à gauche, se trouve l''''alimentation électrique''', qui convertit le courant de la prise électrique en un courant plus faible, utilisable par les autres composants. Elle émet de nombreux câbles assez gros, qui sont reliés au reste. Les PC actuels utilisent des alimentations électriques standardisées, qui fournissent trois tensions au reste de l'ordinateur : une tension de 12 Volts, une de 5 Volts, une de 3,3 Volts.

À droite, caché par la partie &quot;métallique&quot; du boitier, se trouvent les lecteurs de CD/DVD, et les disques durs. Les lecteurs CD-ROM ou DVD-ROM permettaient de lire des CD ou des DVD. Je parle au passé, car ils ont aujourd'hui disparu des ordinateurs modernes. Les '''disques durs''' sont des mémoires de stockage, qui mémorisent vos données de manière permanente. De nos jours, ils sont remplacés par des SSD, qui sont des disques durs électroniques, là où les disques durs proprement dit sont des mémoires magnétiques. Nous verrons la différence dans deux chapitres dédiés, un sur les disques durs, l'autre sur les SSD.

En bas à droite, se trouve la '''carte mère''' un support plat, en plastique ou en céramique, sur laquelle sont soudés/connectés les autres composants. Sur celle-ci, de nombreux composants sont soudés, d'autres sont branchés dessus avec des câbles, d'autres sont connectés dessus avec des connecteurs. Ils sont reliés entre eux par des fils conducteurs, le plus souvent du cuivre ou de l’aluminium, ce qui leur permet de s’échanger des données. Sur les cartes simples, ces fils sont intégrés dans la carte électronique, dans des creux du plastique. Ils portent le nom de pistes.

Avant, les disques durs, SSD et lecteurs de CD/DVD sont branchés dessus via des connecteurs dédiés, appelés des connecteurs S-ATA. De nos jours, ils sont branchés sur un autre connecteur, grâce à l'interface NVME. Toujours est-il qu'ils sont reliés à la carte mère par des câbles, ce qui montre que ce sont des sortes de périphériques interne. Ils sont placés dans le boitier, mais on aurait tout aussi bien pu les mettre à l'extérieur, vu qu'ils communiquent avec l'ordinateur par l'intermédiaire d'un câble ou d'un connecteur dédié.

Mais deux autres composants très importants sont eux placés sur la carte mère, directement. Ils ont chacun un connecteur dédié, sur lequel ils sont branchés directement, sans passer par l'intermédiaire d'un câble, mais sans être soudés non plus. Il s'agit du processeur et de la mémoire RAM, deux composants centraux des PC modernes.

[[File:Pentium III SL4CB.jpg|thumb|Processeur Pentium III.]]

Le '''processeur''' traite les données, les modifie, les manipule. Pour faire simple, il s’agit d’une grosse calculatrice hyper-puissante. Il comprend à la fois un circuit qui fait des calculs, et un circuit de contrôle qui s'occupe de séquencer les calculs dans l'ordre demandé. Il est souvent caché sous un radiateur, lui-même surmonté par un ventilateur. En effet, un processeur chauffe beaucoup, ce qui demande d'évacuer cette chaleur. Un chapitre entier expliquera pourquoi les processeurs chauffent, ainsi que les techniques utilisées pour limiter leur production de chaleur et leur consommation électrique.

La '''mémoire vive''' conserve des informations/données temporairement, tant que le processeur en a besoin. Elle prend la forme de barrettes de RAM, comme montré ci-dessous.

[[File:2 gb ddr2 667.jpg|centre|vignette|upright=2|Barrette de RAM.]]

Outre ces composants dits principaux, un ordinateur peut comprendre plusieurs composants moins importants, surtout présents sur les ordinateurs personnels. Ils sont techniquement facultatifs, mais sont très présents dans les ordinateurs personnels. Cependant, certains ordinateurs spécialisés s'en passent. Il s'agit des diverses '''cartes d'extension''' sont branchées sur la carte mère. Elles permettent d’accélérer certains calculs ou certaines applications, afin de décharger le processeur. Par exemple, la carte graphique s'occupe des calculs graphiques, qu'il s'agisse de graphismes 3D de jeux vidéos ou de l'affichage en 2D du bureau. Dans un autre registre, la carte son prend en charge le microphone et les haut-parleurs.

[[Fichier:Personal computer, exploded 4.svg|thumb|upright=1.0|Éclaté d'un ordinateur de type PC :&lt;br /&gt;
1 : Écran ;&lt;br /&gt;
2 : Carte mère ;&lt;br /&gt;
3 : Processeur ;&lt;br /&gt;
4 : Câble Parallel ATA ;&lt;br /&gt;
5 : Mémoire vive (RAM) ;&lt;br /&gt;
6 : Carte d'extension ;&lt;br /&gt;
7 : Alimentation électrique ;&lt;br /&gt;
8 : Lecteur de disque optique ;&lt;br /&gt;
9 : Disque dur ;&lt;br /&gt;
10 : Clavier ;&lt;br /&gt;
11 : Souris.]]

Si on regarde une carte mère de face, on voit un grand nombre de connecteurs, mais aussi des circuits électroniques soudés à la carte mère.

[[File:Architecture matérielle d'une carte mère.png|centre|vignette|upright=2.0|Architecture matérielle d'une carte mère]]

Les '''connecteurs''' sont là où on branche les périphériques, la carte graphique, le processeur, la mémoire, etc. Dans l'ensemble, toute carte mère contient les connecteurs suivants :
* Le processeur vient s’enchâsser dans la carte mère sur un connecteur particulier : le '''socket'''. Celui-ci varie suivant la carte mère et le processeur, ce qui est source d'incompatibilités.
* Les barrettes de mémoire RAM s’enchâssent dans un autre type de connecteurs: les '''slots mémoire'''.
* Les mémoires de masse disposent de leurs propres connecteurs : connecteurs P-ATA pour les anciens disques durs, et S-ATA pour les récents.
* Les périphériques (clavier, souris, USB, Firewire, ...) sont connectés sur un ensemble de connecteurs dédiés, localisés à l'arrière du boitier de l'unité centrale. 
* Les autres périphériques sont placés dans l'unité centrale et sont connectés via des connecteurs spécialisés. Ces périphériques sont des cartes imprimées, d'où leur nom de '''cartes filles'''. On peut notamment citer les cartes réseau, les cartes son, ou les cartes vidéo.

===Les ordinateurs portables===

[[File:Samsung QX-511 (2).JPG|vignette|Ordinateur portable Samsung QX-511 (2), pour illustration.]]

Un ordinateur portable est identique à un ordinateur de type PC. Si vous ouvrez votre ordinateur portable (attention à la garantie), vous retrouverez les mêmes composants qu'un PC à l'intérieur. Un point important est la présence d'une batterie à l'intérieur du PC portable, absente des PC fixes.

[[File:LG gram 14Z90Q mainboard with battery.jpg|centre|vignette|upright=2|LG gram 14Z90Q avec sa batterie.]]

Une fois la batterie et les circuits associés retiré, la seule différence notable est que tous les composants sont soudés sur la carte mère, au lieu d'être branchés sur des connecteurs, à part éventuellement la RAM et le disque dur.

[[File:LG gram 14Z90Q mainboard without battery.jpg|centre|vignette|upright=2|LG gram 14Z90Q sans sa batterie.]]

La RAM est parfois soudée sur la carte mère, d'autres fois sous la forme de barrettes de mémoire vive semblables à celles des PC. Dans le dernier cas, elle est connectée à des connecteurs spécifiques, ce qui permet de les changer/upgrader. Les PC portables sont parfois construits de manière à pouvoir changer la RAM facilement, en ouvrant un cache spécial, concu pour.

[[File:Lenovo G555 состав - Донор.JPG|centre|vignette|upright=2|Lenovo G555.]]

La conception d'un ordinateur portable est légèrement différente de celle d'un PC, pour des raisons thermiques. Un PC fixe a plus de place pour évacuer sa chaleur. Les ventilateurs peuvent plus facilement déplacer l'air dans le boitier, même si le flux d'air dans le boitier est éventuellement gêné par la carte graphique. Mais l'évacuation de la chaleur est assez efficace. Sur les PC portables, leur finesse fait que le trajet de l'air est beaucoup plus contraint. Évacuer la chaleur produite par l'ordinateur est plus complexe, ce qui demande d'utiliser des systèmes de refroidissement et de ventilation spécifiques.

Là où les PC fixes se débrouillent avec des radiateurs et des ventilateurs posés sur le processeur, les PC portables font autrement. Ils ne peuvent pas forcément mettre le ventilateur sur le processeur. A la place, ils mettent le ventilateur à côté, mais le processeur est surmonté par un mécanisme de transmission de la chaleur, qui transfère la chaleur du processeur vers le ventilateur.

[[File:Diagram - How a laptop cooling system works.png|centre|vignette|upright=2|Comment fonctionne le système de ventilation d'un ordinateur portable, en anglais.]]

Les difficultés pour dissiper la chaleur font que les ordinateurs portables utilisent souvent des composants peu performants, mais qui chauffent peu. En effet, nous verrons que plus un composant est puissant, plus il chauffe. La relation n'est pas parfaite, mais les processeurs haute performance chauffent plus que les modèles d'entrée ou milieu de gamme moins puissants. En conséquence, les PC portables sont souvent moins puissants que les PC fixes, même pour les modèles dit ''gaming''.

===Les serveurs et ''mainframes''===

Les grandes entreprises utilisent des ordinateurs de grande taille, très puissants, appelés des ''mainframes''. Ils sont souvent confondus avec les serveurs par le grand public, il y a une différence entre les deux. Un serveur est une fonction logicielle/réseau, pas un type d'ordinateur. Mais laissons cette différence de côté, ce qui est dit pour les ''mainframes'' sert pour les gros serveurs haute performance.

[[File:IBM Z15 mainframe.jpg|vignette|Exemple de ''mainframe''' de type IBM Z15.]]

Les anciens ''mainframes'' des années 50-80 avaient une taille pouvant être impressionnante, au point de prendre une pièce complète d'un bâtiment. Mais de nos jours, les ''mainframes'' tiennent dans une grosse armoire un peu haute. Les ''mainframes'' doivent rester allumé en permanence et ne doivent pas être éteint, sauf éventuellement quelques jours par an pour des opérations de maintenance. Ils utilisent pour cela des techniques spécifiques, avec beaucoup de redondance interne.

[[File:ACONIT hall grandes machines.jpg|centre|vignette|upright=2|''Mainframe'' ACONIT.]]

Les ''mainframes'' sont aussi conçus pour mutualiser au maximum leur utilisation, ils peuvent être utilisés par plusieurs utilisateurs à la suite, voire en même temps. Pour cela, les anciens ''mainframes'' étaient capables de faire tourner plusieurs applications distinctes l'une à la suite de l'autre, avec des commutations fréquentes entre logiciels. De nos jours, ils sont capables d'exécuter un grand nombre de tâches en même temps, grâce à la présence de plusieurs processeurs. Les ''mainframes'' modernes sont même capables de faire tourner plusieurs systèmes d'exploitation en même temps si besoin.

Les anciens ''mainframes'' étaient des ordinateurs assez simples, avec un processeur, de la mémoire RAM, un ou plusieurs disques durs, pas plus. Le ''mainframe'' était tellement énorme et cher que les entreprises n'en avaient qu'un seul pour toute l'entreprise. Les employés avaient sur leur bureau des terminaux, qui permettaient d'accéder à l'ordinateur central, mais n'étaient pas des ordinateurs. Les terminaux étaient des composants électroniques simples, avec un écran, un clavier et une souris, mais sans processeur. Ils envoyaient des données au ''mainframe'', ils en recevaient de sa part, mais tout traitement était réalisé sur le ''mainframe''. L'arrivée sur le marché des ordinateurs personnels, de type PC fixe/portable, a entrainé l'abandon de ce genre de pratique, tous les employés ont maintenant un ordinateur rien que pour eux.

{|
|-
! colspan=&quot;2&quot; | Exemples de terminaux
|-
|[[File:Terminal-in2-sm9400.jpg|centre|vignette|upright=1.5|Exemple de terminal. Notez la présence d'un écran et d'un clavier, mais l'asbence d'une unité centrale.]]
|[[File:Chromatics CT4100.jpg|vignette|upright=1.5|Autre exemple de terminal. Le clavier est couplé à un stylo CRT, qui remplacait la souris et agissait sur l'écran comme s'il était tactile.]]
|-
! colspan=&quot;2&quot; | Intérieur d'un terminal
|-
|[[File:CT1024 Monitor.jpg|vignette|upright=1.5|Terminal CT1024, sans le boitier extérieur.]]
|[[File:CT1024 Terminal System.jpg|vignette|upright=1.5|Terminal CT1024, description des composants interne.]]
|}

De nos jours, les ''mainframes'' contiennent en réalité plusieurs ordinateurs simples interconnectés via un réseau local. Un ''mainframe'' qui tient dans une armoire contient facilement une dizaine ou centaine de processeurs, plein de RAM, des disques durs séparés dans une armoire distincte, etc. Vu qu'ils communiquent uniquement via le réseau, ils n'ont pas d'interface, pas d'écran, 'entrée via clavier/souris. Le tout est commandé avec une console de commande, typiquement un ordinateur portable ou un terminal assez simple séparé de l'armoire, qui permet à un administrateur de faire des opérations de surveillance, configuration et maintenance. Il peut y avoir une console de commande pour plusieurs armoires séparées, la console peut même être dans un autre bâtiment et accéder au ''mainframe'' par le réseau.

[[File:IBM System Z9 (type 2094 inside).jpg|centre|vignette|upright=2|''Mainframe'' de type IBM System Z9. L'ordinateur portable sert de console pour qu'un administrateur fasse des opérations de surveillance, configuration et maintenance.]]

Les processeurs et la RAM sont typiquement installés sur des cartes amovibles, qui sont connectées au fond de l'armoire lors de l'installation. Il est même possible de retirer ou d'ajouter des cartes en fonctionnement, afin d'ajouter/retirer des processeurs, des disques durs, etc. Ce qui est très utile si un composant est en panne et qu'il faut le remplacer. 

[[File:IBM TotalStorage Exp400.jpg|centre|vignette|upright=2|IBM TotalStorage Exp400]]

==Un peu d'abstraction : qu'est-ce qu'un ordinateur ?==

Un ordinateur comprend donc un processeur, plusieurs mémoires, des cartes d'extension et une carte mère pour connecter le tout. Mais il s'agit là d'une description assez terre-à-terre de ce qu'est un ordinateur. Une autre description, plus abstraite, se base sur le fait qu'un ordinateur est une énorme calculatrice programmable. Elle permet d'expliquer pourquoi il y a une distinction entre processeur et mémoire, entre unité centrale et périphériques. Tout ce qui va suivre pourra vous paraitre assez abstrait, mais rassurez-vous : les prochains chapitres rendront tout cela plus concrets.

===La séparation entre entrées-sorties et traitement===

L'unité centrale peut être vue comme une énorme calculatrice ultra-puissante, qui exécute des commandes/opérations. Mais à elle seule, elle ne servirait à rien, il faut interagir avec par l'intermédiaire de plusieurs périphériques. Il existe deux types de périphériques, qui sont conceptuellement différents. Les périphériques comme le clavier ou la souris permettent d'envoyer des informations à l'ordinateur, d'agir sur celui-ci. A l'inverse, les écrans transmettent des informations dans le sens inverse : de l'ordinateur vers l'utilisateur. Les premiers sont appelés des '''entrées''', les seconds des '''sorties'''.

Dans un ordinateur, les informations sont représentées sous la forme de nombres. Toute donnée dans un ordinateur est codée avec un ou plusieurs nombres regroupés dans une donnée, un fichier, ou autre. Et la transmissions avec les entrées et sorties se fait là-encore avec des nombres. Par exemple, quand vous appuyez sur votre clavier, le clavier envoie un numéro de touche à l'unité centrale, qui indique quelle touche a été appuyée. L'image à afficher à l'écran est codée sous la forme d'une suite de nombres (un par pixel). L'image est envoyée à l'écran, qui traduit la suite de nombre en image à afficher. Les entrées traduisent des actions utilisateurs en nombres, on dit que les entrées encodent les actions utilisateur. Les sorties font la traduction inverse, elles transforment des suites de nombres en une action physique. On dit qu'elles décodent des informations.

Pour résumer, toute appareil électronique est composé par :
* Des '''entrées''' sur lesquelles l'utilisateur agit sur l'ordinateur. Les entrées transforment les actions de l'utilisateur en nombres, qui sont interprétés par l'ordinateur.
* Une '''unité de traitement''', qui manipule des nombres et fait des calculs/opérations dessus. Les nombres proviennent des entrées, du disque dur, ou d'autres sources, peu importe.
* Des '''sorties''', qui va récupèrent le résultat calculé par l'unité de traitement pour en faire quelque chose : écrire sur une imprimante ou sur un moniteur, émettre du son,...

[[File:Ordinateur théorique Simple 1.png|centre|vignette|upright=2|Ordinateur théorique Simple 1]]

L'unité de traitement proprement dite, celle qui fait les calculs, est couplée à une mémoire qui mémorise les opérandes et résultats des calculs. La séparation entre processeur et mémoire est nécessaire pour qu'un appareil électronique soit qualifié d'ordinateur. De nombreux appareils n'ont pas de séparation entre unité de traitement et mémoire, comme certaines vielles radios AM/FM.

[[File:Schéma de principe d'un ordinateur.png|centre|vignette|upright=2|Schéma de principe d'un ordinateur]]

===Un ordinateur est un appareil programmable===

Les appareils simples sont non-programmables, ce qui veut dire qu’ils sont conçus pour une utilisation particulière et qu’ils ne peuvent pas faire autre chose. Par exemple, les circuits électroniques d’un lecteur de DVD ne peuvent pas être transformé en lecteur audio ou en console de jeux... Les circuits non-programmables sont câblés une bonne fois pour toute, et on ne peut pas les modifier. On peut parfois reconfigurer le circuit, pour faire varier certains paramètres, via des interrupteurs ou des boutons, mais cela s’arrête là. Et cela pose un problème : à chaque problème qu'on veut résoudre en utilisant un automate, on doit recréer un nouveau circuit.

À l'inverse, un ordinateur n’est pas conçu pour une utilisation particulière, contrairement aux autres objets techniques. Il est possible de modifier leur fonction du jour au lendemain, on peut lui faire faire ce qu’on veut. On dit qu'ils sont '''programmables'''. Pour cela, il suffit d’utiliser un logiciel, une application, un programme (ces termes sont synonymes), qui fait ce que l'on souhaite. La totalité des logiciels présents sur un ordinateur sont des programmes comme les autres, même le système d'exploitation (Windows, Linux, ...) ne fait pas exception.

Un programme est une suite de d'instructions, chaque instruction effectuant une action dans l'ordinateur. Sur les ordinateurs modernes, la majorité de ces instructions effectuent une opération arithmétique, comme une addition, une multiplication, une soustraction, etc. Les ordinateurs modernes sont donc de grosses calculettes très puissantes, capables d'effectuer des millions d'opérations par secondes. Et qui dit opération dit nombres : un ordinateur gère nativement des nombres, qui sont codés en binaire sur la quasi-totalité des ordinateurs modernes.

Une instruction est représentée dans un ordinateur par une série de nombres : un nombre qui indique quelle opération/commande effectuer et des autres nombres pour coder les données (ou de quoi les retrouver dans l'ordinateur). L'ordinateur récupére les commandes une par une, les traduit en opération à effectuer, exécuter l'opération, et enregistre le résultat. Puis il recommence avec la commande suivante.

[[File:Ordinateur Théorique Complexe 1.png|centre|vignette|upright=3|Ordinateur Théorique Complexe. En jaune, le programme informatique, la liste de commande. Le rectangle gris est l'ordinateur proprement dit.]]

De nombreux appareils sont programmables, mais tous ne sont pas des ordinateurs. Par exemple, certains circuits programmables nommés FPGA n'en sont pas. Pour être qualifié d'ordinateur, un appareil programmable doit avoir un processeur séparé de la mémoire. De plus, il doit utiliser un '''codage numérique''', chose que nous allons aborder dans le chapitre suivant.

===Les ordinateurs à programme mémorisé ou programme externe===

Au tout début de l'informatique, on utilisait des cartes perforées en plastique, sur lesquelles on inscrivait le programme à exécuter, les données à traiter, bref : tout ce qu'on donnait à manger à l'ordinateur. Par la suite, les premiers ordinateurs grand public, comme les Amstrad ou les Commodore, utilisaient des cassettes audio magnétiques pour stocker les programmes. Dans le même style, les consoles de jeu utilisaient autrefois des cartouches de jeu, qui contenaient le programme du jeu à exécuter. Pour résumer, les anciens ordinateurs mémorisaient les programmes sur un support externe, lu par un périphérique. De tels ordinateurs sont dits à '''programme externe'''.

: D’anciens ordinateurs personnels, comme l’Amstrad ou le Commodore, permettaient de taper les programmes à exécuter à la main, au clavier, avant d’appuyer une touche pour les exécuter. Nul besoin de vous dire que les cassettes audio étaient plus pratiques.

Mais de nos jours, les programmes sont enregistrés sur le disque dur de l'ordinateur ou dans une mémoire intégrée à l'ordinateur. On dit qu'ils sont installés, ce qui est un mot bien compliqué pour dire que le programme est enregistré sur le disque dur de l’ordinateur. A défaut de disque dur, le programme/logiciel est enregistré dans une mémoire spécialisée pour le stockage. Par exemple, sur les cartes électroniques grand public de marque Arduino, les programmes sont envoyés à la carte via le port USB, mais les programmes sont enregistrés dans la carte Arduino, dans une mémoire FLASH dédiée. Disque dur ou non, le programme est mémorisé dans la mémoire de l'ordinateur. Il est possible d'installer ou de désinstaller les programmes en modifiant le contenu de la mémoire. Le terme utilisé est alors celui de '''programme stocké en mémoire'''.

Les programmes à installer sont disponibles soit sur un périphérique, comme un DVD ou une clé USB, soit sont téléchargés depuis internet. Les premiers PC fournissaient les logiciels sur des disquettes, qui contenaient un programme d'installation pour enregistrer le programme sur le disque dur de l'ordinateur. Par la suite, le support des logiciels a migré vers les CD et DVD, les logiciels devenant de plus en plus gros. De nos jours, la majorité des applications sont téléchargées depuis le net, l'usage de périphériques est devenu obsolète, même les consoles de jeu abandonnent cette méthode de distribution.

==Les générations d'ordinateurs : un historique rapide==

L'informatique a beaucoup évolué dans le temps. Et une bonne partie de cette évolution tient à l'évolution de l’électronique sous-jacente. Les ordinateurs actuels sont fabriqués avec des transistors, des petits composants électroniques qui servent d'interrupteur programmables, qu'on détaillera dans ce qui suit. Mais ça n'a pas toujours été le cas. Et cela permet de distinguer plusieurs '''générations d'ordinateurs'''.

===Les ordinateurs électro-mécaniques : les premiers ordinateurs===

Le tout premier ordinateur est le '''Z1''', un modèle unique inventé par Konrad Suze entre 1936 et 1938. Son processeur gérait non pas des nombres entiers, mais des nombres à virgule (des nombres dits flottants, pour être précis), encodés sur 22 bits. Le processeur du Z1 était capable de faire des additions et des soustractions, car il intégrait un circuit additionneur-soustracteur basique. Des circuits annexes permettaient de faire des multiplications et des divisions en enchainant des additions/soustractions successives. Il fonctionnait à une fréquence de 1 Hz, ce qui fait qu'il pouvait faire une addition/soustraction par seconde maximum.

[[File:Blue-punch-card-front.png|vignette|upright=0.5|Carte Perforée.]]

Niveau mémoire, la RAM de l'ordinateur était très limitée : seulement 16 nombres de 22 bits chacun. S'il s'agissait d'une mémoire électronique, les programmes étaient mémorisés sur une mémoire mécanique. Les programmes étaient enregistrés sur des cartes perforées, à savoir des cartes en papier dans lesquelles un 1 est codé par un trou dans le papier et un 0 par une absence de trou. Les programmes étaient exécutés par l'ordinateur quand on insérait la carte perforée dans le lecteur et qu'on appuyait sur un bouton.

[[File:German Museum of Technology, Berlin 2017 024.jpg|centre|vignette|upright=2|Réplique du Z1 au ''German Museum of Technology'' de Berlin, 2017.]]

Après sa destruction dans un bombardement, le Z1 a été reconstruit et amélioré, ce qui donné les deux ordinateurs Z2 et Z3. Quelques années plus tard, de nombreux ordinateurs ont été construits dans des laboratoires de recherche. Des grandes noms de l'histoire de l'informatique datent de cette époque : le Harvard Mark I et le Colossus Mark 1 (UK) ont tous deux été mis en service en 1944, par exemple. Ils ont servis pour les cryptanalystes pour casser les codes utilisés par les allemands pour leurs transmissions, pendant la seconde guerre mondiale.

Les ordinateurs cités dans le précédent paragraphe étaient tous des ordinateurs dit '''électro-mécaniques''', car ils mélangeaient des composants électroniques et des composants mécaniques (tout ce qui a trait aux cartes perforées, notamment). Les composants électroniques étaient soit des relais, soit des tubes à vides, les deux étant des interrupteurs commandables électriquement plus ou moins équivalents aux transistors. Les ordinateurs d'avant l'année 1944, étaient tous de ce type. Quelques ordinateurs des années 50 étaient de ce type, mais leur nombre n'a pas dépassé 30. Il faut dire qu'ils ont rapidement laissé la place à des ordinateurs purement électroniques, que nous allons voir dans ce qui suit..

===La première génération : les tubes à vide===

Les ordinateurs qui ont suivi les ordinateurs électromécaniques sont regroupés dans la '''première génération d'ordinateur'''. Ils étaient conçus avec des tubes à vide, ce qui les place entre les premiers ordinateurs électro-mécaniques et les ordinateurs utilisant des transistors. Les tubes à vide étaient assez encombrants, ils consommaient beaucoup de courant, ils chauffaient et étaient assez peu fiables. Ils tombaient en panne assez souvent. Et ils étaient assez simple à fabriquer, mais restaient malgré tout chers.

[[File:Elektronenroehren-auswahl.jpg|centre|vignette|upright=2|Tubes à vides.]]

Au vu de de la taille des  tubes à vide, les ordinateurs de l'époque étaient composé de plusieurs milliers de ces tubes, guère plus. Et malgré cela, un ordinateur prenait facilement un étage de bâtiment entier, ou au moins plusieurs pièces. La conséquence est que les ordinateurs de première génération étaient très simples, rudimentaires quand on les compare aux ordinateurs modernes. Ils ne géraient que quelques opérations simples : l'addition, la soustraction, pas grand chose de plus. A quelques exceptions près, ils ne géraient pas la multiplication et encore moins la division, cela aurait demandé trop de tubes à vides.

Une des toutes premières machines construite avec des tubes à vide était l'Atanasoff–Berry. Ce n'était pas un ordinateur, car elle ne pouvait pas exécuter de programme sans intervention humaine pour séquencer des opérations, mais c'était la première machine de calcul purement électronique, sans aucune pièce mécanique. Elle utilisait une mémoire RAM construite avec des condensateurs, ceux-ci étant placés sur des cylindres tournants. Les circuits de calcul étaient construits avec des tubes à vide et faisaient leur travail un bit à la fois. Elle fonctionnait à une fréquence de 60 Hz et pouvait faire 30 additions/soustractions par seconde. Les nombres étaient encodés sur 50 bits. 

[[File:Atanasoff Berry Computer.gif|centre|vignette|upright=2.5|Atanasoff–Berry.]]

L'arrivée de l'ENIAC en 1945 a changé la donne. Cet ordinateur a introduit plusieurs innovations majeures. La première est assez technique, il s'agit de la turing-complétude, elle a trait aux programmes qui peuvent être écrit pour un ordinateur, nous ne la détaillerons pas ici.

En 1948, le ''Manchester Baby'' a introduit une innovation extrêmement importante, au point où on considère que c'est le premier ordinateur à avoir tous les critères nécessaires pour être appelé un ordinateur. Son innovation est que le programme n'était plus mémorisé sur des cartes perforée, mais dans une mémoire électronique dans l'ordinateur lui-même. En clair, le ''Manchester Baby'' était le premier '''''Stored-program computer''''', ordinateur à programme enregistré en français. 

Le Manchester Baby avait une RAM de 32 nombres de 32 bits, fabriquées avec des tubes Willimas (abordés dans une annexe à la fin du cours). Il gérait 8 instructions en tout, mais ne gérait pas l'addition. Il gérait la soustraction, des instructions de branchement et d'accès mémoire, mais rien d'autre. Il pouvait cependant émuler l'addition à partir d'une soustraction et inversant l'opérande soustraite.

===La seconde génération : le remplacement des tubes à vides par des transistors===

[[File:IBM 7070.jpg|vignette|Cartes imprimées de l'IBM 704, avec des transistors et résistances dessus.]]

La '''seconde génération''' est celle des ordinateurs fabriqués avec des '''transistors''' isolés, reliés entre avec des fils électriques. Les transistors en question possèdent trois broches, des pattes métalliques sur lesquelles on connecte des fils électriques. Le transistor s'utilise le plus souvent comme un interrupteur commandé par sa troisième broche. Le courant qui traverse les deux premières broches passe ou ne passe pas selon ce qu'on met sur la troisième.

[[File:Transistor basic flow.svg|centre|vignette|Un transistor est un morceau de conducteur, dont la conductivité est contrôlée par sa troisième broche/borne.]]

Les ordinateurs de seconde génération avaient entre 1000 et 500 000 transistors. Les capacités des ordinateurs étaient donc nettement supérieures à celles des ordinateurs de première génération. Une part non négligeable des ordinateurs de seconde génération supportait l'opération de multiplication, absente sur les ordinateurs de première génération. Néanmoins, cela variait beaucoup selon les ordinateurs.

Un exemple assez hors du commun est celui du premier modèle de l'IBM 1620. Le tout premier modèle n'avait aucun circuit de calcul, il n'était même pas capable de faire une addition ou une multiplication. A la place, il utilisait une table d'addition et une table de multiplication en mémoire RAM. Les deux tables devaient être initialisées par le logiciel lors du démarrage de la machine. La table d'addition faisait une centaine de chiffre, la table de multiplication faisait le double. Le processeur de l'ordinateur gérait des instructions pour faire des additions ou des multiplications, mais ces opérations lisaient le résultat dans la table d'addition. Les calculs étaient fait chiffre par chiffre, avec un encodage partiellement décimal, partiellement binaire (des chiffres décimaux étaient encodés en binaire, nous en reparlerons quand nous parlerons du BCD) !

[[File:KL CoreMemory.jpg|vignette|Mémoire à tore de ferrite.]]

Les transistors n'étaient utilisés que pour le processeur et les circuits annexes. La mémoire n'était pas faite en transistors, pas à cette époque. La mémoire était une mémoire aujourd'hui abandonnée, appelée une '''mémoire à tores de ferrite'''. Elle sera détaillée dans un chapitre ultérieur. Mais sachez pour le moment qu'il s'agit d'une mémoire au support magnétique, les données étant stockées sur un support magnétique.

Transistors comme tubes à vide prenaient beaucoup de place, ce qui fait que les ordinateurs étaient assez gros. Concrètement, ils prenaient une pièce de bâtiment entière dans le meilleur des cas. C'était l'époque des gros ''mainframes'', reliés à des terminaux, peu puissants comparé aux standards actuels. Seules les grandes entreprises et les grands instituts de recherche pouvaient se payer les services de ce genre d'ordinateurs. Seuls les professionnels avaient accès à ce genre d'équipement.

===La troisième génération : le circuit intégré===

[[File:D8259AC-2.jpg|vignette|Exemple de circuit intégré.]]

La troisième génération est toujours fabriquée avec des transistors, mais dont la taille a été réduite. Avec l'évolution de la technologie, les transistors ont diminué en taille, de plus en plus. Ils sont devenus tellement petits qu'ils ont finit par être regroupés dans des '''circuits intégrés''', des circuits regroupent plusieurs transistors sur la même puce de silicium. Les circuits intégrés se présentent le plus souvent sous la forme de boitiers rectangulaires, comme illustré ci-contre. D'autres ont des boitiers de forme carrées, comme ceux que l'on peut trouver sur les barrettes de mémoire RAM, ou à l'intérieur des clés USB/ disques SSD.

Lors de cette génération, les processeurs étaient fournis en pièces détachées qu'il fallait relier entre elles. Le processeur était composé de plusieurs circuits intégrés séparés, impossible de mettre un processeur dans un seul boitier. Un exemple de processeur conçu en kit est la série des Intel 3000. Elle regroupe plusieurs circuits séparés aux noms à coucher dehors, mais dont vous comprendrez ce qu'ils veulent dire dans les chapitres adéquats : l'Intel 3001 est un séquenceur, l'Intel 3002 regroupe unité de calcul et registres, le 3003 est un circuit d'anticipation de retenue complémentaire du 3002, le 3212 est une mémoire tampon, le 3214 est une unité de gestion des interruptions, les 3216/3226 sont des interfaces de bus mémoire. On pourrait aussi citer la famille de circuits intégrés AMD Am2900.

Même si le processeur était en pièce détachées, utiliser une dizaine de circuits intégrés était nettement mieux que d'utiliser plusieurs milliers de transistors individuels. En conséquence, les ordinateurs ont vu leur taille grandement réduite, passant de pièces entières à une simple armoire, voire à quelques cartes intégrées superposées. De plus, le prix des circuits intégré était abordable, du moins comparé aux ordinateurs d'avant. Le prix des ordinateurs a alors grandement décru, permettant à des entreprises et administrations de taille modeste de s'équiper d'ordinateurs.

===La quatrième génération : le microprocesseur===

[[File:MOS6502.svg|vignette|Microprocesseur, ici un processeur MOS6502, de la quatrième génération.]]

Lors de la troisième génération, les circuits intégrés regroupaient plusieurs dizaines ou centaines de transistors, mais sont rapidement montés en gamme. De centaines de transistors, ils sont passé au milliers de transistors, puis au millions et maintenant au-delà du milliard. Les transistors étaient devenus tellement petits, tellement miniaturisés, qu'il était devenu possible de mettre un processeur entier dans un circuit intégré. C'est ainsi qu'est né le microprocesseur, à savoir un processeur qui tient tout entier dans un seul circuit imprimé. La quatrième génération d’ordinateur est celle des ordinateurs basés autour d'un microprocesseur.

Les tout premiers microprocesseurs étaient des processeurs à application militaire, comme le processeur du F-14 CADC ou celui de l'Air data computer. Le tout premier microprocesseur commercialisé au grand public est le 4004 d'Intel, sorti en 1971. L'intel 4004 comprenait environ 2300 transistors, avait une fréquence de 740 MHz, pouvait faire 46 opérations différentes, et manipulait des entiers de 4 bits. Il était au départ un processeur de commande, prévu pour être intégré dans la calculatrice Busicom calculator 141-P, mais il fut utilisé pour d'autres applications quelque temps plus tard. Immédiatement après le 4004, les premiers microprocesseurs 8 bits furent commercialisés. Le 4004 fut suivi par le 8008 et quelques autres processeurs 8 bits extrêmement connus, comme le 8080 d'Intel, le 68000 de Motorola, le 6502 ou le Z80.

Les microprocesseurs permirent encore uen fois de réduire la taille des ordinateurs, qui pouvaient tenir dans un boitier de PC, ou un boitier de console de jeu. Le prix des ordinateurs a aussi chuté en même temps que les transistors était miniaturisés. C'est cette invention qui permis l'invention des consoles de jeux et des mini-ordinateurs, à savoir les ordinateurs personnels. Sans miniaturisation, on n'aurait pas d'ordinateur personnel, pas de PC fixe ou portable.

==L'organisation du cours : les différents niveaux d'explication==

Le fonctionnement d'un ordinateur est assez complexe à expliquer car les explications peuvent se faire sur plusieurs niveaux. Par plusieurs niveaux, on veut dire qu'un ordinateur est composé de composants très simples, qui sont assemblés pour donner des composants eux-même plus complexes, qui sont eux-même regrouper, etc. Étudier tout cela demande de voir plusieurs niveaux, allant de transistors très petits à des processeurs multicœurs. Les niveaux les plus bas sont de l'électronique pur et dure, alors que ceux plus haut sont à mi-chemin entre électronique et informatique.

===Les niveaux d'abstraction en architecture des ordinateurs===

Les trois premiers niveaux sont de l'électronique pur et dure. Ils correspondent aux premiers chapitres du cours, qui porteront sur les circuits électroniques en général.
* Le premier niveau est celui des '''transistors''', des circuits intégrés, des ''wafer'' et autres circuits de très petite taille.
* Le second niveau est celui des '''portes logiques''', des circuits très basiques, très simples, à la base de tous les autres.
* Le troisième niveau est celui dit de la '''''Register Transfer Level''''', où un circuit électronique est construit à partir de circuits basiques, dont des registres et autres circuits dits combinatoires.
Les deux niveaux suivants sont de l'informatique proprement dit. C'est dans ces deux niveaux qu'on étudie les ordinateurs proprement dit, les circuits qu'il y a dedans et non l'électronique en général.
* Le quatrième niveau est celui de la '''microarchitecture''', qui étudie ce qu'il y a à l'intérieur d'un processeur, d'une mémoire, des périphériques et autres.
* Le cinquième niveau est celui de l''''architecture externe''', qui décrit l'interface du processeur, de la mémoire, d'un périphérique ou autre. Par décrire l'interface, on veut dire : comment un programmeur voit le processeur et la mémoire, comment il peut les manipuler. Une architecture externe unique peut avoir plusieurs microarchitecture, ce qui fait qu'on sépare les deux. Tout cela sera plus clair quand on passera aux chapitres sur le processeur et les mémoires.

Nous n'allons pas voir les 5 niveaux dans l'ordre, des transistors vers l'architecture externe. En réalité, nous allons procéder autrement. La première partie du cours portera sur les trois premiers niveaux, le reste sur les deux autres. Les 5 niveaux seront vus dans des chapitres séparés, du moins le plus possible. Au niveau pédagogique, tout est plus simple si on scinde les 5 niveaux. Bien sûr, il y a quelques explications qui demandent de voir plusieurs niveaux à la fois. Par exemple, dans le chapitre sur les mémoires caches, nous auront des explications portant sur la RTL, la microarchitecture du cache et son architecture externe. Mais le gros du cours tentera de séparer le plus possible les 5 niveaux.

===Les trois parties principales du cours===

Nous allons commencer par parler du binaire, avant de voir les portes logiques. Avec ces portes logiques, nous allons voir comment fabriquer des circuits basiques qui reviendront très souvent dans la suite du cours. Nous verrons les registres, les décodeurs, les additionneurs et plein d'autres circuits. Puis, nous reviendrons au niveau des transistors pour finir la première partie. La raison est que c'est plus simple de faire comme cela. Tout ce qui a trait aux transistors sert à expliquer comment fabriquer des portes logiques, et il faut expliquer les portes logiques pour voir le niveau de la RTL.

Une fois la première partie finie, nous allons voir les différents composants d'un ordinateur. Une première partie expliquera ce qu'il y a dans un ordinateur, quels sont ses composants. Nous y parlerons de l'architecture de base, de la hiérarchie mémoire, des tendances technologiques, et d'autres généralités qui serviront de base pour la suite. Puis, nous verrons dans l'ordre les bus électroniques, les mémoires RAM/ROM, le processeur, les périphériques, les mémoires de stockage (SSD et disques durs) et les mémoires caches. Pour chaque composant, nous allons voir leur architecture externe, avant de voir leur microarchitecture. La raison est que la microarchitecture ne peut se comprendre que quand on sait quelle architecture externe elle implémente.

Enfin, dans une troisième partie, nous allons voir les optimisations majeures présentes dans tous les ordinateurs modernes, avec une partie sur le pipeline et le parallélisme d'instruction, et une autre sur les architectures parallèles. Pour finir, les annexes de fin parlerons de sujets un peu à part.

&lt;noinclude&gt;
{{NavChapitre | book=Fonctionnement d'un ordinateur
           | next=L'encodage des données
           | nextText=L'encodage des données
}}
&lt;/noinclude&gt;</text>
      <sha1>3c5ofvrq7d5mfb97yd36p51bm44p7nv</sha1>
    </revision>
    <revision>
      <id>744121</id>
      <parentid>744120</parentid>
      <timestamp>2025-06-04T23:57:17Z</timestamp>
      <contributor>
        <username>Mewtow</username>
        <id>31375</id>
      </contributor>
      <minor />
      <comment>/* La première génération : les tubes à vide */</comment>
      <origin>744121</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="43863" sha1="tbu1fpun59u3h23rh9axdur57hyor1f" xml:space="preserve">Pour commencer, nous allons voir qu'il existe de nombreux types d'ordinateurs. Le plus connu est certainement le PC, l'ordinateur personnel, que vous avez sans doute dans votre salon. Les ordinateurs portables sont un deuxième type d'ordinateur assez intuitif, que vous avez peut-être. Mais il y a aussi d'autres types d'ordinateurs auxquels vous n'avez jamais été confrontés.

==Les différents types d'ordinateurs==

Dans cette section, nous allons décrire rapidement les ordinateurs les plus courant, mais surtout voir ce qu'il y a à l'intérieur d'un ordinateur.

===L'ordinateur de type PC fixe===

De l'extérieur, l'ordinateur est composé d'une unité centrale sur laquelle on branche des périphériques.

[[File:Typical computer architecture systems.jpg|vignette|upright=1.5|Exemples de périphériques, connectés à une unité centrale (ici appelée à tort ''operating system'').]]

Les '''périphériques''' regroupent l'écran, la souris, le clavier, l'imprimante, et bien d'autres choses. Ils permettent à l'utilisateur d'interagir avec l'ordinateur : un clavier permet de saisir du texte sous dans un fichier, une souris enregistre des déplacements de la main en déplacement du curseur, un écran affiche des données d’images/vidéos, un haut-parleur émet du son, etc. Tout ce qui est branché sur un ordinateur est, formellement un périphérique.

L''''unité centrale''' est là où se trouvent tous les composants importants d'un ordinateur, ceux qui font des calculs, qui exécutent des logiciels, qui mémorisent vos données, etc. Voici ce à quoi ressemble l'intérieur de l'unité centrale. Trois sections sont visibles : l'alimentation électrique en haut à gauche, la carte mère en bas à gauche et en jaune/orange, les disques et lecteurs à droite des câbles. Et on voit aussi beaucoup de câbles.

[[File:Asus P5K-SEIntel E6320.jpg|centre|vignette|upright=2|Exemple d'unité centrale.]]

Tout en haut à gauche, se trouve l''''alimentation électrique''', qui convertit le courant de la prise électrique en un courant plus faible, utilisable par les autres composants. Elle émet de nombreux câbles assez gros, qui sont reliés au reste. Les PC actuels utilisent des alimentations électriques standardisées, qui fournissent trois tensions au reste de l'ordinateur : une tension de 12 Volts, une de 5 Volts, une de 3,3 Volts.

À droite, caché par la partie &quot;métallique&quot; du boitier, se trouvent les lecteurs de CD/DVD, et les disques durs. Les lecteurs CD-ROM ou DVD-ROM permettaient de lire des CD ou des DVD. Je parle au passé, car ils ont aujourd'hui disparu des ordinateurs modernes. Les '''disques durs''' sont des mémoires de stockage, qui mémorisent vos données de manière permanente. De nos jours, ils sont remplacés par des SSD, qui sont des disques durs électroniques, là où les disques durs proprement dit sont des mémoires magnétiques. Nous verrons la différence dans deux chapitres dédiés, un sur les disques durs, l'autre sur les SSD.

En bas à droite, se trouve la '''carte mère''' un support plat, en plastique ou en céramique, sur laquelle sont soudés/connectés les autres composants. Sur celle-ci, de nombreux composants sont soudés, d'autres sont branchés dessus avec des câbles, d'autres sont connectés dessus avec des connecteurs. Ils sont reliés entre eux par des fils conducteurs, le plus souvent du cuivre ou de l’aluminium, ce qui leur permet de s’échanger des données. Sur les cartes simples, ces fils sont intégrés dans la carte électronique, dans des creux du plastique. Ils portent le nom de pistes.

Avant, les disques durs, SSD et lecteurs de CD/DVD sont branchés dessus via des connecteurs dédiés, appelés des connecteurs S-ATA. De nos jours, ils sont branchés sur un autre connecteur, grâce à l'interface NVME. Toujours est-il qu'ils sont reliés à la carte mère par des câbles, ce qui montre que ce sont des sortes de périphériques interne. Ils sont placés dans le boitier, mais on aurait tout aussi bien pu les mettre à l'extérieur, vu qu'ils communiquent avec l'ordinateur par l'intermédiaire d'un câble ou d'un connecteur dédié.

Mais deux autres composants très importants sont eux placés sur la carte mère, directement. Ils ont chacun un connecteur dédié, sur lequel ils sont branchés directement, sans passer par l'intermédiaire d'un câble, mais sans être soudés non plus. Il s'agit du processeur et de la mémoire RAM, deux composants centraux des PC modernes.

[[File:Pentium III SL4CB.jpg|thumb|Processeur Pentium III.]]

Le '''processeur''' traite les données, les modifie, les manipule. Pour faire simple, il s’agit d’une grosse calculatrice hyper-puissante. Il comprend à la fois un circuit qui fait des calculs, et un circuit de contrôle qui s'occupe de séquencer les calculs dans l'ordre demandé. Il est souvent caché sous un radiateur, lui-même surmonté par un ventilateur. En effet, un processeur chauffe beaucoup, ce qui demande d'évacuer cette chaleur. Un chapitre entier expliquera pourquoi les processeurs chauffent, ainsi que les techniques utilisées pour limiter leur production de chaleur et leur consommation électrique.

La '''mémoire vive''' conserve des informations/données temporairement, tant que le processeur en a besoin. Elle prend la forme de barrettes de RAM, comme montré ci-dessous.

[[File:2 gb ddr2 667.jpg|centre|vignette|upright=2|Barrette de RAM.]]

Outre ces composants dits principaux, un ordinateur peut comprendre plusieurs composants moins importants, surtout présents sur les ordinateurs personnels. Ils sont techniquement facultatifs, mais sont très présents dans les ordinateurs personnels. Cependant, certains ordinateurs spécialisés s'en passent. Il s'agit des diverses '''cartes d'extension''' sont branchées sur la carte mère. Elles permettent d’accélérer certains calculs ou certaines applications, afin de décharger le processeur. Par exemple, la carte graphique s'occupe des calculs graphiques, qu'il s'agisse de graphismes 3D de jeux vidéos ou de l'affichage en 2D du bureau. Dans un autre registre, la carte son prend en charge le microphone et les haut-parleurs.

[[Fichier:Personal computer, exploded 4.svg|thumb|upright=1.0|Éclaté d'un ordinateur de type PC :&lt;br /&gt;
1 : Écran ;&lt;br /&gt;
2 : Carte mère ;&lt;br /&gt;
3 : Processeur ;&lt;br /&gt;
4 : Câble Parallel ATA ;&lt;br /&gt;
5 : Mémoire vive (RAM) ;&lt;br /&gt;
6 : Carte d'extension ;&lt;br /&gt;
7 : Alimentation électrique ;&lt;br /&gt;
8 : Lecteur de disque optique ;&lt;br /&gt;
9 : Disque dur ;&lt;br /&gt;
10 : Clavier ;&lt;br /&gt;
11 : Souris.]]

Si on regarde une carte mère de face, on voit un grand nombre de connecteurs, mais aussi des circuits électroniques soudés à la carte mère.

[[File:Architecture matérielle d'une carte mère.png|centre|vignette|upright=2.0|Architecture matérielle d'une carte mère]]

Les '''connecteurs''' sont là où on branche les périphériques, la carte graphique, le processeur, la mémoire, etc. Dans l'ensemble, toute carte mère contient les connecteurs suivants :
* Le processeur vient s’enchâsser dans la carte mère sur un connecteur particulier : le '''socket'''. Celui-ci varie suivant la carte mère et le processeur, ce qui est source d'incompatibilités.
* Les barrettes de mémoire RAM s’enchâssent dans un autre type de connecteurs: les '''slots mémoire'''.
* Les mémoires de masse disposent de leurs propres connecteurs : connecteurs P-ATA pour les anciens disques durs, et S-ATA pour les récents.
* Les périphériques (clavier, souris, USB, Firewire, ...) sont connectés sur un ensemble de connecteurs dédiés, localisés à l'arrière du boitier de l'unité centrale. 
* Les autres périphériques sont placés dans l'unité centrale et sont connectés via des connecteurs spécialisés. Ces périphériques sont des cartes imprimées, d'où leur nom de '''cartes filles'''. On peut notamment citer les cartes réseau, les cartes son, ou les cartes vidéo.

===Les ordinateurs portables===

[[File:Samsung QX-511 (2).JPG|vignette|Ordinateur portable Samsung QX-511 (2), pour illustration.]]

Un ordinateur portable est identique à un ordinateur de type PC. Si vous ouvrez votre ordinateur portable (attention à la garantie), vous retrouverez les mêmes composants qu'un PC à l'intérieur. Un point important est la présence d'une batterie à l'intérieur du PC portable, absente des PC fixes.

[[File:LG gram 14Z90Q mainboard with battery.jpg|centre|vignette|upright=2|LG gram 14Z90Q avec sa batterie.]]

Une fois la batterie et les circuits associés retiré, la seule différence notable est que tous les composants sont soudés sur la carte mère, au lieu d'être branchés sur des connecteurs, à part éventuellement la RAM et le disque dur.

[[File:LG gram 14Z90Q mainboard without battery.jpg|centre|vignette|upright=2|LG gram 14Z90Q sans sa batterie.]]

La RAM est parfois soudée sur la carte mère, d'autres fois sous la forme de barrettes de mémoire vive semblables à celles des PC. Dans le dernier cas, elle est connectée à des connecteurs spécifiques, ce qui permet de les changer/upgrader. Les PC portables sont parfois construits de manière à pouvoir changer la RAM facilement, en ouvrant un cache spécial, concu pour.

[[File:Lenovo G555 состав - Донор.JPG|centre|vignette|upright=2|Lenovo G555.]]

La conception d'un ordinateur portable est légèrement différente de celle d'un PC, pour des raisons thermiques. Un PC fixe a plus de place pour évacuer sa chaleur. Les ventilateurs peuvent plus facilement déplacer l'air dans le boitier, même si le flux d'air dans le boitier est éventuellement gêné par la carte graphique. Mais l'évacuation de la chaleur est assez efficace. Sur les PC portables, leur finesse fait que le trajet de l'air est beaucoup plus contraint. Évacuer la chaleur produite par l'ordinateur est plus complexe, ce qui demande d'utiliser des systèmes de refroidissement et de ventilation spécifiques.

Là où les PC fixes se débrouillent avec des radiateurs et des ventilateurs posés sur le processeur, les PC portables font autrement. Ils ne peuvent pas forcément mettre le ventilateur sur le processeur. A la place, ils mettent le ventilateur à côté, mais le processeur est surmonté par un mécanisme de transmission de la chaleur, qui transfère la chaleur du processeur vers le ventilateur.

[[File:Diagram - How a laptop cooling system works.png|centre|vignette|upright=2|Comment fonctionne le système de ventilation d'un ordinateur portable, en anglais.]]

Les difficultés pour dissiper la chaleur font que les ordinateurs portables utilisent souvent des composants peu performants, mais qui chauffent peu. En effet, nous verrons que plus un composant est puissant, plus il chauffe. La relation n'est pas parfaite, mais les processeurs haute performance chauffent plus que les modèles d'entrée ou milieu de gamme moins puissants. En conséquence, les PC portables sont souvent moins puissants que les PC fixes, même pour les modèles dit ''gaming''.

===Les serveurs et ''mainframes''===

Les grandes entreprises utilisent des ordinateurs de grande taille, très puissants, appelés des ''mainframes''. Ils sont souvent confondus avec les serveurs par le grand public, il y a une différence entre les deux. Un serveur est une fonction logicielle/réseau, pas un type d'ordinateur. Mais laissons cette différence de côté, ce qui est dit pour les ''mainframes'' sert pour les gros serveurs haute performance.

[[File:IBM Z15 mainframe.jpg|vignette|Exemple de ''mainframe''' de type IBM Z15.]]

Les anciens ''mainframes'' des années 50-80 avaient une taille pouvant être impressionnante, au point de prendre une pièce complète d'un bâtiment. Mais de nos jours, les ''mainframes'' tiennent dans une grosse armoire un peu haute. Les ''mainframes'' doivent rester allumé en permanence et ne doivent pas être éteint, sauf éventuellement quelques jours par an pour des opérations de maintenance. Ils utilisent pour cela des techniques spécifiques, avec beaucoup de redondance interne.

[[File:ACONIT hall grandes machines.jpg|centre|vignette|upright=2|''Mainframe'' ACONIT.]]

Les ''mainframes'' sont aussi conçus pour mutualiser au maximum leur utilisation, ils peuvent être utilisés par plusieurs utilisateurs à la suite, voire en même temps. Pour cela, les anciens ''mainframes'' étaient capables de faire tourner plusieurs applications distinctes l'une à la suite de l'autre, avec des commutations fréquentes entre logiciels. De nos jours, ils sont capables d'exécuter un grand nombre de tâches en même temps, grâce à la présence de plusieurs processeurs. Les ''mainframes'' modernes sont même capables de faire tourner plusieurs systèmes d'exploitation en même temps si besoin.

Les anciens ''mainframes'' étaient des ordinateurs assez simples, avec un processeur, de la mémoire RAM, un ou plusieurs disques durs, pas plus. Le ''mainframe'' était tellement énorme et cher que les entreprises n'en avaient qu'un seul pour toute l'entreprise. Les employés avaient sur leur bureau des terminaux, qui permettaient d'accéder à l'ordinateur central, mais n'étaient pas des ordinateurs. Les terminaux étaient des composants électroniques simples, avec un écran, un clavier et une souris, mais sans processeur. Ils envoyaient des données au ''mainframe'', ils en recevaient de sa part, mais tout traitement était réalisé sur le ''mainframe''. L'arrivée sur le marché des ordinateurs personnels, de type PC fixe/portable, a entrainé l'abandon de ce genre de pratique, tous les employés ont maintenant un ordinateur rien que pour eux.

{|
|-
! colspan=&quot;2&quot; | Exemples de terminaux
|-
|[[File:Terminal-in2-sm9400.jpg|centre|vignette|upright=1.5|Exemple de terminal. Notez la présence d'un écran et d'un clavier, mais l'asbence d'une unité centrale.]]
|[[File:Chromatics CT4100.jpg|vignette|upright=1.5|Autre exemple de terminal. Le clavier est couplé à un stylo CRT, qui remplacait la souris et agissait sur l'écran comme s'il était tactile.]]
|-
! colspan=&quot;2&quot; | Intérieur d'un terminal
|-
|[[File:CT1024 Monitor.jpg|vignette|upright=1.5|Terminal CT1024, sans le boitier extérieur.]]
|[[File:CT1024 Terminal System.jpg|vignette|upright=1.5|Terminal CT1024, description des composants interne.]]
|}

De nos jours, les ''mainframes'' contiennent en réalité plusieurs ordinateurs simples interconnectés via un réseau local. Un ''mainframe'' qui tient dans une armoire contient facilement une dizaine ou centaine de processeurs, plein de RAM, des disques durs séparés dans une armoire distincte, etc. Vu qu'ils communiquent uniquement via le réseau, ils n'ont pas d'interface, pas d'écran, 'entrée via clavier/souris. Le tout est commandé avec une console de commande, typiquement un ordinateur portable ou un terminal assez simple séparé de l'armoire, qui permet à un administrateur de faire des opérations de surveillance, configuration et maintenance. Il peut y avoir une console de commande pour plusieurs armoires séparées, la console peut même être dans un autre bâtiment et accéder au ''mainframe'' par le réseau.

[[File:IBM System Z9 (type 2094 inside).jpg|centre|vignette|upright=2|''Mainframe'' de type IBM System Z9. L'ordinateur portable sert de console pour qu'un administrateur fasse des opérations de surveillance, configuration et maintenance.]]

Les processeurs et la RAM sont typiquement installés sur des cartes amovibles, qui sont connectées au fond de l'armoire lors de l'installation. Il est même possible de retirer ou d'ajouter des cartes en fonctionnement, afin d'ajouter/retirer des processeurs, des disques durs, etc. Ce qui est très utile si un composant est en panne et qu'il faut le remplacer. 

[[File:IBM TotalStorage Exp400.jpg|centre|vignette|upright=2|IBM TotalStorage Exp400]]

==Un peu d'abstraction : qu'est-ce qu'un ordinateur ?==

Un ordinateur comprend donc un processeur, plusieurs mémoires, des cartes d'extension et une carte mère pour connecter le tout. Mais il s'agit là d'une description assez terre-à-terre de ce qu'est un ordinateur. Une autre description, plus abstraite, se base sur le fait qu'un ordinateur est une énorme calculatrice programmable. Elle permet d'expliquer pourquoi il y a une distinction entre processeur et mémoire, entre unité centrale et périphériques. Tout ce qui va suivre pourra vous paraitre assez abstrait, mais rassurez-vous : les prochains chapitres rendront tout cela plus concrets.

===La séparation entre entrées-sorties et traitement===

L'unité centrale peut être vue comme une énorme calculatrice ultra-puissante, qui exécute des commandes/opérations. Mais à elle seule, elle ne servirait à rien, il faut interagir avec par l'intermédiaire de plusieurs périphériques. Il existe deux types de périphériques, qui sont conceptuellement différents. Les périphériques comme le clavier ou la souris permettent d'envoyer des informations à l'ordinateur, d'agir sur celui-ci. A l'inverse, les écrans transmettent des informations dans le sens inverse : de l'ordinateur vers l'utilisateur. Les premiers sont appelés des '''entrées''', les seconds des '''sorties'''.

Dans un ordinateur, les informations sont représentées sous la forme de nombres. Toute donnée dans un ordinateur est codée avec un ou plusieurs nombres regroupés dans une donnée, un fichier, ou autre. Et la transmissions avec les entrées et sorties se fait là-encore avec des nombres. Par exemple, quand vous appuyez sur votre clavier, le clavier envoie un numéro de touche à l'unité centrale, qui indique quelle touche a été appuyée. L'image à afficher à l'écran est codée sous la forme d'une suite de nombres (un par pixel). L'image est envoyée à l'écran, qui traduit la suite de nombre en image à afficher. Les entrées traduisent des actions utilisateurs en nombres, on dit que les entrées encodent les actions utilisateur. Les sorties font la traduction inverse, elles transforment des suites de nombres en une action physique. On dit qu'elles décodent des informations.

Pour résumer, toute appareil électronique est composé par :
* Des '''entrées''' sur lesquelles l'utilisateur agit sur l'ordinateur. Les entrées transforment les actions de l'utilisateur en nombres, qui sont interprétés par l'ordinateur.
* Une '''unité de traitement''', qui manipule des nombres et fait des calculs/opérations dessus. Les nombres proviennent des entrées, du disque dur, ou d'autres sources, peu importe.
* Des '''sorties''', qui va récupèrent le résultat calculé par l'unité de traitement pour en faire quelque chose : écrire sur une imprimante ou sur un moniteur, émettre du son,...

[[File:Ordinateur théorique Simple 1.png|centre|vignette|upright=2|Ordinateur théorique Simple 1]]

L'unité de traitement proprement dite, celle qui fait les calculs, est couplée à une mémoire qui mémorise les opérandes et résultats des calculs. La séparation entre processeur et mémoire est nécessaire pour qu'un appareil électronique soit qualifié d'ordinateur. De nombreux appareils n'ont pas de séparation entre unité de traitement et mémoire, comme certaines vielles radios AM/FM.

[[File:Schéma de principe d'un ordinateur.png|centre|vignette|upright=2|Schéma de principe d'un ordinateur]]

===Un ordinateur est un appareil programmable===

Les appareils simples sont non-programmables, ce qui veut dire qu’ils sont conçus pour une utilisation particulière et qu’ils ne peuvent pas faire autre chose. Par exemple, les circuits électroniques d’un lecteur de DVD ne peuvent pas être transformé en lecteur audio ou en console de jeux... Les circuits non-programmables sont câblés une bonne fois pour toute, et on ne peut pas les modifier. On peut parfois reconfigurer le circuit, pour faire varier certains paramètres, via des interrupteurs ou des boutons, mais cela s’arrête là. Et cela pose un problème : à chaque problème qu'on veut résoudre en utilisant un automate, on doit recréer un nouveau circuit.

À l'inverse, un ordinateur n’est pas conçu pour une utilisation particulière, contrairement aux autres objets techniques. Il est possible de modifier leur fonction du jour au lendemain, on peut lui faire faire ce qu’on veut. On dit qu'ils sont '''programmables'''. Pour cela, il suffit d’utiliser un logiciel, une application, un programme (ces termes sont synonymes), qui fait ce que l'on souhaite. La totalité des logiciels présents sur un ordinateur sont des programmes comme les autres, même le système d'exploitation (Windows, Linux, ...) ne fait pas exception.

Un programme est une suite de d'instructions, chaque instruction effectuant une action dans l'ordinateur. Sur les ordinateurs modernes, la majorité de ces instructions effectuent une opération arithmétique, comme une addition, une multiplication, une soustraction, etc. Les ordinateurs modernes sont donc de grosses calculettes très puissantes, capables d'effectuer des millions d'opérations par secondes. Et qui dit opération dit nombres : un ordinateur gère nativement des nombres, qui sont codés en binaire sur la quasi-totalité des ordinateurs modernes.

Une instruction est représentée dans un ordinateur par une série de nombres : un nombre qui indique quelle opération/commande effectuer et des autres nombres pour coder les données (ou de quoi les retrouver dans l'ordinateur). L'ordinateur récupére les commandes une par une, les traduit en opération à effectuer, exécuter l'opération, et enregistre le résultat. Puis il recommence avec la commande suivante.

[[File:Ordinateur Théorique Complexe 1.png|centre|vignette|upright=3|Ordinateur Théorique Complexe. En jaune, le programme informatique, la liste de commande. Le rectangle gris est l'ordinateur proprement dit.]]

De nombreux appareils sont programmables, mais tous ne sont pas des ordinateurs. Par exemple, certains circuits programmables nommés FPGA n'en sont pas. Pour être qualifié d'ordinateur, un appareil programmable doit avoir un processeur séparé de la mémoire. De plus, il doit utiliser un '''codage numérique''', chose que nous allons aborder dans le chapitre suivant.

===Les ordinateurs à programme mémorisé ou programme externe===

Au tout début de l'informatique, on utilisait des cartes perforées en plastique, sur lesquelles on inscrivait le programme à exécuter, les données à traiter, bref : tout ce qu'on donnait à manger à l'ordinateur. Par la suite, les premiers ordinateurs grand public, comme les Amstrad ou les Commodore, utilisaient des cassettes audio magnétiques pour stocker les programmes. Dans le même style, les consoles de jeu utilisaient autrefois des cartouches de jeu, qui contenaient le programme du jeu à exécuter. Pour résumer, les anciens ordinateurs mémorisaient les programmes sur un support externe, lu par un périphérique. De tels ordinateurs sont dits à '''programme externe'''.

: D’anciens ordinateurs personnels, comme l’Amstrad ou le Commodore, permettaient de taper les programmes à exécuter à la main, au clavier, avant d’appuyer une touche pour les exécuter. Nul besoin de vous dire que les cassettes audio étaient plus pratiques.

Mais de nos jours, les programmes sont enregistrés sur le disque dur de l'ordinateur ou dans une mémoire intégrée à l'ordinateur. On dit qu'ils sont installés, ce qui est un mot bien compliqué pour dire que le programme est enregistré sur le disque dur de l’ordinateur. A défaut de disque dur, le programme/logiciel est enregistré dans une mémoire spécialisée pour le stockage. Par exemple, sur les cartes électroniques grand public de marque Arduino, les programmes sont envoyés à la carte via le port USB, mais les programmes sont enregistrés dans la carte Arduino, dans une mémoire FLASH dédiée. Disque dur ou non, le programme est mémorisé dans la mémoire de l'ordinateur. Il est possible d'installer ou de désinstaller les programmes en modifiant le contenu de la mémoire. Le terme utilisé est alors celui de '''programme stocké en mémoire'''.

Les programmes à installer sont disponibles soit sur un périphérique, comme un DVD ou une clé USB, soit sont téléchargés depuis internet. Les premiers PC fournissaient les logiciels sur des disquettes, qui contenaient un programme d'installation pour enregistrer le programme sur le disque dur de l'ordinateur. Par la suite, le support des logiciels a migré vers les CD et DVD, les logiciels devenant de plus en plus gros. De nos jours, la majorité des applications sont téléchargées depuis le net, l'usage de périphériques est devenu obsolète, même les consoles de jeu abandonnent cette méthode de distribution.

==Les générations d'ordinateurs : un historique rapide==

L'informatique a beaucoup évolué dans le temps. Et une bonne partie de cette évolution tient à l'évolution de l’électronique sous-jacente. Les ordinateurs actuels sont fabriqués avec des transistors, des petits composants électroniques qui servent d'interrupteur programmables, qu'on détaillera dans ce qui suit. Mais ça n'a pas toujours été le cas. Et cela permet de distinguer plusieurs '''générations d'ordinateurs'''.

===Les ordinateurs électro-mécaniques : les premiers ordinateurs===

Le tout premier ordinateur est le '''Z1''', un modèle unique inventé par Konrad Suze entre 1936 et 1938. Son processeur gérait non pas des nombres entiers, mais des nombres à virgule (des nombres dits flottants, pour être précis), encodés sur 22 bits. Le processeur du Z1 était capable de faire des additions et des soustractions, car il intégrait un circuit additionneur-soustracteur basique. Des circuits annexes permettaient de faire des multiplications et des divisions en enchainant des additions/soustractions successives. Il fonctionnait à une fréquence de 1 Hz, ce qui fait qu'il pouvait faire une addition/soustraction par seconde maximum.

[[File:Blue-punch-card-front.png|vignette|upright=0.5|Carte Perforée.]]

Niveau mémoire, la RAM de l'ordinateur était très limitée : seulement 16 nombres de 22 bits chacun. S'il s'agissait d'une mémoire électronique, les programmes étaient mémorisés sur une mémoire mécanique. Les programmes étaient enregistrés sur des cartes perforées, à savoir des cartes en papier dans lesquelles un 1 est codé par un trou dans le papier et un 0 par une absence de trou. Les programmes étaient exécutés par l'ordinateur quand on insérait la carte perforée dans le lecteur et qu'on appuyait sur un bouton.

[[File:German Museum of Technology, Berlin 2017 024.jpg|centre|vignette|upright=2|Réplique du Z1 au ''German Museum of Technology'' de Berlin, 2017.]]

Après sa destruction dans un bombardement, le Z1 a été reconstruit et amélioré, ce qui donné les deux ordinateurs Z2 et Z3. Quelques années plus tard, de nombreux ordinateurs ont été construits dans des laboratoires de recherche. Des grandes noms de l'histoire de l'informatique datent de cette époque : le Harvard Mark I et le Colossus Mark 1 (UK) ont tous deux été mis en service en 1944, par exemple. Ils ont servis pour les cryptanalystes pour casser les codes utilisés par les allemands pour leurs transmissions, pendant la seconde guerre mondiale.

Les ordinateurs cités dans le précédent paragraphe étaient tous des ordinateurs dit '''électro-mécaniques''', car ils mélangeaient des composants électroniques et des composants mécaniques (tout ce qui a trait aux cartes perforées, notamment). Les composants électroniques étaient soit des relais, soit des tubes à vides, les deux étant des interrupteurs commandables électriquement plus ou moins équivalents aux transistors. Les ordinateurs d'avant l'année 1944, étaient tous de ce type. Quelques ordinateurs des années 50 étaient de ce type, mais leur nombre n'a pas dépassé 30. Il faut dire qu'ils ont rapidement laissé la place à des ordinateurs purement électroniques, que nous allons voir dans ce qui suit..

===La première génération : les tubes à vide===

Les ordinateurs qui ont suivi les ordinateurs électromécaniques sont regroupés dans la '''première génération d'ordinateur'''. Ils étaient conçus avec des tubes à vide, ce qui les place entre les premiers ordinateurs électro-mécaniques et les ordinateurs utilisant des transistors. Les tubes à vide étaient assez encombrants, ils consommaient beaucoup de courant, ils chauffaient et étaient assez peu fiables. Ils tombaient en panne assez souvent. Et ils étaient assez simple à fabriquer, mais restaient malgré tout chers.

[[File:Elektronenroehren-auswahl.jpg|centre|vignette|upright=2|Tubes à vides.]]

Au vu de de la taille des  tubes à vide, les ordinateurs de l'époque étaient composé de plusieurs milliers de ces tubes, guère plus. Et malgré cela, un ordinateur prenait facilement un étage de bâtiment entier, ou au moins plusieurs pièces. La conséquence est que les ordinateurs de première génération étaient très simples, rudimentaires quand on les compare aux ordinateurs modernes. Ils ne géraient que quelques opérations simples : l'addition, la soustraction, pas grand chose de plus. A quelques exceptions près, ils ne géraient pas la multiplication et encore moins la division, cela aurait demandé trop de tubes à vides.

Une des toutes premières machines construite avec des tubes à vide était l'Atanasoff–Berry. Ce n'était pas un ordinateur, car elle ne pouvait pas exécuter de programme sans intervention humaine pour séquencer des opérations, mais c'était la première machine de calcul purement électronique, sans aucune pièce mécanique. Elle utilisait une mémoire RAM construite avec des condensateurs, ceux-ci étant placés sur des cylindres tournants. Les circuits de calcul étaient construits avec des tubes à vide et faisaient leur travail un bit à la fois. Elle fonctionnait à une fréquence de 60 Hz et pouvait faire 30 additions/soustractions par seconde. Les nombres étaient encodés sur 50 bits. 

[[File:Atanasoff Berry Computer.gif|centre|vignette|upright=2.5|Atanasoff–Berry.]]

L'arrivée de l'ENIAC en 1945 a changé la donne. Cet ordinateur a introduit plusieurs innovations majeures. La première est assez technique, il s'agit de la turing-complétude, elle a trait aux programmes qui peuvent être écrit pour un ordinateur, nous ne la détaillerons pas ici.

En 1948, le ''Manchester Baby'' a introduit une innovation extrêmement importante : le programme n'était plus mémorisé sur des cartes perforées, mais dans une mémoire électronique à l’intérieur de l'ordinateur lui-même. En clair, le ''Manchester Baby'' était le premier '''ordinateur à programme enregistré''' en français. Au-delà de ça, le Manchester Baby restait quand même très simple, c'était limite un prototype. Il avait une RAM de 32 nombres de 32 bits, fabriquées avec des tubes Willimas (abordés dans une annexe à la fin du cours). Il gérait 8 instructions en tout, mais ne gérait pas l'addition. Il gérait la soustraction, des instructions de branchement et d'accès mémoire, mais rien d'autre. Il pouvait cependant émuler l'addition à partir d'une soustraction et inversant l'opérande soustraite.

===La seconde génération : le remplacement des tubes à vides par des transistors===

[[File:IBM 7070.jpg|vignette|Cartes imprimées de l'IBM 704, avec des transistors et résistances dessus.]]

La '''seconde génération''' est celle des ordinateurs fabriqués avec des '''transistors''' isolés, reliés entre avec des fils électriques. Les transistors en question possèdent trois broches, des pattes métalliques sur lesquelles on connecte des fils électriques. Le transistor s'utilise le plus souvent comme un interrupteur commandé par sa troisième broche. Le courant qui traverse les deux premières broches passe ou ne passe pas selon ce qu'on met sur la troisième.

[[File:Transistor basic flow.svg|centre|vignette|Un transistor est un morceau de conducteur, dont la conductivité est contrôlée par sa troisième broche/borne.]]

Les ordinateurs de seconde génération avaient entre 1000 et 500 000 transistors. Les capacités des ordinateurs étaient donc nettement supérieures à celles des ordinateurs de première génération. Une part non négligeable des ordinateurs de seconde génération supportait l'opération de multiplication, absente sur les ordinateurs de première génération. Néanmoins, cela variait beaucoup selon les ordinateurs.

Un exemple assez hors du commun est celui du premier modèle de l'IBM 1620. Le tout premier modèle n'avait aucun circuit de calcul, il n'était même pas capable de faire une addition ou une multiplication. A la place, il utilisait une table d'addition et une table de multiplication en mémoire RAM. Les deux tables devaient être initialisées par le logiciel lors du démarrage de la machine. La table d'addition faisait une centaine de chiffre, la table de multiplication faisait le double. Le processeur de l'ordinateur gérait des instructions pour faire des additions ou des multiplications, mais ces opérations lisaient le résultat dans la table d'addition. Les calculs étaient fait chiffre par chiffre, avec un encodage partiellement décimal, partiellement binaire (des chiffres décimaux étaient encodés en binaire, nous en reparlerons quand nous parlerons du BCD) !

[[File:KL CoreMemory.jpg|vignette|Mémoire à tore de ferrite.]]

Les transistors n'étaient utilisés que pour le processeur et les circuits annexes. La mémoire n'était pas faite en transistors, pas à cette époque. La mémoire était une mémoire aujourd'hui abandonnée, appelée une '''mémoire à tores de ferrite'''. Elle sera détaillée dans un chapitre ultérieur. Mais sachez pour le moment qu'il s'agit d'une mémoire au support magnétique, les données étant stockées sur un support magnétique.

Transistors comme tubes à vide prenaient beaucoup de place, ce qui fait que les ordinateurs étaient assez gros. Concrètement, ils prenaient une pièce de bâtiment entière dans le meilleur des cas. C'était l'époque des gros ''mainframes'', reliés à des terminaux, peu puissants comparé aux standards actuels. Seules les grandes entreprises et les grands instituts de recherche pouvaient se payer les services de ce genre d'ordinateurs. Seuls les professionnels avaient accès à ce genre d'équipement.

===La troisième génération : le circuit intégré===

[[File:D8259AC-2.jpg|vignette|Exemple de circuit intégré.]]

La troisième génération est toujours fabriquée avec des transistors, mais dont la taille a été réduite. Avec l'évolution de la technologie, les transistors ont diminué en taille, de plus en plus. Ils sont devenus tellement petits qu'ils ont finit par être regroupés dans des '''circuits intégrés''', des circuits regroupent plusieurs transistors sur la même puce de silicium. Les circuits intégrés se présentent le plus souvent sous la forme de boitiers rectangulaires, comme illustré ci-contre. D'autres ont des boitiers de forme carrées, comme ceux que l'on peut trouver sur les barrettes de mémoire RAM, ou à l'intérieur des clés USB/ disques SSD.

Lors de cette génération, les processeurs étaient fournis en pièces détachées qu'il fallait relier entre elles. Le processeur était composé de plusieurs circuits intégrés séparés, impossible de mettre un processeur dans un seul boitier. Un exemple de processeur conçu en kit est la série des Intel 3000. Elle regroupe plusieurs circuits séparés aux noms à coucher dehors, mais dont vous comprendrez ce qu'ils veulent dire dans les chapitres adéquats : l'Intel 3001 est un séquenceur, l'Intel 3002 regroupe unité de calcul et registres, le 3003 est un circuit d'anticipation de retenue complémentaire du 3002, le 3212 est une mémoire tampon, le 3214 est une unité de gestion des interruptions, les 3216/3226 sont des interfaces de bus mémoire. On pourrait aussi citer la famille de circuits intégrés AMD Am2900.

Même si le processeur était en pièce détachées, utiliser une dizaine de circuits intégrés était nettement mieux que d'utiliser plusieurs milliers de transistors individuels. En conséquence, les ordinateurs ont vu leur taille grandement réduite, passant de pièces entières à une simple armoire, voire à quelques cartes intégrées superposées. De plus, le prix des circuits intégré était abordable, du moins comparé aux ordinateurs d'avant. Le prix des ordinateurs a alors grandement décru, permettant à des entreprises et administrations de taille modeste de s'équiper d'ordinateurs.

===La quatrième génération : le microprocesseur===

[[File:MOS6502.svg|vignette|Microprocesseur, ici un processeur MOS6502, de la quatrième génération.]]

Lors de la troisième génération, les circuits intégrés regroupaient plusieurs dizaines ou centaines de transistors, mais sont rapidement montés en gamme. De centaines de transistors, ils sont passé au milliers de transistors, puis au millions et maintenant au-delà du milliard. Les transistors étaient devenus tellement petits, tellement miniaturisés, qu'il était devenu possible de mettre un processeur entier dans un circuit intégré. C'est ainsi qu'est né le microprocesseur, à savoir un processeur qui tient tout entier dans un seul circuit imprimé. La quatrième génération d’ordinateur est celle des ordinateurs basés autour d'un microprocesseur.

Les tout premiers microprocesseurs étaient des processeurs à application militaire, comme le processeur du F-14 CADC ou celui de l'Air data computer. Le tout premier microprocesseur commercialisé au grand public est le 4004 d'Intel, sorti en 1971. L'intel 4004 comprenait environ 2300 transistors, avait une fréquence de 740 MHz, pouvait faire 46 opérations différentes, et manipulait des entiers de 4 bits. Il était au départ un processeur de commande, prévu pour être intégré dans la calculatrice Busicom calculator 141-P, mais il fut utilisé pour d'autres applications quelque temps plus tard. Immédiatement après le 4004, les premiers microprocesseurs 8 bits furent commercialisés. Le 4004 fut suivi par le 8008 et quelques autres processeurs 8 bits extrêmement connus, comme le 8080 d'Intel, le 68000 de Motorola, le 6502 ou le Z80.

Les microprocesseurs permirent encore uen fois de réduire la taille des ordinateurs, qui pouvaient tenir dans un boitier de PC, ou un boitier de console de jeu. Le prix des ordinateurs a aussi chuté en même temps que les transistors était miniaturisés. C'est cette invention qui permis l'invention des consoles de jeux et des mini-ordinateurs, à savoir les ordinateurs personnels. Sans miniaturisation, on n'aurait pas d'ordinateur personnel, pas de PC fixe ou portable.

==L'organisation du cours : les différents niveaux d'explication==

Le fonctionnement d'un ordinateur est assez complexe à expliquer car les explications peuvent se faire sur plusieurs niveaux. Par plusieurs niveaux, on veut dire qu'un ordinateur est composé de composants très simples, qui sont assemblés pour donner des composants eux-même plus complexes, qui sont eux-même regrouper, etc. Étudier tout cela demande de voir plusieurs niveaux, allant de transistors très petits à des processeurs multicœurs. Les niveaux les plus bas sont de l'électronique pur et dure, alors que ceux plus haut sont à mi-chemin entre électronique et informatique.

===Les niveaux d'abstraction en architecture des ordinateurs===

Les trois premiers niveaux sont de l'électronique pur et dure. Ils correspondent aux premiers chapitres du cours, qui porteront sur les circuits électroniques en général.
* Le premier niveau est celui des '''transistors''', des circuits intégrés, des ''wafer'' et autres circuits de très petite taille.
* Le second niveau est celui des '''portes logiques''', des circuits très basiques, très simples, à la base de tous les autres.
* Le troisième niveau est celui dit de la '''''Register Transfer Level''''', où un circuit électronique est construit à partir de circuits basiques, dont des registres et autres circuits dits combinatoires.
Les deux niveaux suivants sont de l'informatique proprement dit. C'est dans ces deux niveaux qu'on étudie les ordinateurs proprement dit, les circuits qu'il y a dedans et non l'électronique en général.
* Le quatrième niveau est celui de la '''microarchitecture''', qui étudie ce qu'il y a à l'intérieur d'un processeur, d'une mémoire, des périphériques et autres.
* Le cinquième niveau est celui de l''''architecture externe''', qui décrit l'interface du processeur, de la mémoire, d'un périphérique ou autre. Par décrire l'interface, on veut dire : comment un programmeur voit le processeur et la mémoire, comment il peut les manipuler. Une architecture externe unique peut avoir plusieurs microarchitecture, ce qui fait qu'on sépare les deux. Tout cela sera plus clair quand on passera aux chapitres sur le processeur et les mémoires.

Nous n'allons pas voir les 5 niveaux dans l'ordre, des transistors vers l'architecture externe. En réalité, nous allons procéder autrement. La première partie du cours portera sur les trois premiers niveaux, le reste sur les deux autres. Les 5 niveaux seront vus dans des chapitres séparés, du moins le plus possible. Au niveau pédagogique, tout est plus simple si on scinde les 5 niveaux. Bien sûr, il y a quelques explications qui demandent de voir plusieurs niveaux à la fois. Par exemple, dans le chapitre sur les mémoires caches, nous auront des explications portant sur la RTL, la microarchitecture du cache et son architecture externe. Mais le gros du cours tentera de séparer le plus possible les 5 niveaux.

===Les trois parties principales du cours===

Nous allons commencer par parler du binaire, avant de voir les portes logiques. Avec ces portes logiques, nous allons voir comment fabriquer des circuits basiques qui reviendront très souvent dans la suite du cours. Nous verrons les registres, les décodeurs, les additionneurs et plein d'autres circuits. Puis, nous reviendrons au niveau des transistors pour finir la première partie. La raison est que c'est plus simple de faire comme cela. Tout ce qui a trait aux transistors sert à expliquer comment fabriquer des portes logiques, et il faut expliquer les portes logiques pour voir le niveau de la RTL.

Une fois la première partie finie, nous allons voir les différents composants d'un ordinateur. Une première partie expliquera ce qu'il y a dans un ordinateur, quels sont ses composants. Nous y parlerons de l'architecture de base, de la hiérarchie mémoire, des tendances technologiques, et d'autres généralités qui serviront de base pour la suite. Puis, nous verrons dans l'ordre les bus électroniques, les mémoires RAM/ROM, le processeur, les périphériques, les mémoires de stockage (SSD et disques durs) et les mémoires caches. Pour chaque composant, nous allons voir leur architecture externe, avant de voir leur microarchitecture. La raison est que la microarchitecture ne peut se comprendre que quand on sait quelle architecture externe elle implémente.

Enfin, dans une troisième partie, nous allons voir les optimisations majeures présentes dans tous les ordinateurs modernes, avec une partie sur le pipeline et le parallélisme d'instruction, et une autre sur les architectures parallèles. Pour finir, les annexes de fin parlerons de sujets un peu à part.

&lt;noinclude&gt;
{{NavChapitre | book=Fonctionnement d'un ordinateur
           | next=L'encodage des données
           | nextText=L'encodage des données
}}
&lt;/noinclude&gt;</text>
      <sha1>tbu1fpun59u3h23rh9axdur57hyor1f</sha1>
    </revision>
    <revision>
      <id>744122</id>
      <parentid>744121</parentid>
      <timestamp>2025-06-04T23:57:47Z</timestamp>
      <contributor>
        <username>Mewtow</username>
        <id>31375</id>
      </contributor>
      <minor />
      <comment>/* La première génération : les tubes à vide */</comment>
      <origin>744122</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="43871" sha1="exq4gh46e2zivxqi50z6r1tihffw07s" xml:space="preserve">Pour commencer, nous allons voir qu'il existe de nombreux types d'ordinateurs. Le plus connu est certainement le PC, l'ordinateur personnel, que vous avez sans doute dans votre salon. Les ordinateurs portables sont un deuxième type d'ordinateur assez intuitif, que vous avez peut-être. Mais il y a aussi d'autres types d'ordinateurs auxquels vous n'avez jamais été confrontés.

==Les différents types d'ordinateurs==

Dans cette section, nous allons décrire rapidement les ordinateurs les plus courant, mais surtout voir ce qu'il y a à l'intérieur d'un ordinateur.

===L'ordinateur de type PC fixe===

De l'extérieur, l'ordinateur est composé d'une unité centrale sur laquelle on branche des périphériques.

[[File:Typical computer architecture systems.jpg|vignette|upright=1.5|Exemples de périphériques, connectés à une unité centrale (ici appelée à tort ''operating system'').]]

Les '''périphériques''' regroupent l'écran, la souris, le clavier, l'imprimante, et bien d'autres choses. Ils permettent à l'utilisateur d'interagir avec l'ordinateur : un clavier permet de saisir du texte sous dans un fichier, une souris enregistre des déplacements de la main en déplacement du curseur, un écran affiche des données d’images/vidéos, un haut-parleur émet du son, etc. Tout ce qui est branché sur un ordinateur est, formellement un périphérique.

L''''unité centrale''' est là où se trouvent tous les composants importants d'un ordinateur, ceux qui font des calculs, qui exécutent des logiciels, qui mémorisent vos données, etc. Voici ce à quoi ressemble l'intérieur de l'unité centrale. Trois sections sont visibles : l'alimentation électrique en haut à gauche, la carte mère en bas à gauche et en jaune/orange, les disques et lecteurs à droite des câbles. Et on voit aussi beaucoup de câbles.

[[File:Asus P5K-SEIntel E6320.jpg|centre|vignette|upright=2|Exemple d'unité centrale.]]

Tout en haut à gauche, se trouve l''''alimentation électrique''', qui convertit le courant de la prise électrique en un courant plus faible, utilisable par les autres composants. Elle émet de nombreux câbles assez gros, qui sont reliés au reste. Les PC actuels utilisent des alimentations électriques standardisées, qui fournissent trois tensions au reste de l'ordinateur : une tension de 12 Volts, une de 5 Volts, une de 3,3 Volts.

À droite, caché par la partie &quot;métallique&quot; du boitier, se trouvent les lecteurs de CD/DVD, et les disques durs. Les lecteurs CD-ROM ou DVD-ROM permettaient de lire des CD ou des DVD. Je parle au passé, car ils ont aujourd'hui disparu des ordinateurs modernes. Les '''disques durs''' sont des mémoires de stockage, qui mémorisent vos données de manière permanente. De nos jours, ils sont remplacés par des SSD, qui sont des disques durs électroniques, là où les disques durs proprement dit sont des mémoires magnétiques. Nous verrons la différence dans deux chapitres dédiés, un sur les disques durs, l'autre sur les SSD.

En bas à droite, se trouve la '''carte mère''' un support plat, en plastique ou en céramique, sur laquelle sont soudés/connectés les autres composants. Sur celle-ci, de nombreux composants sont soudés, d'autres sont branchés dessus avec des câbles, d'autres sont connectés dessus avec des connecteurs. Ils sont reliés entre eux par des fils conducteurs, le plus souvent du cuivre ou de l’aluminium, ce qui leur permet de s’échanger des données. Sur les cartes simples, ces fils sont intégrés dans la carte électronique, dans des creux du plastique. Ils portent le nom de pistes.

Avant, les disques durs, SSD et lecteurs de CD/DVD sont branchés dessus via des connecteurs dédiés, appelés des connecteurs S-ATA. De nos jours, ils sont branchés sur un autre connecteur, grâce à l'interface NVME. Toujours est-il qu'ils sont reliés à la carte mère par des câbles, ce qui montre que ce sont des sortes de périphériques interne. Ils sont placés dans le boitier, mais on aurait tout aussi bien pu les mettre à l'extérieur, vu qu'ils communiquent avec l'ordinateur par l'intermédiaire d'un câble ou d'un connecteur dédié.

Mais deux autres composants très importants sont eux placés sur la carte mère, directement. Ils ont chacun un connecteur dédié, sur lequel ils sont branchés directement, sans passer par l'intermédiaire d'un câble, mais sans être soudés non plus. Il s'agit du processeur et de la mémoire RAM, deux composants centraux des PC modernes.

[[File:Pentium III SL4CB.jpg|thumb|Processeur Pentium III.]]

Le '''processeur''' traite les données, les modifie, les manipule. Pour faire simple, il s’agit d’une grosse calculatrice hyper-puissante. Il comprend à la fois un circuit qui fait des calculs, et un circuit de contrôle qui s'occupe de séquencer les calculs dans l'ordre demandé. Il est souvent caché sous un radiateur, lui-même surmonté par un ventilateur. En effet, un processeur chauffe beaucoup, ce qui demande d'évacuer cette chaleur. Un chapitre entier expliquera pourquoi les processeurs chauffent, ainsi que les techniques utilisées pour limiter leur production de chaleur et leur consommation électrique.

La '''mémoire vive''' conserve des informations/données temporairement, tant que le processeur en a besoin. Elle prend la forme de barrettes de RAM, comme montré ci-dessous.

[[File:2 gb ddr2 667.jpg|centre|vignette|upright=2|Barrette de RAM.]]

Outre ces composants dits principaux, un ordinateur peut comprendre plusieurs composants moins importants, surtout présents sur les ordinateurs personnels. Ils sont techniquement facultatifs, mais sont très présents dans les ordinateurs personnels. Cependant, certains ordinateurs spécialisés s'en passent. Il s'agit des diverses '''cartes d'extension''' sont branchées sur la carte mère. Elles permettent d’accélérer certains calculs ou certaines applications, afin de décharger le processeur. Par exemple, la carte graphique s'occupe des calculs graphiques, qu'il s'agisse de graphismes 3D de jeux vidéos ou de l'affichage en 2D du bureau. Dans un autre registre, la carte son prend en charge le microphone et les haut-parleurs.

[[Fichier:Personal computer, exploded 4.svg|thumb|upright=1.0|Éclaté d'un ordinateur de type PC :&lt;br /&gt;
1 : Écran ;&lt;br /&gt;
2 : Carte mère ;&lt;br /&gt;
3 : Processeur ;&lt;br /&gt;
4 : Câble Parallel ATA ;&lt;br /&gt;
5 : Mémoire vive (RAM) ;&lt;br /&gt;
6 : Carte d'extension ;&lt;br /&gt;
7 : Alimentation électrique ;&lt;br /&gt;
8 : Lecteur de disque optique ;&lt;br /&gt;
9 : Disque dur ;&lt;br /&gt;
10 : Clavier ;&lt;br /&gt;
11 : Souris.]]

Si on regarde une carte mère de face, on voit un grand nombre de connecteurs, mais aussi des circuits électroniques soudés à la carte mère.

[[File:Architecture matérielle d'une carte mère.png|centre|vignette|upright=2.0|Architecture matérielle d'une carte mère]]

Les '''connecteurs''' sont là où on branche les périphériques, la carte graphique, le processeur, la mémoire, etc. Dans l'ensemble, toute carte mère contient les connecteurs suivants :
* Le processeur vient s’enchâsser dans la carte mère sur un connecteur particulier : le '''socket'''. Celui-ci varie suivant la carte mère et le processeur, ce qui est source d'incompatibilités.
* Les barrettes de mémoire RAM s’enchâssent dans un autre type de connecteurs: les '''slots mémoire'''.
* Les mémoires de masse disposent de leurs propres connecteurs : connecteurs P-ATA pour les anciens disques durs, et S-ATA pour les récents.
* Les périphériques (clavier, souris, USB, Firewire, ...) sont connectés sur un ensemble de connecteurs dédiés, localisés à l'arrière du boitier de l'unité centrale. 
* Les autres périphériques sont placés dans l'unité centrale et sont connectés via des connecteurs spécialisés. Ces périphériques sont des cartes imprimées, d'où leur nom de '''cartes filles'''. On peut notamment citer les cartes réseau, les cartes son, ou les cartes vidéo.

===Les ordinateurs portables===

[[File:Samsung QX-511 (2).JPG|vignette|Ordinateur portable Samsung QX-511 (2), pour illustration.]]

Un ordinateur portable est identique à un ordinateur de type PC. Si vous ouvrez votre ordinateur portable (attention à la garantie), vous retrouverez les mêmes composants qu'un PC à l'intérieur. Un point important est la présence d'une batterie à l'intérieur du PC portable, absente des PC fixes.

[[File:LG gram 14Z90Q mainboard with battery.jpg|centre|vignette|upright=2|LG gram 14Z90Q avec sa batterie.]]

Une fois la batterie et les circuits associés retiré, la seule différence notable est que tous les composants sont soudés sur la carte mère, au lieu d'être branchés sur des connecteurs, à part éventuellement la RAM et le disque dur.

[[File:LG gram 14Z90Q mainboard without battery.jpg|centre|vignette|upright=2|LG gram 14Z90Q sans sa batterie.]]

La RAM est parfois soudée sur la carte mère, d'autres fois sous la forme de barrettes de mémoire vive semblables à celles des PC. Dans le dernier cas, elle est connectée à des connecteurs spécifiques, ce qui permet de les changer/upgrader. Les PC portables sont parfois construits de manière à pouvoir changer la RAM facilement, en ouvrant un cache spécial, concu pour.

[[File:Lenovo G555 состав - Донор.JPG|centre|vignette|upright=2|Lenovo G555.]]

La conception d'un ordinateur portable est légèrement différente de celle d'un PC, pour des raisons thermiques. Un PC fixe a plus de place pour évacuer sa chaleur. Les ventilateurs peuvent plus facilement déplacer l'air dans le boitier, même si le flux d'air dans le boitier est éventuellement gêné par la carte graphique. Mais l'évacuation de la chaleur est assez efficace. Sur les PC portables, leur finesse fait que le trajet de l'air est beaucoup plus contraint. Évacuer la chaleur produite par l'ordinateur est plus complexe, ce qui demande d'utiliser des systèmes de refroidissement et de ventilation spécifiques.

Là où les PC fixes se débrouillent avec des radiateurs et des ventilateurs posés sur le processeur, les PC portables font autrement. Ils ne peuvent pas forcément mettre le ventilateur sur le processeur. A la place, ils mettent le ventilateur à côté, mais le processeur est surmonté par un mécanisme de transmission de la chaleur, qui transfère la chaleur du processeur vers le ventilateur.

[[File:Diagram - How a laptop cooling system works.png|centre|vignette|upright=2|Comment fonctionne le système de ventilation d'un ordinateur portable, en anglais.]]

Les difficultés pour dissiper la chaleur font que les ordinateurs portables utilisent souvent des composants peu performants, mais qui chauffent peu. En effet, nous verrons que plus un composant est puissant, plus il chauffe. La relation n'est pas parfaite, mais les processeurs haute performance chauffent plus que les modèles d'entrée ou milieu de gamme moins puissants. En conséquence, les PC portables sont souvent moins puissants que les PC fixes, même pour les modèles dit ''gaming''.

===Les serveurs et ''mainframes''===

Les grandes entreprises utilisent des ordinateurs de grande taille, très puissants, appelés des ''mainframes''. Ils sont souvent confondus avec les serveurs par le grand public, il y a une différence entre les deux. Un serveur est une fonction logicielle/réseau, pas un type d'ordinateur. Mais laissons cette différence de côté, ce qui est dit pour les ''mainframes'' sert pour les gros serveurs haute performance.

[[File:IBM Z15 mainframe.jpg|vignette|Exemple de ''mainframe''' de type IBM Z15.]]

Les anciens ''mainframes'' des années 50-80 avaient une taille pouvant être impressionnante, au point de prendre une pièce complète d'un bâtiment. Mais de nos jours, les ''mainframes'' tiennent dans une grosse armoire un peu haute. Les ''mainframes'' doivent rester allumé en permanence et ne doivent pas être éteint, sauf éventuellement quelques jours par an pour des opérations de maintenance. Ils utilisent pour cela des techniques spécifiques, avec beaucoup de redondance interne.

[[File:ACONIT hall grandes machines.jpg|centre|vignette|upright=2|''Mainframe'' ACONIT.]]

Les ''mainframes'' sont aussi conçus pour mutualiser au maximum leur utilisation, ils peuvent être utilisés par plusieurs utilisateurs à la suite, voire en même temps. Pour cela, les anciens ''mainframes'' étaient capables de faire tourner plusieurs applications distinctes l'une à la suite de l'autre, avec des commutations fréquentes entre logiciels. De nos jours, ils sont capables d'exécuter un grand nombre de tâches en même temps, grâce à la présence de plusieurs processeurs. Les ''mainframes'' modernes sont même capables de faire tourner plusieurs systèmes d'exploitation en même temps si besoin.

Les anciens ''mainframes'' étaient des ordinateurs assez simples, avec un processeur, de la mémoire RAM, un ou plusieurs disques durs, pas plus. Le ''mainframe'' était tellement énorme et cher que les entreprises n'en avaient qu'un seul pour toute l'entreprise. Les employés avaient sur leur bureau des terminaux, qui permettaient d'accéder à l'ordinateur central, mais n'étaient pas des ordinateurs. Les terminaux étaient des composants électroniques simples, avec un écran, un clavier et une souris, mais sans processeur. Ils envoyaient des données au ''mainframe'', ils en recevaient de sa part, mais tout traitement était réalisé sur le ''mainframe''. L'arrivée sur le marché des ordinateurs personnels, de type PC fixe/portable, a entrainé l'abandon de ce genre de pratique, tous les employés ont maintenant un ordinateur rien que pour eux.

{|
|-
! colspan=&quot;2&quot; | Exemples de terminaux
|-
|[[File:Terminal-in2-sm9400.jpg|centre|vignette|upright=1.5|Exemple de terminal. Notez la présence d'un écran et d'un clavier, mais l'asbence d'une unité centrale.]]
|[[File:Chromatics CT4100.jpg|vignette|upright=1.5|Autre exemple de terminal. Le clavier est couplé à un stylo CRT, qui remplacait la souris et agissait sur l'écran comme s'il était tactile.]]
|-
! colspan=&quot;2&quot; | Intérieur d'un terminal
|-
|[[File:CT1024 Monitor.jpg|vignette|upright=1.5|Terminal CT1024, sans le boitier extérieur.]]
|[[File:CT1024 Terminal System.jpg|vignette|upright=1.5|Terminal CT1024, description des composants interne.]]
|}

De nos jours, les ''mainframes'' contiennent en réalité plusieurs ordinateurs simples interconnectés via un réseau local. Un ''mainframe'' qui tient dans une armoire contient facilement une dizaine ou centaine de processeurs, plein de RAM, des disques durs séparés dans une armoire distincte, etc. Vu qu'ils communiquent uniquement via le réseau, ils n'ont pas d'interface, pas d'écran, 'entrée via clavier/souris. Le tout est commandé avec une console de commande, typiquement un ordinateur portable ou un terminal assez simple séparé de l'armoire, qui permet à un administrateur de faire des opérations de surveillance, configuration et maintenance. Il peut y avoir une console de commande pour plusieurs armoires séparées, la console peut même être dans un autre bâtiment et accéder au ''mainframe'' par le réseau.

[[File:IBM System Z9 (type 2094 inside).jpg|centre|vignette|upright=2|''Mainframe'' de type IBM System Z9. L'ordinateur portable sert de console pour qu'un administrateur fasse des opérations de surveillance, configuration et maintenance.]]

Les processeurs et la RAM sont typiquement installés sur des cartes amovibles, qui sont connectées au fond de l'armoire lors de l'installation. Il est même possible de retirer ou d'ajouter des cartes en fonctionnement, afin d'ajouter/retirer des processeurs, des disques durs, etc. Ce qui est très utile si un composant est en panne et qu'il faut le remplacer. 

[[File:IBM TotalStorage Exp400.jpg|centre|vignette|upright=2|IBM TotalStorage Exp400]]

==Un peu d'abstraction : qu'est-ce qu'un ordinateur ?==

Un ordinateur comprend donc un processeur, plusieurs mémoires, des cartes d'extension et une carte mère pour connecter le tout. Mais il s'agit là d'une description assez terre-à-terre de ce qu'est un ordinateur. Une autre description, plus abstraite, se base sur le fait qu'un ordinateur est une énorme calculatrice programmable. Elle permet d'expliquer pourquoi il y a une distinction entre processeur et mémoire, entre unité centrale et périphériques. Tout ce qui va suivre pourra vous paraitre assez abstrait, mais rassurez-vous : les prochains chapitres rendront tout cela plus concrets.

===La séparation entre entrées-sorties et traitement===

L'unité centrale peut être vue comme une énorme calculatrice ultra-puissante, qui exécute des commandes/opérations. Mais à elle seule, elle ne servirait à rien, il faut interagir avec par l'intermédiaire de plusieurs périphériques. Il existe deux types de périphériques, qui sont conceptuellement différents. Les périphériques comme le clavier ou la souris permettent d'envoyer des informations à l'ordinateur, d'agir sur celui-ci. A l'inverse, les écrans transmettent des informations dans le sens inverse : de l'ordinateur vers l'utilisateur. Les premiers sont appelés des '''entrées''', les seconds des '''sorties'''.

Dans un ordinateur, les informations sont représentées sous la forme de nombres. Toute donnée dans un ordinateur est codée avec un ou plusieurs nombres regroupés dans une donnée, un fichier, ou autre. Et la transmissions avec les entrées et sorties se fait là-encore avec des nombres. Par exemple, quand vous appuyez sur votre clavier, le clavier envoie un numéro de touche à l'unité centrale, qui indique quelle touche a été appuyée. L'image à afficher à l'écran est codée sous la forme d'une suite de nombres (un par pixel). L'image est envoyée à l'écran, qui traduit la suite de nombre en image à afficher. Les entrées traduisent des actions utilisateurs en nombres, on dit que les entrées encodent les actions utilisateur. Les sorties font la traduction inverse, elles transforment des suites de nombres en une action physique. On dit qu'elles décodent des informations.

Pour résumer, toute appareil électronique est composé par :
* Des '''entrées''' sur lesquelles l'utilisateur agit sur l'ordinateur. Les entrées transforment les actions de l'utilisateur en nombres, qui sont interprétés par l'ordinateur.
* Une '''unité de traitement''', qui manipule des nombres et fait des calculs/opérations dessus. Les nombres proviennent des entrées, du disque dur, ou d'autres sources, peu importe.
* Des '''sorties''', qui va récupèrent le résultat calculé par l'unité de traitement pour en faire quelque chose : écrire sur une imprimante ou sur un moniteur, émettre du son,...

[[File:Ordinateur théorique Simple 1.png|centre|vignette|upright=2|Ordinateur théorique Simple 1]]

L'unité de traitement proprement dite, celle qui fait les calculs, est couplée à une mémoire qui mémorise les opérandes et résultats des calculs. La séparation entre processeur et mémoire est nécessaire pour qu'un appareil électronique soit qualifié d'ordinateur. De nombreux appareils n'ont pas de séparation entre unité de traitement et mémoire, comme certaines vielles radios AM/FM.

[[File:Schéma de principe d'un ordinateur.png|centre|vignette|upright=2|Schéma de principe d'un ordinateur]]

===Un ordinateur est un appareil programmable===

Les appareils simples sont non-programmables, ce qui veut dire qu’ils sont conçus pour une utilisation particulière et qu’ils ne peuvent pas faire autre chose. Par exemple, les circuits électroniques d’un lecteur de DVD ne peuvent pas être transformé en lecteur audio ou en console de jeux... Les circuits non-programmables sont câblés une bonne fois pour toute, et on ne peut pas les modifier. On peut parfois reconfigurer le circuit, pour faire varier certains paramètres, via des interrupteurs ou des boutons, mais cela s’arrête là. Et cela pose un problème : à chaque problème qu'on veut résoudre en utilisant un automate, on doit recréer un nouveau circuit.

À l'inverse, un ordinateur n’est pas conçu pour une utilisation particulière, contrairement aux autres objets techniques. Il est possible de modifier leur fonction du jour au lendemain, on peut lui faire faire ce qu’on veut. On dit qu'ils sont '''programmables'''. Pour cela, il suffit d’utiliser un logiciel, une application, un programme (ces termes sont synonymes), qui fait ce que l'on souhaite. La totalité des logiciels présents sur un ordinateur sont des programmes comme les autres, même le système d'exploitation (Windows, Linux, ...) ne fait pas exception.

Un programme est une suite de d'instructions, chaque instruction effectuant une action dans l'ordinateur. Sur les ordinateurs modernes, la majorité de ces instructions effectuent une opération arithmétique, comme une addition, une multiplication, une soustraction, etc. Les ordinateurs modernes sont donc de grosses calculettes très puissantes, capables d'effectuer des millions d'opérations par secondes. Et qui dit opération dit nombres : un ordinateur gère nativement des nombres, qui sont codés en binaire sur la quasi-totalité des ordinateurs modernes.

Une instruction est représentée dans un ordinateur par une série de nombres : un nombre qui indique quelle opération/commande effectuer et des autres nombres pour coder les données (ou de quoi les retrouver dans l'ordinateur). L'ordinateur récupére les commandes une par une, les traduit en opération à effectuer, exécuter l'opération, et enregistre le résultat. Puis il recommence avec la commande suivante.

[[File:Ordinateur Théorique Complexe 1.png|centre|vignette|upright=3|Ordinateur Théorique Complexe. En jaune, le programme informatique, la liste de commande. Le rectangle gris est l'ordinateur proprement dit.]]

De nombreux appareils sont programmables, mais tous ne sont pas des ordinateurs. Par exemple, certains circuits programmables nommés FPGA n'en sont pas. Pour être qualifié d'ordinateur, un appareil programmable doit avoir un processeur séparé de la mémoire. De plus, il doit utiliser un '''codage numérique''', chose que nous allons aborder dans le chapitre suivant.

===Les ordinateurs à programme mémorisé ou programme externe===

Au tout début de l'informatique, on utilisait des cartes perforées en plastique, sur lesquelles on inscrivait le programme à exécuter, les données à traiter, bref : tout ce qu'on donnait à manger à l'ordinateur. Par la suite, les premiers ordinateurs grand public, comme les Amstrad ou les Commodore, utilisaient des cassettes audio magnétiques pour stocker les programmes. Dans le même style, les consoles de jeu utilisaient autrefois des cartouches de jeu, qui contenaient le programme du jeu à exécuter. Pour résumer, les anciens ordinateurs mémorisaient les programmes sur un support externe, lu par un périphérique. De tels ordinateurs sont dits à '''programme externe'''.

: D’anciens ordinateurs personnels, comme l’Amstrad ou le Commodore, permettaient de taper les programmes à exécuter à la main, au clavier, avant d’appuyer une touche pour les exécuter. Nul besoin de vous dire que les cassettes audio étaient plus pratiques.

Mais de nos jours, les programmes sont enregistrés sur le disque dur de l'ordinateur ou dans une mémoire intégrée à l'ordinateur. On dit qu'ils sont installés, ce qui est un mot bien compliqué pour dire que le programme est enregistré sur le disque dur de l’ordinateur. A défaut de disque dur, le programme/logiciel est enregistré dans une mémoire spécialisée pour le stockage. Par exemple, sur les cartes électroniques grand public de marque Arduino, les programmes sont envoyés à la carte via le port USB, mais les programmes sont enregistrés dans la carte Arduino, dans une mémoire FLASH dédiée. Disque dur ou non, le programme est mémorisé dans la mémoire de l'ordinateur. Il est possible d'installer ou de désinstaller les programmes en modifiant le contenu de la mémoire. Le terme utilisé est alors celui de '''programme stocké en mémoire'''.

Les programmes à installer sont disponibles soit sur un périphérique, comme un DVD ou une clé USB, soit sont téléchargés depuis internet. Les premiers PC fournissaient les logiciels sur des disquettes, qui contenaient un programme d'installation pour enregistrer le programme sur le disque dur de l'ordinateur. Par la suite, le support des logiciels a migré vers les CD et DVD, les logiciels devenant de plus en plus gros. De nos jours, la majorité des applications sont téléchargées depuis le net, l'usage de périphériques est devenu obsolète, même les consoles de jeu abandonnent cette méthode de distribution.

==Les générations d'ordinateurs : un historique rapide==

L'informatique a beaucoup évolué dans le temps. Et une bonne partie de cette évolution tient à l'évolution de l’électronique sous-jacente. Les ordinateurs actuels sont fabriqués avec des transistors, des petits composants électroniques qui servent d'interrupteur programmables, qu'on détaillera dans ce qui suit. Mais ça n'a pas toujours été le cas. Et cela permet de distinguer plusieurs '''générations d'ordinateurs'''.

===Les ordinateurs électro-mécaniques : les premiers ordinateurs===

Le tout premier ordinateur est le '''Z1''', un modèle unique inventé par Konrad Suze entre 1936 et 1938. Son processeur gérait non pas des nombres entiers, mais des nombres à virgule (des nombres dits flottants, pour être précis), encodés sur 22 bits. Le processeur du Z1 était capable de faire des additions et des soustractions, car il intégrait un circuit additionneur-soustracteur basique. Des circuits annexes permettaient de faire des multiplications et des divisions en enchainant des additions/soustractions successives. Il fonctionnait à une fréquence de 1 Hz, ce qui fait qu'il pouvait faire une addition/soustraction par seconde maximum.

[[File:Blue-punch-card-front.png|vignette|upright=0.5|Carte Perforée.]]

Niveau mémoire, la RAM de l'ordinateur était très limitée : seulement 16 nombres de 22 bits chacun. S'il s'agissait d'une mémoire électronique, les programmes étaient mémorisés sur une mémoire mécanique. Les programmes étaient enregistrés sur des cartes perforées, à savoir des cartes en papier dans lesquelles un 1 est codé par un trou dans le papier et un 0 par une absence de trou. Les programmes étaient exécutés par l'ordinateur quand on insérait la carte perforée dans le lecteur et qu'on appuyait sur un bouton.

[[File:German Museum of Technology, Berlin 2017 024.jpg|centre|vignette|upright=2|Réplique du Z1 au ''German Museum of Technology'' de Berlin, 2017.]]

Après sa destruction dans un bombardement, le Z1 a été reconstruit et amélioré, ce qui donné les deux ordinateurs Z2 et Z3. Quelques années plus tard, de nombreux ordinateurs ont été construits dans des laboratoires de recherche. Des grandes noms de l'histoire de l'informatique datent de cette époque : le Harvard Mark I et le Colossus Mark 1 (UK) ont tous deux été mis en service en 1944, par exemple. Ils ont servis pour les cryptanalystes pour casser les codes utilisés par les allemands pour leurs transmissions, pendant la seconde guerre mondiale.

Les ordinateurs cités dans le précédent paragraphe étaient tous des ordinateurs dit '''électro-mécaniques''', car ils mélangeaient des composants électroniques et des composants mécaniques (tout ce qui a trait aux cartes perforées, notamment). Les composants électroniques étaient soit des relais, soit des tubes à vides, les deux étant des interrupteurs commandables électriquement plus ou moins équivalents aux transistors. Les ordinateurs d'avant l'année 1944, étaient tous de ce type. Quelques ordinateurs des années 50 étaient de ce type, mais leur nombre n'a pas dépassé 30. Il faut dire qu'ils ont rapidement laissé la place à des ordinateurs purement électroniques, que nous allons voir dans ce qui suit..

===La première génération : les tubes à vide===

Les ordinateurs qui ont suivi les ordinateurs électromécaniques sont regroupés dans la '''première génération d'ordinateur'''. Ils étaient conçus avec des tubes à vide, ce qui les place entre les premiers ordinateurs électro-mécaniques et les ordinateurs utilisant des transistors. Les tubes à vide étaient assez encombrants, ils consommaient beaucoup de courant, ils chauffaient et étaient assez peu fiables. Ils tombaient en panne assez souvent. Et ils étaient assez simple à fabriquer, mais restaient malgré tout chers.

[[File:Elektronenroehren-auswahl.jpg|centre|vignette|upright=2|Tubes à vides.]]

Au vu de de la taille des  tubes à vide, les ordinateurs de l'époque étaient composé de plusieurs milliers de ces tubes, guère plus. Et malgré cela, un ordinateur prenait facilement un étage de bâtiment entier, ou au moins plusieurs pièces. La conséquence est que les ordinateurs de première génération étaient très simples, rudimentaires quand on les compare aux ordinateurs modernes. Ils ne géraient que quelques opérations simples : l'addition, la soustraction, pas grand chose de plus. A quelques exceptions près, ils ne géraient pas la multiplication et encore moins la division, cela aurait demandé trop de tubes à vides.

Une des toutes premières machines construite avec des tubes à vide était l'Atanasoff–Berry. Ce n'était pas un ordinateur, car elle ne pouvait pas exécuter de programme sans intervention humaine pour séquencer des opérations, mais c'était la première machine de calcul purement électronique, sans aucune pièce mécanique. Elle utilisait une mémoire RAM construite avec des condensateurs, ceux-ci étant placés sur des cylindres tournants. Les circuits de calcul étaient construits avec des tubes à vide et faisaient leur travail un bit à la fois. Elle fonctionnait à une fréquence de 60 Hz et pouvait faire 30 additions/soustractions par seconde. Les nombres étaient encodés sur 50 bits. 

[[File:Atanasoff Berry Computer.gif|centre|vignette|upright=2.5|Atanasoff–Berry.]]

L'arrivée de l'ENIAC en 1945 a changé la donne. Cet ordinateur a introduit plusieurs innovations majeures. La première est assez technique, il s'agit de la turing-complétude, elle a trait aux programmes qui peuvent être écrit pour un ordinateur, nous ne la détaillerons pas ici.

En 1948, le ''Manchester Baby'' a introduit une innovation extrêmement importante : le programme n'était plus mémorisé sur des cartes perforées, mais dans une mémoire électronique à l’intérieur de l'ordinateur lui-même. En clair, le ''Manchester Baby'' était le premier '''ordinateur à programme stocké en mémoire''' en français. Au-delà de ça, le Manchester Baby restait quand même très simple, c'était limite un prototype. Il avait une RAM de 32 nombres de 32 bits, fabriquées avec des tubes Willimas (abordés dans une annexe à la fin du cours). Il gérait 8 instructions en tout, mais ne gérait pas l'addition. Il gérait la soustraction, des instructions de branchement et d'accès mémoire, mais rien d'autre. Il pouvait cependant émuler l'addition à partir d'une soustraction et inversant l'opérande soustraite.

===La seconde génération : le remplacement des tubes à vides par des transistors===

[[File:IBM 7070.jpg|vignette|Cartes imprimées de l'IBM 704, avec des transistors et résistances dessus.]]

La '''seconde génération''' est celle des ordinateurs fabriqués avec des '''transistors''' isolés, reliés entre avec des fils électriques. Les transistors en question possèdent trois broches, des pattes métalliques sur lesquelles on connecte des fils électriques. Le transistor s'utilise le plus souvent comme un interrupteur commandé par sa troisième broche. Le courant qui traverse les deux premières broches passe ou ne passe pas selon ce qu'on met sur la troisième.

[[File:Transistor basic flow.svg|centre|vignette|Un transistor est un morceau de conducteur, dont la conductivité est contrôlée par sa troisième broche/borne.]]

Les ordinateurs de seconde génération avaient entre 1000 et 500 000 transistors. Les capacités des ordinateurs étaient donc nettement supérieures à celles des ordinateurs de première génération. Une part non négligeable des ordinateurs de seconde génération supportait l'opération de multiplication, absente sur les ordinateurs de première génération. Néanmoins, cela variait beaucoup selon les ordinateurs.

Un exemple assez hors du commun est celui du premier modèle de l'IBM 1620. Le tout premier modèle n'avait aucun circuit de calcul, il n'était même pas capable de faire une addition ou une multiplication. A la place, il utilisait une table d'addition et une table de multiplication en mémoire RAM. Les deux tables devaient être initialisées par le logiciel lors du démarrage de la machine. La table d'addition faisait une centaine de chiffre, la table de multiplication faisait le double. Le processeur de l'ordinateur gérait des instructions pour faire des additions ou des multiplications, mais ces opérations lisaient le résultat dans la table d'addition. Les calculs étaient fait chiffre par chiffre, avec un encodage partiellement décimal, partiellement binaire (des chiffres décimaux étaient encodés en binaire, nous en reparlerons quand nous parlerons du BCD) !

[[File:KL CoreMemory.jpg|vignette|Mémoire à tore de ferrite.]]

Les transistors n'étaient utilisés que pour le processeur et les circuits annexes. La mémoire n'était pas faite en transistors, pas à cette époque. La mémoire était une mémoire aujourd'hui abandonnée, appelée une '''mémoire à tores de ferrite'''. Elle sera détaillée dans un chapitre ultérieur. Mais sachez pour le moment qu'il s'agit d'une mémoire au support magnétique, les données étant stockées sur un support magnétique.

Transistors comme tubes à vide prenaient beaucoup de place, ce qui fait que les ordinateurs étaient assez gros. Concrètement, ils prenaient une pièce de bâtiment entière dans le meilleur des cas. C'était l'époque des gros ''mainframes'', reliés à des terminaux, peu puissants comparé aux standards actuels. Seules les grandes entreprises et les grands instituts de recherche pouvaient se payer les services de ce genre d'ordinateurs. Seuls les professionnels avaient accès à ce genre d'équipement.

===La troisième génération : le circuit intégré===

[[File:D8259AC-2.jpg|vignette|Exemple de circuit intégré.]]

La troisième génération est toujours fabriquée avec des transistors, mais dont la taille a été réduite. Avec l'évolution de la technologie, les transistors ont diminué en taille, de plus en plus. Ils sont devenus tellement petits qu'ils ont finit par être regroupés dans des '''circuits intégrés''', des circuits regroupent plusieurs transistors sur la même puce de silicium. Les circuits intégrés se présentent le plus souvent sous la forme de boitiers rectangulaires, comme illustré ci-contre. D'autres ont des boitiers de forme carrées, comme ceux que l'on peut trouver sur les barrettes de mémoire RAM, ou à l'intérieur des clés USB/ disques SSD.

Lors de cette génération, les processeurs étaient fournis en pièces détachées qu'il fallait relier entre elles. Le processeur était composé de plusieurs circuits intégrés séparés, impossible de mettre un processeur dans un seul boitier. Un exemple de processeur conçu en kit est la série des Intel 3000. Elle regroupe plusieurs circuits séparés aux noms à coucher dehors, mais dont vous comprendrez ce qu'ils veulent dire dans les chapitres adéquats : l'Intel 3001 est un séquenceur, l'Intel 3002 regroupe unité de calcul et registres, le 3003 est un circuit d'anticipation de retenue complémentaire du 3002, le 3212 est une mémoire tampon, le 3214 est une unité de gestion des interruptions, les 3216/3226 sont des interfaces de bus mémoire. On pourrait aussi citer la famille de circuits intégrés AMD Am2900.

Même si le processeur était en pièce détachées, utiliser une dizaine de circuits intégrés était nettement mieux que d'utiliser plusieurs milliers de transistors individuels. En conséquence, les ordinateurs ont vu leur taille grandement réduite, passant de pièces entières à une simple armoire, voire à quelques cartes intégrées superposées. De plus, le prix des circuits intégré était abordable, du moins comparé aux ordinateurs d'avant. Le prix des ordinateurs a alors grandement décru, permettant à des entreprises et administrations de taille modeste de s'équiper d'ordinateurs.

===La quatrième génération : le microprocesseur===

[[File:MOS6502.svg|vignette|Microprocesseur, ici un processeur MOS6502, de la quatrième génération.]]

Lors de la troisième génération, les circuits intégrés regroupaient plusieurs dizaines ou centaines de transistors, mais sont rapidement montés en gamme. De centaines de transistors, ils sont passé au milliers de transistors, puis au millions et maintenant au-delà du milliard. Les transistors étaient devenus tellement petits, tellement miniaturisés, qu'il était devenu possible de mettre un processeur entier dans un circuit intégré. C'est ainsi qu'est né le microprocesseur, à savoir un processeur qui tient tout entier dans un seul circuit imprimé. La quatrième génération d’ordinateur est celle des ordinateurs basés autour d'un microprocesseur.

Les tout premiers microprocesseurs étaient des processeurs à application militaire, comme le processeur du F-14 CADC ou celui de l'Air data computer. Le tout premier microprocesseur commercialisé au grand public est le 4004 d'Intel, sorti en 1971. L'intel 4004 comprenait environ 2300 transistors, avait une fréquence de 740 MHz, pouvait faire 46 opérations différentes, et manipulait des entiers de 4 bits. Il était au départ un processeur de commande, prévu pour être intégré dans la calculatrice Busicom calculator 141-P, mais il fut utilisé pour d'autres applications quelque temps plus tard. Immédiatement après le 4004, les premiers microprocesseurs 8 bits furent commercialisés. Le 4004 fut suivi par le 8008 et quelques autres processeurs 8 bits extrêmement connus, comme le 8080 d'Intel, le 68000 de Motorola, le 6502 ou le Z80.

Les microprocesseurs permirent encore uen fois de réduire la taille des ordinateurs, qui pouvaient tenir dans un boitier de PC, ou un boitier de console de jeu. Le prix des ordinateurs a aussi chuté en même temps que les transistors était miniaturisés. C'est cette invention qui permis l'invention des consoles de jeux et des mini-ordinateurs, à savoir les ordinateurs personnels. Sans miniaturisation, on n'aurait pas d'ordinateur personnel, pas de PC fixe ou portable.

==L'organisation du cours : les différents niveaux d'explication==

Le fonctionnement d'un ordinateur est assez complexe à expliquer car les explications peuvent se faire sur plusieurs niveaux. Par plusieurs niveaux, on veut dire qu'un ordinateur est composé de composants très simples, qui sont assemblés pour donner des composants eux-même plus complexes, qui sont eux-même regrouper, etc. Étudier tout cela demande de voir plusieurs niveaux, allant de transistors très petits à des processeurs multicœurs. Les niveaux les plus bas sont de l'électronique pur et dure, alors que ceux plus haut sont à mi-chemin entre électronique et informatique.

===Les niveaux d'abstraction en architecture des ordinateurs===

Les trois premiers niveaux sont de l'électronique pur et dure. Ils correspondent aux premiers chapitres du cours, qui porteront sur les circuits électroniques en général.
* Le premier niveau est celui des '''transistors''', des circuits intégrés, des ''wafer'' et autres circuits de très petite taille.
* Le second niveau est celui des '''portes logiques''', des circuits très basiques, très simples, à la base de tous les autres.
* Le troisième niveau est celui dit de la '''''Register Transfer Level''''', où un circuit électronique est construit à partir de circuits basiques, dont des registres et autres circuits dits combinatoires.
Les deux niveaux suivants sont de l'informatique proprement dit. C'est dans ces deux niveaux qu'on étudie les ordinateurs proprement dit, les circuits qu'il y a dedans et non l'électronique en général.
* Le quatrième niveau est celui de la '''microarchitecture''', qui étudie ce qu'il y a à l'intérieur d'un processeur, d'une mémoire, des périphériques et autres.
* Le cinquième niveau est celui de l''''architecture externe''', qui décrit l'interface du processeur, de la mémoire, d'un périphérique ou autre. Par décrire l'interface, on veut dire : comment un programmeur voit le processeur et la mémoire, comment il peut les manipuler. Une architecture externe unique peut avoir plusieurs microarchitecture, ce qui fait qu'on sépare les deux. Tout cela sera plus clair quand on passera aux chapitres sur le processeur et les mémoires.

Nous n'allons pas voir les 5 niveaux dans l'ordre, des transistors vers l'architecture externe. En réalité, nous allons procéder autrement. La première partie du cours portera sur les trois premiers niveaux, le reste sur les deux autres. Les 5 niveaux seront vus dans des chapitres séparés, du moins le plus possible. Au niveau pédagogique, tout est plus simple si on scinde les 5 niveaux. Bien sûr, il y a quelques explications qui demandent de voir plusieurs niveaux à la fois. Par exemple, dans le chapitre sur les mémoires caches, nous auront des explications portant sur la RTL, la microarchitecture du cache et son architecture externe. Mais le gros du cours tentera de séparer le plus possible les 5 niveaux.

===Les trois parties principales du cours===

Nous allons commencer par parler du binaire, avant de voir les portes logiques. Avec ces portes logiques, nous allons voir comment fabriquer des circuits basiques qui reviendront très souvent dans la suite du cours. Nous verrons les registres, les décodeurs, les additionneurs et plein d'autres circuits. Puis, nous reviendrons au niveau des transistors pour finir la première partie. La raison est que c'est plus simple de faire comme cela. Tout ce qui a trait aux transistors sert à expliquer comment fabriquer des portes logiques, et il faut expliquer les portes logiques pour voir le niveau de la RTL.

Une fois la première partie finie, nous allons voir les différents composants d'un ordinateur. Une première partie expliquera ce qu'il y a dans un ordinateur, quels sont ses composants. Nous y parlerons de l'architecture de base, de la hiérarchie mémoire, des tendances technologiques, et d'autres généralités qui serviront de base pour la suite. Puis, nous verrons dans l'ordre les bus électroniques, les mémoires RAM/ROM, le processeur, les périphériques, les mémoires de stockage (SSD et disques durs) et les mémoires caches. Pour chaque composant, nous allons voir leur architecture externe, avant de voir leur microarchitecture. La raison est que la microarchitecture ne peut se comprendre que quand on sait quelle architecture externe elle implémente.

Enfin, dans une troisième partie, nous allons voir les optimisations majeures présentes dans tous les ordinateurs modernes, avec une partie sur le pipeline et le parallélisme d'instruction, et une autre sur les architectures parallèles. Pour finir, les annexes de fin parlerons de sujets un peu à part.

&lt;noinclude&gt;
{{NavChapitre | book=Fonctionnement d'un ordinateur
           | next=L'encodage des données
           | nextText=L'encodage des données
}}
&lt;/noinclude&gt;</text>
      <sha1>exq4gh46e2zivxqi50z6r1tihffw07s</sha1>
    </revision>
    <revision>
      <id>744123</id>
      <parentid>744122</parentid>
      <timestamp>2025-06-05T00:00:25Z</timestamp>
      <contributor>
        <username>Mewtow</username>
        <id>31375</id>
      </contributor>
      <minor />
      <comment>/* La première génération : les tubes à vide */</comment>
      <origin>744123</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="44335" sha1="olx48xn316yj31ou592ymgk5svvcj28" xml:space="preserve">Pour commencer, nous allons voir qu'il existe de nombreux types d'ordinateurs. Le plus connu est certainement le PC, l'ordinateur personnel, que vous avez sans doute dans votre salon. Les ordinateurs portables sont un deuxième type d'ordinateur assez intuitif, que vous avez peut-être. Mais il y a aussi d'autres types d'ordinateurs auxquels vous n'avez jamais été confrontés.

==Les différents types d'ordinateurs==

Dans cette section, nous allons décrire rapidement les ordinateurs les plus courant, mais surtout voir ce qu'il y a à l'intérieur d'un ordinateur.

===L'ordinateur de type PC fixe===

De l'extérieur, l'ordinateur est composé d'une unité centrale sur laquelle on branche des périphériques.

[[File:Typical computer architecture systems.jpg|vignette|upright=1.5|Exemples de périphériques, connectés à une unité centrale (ici appelée à tort ''operating system'').]]

Les '''périphériques''' regroupent l'écran, la souris, le clavier, l'imprimante, et bien d'autres choses. Ils permettent à l'utilisateur d'interagir avec l'ordinateur : un clavier permet de saisir du texte sous dans un fichier, une souris enregistre des déplacements de la main en déplacement du curseur, un écran affiche des données d’images/vidéos, un haut-parleur émet du son, etc. Tout ce qui est branché sur un ordinateur est, formellement un périphérique.

L''''unité centrale''' est là où se trouvent tous les composants importants d'un ordinateur, ceux qui font des calculs, qui exécutent des logiciels, qui mémorisent vos données, etc. Voici ce à quoi ressemble l'intérieur de l'unité centrale. Trois sections sont visibles : l'alimentation électrique en haut à gauche, la carte mère en bas à gauche et en jaune/orange, les disques et lecteurs à droite des câbles. Et on voit aussi beaucoup de câbles.

[[File:Asus P5K-SEIntel E6320.jpg|centre|vignette|upright=2|Exemple d'unité centrale.]]

Tout en haut à gauche, se trouve l''''alimentation électrique''', qui convertit le courant de la prise électrique en un courant plus faible, utilisable par les autres composants. Elle émet de nombreux câbles assez gros, qui sont reliés au reste. Les PC actuels utilisent des alimentations électriques standardisées, qui fournissent trois tensions au reste de l'ordinateur : une tension de 12 Volts, une de 5 Volts, une de 3,3 Volts.

À droite, caché par la partie &quot;métallique&quot; du boitier, se trouvent les lecteurs de CD/DVD, et les disques durs. Les lecteurs CD-ROM ou DVD-ROM permettaient de lire des CD ou des DVD. Je parle au passé, car ils ont aujourd'hui disparu des ordinateurs modernes. Les '''disques durs''' sont des mémoires de stockage, qui mémorisent vos données de manière permanente. De nos jours, ils sont remplacés par des SSD, qui sont des disques durs électroniques, là où les disques durs proprement dit sont des mémoires magnétiques. Nous verrons la différence dans deux chapitres dédiés, un sur les disques durs, l'autre sur les SSD.

En bas à droite, se trouve la '''carte mère''' un support plat, en plastique ou en céramique, sur laquelle sont soudés/connectés les autres composants. Sur celle-ci, de nombreux composants sont soudés, d'autres sont branchés dessus avec des câbles, d'autres sont connectés dessus avec des connecteurs. Ils sont reliés entre eux par des fils conducteurs, le plus souvent du cuivre ou de l’aluminium, ce qui leur permet de s’échanger des données. Sur les cartes simples, ces fils sont intégrés dans la carte électronique, dans des creux du plastique. Ils portent le nom de pistes.

Avant, les disques durs, SSD et lecteurs de CD/DVD sont branchés dessus via des connecteurs dédiés, appelés des connecteurs S-ATA. De nos jours, ils sont branchés sur un autre connecteur, grâce à l'interface NVME. Toujours est-il qu'ils sont reliés à la carte mère par des câbles, ce qui montre que ce sont des sortes de périphériques interne. Ils sont placés dans le boitier, mais on aurait tout aussi bien pu les mettre à l'extérieur, vu qu'ils communiquent avec l'ordinateur par l'intermédiaire d'un câble ou d'un connecteur dédié.

Mais deux autres composants très importants sont eux placés sur la carte mère, directement. Ils ont chacun un connecteur dédié, sur lequel ils sont branchés directement, sans passer par l'intermédiaire d'un câble, mais sans être soudés non plus. Il s'agit du processeur et de la mémoire RAM, deux composants centraux des PC modernes.

[[File:Pentium III SL4CB.jpg|thumb|Processeur Pentium III.]]

Le '''processeur''' traite les données, les modifie, les manipule. Pour faire simple, il s’agit d’une grosse calculatrice hyper-puissante. Il comprend à la fois un circuit qui fait des calculs, et un circuit de contrôle qui s'occupe de séquencer les calculs dans l'ordre demandé. Il est souvent caché sous un radiateur, lui-même surmonté par un ventilateur. En effet, un processeur chauffe beaucoup, ce qui demande d'évacuer cette chaleur. Un chapitre entier expliquera pourquoi les processeurs chauffent, ainsi que les techniques utilisées pour limiter leur production de chaleur et leur consommation électrique.

La '''mémoire vive''' conserve des informations/données temporairement, tant que le processeur en a besoin. Elle prend la forme de barrettes de RAM, comme montré ci-dessous.

[[File:2 gb ddr2 667.jpg|centre|vignette|upright=2|Barrette de RAM.]]

Outre ces composants dits principaux, un ordinateur peut comprendre plusieurs composants moins importants, surtout présents sur les ordinateurs personnels. Ils sont techniquement facultatifs, mais sont très présents dans les ordinateurs personnels. Cependant, certains ordinateurs spécialisés s'en passent. Il s'agit des diverses '''cartes d'extension''' sont branchées sur la carte mère. Elles permettent d’accélérer certains calculs ou certaines applications, afin de décharger le processeur. Par exemple, la carte graphique s'occupe des calculs graphiques, qu'il s'agisse de graphismes 3D de jeux vidéos ou de l'affichage en 2D du bureau. Dans un autre registre, la carte son prend en charge le microphone et les haut-parleurs.

[[Fichier:Personal computer, exploded 4.svg|thumb|upright=1.0|Éclaté d'un ordinateur de type PC :&lt;br /&gt;
1 : Écran ;&lt;br /&gt;
2 : Carte mère ;&lt;br /&gt;
3 : Processeur ;&lt;br /&gt;
4 : Câble Parallel ATA ;&lt;br /&gt;
5 : Mémoire vive (RAM) ;&lt;br /&gt;
6 : Carte d'extension ;&lt;br /&gt;
7 : Alimentation électrique ;&lt;br /&gt;
8 : Lecteur de disque optique ;&lt;br /&gt;
9 : Disque dur ;&lt;br /&gt;
10 : Clavier ;&lt;br /&gt;
11 : Souris.]]

Si on regarde une carte mère de face, on voit un grand nombre de connecteurs, mais aussi des circuits électroniques soudés à la carte mère.

[[File:Architecture matérielle d'une carte mère.png|centre|vignette|upright=2.0|Architecture matérielle d'une carte mère]]

Les '''connecteurs''' sont là où on branche les périphériques, la carte graphique, le processeur, la mémoire, etc. Dans l'ensemble, toute carte mère contient les connecteurs suivants :
* Le processeur vient s’enchâsser dans la carte mère sur un connecteur particulier : le '''socket'''. Celui-ci varie suivant la carte mère et le processeur, ce qui est source d'incompatibilités.
* Les barrettes de mémoire RAM s’enchâssent dans un autre type de connecteurs: les '''slots mémoire'''.
* Les mémoires de masse disposent de leurs propres connecteurs : connecteurs P-ATA pour les anciens disques durs, et S-ATA pour les récents.
* Les périphériques (clavier, souris, USB, Firewire, ...) sont connectés sur un ensemble de connecteurs dédiés, localisés à l'arrière du boitier de l'unité centrale. 
* Les autres périphériques sont placés dans l'unité centrale et sont connectés via des connecteurs spécialisés. Ces périphériques sont des cartes imprimées, d'où leur nom de '''cartes filles'''. On peut notamment citer les cartes réseau, les cartes son, ou les cartes vidéo.

===Les ordinateurs portables===

[[File:Samsung QX-511 (2).JPG|vignette|Ordinateur portable Samsung QX-511 (2), pour illustration.]]

Un ordinateur portable est identique à un ordinateur de type PC. Si vous ouvrez votre ordinateur portable (attention à la garantie), vous retrouverez les mêmes composants qu'un PC à l'intérieur. Un point important est la présence d'une batterie à l'intérieur du PC portable, absente des PC fixes.

[[File:LG gram 14Z90Q mainboard with battery.jpg|centre|vignette|upright=2|LG gram 14Z90Q avec sa batterie.]]

Une fois la batterie et les circuits associés retiré, la seule différence notable est que tous les composants sont soudés sur la carte mère, au lieu d'être branchés sur des connecteurs, à part éventuellement la RAM et le disque dur.

[[File:LG gram 14Z90Q mainboard without battery.jpg|centre|vignette|upright=2|LG gram 14Z90Q sans sa batterie.]]

La RAM est parfois soudée sur la carte mère, d'autres fois sous la forme de barrettes de mémoire vive semblables à celles des PC. Dans le dernier cas, elle est connectée à des connecteurs spécifiques, ce qui permet de les changer/upgrader. Les PC portables sont parfois construits de manière à pouvoir changer la RAM facilement, en ouvrant un cache spécial, concu pour.

[[File:Lenovo G555 состав - Донор.JPG|centre|vignette|upright=2|Lenovo G555.]]

La conception d'un ordinateur portable est légèrement différente de celle d'un PC, pour des raisons thermiques. Un PC fixe a plus de place pour évacuer sa chaleur. Les ventilateurs peuvent plus facilement déplacer l'air dans le boitier, même si le flux d'air dans le boitier est éventuellement gêné par la carte graphique. Mais l'évacuation de la chaleur est assez efficace. Sur les PC portables, leur finesse fait que le trajet de l'air est beaucoup plus contraint. Évacuer la chaleur produite par l'ordinateur est plus complexe, ce qui demande d'utiliser des systèmes de refroidissement et de ventilation spécifiques.

Là où les PC fixes se débrouillent avec des radiateurs et des ventilateurs posés sur le processeur, les PC portables font autrement. Ils ne peuvent pas forcément mettre le ventilateur sur le processeur. A la place, ils mettent le ventilateur à côté, mais le processeur est surmonté par un mécanisme de transmission de la chaleur, qui transfère la chaleur du processeur vers le ventilateur.

[[File:Diagram - How a laptop cooling system works.png|centre|vignette|upright=2|Comment fonctionne le système de ventilation d'un ordinateur portable, en anglais.]]

Les difficultés pour dissiper la chaleur font que les ordinateurs portables utilisent souvent des composants peu performants, mais qui chauffent peu. En effet, nous verrons que plus un composant est puissant, plus il chauffe. La relation n'est pas parfaite, mais les processeurs haute performance chauffent plus que les modèles d'entrée ou milieu de gamme moins puissants. En conséquence, les PC portables sont souvent moins puissants que les PC fixes, même pour les modèles dit ''gaming''.

===Les serveurs et ''mainframes''===

Les grandes entreprises utilisent des ordinateurs de grande taille, très puissants, appelés des ''mainframes''. Ils sont souvent confondus avec les serveurs par le grand public, il y a une différence entre les deux. Un serveur est une fonction logicielle/réseau, pas un type d'ordinateur. Mais laissons cette différence de côté, ce qui est dit pour les ''mainframes'' sert pour les gros serveurs haute performance.

[[File:IBM Z15 mainframe.jpg|vignette|Exemple de ''mainframe''' de type IBM Z15.]]

Les anciens ''mainframes'' des années 50-80 avaient une taille pouvant être impressionnante, au point de prendre une pièce complète d'un bâtiment. Mais de nos jours, les ''mainframes'' tiennent dans une grosse armoire un peu haute. Les ''mainframes'' doivent rester allumé en permanence et ne doivent pas être éteint, sauf éventuellement quelques jours par an pour des opérations de maintenance. Ils utilisent pour cela des techniques spécifiques, avec beaucoup de redondance interne.

[[File:ACONIT hall grandes machines.jpg|centre|vignette|upright=2|''Mainframe'' ACONIT.]]

Les ''mainframes'' sont aussi conçus pour mutualiser au maximum leur utilisation, ils peuvent être utilisés par plusieurs utilisateurs à la suite, voire en même temps. Pour cela, les anciens ''mainframes'' étaient capables de faire tourner plusieurs applications distinctes l'une à la suite de l'autre, avec des commutations fréquentes entre logiciels. De nos jours, ils sont capables d'exécuter un grand nombre de tâches en même temps, grâce à la présence de plusieurs processeurs. Les ''mainframes'' modernes sont même capables de faire tourner plusieurs systèmes d'exploitation en même temps si besoin.

Les anciens ''mainframes'' étaient des ordinateurs assez simples, avec un processeur, de la mémoire RAM, un ou plusieurs disques durs, pas plus. Le ''mainframe'' était tellement énorme et cher que les entreprises n'en avaient qu'un seul pour toute l'entreprise. Les employés avaient sur leur bureau des terminaux, qui permettaient d'accéder à l'ordinateur central, mais n'étaient pas des ordinateurs. Les terminaux étaient des composants électroniques simples, avec un écran, un clavier et une souris, mais sans processeur. Ils envoyaient des données au ''mainframe'', ils en recevaient de sa part, mais tout traitement était réalisé sur le ''mainframe''. L'arrivée sur le marché des ordinateurs personnels, de type PC fixe/portable, a entrainé l'abandon de ce genre de pratique, tous les employés ont maintenant un ordinateur rien que pour eux.

{|
|-
! colspan=&quot;2&quot; | Exemples de terminaux
|-
|[[File:Terminal-in2-sm9400.jpg|centre|vignette|upright=1.5|Exemple de terminal. Notez la présence d'un écran et d'un clavier, mais l'asbence d'une unité centrale.]]
|[[File:Chromatics CT4100.jpg|vignette|upright=1.5|Autre exemple de terminal. Le clavier est couplé à un stylo CRT, qui remplacait la souris et agissait sur l'écran comme s'il était tactile.]]
|-
! colspan=&quot;2&quot; | Intérieur d'un terminal
|-
|[[File:CT1024 Monitor.jpg|vignette|upright=1.5|Terminal CT1024, sans le boitier extérieur.]]
|[[File:CT1024 Terminal System.jpg|vignette|upright=1.5|Terminal CT1024, description des composants interne.]]
|}

De nos jours, les ''mainframes'' contiennent en réalité plusieurs ordinateurs simples interconnectés via un réseau local. Un ''mainframe'' qui tient dans une armoire contient facilement une dizaine ou centaine de processeurs, plein de RAM, des disques durs séparés dans une armoire distincte, etc. Vu qu'ils communiquent uniquement via le réseau, ils n'ont pas d'interface, pas d'écran, 'entrée via clavier/souris. Le tout est commandé avec une console de commande, typiquement un ordinateur portable ou un terminal assez simple séparé de l'armoire, qui permet à un administrateur de faire des opérations de surveillance, configuration et maintenance. Il peut y avoir une console de commande pour plusieurs armoires séparées, la console peut même être dans un autre bâtiment et accéder au ''mainframe'' par le réseau.

[[File:IBM System Z9 (type 2094 inside).jpg|centre|vignette|upright=2|''Mainframe'' de type IBM System Z9. L'ordinateur portable sert de console pour qu'un administrateur fasse des opérations de surveillance, configuration et maintenance.]]

Les processeurs et la RAM sont typiquement installés sur des cartes amovibles, qui sont connectées au fond de l'armoire lors de l'installation. Il est même possible de retirer ou d'ajouter des cartes en fonctionnement, afin d'ajouter/retirer des processeurs, des disques durs, etc. Ce qui est très utile si un composant est en panne et qu'il faut le remplacer. 

[[File:IBM TotalStorage Exp400.jpg|centre|vignette|upright=2|IBM TotalStorage Exp400]]

==Un peu d'abstraction : qu'est-ce qu'un ordinateur ?==

Un ordinateur comprend donc un processeur, plusieurs mémoires, des cartes d'extension et une carte mère pour connecter le tout. Mais il s'agit là d'une description assez terre-à-terre de ce qu'est un ordinateur. Une autre description, plus abstraite, se base sur le fait qu'un ordinateur est une énorme calculatrice programmable. Elle permet d'expliquer pourquoi il y a une distinction entre processeur et mémoire, entre unité centrale et périphériques. Tout ce qui va suivre pourra vous paraitre assez abstrait, mais rassurez-vous : les prochains chapitres rendront tout cela plus concrets.

===La séparation entre entrées-sorties et traitement===

L'unité centrale peut être vue comme une énorme calculatrice ultra-puissante, qui exécute des commandes/opérations. Mais à elle seule, elle ne servirait à rien, il faut interagir avec par l'intermédiaire de plusieurs périphériques. Il existe deux types de périphériques, qui sont conceptuellement différents. Les périphériques comme le clavier ou la souris permettent d'envoyer des informations à l'ordinateur, d'agir sur celui-ci. A l'inverse, les écrans transmettent des informations dans le sens inverse : de l'ordinateur vers l'utilisateur. Les premiers sont appelés des '''entrées''', les seconds des '''sorties'''.

Dans un ordinateur, les informations sont représentées sous la forme de nombres. Toute donnée dans un ordinateur est codée avec un ou plusieurs nombres regroupés dans une donnée, un fichier, ou autre. Et la transmissions avec les entrées et sorties se fait là-encore avec des nombres. Par exemple, quand vous appuyez sur votre clavier, le clavier envoie un numéro de touche à l'unité centrale, qui indique quelle touche a été appuyée. L'image à afficher à l'écran est codée sous la forme d'une suite de nombres (un par pixel). L'image est envoyée à l'écran, qui traduit la suite de nombre en image à afficher. Les entrées traduisent des actions utilisateurs en nombres, on dit que les entrées encodent les actions utilisateur. Les sorties font la traduction inverse, elles transforment des suites de nombres en une action physique. On dit qu'elles décodent des informations.

Pour résumer, toute appareil électronique est composé par :
* Des '''entrées''' sur lesquelles l'utilisateur agit sur l'ordinateur. Les entrées transforment les actions de l'utilisateur en nombres, qui sont interprétés par l'ordinateur.
* Une '''unité de traitement''', qui manipule des nombres et fait des calculs/opérations dessus. Les nombres proviennent des entrées, du disque dur, ou d'autres sources, peu importe.
* Des '''sorties''', qui va récupèrent le résultat calculé par l'unité de traitement pour en faire quelque chose : écrire sur une imprimante ou sur un moniteur, émettre du son,...

[[File:Ordinateur théorique Simple 1.png|centre|vignette|upright=2|Ordinateur théorique Simple 1]]

L'unité de traitement proprement dite, celle qui fait les calculs, est couplée à une mémoire qui mémorise les opérandes et résultats des calculs. La séparation entre processeur et mémoire est nécessaire pour qu'un appareil électronique soit qualifié d'ordinateur. De nombreux appareils n'ont pas de séparation entre unité de traitement et mémoire, comme certaines vielles radios AM/FM.

[[File:Schéma de principe d'un ordinateur.png|centre|vignette|upright=2|Schéma de principe d'un ordinateur]]

===Un ordinateur est un appareil programmable===

Les appareils simples sont non-programmables, ce qui veut dire qu’ils sont conçus pour une utilisation particulière et qu’ils ne peuvent pas faire autre chose. Par exemple, les circuits électroniques d’un lecteur de DVD ne peuvent pas être transformé en lecteur audio ou en console de jeux... Les circuits non-programmables sont câblés une bonne fois pour toute, et on ne peut pas les modifier. On peut parfois reconfigurer le circuit, pour faire varier certains paramètres, via des interrupteurs ou des boutons, mais cela s’arrête là. Et cela pose un problème : à chaque problème qu'on veut résoudre en utilisant un automate, on doit recréer un nouveau circuit.

À l'inverse, un ordinateur n’est pas conçu pour une utilisation particulière, contrairement aux autres objets techniques. Il est possible de modifier leur fonction du jour au lendemain, on peut lui faire faire ce qu’on veut. On dit qu'ils sont '''programmables'''. Pour cela, il suffit d’utiliser un logiciel, une application, un programme (ces termes sont synonymes), qui fait ce que l'on souhaite. La totalité des logiciels présents sur un ordinateur sont des programmes comme les autres, même le système d'exploitation (Windows, Linux, ...) ne fait pas exception.

Un programme est une suite de d'instructions, chaque instruction effectuant une action dans l'ordinateur. Sur les ordinateurs modernes, la majorité de ces instructions effectuent une opération arithmétique, comme une addition, une multiplication, une soustraction, etc. Les ordinateurs modernes sont donc de grosses calculettes très puissantes, capables d'effectuer des millions d'opérations par secondes. Et qui dit opération dit nombres : un ordinateur gère nativement des nombres, qui sont codés en binaire sur la quasi-totalité des ordinateurs modernes.

Une instruction est représentée dans un ordinateur par une série de nombres : un nombre qui indique quelle opération/commande effectuer et des autres nombres pour coder les données (ou de quoi les retrouver dans l'ordinateur). L'ordinateur récupére les commandes une par une, les traduit en opération à effectuer, exécuter l'opération, et enregistre le résultat. Puis il recommence avec la commande suivante.

[[File:Ordinateur Théorique Complexe 1.png|centre|vignette|upright=3|Ordinateur Théorique Complexe. En jaune, le programme informatique, la liste de commande. Le rectangle gris est l'ordinateur proprement dit.]]

De nombreux appareils sont programmables, mais tous ne sont pas des ordinateurs. Par exemple, certains circuits programmables nommés FPGA n'en sont pas. Pour être qualifié d'ordinateur, un appareil programmable doit avoir un processeur séparé de la mémoire. De plus, il doit utiliser un '''codage numérique''', chose que nous allons aborder dans le chapitre suivant.

===Les ordinateurs à programme mémorisé ou programme externe===

Au tout début de l'informatique, on utilisait des cartes perforées en plastique, sur lesquelles on inscrivait le programme à exécuter, les données à traiter, bref : tout ce qu'on donnait à manger à l'ordinateur. Par la suite, les premiers ordinateurs grand public, comme les Amstrad ou les Commodore, utilisaient des cassettes audio magnétiques pour stocker les programmes. Dans le même style, les consoles de jeu utilisaient autrefois des cartouches de jeu, qui contenaient le programme du jeu à exécuter. Pour résumer, les anciens ordinateurs mémorisaient les programmes sur un support externe, lu par un périphérique. De tels ordinateurs sont dits à '''programme externe'''.

: D’anciens ordinateurs personnels, comme l’Amstrad ou le Commodore, permettaient de taper les programmes à exécuter à la main, au clavier, avant d’appuyer une touche pour les exécuter. Nul besoin de vous dire que les cassettes audio étaient plus pratiques.

Mais de nos jours, les programmes sont enregistrés sur le disque dur de l'ordinateur ou dans une mémoire intégrée à l'ordinateur. On dit qu'ils sont installés, ce qui est un mot bien compliqué pour dire que le programme est enregistré sur le disque dur de l’ordinateur. A défaut de disque dur, le programme/logiciel est enregistré dans une mémoire spécialisée pour le stockage. Par exemple, sur les cartes électroniques grand public de marque Arduino, les programmes sont envoyés à la carte via le port USB, mais les programmes sont enregistrés dans la carte Arduino, dans une mémoire FLASH dédiée. Disque dur ou non, le programme est mémorisé dans la mémoire de l'ordinateur. Il est possible d'installer ou de désinstaller les programmes en modifiant le contenu de la mémoire. Le terme utilisé est alors celui de '''programme stocké en mémoire'''.

Les programmes à installer sont disponibles soit sur un périphérique, comme un DVD ou une clé USB, soit sont téléchargés depuis internet. Les premiers PC fournissaient les logiciels sur des disquettes, qui contenaient un programme d'installation pour enregistrer le programme sur le disque dur de l'ordinateur. Par la suite, le support des logiciels a migré vers les CD et DVD, les logiciels devenant de plus en plus gros. De nos jours, la majorité des applications sont téléchargées depuis le net, l'usage de périphériques est devenu obsolète, même les consoles de jeu abandonnent cette méthode de distribution.

==Les générations d'ordinateurs : un historique rapide==

L'informatique a beaucoup évolué dans le temps. Et une bonne partie de cette évolution tient à l'évolution de l’électronique sous-jacente. Les ordinateurs actuels sont fabriqués avec des transistors, des petits composants électroniques qui servent d'interrupteur programmables, qu'on détaillera dans ce qui suit. Mais ça n'a pas toujours été le cas. Et cela permet de distinguer plusieurs '''générations d'ordinateurs'''.

===Les ordinateurs électro-mécaniques : les premiers ordinateurs===

Le tout premier ordinateur est le '''Z1''', un modèle unique inventé par Konrad Suze entre 1936 et 1938. Son processeur gérait non pas des nombres entiers, mais des nombres à virgule (des nombres dits flottants, pour être précis), encodés sur 22 bits. Le processeur du Z1 était capable de faire des additions et des soustractions, car il intégrait un circuit additionneur-soustracteur basique. Des circuits annexes permettaient de faire des multiplications et des divisions en enchainant des additions/soustractions successives. Il fonctionnait à une fréquence de 1 Hz, ce qui fait qu'il pouvait faire une addition/soustraction par seconde maximum.

[[File:Blue-punch-card-front.png|vignette|upright=0.5|Carte Perforée.]]

Niveau mémoire, la RAM de l'ordinateur était très limitée : seulement 16 nombres de 22 bits chacun. S'il s'agissait d'une mémoire électronique, les programmes étaient mémorisés sur une mémoire mécanique. Les programmes étaient enregistrés sur des cartes perforées, à savoir des cartes en papier dans lesquelles un 1 est codé par un trou dans le papier et un 0 par une absence de trou. Les programmes étaient exécutés par l'ordinateur quand on insérait la carte perforée dans le lecteur et qu'on appuyait sur un bouton.

[[File:German Museum of Technology, Berlin 2017 024.jpg|centre|vignette|upright=2|Réplique du Z1 au ''German Museum of Technology'' de Berlin, 2017.]]

Après sa destruction dans un bombardement, le Z1 a été reconstruit et amélioré, ce qui donné les deux ordinateurs Z2 et Z3. Quelques années plus tard, de nombreux ordinateurs ont été construits dans des laboratoires de recherche. Des grandes noms de l'histoire de l'informatique datent de cette époque : le Harvard Mark I et le Colossus Mark 1 (UK) ont tous deux été mis en service en 1944, par exemple. Ils ont servis pour les cryptanalystes pour casser les codes utilisés par les allemands pour leurs transmissions, pendant la seconde guerre mondiale.

Les ordinateurs cités dans le précédent paragraphe étaient tous des ordinateurs dit '''électro-mécaniques''', car ils mélangeaient des composants électroniques et des composants mécaniques (tout ce qui a trait aux cartes perforées, notamment). Les composants électroniques étaient soit des relais, soit des tubes à vides, les deux étant des interrupteurs commandables électriquement plus ou moins équivalents aux transistors. Les ordinateurs d'avant l'année 1944, étaient tous de ce type. Quelques ordinateurs des années 50 étaient de ce type, mais leur nombre n'a pas dépassé 30. Il faut dire qu'ils ont rapidement laissé la place à des ordinateurs purement électroniques, que nous allons voir dans ce qui suit..

===La première génération : les tubes à vide===

Les ordinateurs qui ont suivi les ordinateurs électromécaniques sont regroupés dans la '''première génération d'ordinateur'''. Ils étaient conçus avec des tubes à vide, ce qui les place entre les premiers ordinateurs électro-mécaniques et les ordinateurs utilisant des transistors. Les tubes à vide étaient assez encombrants, ils consommaient beaucoup de courant, ils chauffaient et étaient assez peu fiables. Ils tombaient en panne assez souvent. Et ils étaient assez simple à fabriquer, mais restaient malgré tout chers.

[[File:Elektronenroehren-auswahl.jpg|centre|vignette|upright=2|Tubes à vides.]]

Au vu de de la taille des  tubes à vide, les ordinateurs de l'époque étaient composé de plusieurs milliers de ces tubes, guère plus. Et malgré cela, un ordinateur prenait facilement un étage de bâtiment entier, ou au moins plusieurs pièces. La conséquence est que les ordinateurs de première génération étaient très simples, rudimentaires quand on les compare aux ordinateurs modernes. Ils ne géraient que quelques opérations simples : l'addition, la soustraction, pas grand chose de plus. A quelques exceptions près, ils ne géraient pas la multiplication et encore moins la division, cela aurait demandé trop de tubes à vides.

Une des toutes premières machines construite avec des tubes à vide était l'Atanasoff–Berry. Ce n'était pas un ordinateur, car elle ne pouvait pas exécuter de programme sans intervention humaine pour séquencer des opérations, mais c'était la première machine de calcul purement électronique, sans aucune pièce mécanique. Elle utilisait une mémoire RAM construite avec des condensateurs, ceux-ci étant placés sur des cylindres tournants. Les circuits de calcul étaient construits avec des tubes à vide et faisaient leur travail un bit à la fois. Elle fonctionnait à une fréquence de 60 Hz et pouvait faire 30 additions/soustractions par seconde. Les nombres étaient encodés sur 50 bits. 

[[File:Atanasoff Berry Computer.gif|centre|vignette|upright=2.5|Atanasoff–Berry.]]

L'arrivée de l'ENIAC en 1945 a changé la donne. Cet ordinateur a introduit plusieurs innovations majeures. La première est assez technique, il s'agit de la turing-complétude, elle a trait aux programmes qui peuvent être écrit pour un ordinateur, nous ne la détaillerons pas ici.

[[File:BabyArchitecture.png|vignette|Architecture de la Manchester Baby.]]

En 1948, le ''Manchester Baby'' a introduit une innovation extrêmement importante : le programme n'était plus mémorisé sur des cartes perforées, mais dans une mémoire électronique à l’intérieur de l'ordinateur lui-même. En clair, le ''Manchester Baby'' était le premier '''ordinateur à programme stocké en mémoire''' en français. Au-delà de ça, le Manchester Baby restait quand même très simple, c'était limite un prototype.

Il avait une RAM de 32 nombres de 32 bits, fabriquées avec des tubes Willimas (abordés dans une annexe à la fin du cours). Il gérait 8 instructions en tout, mais ne gérait pas l'addition. Il gérait la soustraction, des instructions de branchement et d'accès mémoire, mais rien d'autre. Il pouvait cependant émuler l'addition à partir d'une soustraction et inversant l'opérande soustraite. C'était une architecture avec un registre unique, appelé l'accumulateur, avec une instruction STORE pour copier son contenu en RAM et une instruction LOAD pour copier du nombre de la RAM vers l'accumulateur. Les instructions étaient chargées dans un registre pour être exécutées, le processeur avait aussi un registre pour mémoriser la position de l'instruction suivante en RAM.

===La seconde génération : le remplacement des tubes à vides par des transistors===

[[File:IBM 7070.jpg|vignette|Cartes imprimées de l'IBM 704, avec des transistors et résistances dessus.]]

La '''seconde génération''' est celle des ordinateurs fabriqués avec des '''transistors''' isolés, reliés entre avec des fils électriques. Les transistors en question possèdent trois broches, des pattes métalliques sur lesquelles on connecte des fils électriques. Le transistor s'utilise le plus souvent comme un interrupteur commandé par sa troisième broche. Le courant qui traverse les deux premières broches passe ou ne passe pas selon ce qu'on met sur la troisième.

[[File:Transistor basic flow.svg|centre|vignette|Un transistor est un morceau de conducteur, dont la conductivité est contrôlée par sa troisième broche/borne.]]

Les ordinateurs de seconde génération avaient entre 1000 et 500 000 transistors. Les capacités des ordinateurs étaient donc nettement supérieures à celles des ordinateurs de première génération. Une part non négligeable des ordinateurs de seconde génération supportait l'opération de multiplication, absente sur les ordinateurs de première génération. Néanmoins, cela variait beaucoup selon les ordinateurs.

Un exemple assez hors du commun est celui du premier modèle de l'IBM 1620. Le tout premier modèle n'avait aucun circuit de calcul, il n'était même pas capable de faire une addition ou une multiplication. A la place, il utilisait une table d'addition et une table de multiplication en mémoire RAM. Les deux tables devaient être initialisées par le logiciel lors du démarrage de la machine. La table d'addition faisait une centaine de chiffre, la table de multiplication faisait le double. Le processeur de l'ordinateur gérait des instructions pour faire des additions ou des multiplications, mais ces opérations lisaient le résultat dans la table d'addition. Les calculs étaient fait chiffre par chiffre, avec un encodage partiellement décimal, partiellement binaire (des chiffres décimaux étaient encodés en binaire, nous en reparlerons quand nous parlerons du BCD) !

[[File:KL CoreMemory.jpg|vignette|Mémoire à tore de ferrite.]]

Les transistors n'étaient utilisés que pour le processeur et les circuits annexes. La mémoire n'était pas faite en transistors, pas à cette époque. La mémoire était une mémoire aujourd'hui abandonnée, appelée une '''mémoire à tores de ferrite'''. Elle sera détaillée dans un chapitre ultérieur. Mais sachez pour le moment qu'il s'agit d'une mémoire au support magnétique, les données étant stockées sur un support magnétique.

Transistors comme tubes à vide prenaient beaucoup de place, ce qui fait que les ordinateurs étaient assez gros. Concrètement, ils prenaient une pièce de bâtiment entière dans le meilleur des cas. C'était l'époque des gros ''mainframes'', reliés à des terminaux, peu puissants comparé aux standards actuels. Seules les grandes entreprises et les grands instituts de recherche pouvaient se payer les services de ce genre d'ordinateurs. Seuls les professionnels avaient accès à ce genre d'équipement.

===La troisième génération : le circuit intégré===

[[File:D8259AC-2.jpg|vignette|Exemple de circuit intégré.]]

La troisième génération est toujours fabriquée avec des transistors, mais dont la taille a été réduite. Avec l'évolution de la technologie, les transistors ont diminué en taille, de plus en plus. Ils sont devenus tellement petits qu'ils ont finit par être regroupés dans des '''circuits intégrés''', des circuits regroupent plusieurs transistors sur la même puce de silicium. Les circuits intégrés se présentent le plus souvent sous la forme de boitiers rectangulaires, comme illustré ci-contre. D'autres ont des boitiers de forme carrées, comme ceux que l'on peut trouver sur les barrettes de mémoire RAM, ou à l'intérieur des clés USB/ disques SSD.

Lors de cette génération, les processeurs étaient fournis en pièces détachées qu'il fallait relier entre elles. Le processeur était composé de plusieurs circuits intégrés séparés, impossible de mettre un processeur dans un seul boitier. Un exemple de processeur conçu en kit est la série des Intel 3000. Elle regroupe plusieurs circuits séparés aux noms à coucher dehors, mais dont vous comprendrez ce qu'ils veulent dire dans les chapitres adéquats : l'Intel 3001 est un séquenceur, l'Intel 3002 regroupe unité de calcul et registres, le 3003 est un circuit d'anticipation de retenue complémentaire du 3002, le 3212 est une mémoire tampon, le 3214 est une unité de gestion des interruptions, les 3216/3226 sont des interfaces de bus mémoire. On pourrait aussi citer la famille de circuits intégrés AMD Am2900.

Même si le processeur était en pièce détachées, utiliser une dizaine de circuits intégrés était nettement mieux que d'utiliser plusieurs milliers de transistors individuels. En conséquence, les ordinateurs ont vu leur taille grandement réduite, passant de pièces entières à une simple armoire, voire à quelques cartes intégrées superposées. De plus, le prix des circuits intégré était abordable, du moins comparé aux ordinateurs d'avant. Le prix des ordinateurs a alors grandement décru, permettant à des entreprises et administrations de taille modeste de s'équiper d'ordinateurs.

===La quatrième génération : le microprocesseur===

[[File:MOS6502.svg|vignette|Microprocesseur, ici un processeur MOS6502, de la quatrième génération.]]

Lors de la troisième génération, les circuits intégrés regroupaient plusieurs dizaines ou centaines de transistors, mais sont rapidement montés en gamme. De centaines de transistors, ils sont passé au milliers de transistors, puis au millions et maintenant au-delà du milliard. Les transistors étaient devenus tellement petits, tellement miniaturisés, qu'il était devenu possible de mettre un processeur entier dans un circuit intégré. C'est ainsi qu'est né le microprocesseur, à savoir un processeur qui tient tout entier dans un seul circuit imprimé. La quatrième génération d’ordinateur est celle des ordinateurs basés autour d'un microprocesseur.

Les tout premiers microprocesseurs étaient des processeurs à application militaire, comme le processeur du F-14 CADC ou celui de l'Air data computer. Le tout premier microprocesseur commercialisé au grand public est le 4004 d'Intel, sorti en 1971. L'intel 4004 comprenait environ 2300 transistors, avait une fréquence de 740 MHz, pouvait faire 46 opérations différentes, et manipulait des entiers de 4 bits. Il était au départ un processeur de commande, prévu pour être intégré dans la calculatrice Busicom calculator 141-P, mais il fut utilisé pour d'autres applications quelque temps plus tard. Immédiatement après le 4004, les premiers microprocesseurs 8 bits furent commercialisés. Le 4004 fut suivi par le 8008 et quelques autres processeurs 8 bits extrêmement connus, comme le 8080 d'Intel, le 68000 de Motorola, le 6502 ou le Z80.

Les microprocesseurs permirent encore uen fois de réduire la taille des ordinateurs, qui pouvaient tenir dans un boitier de PC, ou un boitier de console de jeu. Le prix des ordinateurs a aussi chuté en même temps que les transistors était miniaturisés. C'est cette invention qui permis l'invention des consoles de jeux et des mini-ordinateurs, à savoir les ordinateurs personnels. Sans miniaturisation, on n'aurait pas d'ordinateur personnel, pas de PC fixe ou portable.

==L'organisation du cours : les différents niveaux d'explication==

Le fonctionnement d'un ordinateur est assez complexe à expliquer car les explications peuvent se faire sur plusieurs niveaux. Par plusieurs niveaux, on veut dire qu'un ordinateur est composé de composants très simples, qui sont assemblés pour donner des composants eux-même plus complexes, qui sont eux-même regrouper, etc. Étudier tout cela demande de voir plusieurs niveaux, allant de transistors très petits à des processeurs multicœurs. Les niveaux les plus bas sont de l'électronique pur et dure, alors que ceux plus haut sont à mi-chemin entre électronique et informatique.

===Les niveaux d'abstraction en architecture des ordinateurs===

Les trois premiers niveaux sont de l'électronique pur et dure. Ils correspondent aux premiers chapitres du cours, qui porteront sur les circuits électroniques en général.
* Le premier niveau est celui des '''transistors''', des circuits intégrés, des ''wafer'' et autres circuits de très petite taille.
* Le second niveau est celui des '''portes logiques''', des circuits très basiques, très simples, à la base de tous les autres.
* Le troisième niveau est celui dit de la '''''Register Transfer Level''''', où un circuit électronique est construit à partir de circuits basiques, dont des registres et autres circuits dits combinatoires.
Les deux niveaux suivants sont de l'informatique proprement dit. C'est dans ces deux niveaux qu'on étudie les ordinateurs proprement dit, les circuits qu'il y a dedans et non l'électronique en général.
* Le quatrième niveau est celui de la '''microarchitecture''', qui étudie ce qu'il y a à l'intérieur d'un processeur, d'une mémoire, des périphériques et autres.
* Le cinquième niveau est celui de l''''architecture externe''', qui décrit l'interface du processeur, de la mémoire, d'un périphérique ou autre. Par décrire l'interface, on veut dire : comment un programmeur voit le processeur et la mémoire, comment il peut les manipuler. Une architecture externe unique peut avoir plusieurs microarchitecture, ce qui fait qu'on sépare les deux. Tout cela sera plus clair quand on passera aux chapitres sur le processeur et les mémoires.

Nous n'allons pas voir les 5 niveaux dans l'ordre, des transistors vers l'architecture externe. En réalité, nous allons procéder autrement. La première partie du cours portera sur les trois premiers niveaux, le reste sur les deux autres. Les 5 niveaux seront vus dans des chapitres séparés, du moins le plus possible. Au niveau pédagogique, tout est plus simple si on scinde les 5 niveaux. Bien sûr, il y a quelques explications qui demandent de voir plusieurs niveaux à la fois. Par exemple, dans le chapitre sur les mémoires caches, nous auront des explications portant sur la RTL, la microarchitecture du cache et son architecture externe. Mais le gros du cours tentera de séparer le plus possible les 5 niveaux.

===Les trois parties principales du cours===

Nous allons commencer par parler du binaire, avant de voir les portes logiques. Avec ces portes logiques, nous allons voir comment fabriquer des circuits basiques qui reviendront très souvent dans la suite du cours. Nous verrons les registres, les décodeurs, les additionneurs et plein d'autres circuits. Puis, nous reviendrons au niveau des transistors pour finir la première partie. La raison est que c'est plus simple de faire comme cela. Tout ce qui a trait aux transistors sert à expliquer comment fabriquer des portes logiques, et il faut expliquer les portes logiques pour voir le niveau de la RTL.

Une fois la première partie finie, nous allons voir les différents composants d'un ordinateur. Une première partie expliquera ce qu'il y a dans un ordinateur, quels sont ses composants. Nous y parlerons de l'architecture de base, de la hiérarchie mémoire, des tendances technologiques, et d'autres généralités qui serviront de base pour la suite. Puis, nous verrons dans l'ordre les bus électroniques, les mémoires RAM/ROM, le processeur, les périphériques, les mémoires de stockage (SSD et disques durs) et les mémoires caches. Pour chaque composant, nous allons voir leur architecture externe, avant de voir leur microarchitecture. La raison est que la microarchitecture ne peut se comprendre que quand on sait quelle architecture externe elle implémente.

Enfin, dans une troisième partie, nous allons voir les optimisations majeures présentes dans tous les ordinateurs modernes, avec une partie sur le pipeline et le parallélisme d'instruction, et une autre sur les architectures parallèles. Pour finir, les annexes de fin parlerons de sujets un peu à part.

&lt;noinclude&gt;
{{NavChapitre | book=Fonctionnement d'un ordinateur
           | next=L'encodage des données
           | nextText=L'encodage des données
}}
&lt;/noinclude&gt;</text>
      <sha1>olx48xn316yj31ou592ymgk5svvcj28</sha1>
    </revision>
    <revision>
      <id>744124</id>
      <parentid>744123</parentid>
      <timestamp>2025-06-05T00:05:27Z</timestamp>
      <contributor>
        <username>Mewtow</username>
        <id>31375</id>
      </contributor>
      <minor />
      <comment>/* La première génération : les tubes à vide */</comment>
      <origin>744124</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="44847" sha1="sh5imug70k1nhsljbpyqhjv4mndjh7c" xml:space="preserve">Pour commencer, nous allons voir qu'il existe de nombreux types d'ordinateurs. Le plus connu est certainement le PC, l'ordinateur personnel, que vous avez sans doute dans votre salon. Les ordinateurs portables sont un deuxième type d'ordinateur assez intuitif, que vous avez peut-être. Mais il y a aussi d'autres types d'ordinateurs auxquels vous n'avez jamais été confrontés.

==Les différents types d'ordinateurs==

Dans cette section, nous allons décrire rapidement les ordinateurs les plus courant, mais surtout voir ce qu'il y a à l'intérieur d'un ordinateur.

===L'ordinateur de type PC fixe===

De l'extérieur, l'ordinateur est composé d'une unité centrale sur laquelle on branche des périphériques.

[[File:Typical computer architecture systems.jpg|vignette|upright=1.5|Exemples de périphériques, connectés à une unité centrale (ici appelée à tort ''operating system'').]]

Les '''périphériques''' regroupent l'écran, la souris, le clavier, l'imprimante, et bien d'autres choses. Ils permettent à l'utilisateur d'interagir avec l'ordinateur : un clavier permet de saisir du texte sous dans un fichier, une souris enregistre des déplacements de la main en déplacement du curseur, un écran affiche des données d’images/vidéos, un haut-parleur émet du son, etc. Tout ce qui est branché sur un ordinateur est, formellement un périphérique.

L''''unité centrale''' est là où se trouvent tous les composants importants d'un ordinateur, ceux qui font des calculs, qui exécutent des logiciels, qui mémorisent vos données, etc. Voici ce à quoi ressemble l'intérieur de l'unité centrale. Trois sections sont visibles : l'alimentation électrique en haut à gauche, la carte mère en bas à gauche et en jaune/orange, les disques et lecteurs à droite des câbles. Et on voit aussi beaucoup de câbles.

[[File:Asus P5K-SEIntel E6320.jpg|centre|vignette|upright=2|Exemple d'unité centrale.]]

Tout en haut à gauche, se trouve l''''alimentation électrique''', qui convertit le courant de la prise électrique en un courant plus faible, utilisable par les autres composants. Elle émet de nombreux câbles assez gros, qui sont reliés au reste. Les PC actuels utilisent des alimentations électriques standardisées, qui fournissent trois tensions au reste de l'ordinateur : une tension de 12 Volts, une de 5 Volts, une de 3,3 Volts.

À droite, caché par la partie &quot;métallique&quot; du boitier, se trouvent les lecteurs de CD/DVD, et les disques durs. Les lecteurs CD-ROM ou DVD-ROM permettaient de lire des CD ou des DVD. Je parle au passé, car ils ont aujourd'hui disparu des ordinateurs modernes. Les '''disques durs''' sont des mémoires de stockage, qui mémorisent vos données de manière permanente. De nos jours, ils sont remplacés par des SSD, qui sont des disques durs électroniques, là où les disques durs proprement dit sont des mémoires magnétiques. Nous verrons la différence dans deux chapitres dédiés, un sur les disques durs, l'autre sur les SSD.

En bas à droite, se trouve la '''carte mère''' un support plat, en plastique ou en céramique, sur laquelle sont soudés/connectés les autres composants. Sur celle-ci, de nombreux composants sont soudés, d'autres sont branchés dessus avec des câbles, d'autres sont connectés dessus avec des connecteurs. Ils sont reliés entre eux par des fils conducteurs, le plus souvent du cuivre ou de l’aluminium, ce qui leur permet de s’échanger des données. Sur les cartes simples, ces fils sont intégrés dans la carte électronique, dans des creux du plastique. Ils portent le nom de pistes.

Avant, les disques durs, SSD et lecteurs de CD/DVD sont branchés dessus via des connecteurs dédiés, appelés des connecteurs S-ATA. De nos jours, ils sont branchés sur un autre connecteur, grâce à l'interface NVME. Toujours est-il qu'ils sont reliés à la carte mère par des câbles, ce qui montre que ce sont des sortes de périphériques interne. Ils sont placés dans le boitier, mais on aurait tout aussi bien pu les mettre à l'extérieur, vu qu'ils communiquent avec l'ordinateur par l'intermédiaire d'un câble ou d'un connecteur dédié.

Mais deux autres composants très importants sont eux placés sur la carte mère, directement. Ils ont chacun un connecteur dédié, sur lequel ils sont branchés directement, sans passer par l'intermédiaire d'un câble, mais sans être soudés non plus. Il s'agit du processeur et de la mémoire RAM, deux composants centraux des PC modernes.

[[File:Pentium III SL4CB.jpg|thumb|Processeur Pentium III.]]

Le '''processeur''' traite les données, les modifie, les manipule. Pour faire simple, il s’agit d’une grosse calculatrice hyper-puissante. Il comprend à la fois un circuit qui fait des calculs, et un circuit de contrôle qui s'occupe de séquencer les calculs dans l'ordre demandé. Il est souvent caché sous un radiateur, lui-même surmonté par un ventilateur. En effet, un processeur chauffe beaucoup, ce qui demande d'évacuer cette chaleur. Un chapitre entier expliquera pourquoi les processeurs chauffent, ainsi que les techniques utilisées pour limiter leur production de chaleur et leur consommation électrique.

La '''mémoire vive''' conserve des informations/données temporairement, tant que le processeur en a besoin. Elle prend la forme de barrettes de RAM, comme montré ci-dessous.

[[File:2 gb ddr2 667.jpg|centre|vignette|upright=2|Barrette de RAM.]]

Outre ces composants dits principaux, un ordinateur peut comprendre plusieurs composants moins importants, surtout présents sur les ordinateurs personnels. Ils sont techniquement facultatifs, mais sont très présents dans les ordinateurs personnels. Cependant, certains ordinateurs spécialisés s'en passent. Il s'agit des diverses '''cartes d'extension''' sont branchées sur la carte mère. Elles permettent d’accélérer certains calculs ou certaines applications, afin de décharger le processeur. Par exemple, la carte graphique s'occupe des calculs graphiques, qu'il s'agisse de graphismes 3D de jeux vidéos ou de l'affichage en 2D du bureau. Dans un autre registre, la carte son prend en charge le microphone et les haut-parleurs.

[[Fichier:Personal computer, exploded 4.svg|thumb|upright=1.0|Éclaté d'un ordinateur de type PC :&lt;br /&gt;
1 : Écran ;&lt;br /&gt;
2 : Carte mère ;&lt;br /&gt;
3 : Processeur ;&lt;br /&gt;
4 : Câble Parallel ATA ;&lt;br /&gt;
5 : Mémoire vive (RAM) ;&lt;br /&gt;
6 : Carte d'extension ;&lt;br /&gt;
7 : Alimentation électrique ;&lt;br /&gt;
8 : Lecteur de disque optique ;&lt;br /&gt;
9 : Disque dur ;&lt;br /&gt;
10 : Clavier ;&lt;br /&gt;
11 : Souris.]]

Si on regarde une carte mère de face, on voit un grand nombre de connecteurs, mais aussi des circuits électroniques soudés à la carte mère.

[[File:Architecture matérielle d'une carte mère.png|centre|vignette|upright=2.0|Architecture matérielle d'une carte mère]]

Les '''connecteurs''' sont là où on branche les périphériques, la carte graphique, le processeur, la mémoire, etc. Dans l'ensemble, toute carte mère contient les connecteurs suivants :
* Le processeur vient s’enchâsser dans la carte mère sur un connecteur particulier : le '''socket'''. Celui-ci varie suivant la carte mère et le processeur, ce qui est source d'incompatibilités.
* Les barrettes de mémoire RAM s’enchâssent dans un autre type de connecteurs: les '''slots mémoire'''.
* Les mémoires de masse disposent de leurs propres connecteurs : connecteurs P-ATA pour les anciens disques durs, et S-ATA pour les récents.
* Les périphériques (clavier, souris, USB, Firewire, ...) sont connectés sur un ensemble de connecteurs dédiés, localisés à l'arrière du boitier de l'unité centrale. 
* Les autres périphériques sont placés dans l'unité centrale et sont connectés via des connecteurs spécialisés. Ces périphériques sont des cartes imprimées, d'où leur nom de '''cartes filles'''. On peut notamment citer les cartes réseau, les cartes son, ou les cartes vidéo.

===Les ordinateurs portables===

[[File:Samsung QX-511 (2).JPG|vignette|Ordinateur portable Samsung QX-511 (2), pour illustration.]]

Un ordinateur portable est identique à un ordinateur de type PC. Si vous ouvrez votre ordinateur portable (attention à la garantie), vous retrouverez les mêmes composants qu'un PC à l'intérieur. Un point important est la présence d'une batterie à l'intérieur du PC portable, absente des PC fixes.

[[File:LG gram 14Z90Q mainboard with battery.jpg|centre|vignette|upright=2|LG gram 14Z90Q avec sa batterie.]]

Une fois la batterie et les circuits associés retiré, la seule différence notable est que tous les composants sont soudés sur la carte mère, au lieu d'être branchés sur des connecteurs, à part éventuellement la RAM et le disque dur.

[[File:LG gram 14Z90Q mainboard without battery.jpg|centre|vignette|upright=2|LG gram 14Z90Q sans sa batterie.]]

La RAM est parfois soudée sur la carte mère, d'autres fois sous la forme de barrettes de mémoire vive semblables à celles des PC. Dans le dernier cas, elle est connectée à des connecteurs spécifiques, ce qui permet de les changer/upgrader. Les PC portables sont parfois construits de manière à pouvoir changer la RAM facilement, en ouvrant un cache spécial, concu pour.

[[File:Lenovo G555 состав - Донор.JPG|centre|vignette|upright=2|Lenovo G555.]]

La conception d'un ordinateur portable est légèrement différente de celle d'un PC, pour des raisons thermiques. Un PC fixe a plus de place pour évacuer sa chaleur. Les ventilateurs peuvent plus facilement déplacer l'air dans le boitier, même si le flux d'air dans le boitier est éventuellement gêné par la carte graphique. Mais l'évacuation de la chaleur est assez efficace. Sur les PC portables, leur finesse fait que le trajet de l'air est beaucoup plus contraint. Évacuer la chaleur produite par l'ordinateur est plus complexe, ce qui demande d'utiliser des systèmes de refroidissement et de ventilation spécifiques.

Là où les PC fixes se débrouillent avec des radiateurs et des ventilateurs posés sur le processeur, les PC portables font autrement. Ils ne peuvent pas forcément mettre le ventilateur sur le processeur. A la place, ils mettent le ventilateur à côté, mais le processeur est surmonté par un mécanisme de transmission de la chaleur, qui transfère la chaleur du processeur vers le ventilateur.

[[File:Diagram - How a laptop cooling system works.png|centre|vignette|upright=2|Comment fonctionne le système de ventilation d'un ordinateur portable, en anglais.]]

Les difficultés pour dissiper la chaleur font que les ordinateurs portables utilisent souvent des composants peu performants, mais qui chauffent peu. En effet, nous verrons que plus un composant est puissant, plus il chauffe. La relation n'est pas parfaite, mais les processeurs haute performance chauffent plus que les modèles d'entrée ou milieu de gamme moins puissants. En conséquence, les PC portables sont souvent moins puissants que les PC fixes, même pour les modèles dit ''gaming''.

===Les serveurs et ''mainframes''===

Les grandes entreprises utilisent des ordinateurs de grande taille, très puissants, appelés des ''mainframes''. Ils sont souvent confondus avec les serveurs par le grand public, il y a une différence entre les deux. Un serveur est une fonction logicielle/réseau, pas un type d'ordinateur. Mais laissons cette différence de côté, ce qui est dit pour les ''mainframes'' sert pour les gros serveurs haute performance.

[[File:IBM Z15 mainframe.jpg|vignette|Exemple de ''mainframe''' de type IBM Z15.]]

Les anciens ''mainframes'' des années 50-80 avaient une taille pouvant être impressionnante, au point de prendre une pièce complète d'un bâtiment. Mais de nos jours, les ''mainframes'' tiennent dans une grosse armoire un peu haute. Les ''mainframes'' doivent rester allumé en permanence et ne doivent pas être éteint, sauf éventuellement quelques jours par an pour des opérations de maintenance. Ils utilisent pour cela des techniques spécifiques, avec beaucoup de redondance interne.

[[File:ACONIT hall grandes machines.jpg|centre|vignette|upright=2|''Mainframe'' ACONIT.]]

Les ''mainframes'' sont aussi conçus pour mutualiser au maximum leur utilisation, ils peuvent être utilisés par plusieurs utilisateurs à la suite, voire en même temps. Pour cela, les anciens ''mainframes'' étaient capables de faire tourner plusieurs applications distinctes l'une à la suite de l'autre, avec des commutations fréquentes entre logiciels. De nos jours, ils sont capables d'exécuter un grand nombre de tâches en même temps, grâce à la présence de plusieurs processeurs. Les ''mainframes'' modernes sont même capables de faire tourner plusieurs systèmes d'exploitation en même temps si besoin.

Les anciens ''mainframes'' étaient des ordinateurs assez simples, avec un processeur, de la mémoire RAM, un ou plusieurs disques durs, pas plus. Le ''mainframe'' était tellement énorme et cher que les entreprises n'en avaient qu'un seul pour toute l'entreprise. Les employés avaient sur leur bureau des terminaux, qui permettaient d'accéder à l'ordinateur central, mais n'étaient pas des ordinateurs. Les terminaux étaient des composants électroniques simples, avec un écran, un clavier et une souris, mais sans processeur. Ils envoyaient des données au ''mainframe'', ils en recevaient de sa part, mais tout traitement était réalisé sur le ''mainframe''. L'arrivée sur le marché des ordinateurs personnels, de type PC fixe/portable, a entrainé l'abandon de ce genre de pratique, tous les employés ont maintenant un ordinateur rien que pour eux.

{|
|-
! colspan=&quot;2&quot; | Exemples de terminaux
|-
|[[File:Terminal-in2-sm9400.jpg|centre|vignette|upright=1.5|Exemple de terminal. Notez la présence d'un écran et d'un clavier, mais l'asbence d'une unité centrale.]]
|[[File:Chromatics CT4100.jpg|vignette|upright=1.5|Autre exemple de terminal. Le clavier est couplé à un stylo CRT, qui remplacait la souris et agissait sur l'écran comme s'il était tactile.]]
|-
! colspan=&quot;2&quot; | Intérieur d'un terminal
|-
|[[File:CT1024 Monitor.jpg|vignette|upright=1.5|Terminal CT1024, sans le boitier extérieur.]]
|[[File:CT1024 Terminal System.jpg|vignette|upright=1.5|Terminal CT1024, description des composants interne.]]
|}

De nos jours, les ''mainframes'' contiennent en réalité plusieurs ordinateurs simples interconnectés via un réseau local. Un ''mainframe'' qui tient dans une armoire contient facilement une dizaine ou centaine de processeurs, plein de RAM, des disques durs séparés dans une armoire distincte, etc. Vu qu'ils communiquent uniquement via le réseau, ils n'ont pas d'interface, pas d'écran, 'entrée via clavier/souris. Le tout est commandé avec une console de commande, typiquement un ordinateur portable ou un terminal assez simple séparé de l'armoire, qui permet à un administrateur de faire des opérations de surveillance, configuration et maintenance. Il peut y avoir une console de commande pour plusieurs armoires séparées, la console peut même être dans un autre bâtiment et accéder au ''mainframe'' par le réseau.

[[File:IBM System Z9 (type 2094 inside).jpg|centre|vignette|upright=2|''Mainframe'' de type IBM System Z9. L'ordinateur portable sert de console pour qu'un administrateur fasse des opérations de surveillance, configuration et maintenance.]]

Les processeurs et la RAM sont typiquement installés sur des cartes amovibles, qui sont connectées au fond de l'armoire lors de l'installation. Il est même possible de retirer ou d'ajouter des cartes en fonctionnement, afin d'ajouter/retirer des processeurs, des disques durs, etc. Ce qui est très utile si un composant est en panne et qu'il faut le remplacer. 

[[File:IBM TotalStorage Exp400.jpg|centre|vignette|upright=2|IBM TotalStorage Exp400]]

==Un peu d'abstraction : qu'est-ce qu'un ordinateur ?==

Un ordinateur comprend donc un processeur, plusieurs mémoires, des cartes d'extension et une carte mère pour connecter le tout. Mais il s'agit là d'une description assez terre-à-terre de ce qu'est un ordinateur. Une autre description, plus abstraite, se base sur le fait qu'un ordinateur est une énorme calculatrice programmable. Elle permet d'expliquer pourquoi il y a une distinction entre processeur et mémoire, entre unité centrale et périphériques. Tout ce qui va suivre pourra vous paraitre assez abstrait, mais rassurez-vous : les prochains chapitres rendront tout cela plus concrets.

===La séparation entre entrées-sorties et traitement===

L'unité centrale peut être vue comme une énorme calculatrice ultra-puissante, qui exécute des commandes/opérations. Mais à elle seule, elle ne servirait à rien, il faut interagir avec par l'intermédiaire de plusieurs périphériques. Il existe deux types de périphériques, qui sont conceptuellement différents. Les périphériques comme le clavier ou la souris permettent d'envoyer des informations à l'ordinateur, d'agir sur celui-ci. A l'inverse, les écrans transmettent des informations dans le sens inverse : de l'ordinateur vers l'utilisateur. Les premiers sont appelés des '''entrées''', les seconds des '''sorties'''.

Dans un ordinateur, les informations sont représentées sous la forme de nombres. Toute donnée dans un ordinateur est codée avec un ou plusieurs nombres regroupés dans une donnée, un fichier, ou autre. Et la transmissions avec les entrées et sorties se fait là-encore avec des nombres. Par exemple, quand vous appuyez sur votre clavier, le clavier envoie un numéro de touche à l'unité centrale, qui indique quelle touche a été appuyée. L'image à afficher à l'écran est codée sous la forme d'une suite de nombres (un par pixel). L'image est envoyée à l'écran, qui traduit la suite de nombre en image à afficher. Les entrées traduisent des actions utilisateurs en nombres, on dit que les entrées encodent les actions utilisateur. Les sorties font la traduction inverse, elles transforment des suites de nombres en une action physique. On dit qu'elles décodent des informations.

Pour résumer, toute appareil électronique est composé par :
* Des '''entrées''' sur lesquelles l'utilisateur agit sur l'ordinateur. Les entrées transforment les actions de l'utilisateur en nombres, qui sont interprétés par l'ordinateur.
* Une '''unité de traitement''', qui manipule des nombres et fait des calculs/opérations dessus. Les nombres proviennent des entrées, du disque dur, ou d'autres sources, peu importe.
* Des '''sorties''', qui va récupèrent le résultat calculé par l'unité de traitement pour en faire quelque chose : écrire sur une imprimante ou sur un moniteur, émettre du son,...

[[File:Ordinateur théorique Simple 1.png|centre|vignette|upright=2|Ordinateur théorique Simple 1]]

L'unité de traitement proprement dite, celle qui fait les calculs, est couplée à une mémoire qui mémorise les opérandes et résultats des calculs. La séparation entre processeur et mémoire est nécessaire pour qu'un appareil électronique soit qualifié d'ordinateur. De nombreux appareils n'ont pas de séparation entre unité de traitement et mémoire, comme certaines vielles radios AM/FM.

[[File:Schéma de principe d'un ordinateur.png|centre|vignette|upright=2|Schéma de principe d'un ordinateur]]

===Un ordinateur est un appareil programmable===

Les appareils simples sont non-programmables, ce qui veut dire qu’ils sont conçus pour une utilisation particulière et qu’ils ne peuvent pas faire autre chose. Par exemple, les circuits électroniques d’un lecteur de DVD ne peuvent pas être transformé en lecteur audio ou en console de jeux... Les circuits non-programmables sont câblés une bonne fois pour toute, et on ne peut pas les modifier. On peut parfois reconfigurer le circuit, pour faire varier certains paramètres, via des interrupteurs ou des boutons, mais cela s’arrête là. Et cela pose un problème : à chaque problème qu'on veut résoudre en utilisant un automate, on doit recréer un nouveau circuit.

À l'inverse, un ordinateur n’est pas conçu pour une utilisation particulière, contrairement aux autres objets techniques. Il est possible de modifier leur fonction du jour au lendemain, on peut lui faire faire ce qu’on veut. On dit qu'ils sont '''programmables'''. Pour cela, il suffit d’utiliser un logiciel, une application, un programme (ces termes sont synonymes), qui fait ce que l'on souhaite. La totalité des logiciels présents sur un ordinateur sont des programmes comme les autres, même le système d'exploitation (Windows, Linux, ...) ne fait pas exception.

Un programme est une suite de d'instructions, chaque instruction effectuant une action dans l'ordinateur. Sur les ordinateurs modernes, la majorité de ces instructions effectuent une opération arithmétique, comme une addition, une multiplication, une soustraction, etc. Les ordinateurs modernes sont donc de grosses calculettes très puissantes, capables d'effectuer des millions d'opérations par secondes. Et qui dit opération dit nombres : un ordinateur gère nativement des nombres, qui sont codés en binaire sur la quasi-totalité des ordinateurs modernes.

Une instruction est représentée dans un ordinateur par une série de nombres : un nombre qui indique quelle opération/commande effectuer et des autres nombres pour coder les données (ou de quoi les retrouver dans l'ordinateur). L'ordinateur récupére les commandes une par une, les traduit en opération à effectuer, exécuter l'opération, et enregistre le résultat. Puis il recommence avec la commande suivante.

[[File:Ordinateur Théorique Complexe 1.png|centre|vignette|upright=3|Ordinateur Théorique Complexe. En jaune, le programme informatique, la liste de commande. Le rectangle gris est l'ordinateur proprement dit.]]

De nombreux appareils sont programmables, mais tous ne sont pas des ordinateurs. Par exemple, certains circuits programmables nommés FPGA n'en sont pas. Pour être qualifié d'ordinateur, un appareil programmable doit avoir un processeur séparé de la mémoire. De plus, il doit utiliser un '''codage numérique''', chose que nous allons aborder dans le chapitre suivant.

===Les ordinateurs à programme mémorisé ou programme externe===

Au tout début de l'informatique, on utilisait des cartes perforées en plastique, sur lesquelles on inscrivait le programme à exécuter, les données à traiter, bref : tout ce qu'on donnait à manger à l'ordinateur. Par la suite, les premiers ordinateurs grand public, comme les Amstrad ou les Commodore, utilisaient des cassettes audio magnétiques pour stocker les programmes. Dans le même style, les consoles de jeu utilisaient autrefois des cartouches de jeu, qui contenaient le programme du jeu à exécuter. Pour résumer, les anciens ordinateurs mémorisaient les programmes sur un support externe, lu par un périphérique. De tels ordinateurs sont dits à '''programme externe'''.

: D’anciens ordinateurs personnels, comme l’Amstrad ou le Commodore, permettaient de taper les programmes à exécuter à la main, au clavier, avant d’appuyer une touche pour les exécuter. Nul besoin de vous dire que les cassettes audio étaient plus pratiques.

Mais de nos jours, les programmes sont enregistrés sur le disque dur de l'ordinateur ou dans une mémoire intégrée à l'ordinateur. On dit qu'ils sont installés, ce qui est un mot bien compliqué pour dire que le programme est enregistré sur le disque dur de l’ordinateur. A défaut de disque dur, le programme/logiciel est enregistré dans une mémoire spécialisée pour le stockage. Par exemple, sur les cartes électroniques grand public de marque Arduino, les programmes sont envoyés à la carte via le port USB, mais les programmes sont enregistrés dans la carte Arduino, dans une mémoire FLASH dédiée. Disque dur ou non, le programme est mémorisé dans la mémoire de l'ordinateur. Il est possible d'installer ou de désinstaller les programmes en modifiant le contenu de la mémoire. Le terme utilisé est alors celui de '''programme stocké en mémoire'''.

Les programmes à installer sont disponibles soit sur un périphérique, comme un DVD ou une clé USB, soit sont téléchargés depuis internet. Les premiers PC fournissaient les logiciels sur des disquettes, qui contenaient un programme d'installation pour enregistrer le programme sur le disque dur de l'ordinateur. Par la suite, le support des logiciels a migré vers les CD et DVD, les logiciels devenant de plus en plus gros. De nos jours, la majorité des applications sont téléchargées depuis le net, l'usage de périphériques est devenu obsolète, même les consoles de jeu abandonnent cette méthode de distribution.

==Les générations d'ordinateurs : un historique rapide==

L'informatique a beaucoup évolué dans le temps. Et une bonne partie de cette évolution tient à l'évolution de l’électronique sous-jacente. Les ordinateurs actuels sont fabriqués avec des transistors, des petits composants électroniques qui servent d'interrupteur programmables, qu'on détaillera dans ce qui suit. Mais ça n'a pas toujours été le cas. Et cela permet de distinguer plusieurs '''générations d'ordinateurs'''.

===Les ordinateurs électro-mécaniques : les premiers ordinateurs===

Le tout premier ordinateur est le '''Z1''', un modèle unique inventé par Konrad Suze entre 1936 et 1938. Son processeur gérait non pas des nombres entiers, mais des nombres à virgule (des nombres dits flottants, pour être précis), encodés sur 22 bits. Le processeur du Z1 était capable de faire des additions et des soustractions, car il intégrait un circuit additionneur-soustracteur basique. Des circuits annexes permettaient de faire des multiplications et des divisions en enchainant des additions/soustractions successives. Il fonctionnait à une fréquence de 1 Hz, ce qui fait qu'il pouvait faire une addition/soustraction par seconde maximum.

[[File:Blue-punch-card-front.png|vignette|upright=0.5|Carte Perforée.]]

Niveau mémoire, la RAM de l'ordinateur était très limitée : seulement 16 nombres de 22 bits chacun. S'il s'agissait d'une mémoire électronique, les programmes étaient mémorisés sur une mémoire mécanique. Les programmes étaient enregistrés sur des cartes perforées, à savoir des cartes en papier dans lesquelles un 1 est codé par un trou dans le papier et un 0 par une absence de trou. Les programmes étaient exécutés par l'ordinateur quand on insérait la carte perforée dans le lecteur et qu'on appuyait sur un bouton.

[[File:German Museum of Technology, Berlin 2017 024.jpg|centre|vignette|upright=2|Réplique du Z1 au ''German Museum of Technology'' de Berlin, 2017.]]

Après sa destruction dans un bombardement, le Z1 a été reconstruit et amélioré, ce qui donné les deux ordinateurs Z2 et Z3. Quelques années plus tard, de nombreux ordinateurs ont été construits dans des laboratoires de recherche. Des grandes noms de l'histoire de l'informatique datent de cette époque : le Harvard Mark I et le Colossus Mark 1 (UK) ont tous deux été mis en service en 1944, par exemple. Ils ont servis pour les cryptanalystes pour casser les codes utilisés par les allemands pour leurs transmissions, pendant la seconde guerre mondiale.

Les ordinateurs cités dans le précédent paragraphe étaient tous des ordinateurs dit '''électro-mécaniques''', car ils mélangeaient des composants électroniques et des composants mécaniques (tout ce qui a trait aux cartes perforées, notamment). Les composants électroniques étaient soit des relais, soit des tubes à vides, les deux étant des interrupteurs commandables électriquement plus ou moins équivalents aux transistors. Les ordinateurs d'avant l'année 1944, étaient tous de ce type. Quelques ordinateurs des années 50 étaient de ce type, mais leur nombre n'a pas dépassé 30. Il faut dire qu'ils ont rapidement laissé la place à des ordinateurs purement électroniques, que nous allons voir dans ce qui suit..

===La première génération : les tubes à vide===

Les ordinateurs qui ont suivi les ordinateurs électromécaniques sont regroupés dans la '''première génération d'ordinateur'''. Ils étaient conçus avec des tubes à vide, ce qui les place entre les premiers ordinateurs électro-mécaniques et les ordinateurs utilisant des transistors. Les tubes à vide étaient assez encombrants, ils consommaient beaucoup de courant, ils chauffaient et étaient assez peu fiables. Ils tombaient en panne assez souvent. Et ils étaient assez simple à fabriquer, mais restaient malgré tout chers.

[[File:Elektronenroehren-auswahl.jpg|centre|vignette|upright=2|Tubes à vides.]]

Au vu de de la taille des  tubes à vide, les ordinateurs de l'époque étaient composé de plusieurs milliers de ces tubes, guère plus. Et malgré cela, un ordinateur prenait facilement un étage de bâtiment entier, ou au moins plusieurs pièces. La conséquence est que les ordinateurs de première génération étaient très simples, rudimentaires quand on les compare aux ordinateurs modernes. Ils ne géraient que quelques opérations simples : l'addition, la soustraction, pas grand chose de plus. A quelques exceptions près, ils ne géraient pas la multiplication et encore moins la division, cela aurait demandé trop de tubes à vides.

Une des toutes premières machines construite avec des tubes à vide était l'Atanasoff–Berry. Ce n'était pas un ordinateur, car elle ne pouvait pas exécuter de programme sans intervention humaine pour séquencer des opérations, mais c'était la première machine de calcul purement électronique, sans aucune pièce mécanique. Elle utilisait une mémoire RAM construite avec des condensateurs, ceux-ci étant placés sur des cylindres tournants. Les circuits de calcul étaient construits avec des tubes à vide et faisaient leur travail un bit à la fois. Elle fonctionnait à une fréquence de 60 Hz et pouvait faire 30 additions/soustractions par seconde. Les nombres étaient encodés sur 50 bits. 

[[File:Atanasoff Berry Computer.gif|centre|vignette|upright=2.5|Atanasoff–Berry.]]

L'arrivée de l'ENIAC en 1945 a changé la donne. Cet ordinateur a introduit plusieurs innovations majeures. La première est assez technique, il s'agit de la turing-complétude, elle a trait aux programmes qui peuvent être écrit pour un ordinateur, nous ne la détaillerons pas ici.

[[File:BabyArchitecture.png|vignette|Architecture de la Manchester Baby.]]

En 1948, le ''Manchester Baby'' a introduit une innovation extrêmement importante : le programme n'était plus mémorisé sur des cartes perforées, mais dans une mémoire électronique à l’intérieur de l'ordinateur lui-même. En clair, le ''Manchester Baby'' était le premier '''ordinateur à programme stocké en mémoire''' en français. Au-delà de ça, le Manchester Baby restait quand même très simple, c'était limite un prototype.

Niveau interface, l'ordinateur avait une console avec 32 boutons, des interrupteurs et un écran de sortie sur lequel afficher les résultats. A l'intérieur, il y avait un processeur et une RAM de 32 nombres de 32 bits, fabriquées avec des tubes Williams (abordés dans une annexe à la fin du cours). Le programme devait tenir dans la RAM, avec une instruction prenant autant de place qu'un nombre, ce qui limitait les programmes à 32 instructions maximum. Une instruction prenait donc 32 bits, 3 indiquaient quelle opération utiliser, 12 servait à indiquer où se trouvent les opérandes en RAM, les 16 restants sont inutilisés.

Il gérait 8 instructions en tout, mais ne gérait pas l'addition. Il gérait la soustraction, des instructions de branchement et d'accès mémoire, mais rien d'autre. Il pouvait cependant émuler l'addition à partir d'une soustraction et inversant l'opérande soustraite. C'était une architecture avec un registre unique, appelé l'accumulateur, avec une instruction STORE pour copier son contenu en RAM et une instruction LOAD pour copier du nombre de la RAM vers l'accumulateur. Les instructions étaient chargées dans un registre pour être exécutées, le processeur avait aussi un registre pour mémoriser la position de l'instruction suivante en RAM.

===La seconde génération : le remplacement des tubes à vides par des transistors===

[[File:IBM 7070.jpg|vignette|Cartes imprimées de l'IBM 704, avec des transistors et résistances dessus.]]

La '''seconde génération''' est celle des ordinateurs fabriqués avec des '''transistors''' isolés, reliés entre avec des fils électriques. Les transistors en question possèdent trois broches, des pattes métalliques sur lesquelles on connecte des fils électriques. Le transistor s'utilise le plus souvent comme un interrupteur commandé par sa troisième broche. Le courant qui traverse les deux premières broches passe ou ne passe pas selon ce qu'on met sur la troisième.

[[File:Transistor basic flow.svg|centre|vignette|Un transistor est un morceau de conducteur, dont la conductivité est contrôlée par sa troisième broche/borne.]]

Les ordinateurs de seconde génération avaient entre 1000 et 500 000 transistors. Les capacités des ordinateurs étaient donc nettement supérieures à celles des ordinateurs de première génération. Une part non négligeable des ordinateurs de seconde génération supportait l'opération de multiplication, absente sur les ordinateurs de première génération. Néanmoins, cela variait beaucoup selon les ordinateurs.

Un exemple assez hors du commun est celui du premier modèle de l'IBM 1620. Le tout premier modèle n'avait aucun circuit de calcul, il n'était même pas capable de faire une addition ou une multiplication. A la place, il utilisait une table d'addition et une table de multiplication en mémoire RAM. Les deux tables devaient être initialisées par le logiciel lors du démarrage de la machine. La table d'addition faisait une centaine de chiffre, la table de multiplication faisait le double. Le processeur de l'ordinateur gérait des instructions pour faire des additions ou des multiplications, mais ces opérations lisaient le résultat dans la table d'addition. Les calculs étaient fait chiffre par chiffre, avec un encodage partiellement décimal, partiellement binaire (des chiffres décimaux étaient encodés en binaire, nous en reparlerons quand nous parlerons du BCD) !

[[File:KL CoreMemory.jpg|vignette|Mémoire à tore de ferrite.]]

Les transistors n'étaient utilisés que pour le processeur et les circuits annexes. La mémoire n'était pas faite en transistors, pas à cette époque. La mémoire était une mémoire aujourd'hui abandonnée, appelée une '''mémoire à tores de ferrite'''. Elle sera détaillée dans un chapitre ultérieur. Mais sachez pour le moment qu'il s'agit d'une mémoire au support magnétique, les données étant stockées sur un support magnétique.

Transistors comme tubes à vide prenaient beaucoup de place, ce qui fait que les ordinateurs étaient assez gros. Concrètement, ils prenaient une pièce de bâtiment entière dans le meilleur des cas. C'était l'époque des gros ''mainframes'', reliés à des terminaux, peu puissants comparé aux standards actuels. Seules les grandes entreprises et les grands instituts de recherche pouvaient se payer les services de ce genre d'ordinateurs. Seuls les professionnels avaient accès à ce genre d'équipement.

===La troisième génération : le circuit intégré===

[[File:D8259AC-2.jpg|vignette|Exemple de circuit intégré.]]

La troisième génération est toujours fabriquée avec des transistors, mais dont la taille a été réduite. Avec l'évolution de la technologie, les transistors ont diminué en taille, de plus en plus. Ils sont devenus tellement petits qu'ils ont finit par être regroupés dans des '''circuits intégrés''', des circuits regroupent plusieurs transistors sur la même puce de silicium. Les circuits intégrés se présentent le plus souvent sous la forme de boitiers rectangulaires, comme illustré ci-contre. D'autres ont des boitiers de forme carrées, comme ceux que l'on peut trouver sur les barrettes de mémoire RAM, ou à l'intérieur des clés USB/ disques SSD.

Lors de cette génération, les processeurs étaient fournis en pièces détachées qu'il fallait relier entre elles. Le processeur était composé de plusieurs circuits intégrés séparés, impossible de mettre un processeur dans un seul boitier. Un exemple de processeur conçu en kit est la série des Intel 3000. Elle regroupe plusieurs circuits séparés aux noms à coucher dehors, mais dont vous comprendrez ce qu'ils veulent dire dans les chapitres adéquats : l'Intel 3001 est un séquenceur, l'Intel 3002 regroupe unité de calcul et registres, le 3003 est un circuit d'anticipation de retenue complémentaire du 3002, le 3212 est une mémoire tampon, le 3214 est une unité de gestion des interruptions, les 3216/3226 sont des interfaces de bus mémoire. On pourrait aussi citer la famille de circuits intégrés AMD Am2900.

Même si le processeur était en pièce détachées, utiliser une dizaine de circuits intégrés était nettement mieux que d'utiliser plusieurs milliers de transistors individuels. En conséquence, les ordinateurs ont vu leur taille grandement réduite, passant de pièces entières à une simple armoire, voire à quelques cartes intégrées superposées. De plus, le prix des circuits intégré était abordable, du moins comparé aux ordinateurs d'avant. Le prix des ordinateurs a alors grandement décru, permettant à des entreprises et administrations de taille modeste de s'équiper d'ordinateurs.

===La quatrième génération : le microprocesseur===

[[File:MOS6502.svg|vignette|Microprocesseur, ici un processeur MOS6502, de la quatrième génération.]]

Lors de la troisième génération, les circuits intégrés regroupaient plusieurs dizaines ou centaines de transistors, mais sont rapidement montés en gamme. De centaines de transistors, ils sont passé au milliers de transistors, puis au millions et maintenant au-delà du milliard. Les transistors étaient devenus tellement petits, tellement miniaturisés, qu'il était devenu possible de mettre un processeur entier dans un circuit intégré. C'est ainsi qu'est né le microprocesseur, à savoir un processeur qui tient tout entier dans un seul circuit imprimé. La quatrième génération d’ordinateur est celle des ordinateurs basés autour d'un microprocesseur.

Les tout premiers microprocesseurs étaient des processeurs à application militaire, comme le processeur du F-14 CADC ou celui de l'Air data computer. Le tout premier microprocesseur commercialisé au grand public est le 4004 d'Intel, sorti en 1971. L'intel 4004 comprenait environ 2300 transistors, avait une fréquence de 740 MHz, pouvait faire 46 opérations différentes, et manipulait des entiers de 4 bits. Il était au départ un processeur de commande, prévu pour être intégré dans la calculatrice Busicom calculator 141-P, mais il fut utilisé pour d'autres applications quelque temps plus tard. Immédiatement après le 4004, les premiers microprocesseurs 8 bits furent commercialisés. Le 4004 fut suivi par le 8008 et quelques autres processeurs 8 bits extrêmement connus, comme le 8080 d'Intel, le 68000 de Motorola, le 6502 ou le Z80.

Les microprocesseurs permirent encore uen fois de réduire la taille des ordinateurs, qui pouvaient tenir dans un boitier de PC, ou un boitier de console de jeu. Le prix des ordinateurs a aussi chuté en même temps que les transistors était miniaturisés. C'est cette invention qui permis l'invention des consoles de jeux et des mini-ordinateurs, à savoir les ordinateurs personnels. Sans miniaturisation, on n'aurait pas d'ordinateur personnel, pas de PC fixe ou portable.

==L'organisation du cours : les différents niveaux d'explication==

Le fonctionnement d'un ordinateur est assez complexe à expliquer car les explications peuvent se faire sur plusieurs niveaux. Par plusieurs niveaux, on veut dire qu'un ordinateur est composé de composants très simples, qui sont assemblés pour donner des composants eux-même plus complexes, qui sont eux-même regrouper, etc. Étudier tout cela demande de voir plusieurs niveaux, allant de transistors très petits à des processeurs multicœurs. Les niveaux les plus bas sont de l'électronique pur et dure, alors que ceux plus haut sont à mi-chemin entre électronique et informatique.

===Les niveaux d'abstraction en architecture des ordinateurs===

Les trois premiers niveaux sont de l'électronique pur et dure. Ils correspondent aux premiers chapitres du cours, qui porteront sur les circuits électroniques en général.
* Le premier niveau est celui des '''transistors''', des circuits intégrés, des ''wafer'' et autres circuits de très petite taille.
* Le second niveau est celui des '''portes logiques''', des circuits très basiques, très simples, à la base de tous les autres.
* Le troisième niveau est celui dit de la '''''Register Transfer Level''''', où un circuit électronique est construit à partir de circuits basiques, dont des registres et autres circuits dits combinatoires.
Les deux niveaux suivants sont de l'informatique proprement dit. C'est dans ces deux niveaux qu'on étudie les ordinateurs proprement dit, les circuits qu'il y a dedans et non l'électronique en général.
* Le quatrième niveau est celui de la '''microarchitecture''', qui étudie ce qu'il y a à l'intérieur d'un processeur, d'une mémoire, des périphériques et autres.
* Le cinquième niveau est celui de l''''architecture externe''', qui décrit l'interface du processeur, de la mémoire, d'un périphérique ou autre. Par décrire l'interface, on veut dire : comment un programmeur voit le processeur et la mémoire, comment il peut les manipuler. Une architecture externe unique peut avoir plusieurs microarchitecture, ce qui fait qu'on sépare les deux. Tout cela sera plus clair quand on passera aux chapitres sur le processeur et les mémoires.

Nous n'allons pas voir les 5 niveaux dans l'ordre, des transistors vers l'architecture externe. En réalité, nous allons procéder autrement. La première partie du cours portera sur les trois premiers niveaux, le reste sur les deux autres. Les 5 niveaux seront vus dans des chapitres séparés, du moins le plus possible. Au niveau pédagogique, tout est plus simple si on scinde les 5 niveaux. Bien sûr, il y a quelques explications qui demandent de voir plusieurs niveaux à la fois. Par exemple, dans le chapitre sur les mémoires caches, nous auront des explications portant sur la RTL, la microarchitecture du cache et son architecture externe. Mais le gros du cours tentera de séparer le plus possible les 5 niveaux.

===Les trois parties principales du cours===

Nous allons commencer par parler du binaire, avant de voir les portes logiques. Avec ces portes logiques, nous allons voir comment fabriquer des circuits basiques qui reviendront très souvent dans la suite du cours. Nous verrons les registres, les décodeurs, les additionneurs et plein d'autres circuits. Puis, nous reviendrons au niveau des transistors pour finir la première partie. La raison est que c'est plus simple de faire comme cela. Tout ce qui a trait aux transistors sert à expliquer comment fabriquer des portes logiques, et il faut expliquer les portes logiques pour voir le niveau de la RTL.

Une fois la première partie finie, nous allons voir les différents composants d'un ordinateur. Une première partie expliquera ce qu'il y a dans un ordinateur, quels sont ses composants. Nous y parlerons de l'architecture de base, de la hiérarchie mémoire, des tendances technologiques, et d'autres généralités qui serviront de base pour la suite. Puis, nous verrons dans l'ordre les bus électroniques, les mémoires RAM/ROM, le processeur, les périphériques, les mémoires de stockage (SSD et disques durs) et les mémoires caches. Pour chaque composant, nous allons voir leur architecture externe, avant de voir leur microarchitecture. La raison est que la microarchitecture ne peut se comprendre que quand on sait quelle architecture externe elle implémente.

Enfin, dans une troisième partie, nous allons voir les optimisations majeures présentes dans tous les ordinateurs modernes, avec une partie sur le pipeline et le parallélisme d'instruction, et une autre sur les architectures parallèles. Pour finir, les annexes de fin parlerons de sujets un peu à part.

&lt;noinclude&gt;
{{NavChapitre | book=Fonctionnement d'un ordinateur
           | next=L'encodage des données
           | nextText=L'encodage des données
}}
&lt;/noinclude&gt;</text>
      <sha1>sh5imug70k1nhsljbpyqhjv4mndjh7c</sha1>
    </revision>
    <revision>
      <id>744125</id>
      <parentid>744124</parentid>
      <timestamp>2025-06-05T00:06:07Z</timestamp>
      <contributor>
        <username>Mewtow</username>
        <id>31375</id>
      </contributor>
      <minor />
      <comment>/* La première génération : les tubes à vide */</comment>
      <origin>744125</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="44858" sha1="3hjaevnmffac5d556i0ml29nih79ggz" xml:space="preserve">Pour commencer, nous allons voir qu'il existe de nombreux types d'ordinateurs. Le plus connu est certainement le PC, l'ordinateur personnel, que vous avez sans doute dans votre salon. Les ordinateurs portables sont un deuxième type d'ordinateur assez intuitif, que vous avez peut-être. Mais il y a aussi d'autres types d'ordinateurs auxquels vous n'avez jamais été confrontés.

==Les différents types d'ordinateurs==

Dans cette section, nous allons décrire rapidement les ordinateurs les plus courant, mais surtout voir ce qu'il y a à l'intérieur d'un ordinateur.

===L'ordinateur de type PC fixe===

De l'extérieur, l'ordinateur est composé d'une unité centrale sur laquelle on branche des périphériques.

[[File:Typical computer architecture systems.jpg|vignette|upright=1.5|Exemples de périphériques, connectés à une unité centrale (ici appelée à tort ''operating system'').]]

Les '''périphériques''' regroupent l'écran, la souris, le clavier, l'imprimante, et bien d'autres choses. Ils permettent à l'utilisateur d'interagir avec l'ordinateur : un clavier permet de saisir du texte sous dans un fichier, une souris enregistre des déplacements de la main en déplacement du curseur, un écran affiche des données d’images/vidéos, un haut-parleur émet du son, etc. Tout ce qui est branché sur un ordinateur est, formellement un périphérique.

L''''unité centrale''' est là où se trouvent tous les composants importants d'un ordinateur, ceux qui font des calculs, qui exécutent des logiciels, qui mémorisent vos données, etc. Voici ce à quoi ressemble l'intérieur de l'unité centrale. Trois sections sont visibles : l'alimentation électrique en haut à gauche, la carte mère en bas à gauche et en jaune/orange, les disques et lecteurs à droite des câbles. Et on voit aussi beaucoup de câbles.

[[File:Asus P5K-SEIntel E6320.jpg|centre|vignette|upright=2|Exemple d'unité centrale.]]

Tout en haut à gauche, se trouve l''''alimentation électrique''', qui convertit le courant de la prise électrique en un courant plus faible, utilisable par les autres composants. Elle émet de nombreux câbles assez gros, qui sont reliés au reste. Les PC actuels utilisent des alimentations électriques standardisées, qui fournissent trois tensions au reste de l'ordinateur : une tension de 12 Volts, une de 5 Volts, une de 3,3 Volts.

À droite, caché par la partie &quot;métallique&quot; du boitier, se trouvent les lecteurs de CD/DVD, et les disques durs. Les lecteurs CD-ROM ou DVD-ROM permettaient de lire des CD ou des DVD. Je parle au passé, car ils ont aujourd'hui disparu des ordinateurs modernes. Les '''disques durs''' sont des mémoires de stockage, qui mémorisent vos données de manière permanente. De nos jours, ils sont remplacés par des SSD, qui sont des disques durs électroniques, là où les disques durs proprement dit sont des mémoires magnétiques. Nous verrons la différence dans deux chapitres dédiés, un sur les disques durs, l'autre sur les SSD.

En bas à droite, se trouve la '''carte mère''' un support plat, en plastique ou en céramique, sur laquelle sont soudés/connectés les autres composants. Sur celle-ci, de nombreux composants sont soudés, d'autres sont branchés dessus avec des câbles, d'autres sont connectés dessus avec des connecteurs. Ils sont reliés entre eux par des fils conducteurs, le plus souvent du cuivre ou de l’aluminium, ce qui leur permet de s’échanger des données. Sur les cartes simples, ces fils sont intégrés dans la carte électronique, dans des creux du plastique. Ils portent le nom de pistes.

Avant, les disques durs, SSD et lecteurs de CD/DVD sont branchés dessus via des connecteurs dédiés, appelés des connecteurs S-ATA. De nos jours, ils sont branchés sur un autre connecteur, grâce à l'interface NVME. Toujours est-il qu'ils sont reliés à la carte mère par des câbles, ce qui montre que ce sont des sortes de périphériques interne. Ils sont placés dans le boitier, mais on aurait tout aussi bien pu les mettre à l'extérieur, vu qu'ils communiquent avec l'ordinateur par l'intermédiaire d'un câble ou d'un connecteur dédié.

Mais deux autres composants très importants sont eux placés sur la carte mère, directement. Ils ont chacun un connecteur dédié, sur lequel ils sont branchés directement, sans passer par l'intermédiaire d'un câble, mais sans être soudés non plus. Il s'agit du processeur et de la mémoire RAM, deux composants centraux des PC modernes.

[[File:Pentium III SL4CB.jpg|thumb|Processeur Pentium III.]]

Le '''processeur''' traite les données, les modifie, les manipule. Pour faire simple, il s’agit d’une grosse calculatrice hyper-puissante. Il comprend à la fois un circuit qui fait des calculs, et un circuit de contrôle qui s'occupe de séquencer les calculs dans l'ordre demandé. Il est souvent caché sous un radiateur, lui-même surmonté par un ventilateur. En effet, un processeur chauffe beaucoup, ce qui demande d'évacuer cette chaleur. Un chapitre entier expliquera pourquoi les processeurs chauffent, ainsi que les techniques utilisées pour limiter leur production de chaleur et leur consommation électrique.

La '''mémoire vive''' conserve des informations/données temporairement, tant que le processeur en a besoin. Elle prend la forme de barrettes de RAM, comme montré ci-dessous.

[[File:2 gb ddr2 667.jpg|centre|vignette|upright=2|Barrette de RAM.]]

Outre ces composants dits principaux, un ordinateur peut comprendre plusieurs composants moins importants, surtout présents sur les ordinateurs personnels. Ils sont techniquement facultatifs, mais sont très présents dans les ordinateurs personnels. Cependant, certains ordinateurs spécialisés s'en passent. Il s'agit des diverses '''cartes d'extension''' sont branchées sur la carte mère. Elles permettent d’accélérer certains calculs ou certaines applications, afin de décharger le processeur. Par exemple, la carte graphique s'occupe des calculs graphiques, qu'il s'agisse de graphismes 3D de jeux vidéos ou de l'affichage en 2D du bureau. Dans un autre registre, la carte son prend en charge le microphone et les haut-parleurs.

[[Fichier:Personal computer, exploded 4.svg|thumb|upright=1.0|Éclaté d'un ordinateur de type PC :&lt;br /&gt;
1 : Écran ;&lt;br /&gt;
2 : Carte mère ;&lt;br /&gt;
3 : Processeur ;&lt;br /&gt;
4 : Câble Parallel ATA ;&lt;br /&gt;
5 : Mémoire vive (RAM) ;&lt;br /&gt;
6 : Carte d'extension ;&lt;br /&gt;
7 : Alimentation électrique ;&lt;br /&gt;
8 : Lecteur de disque optique ;&lt;br /&gt;
9 : Disque dur ;&lt;br /&gt;
10 : Clavier ;&lt;br /&gt;
11 : Souris.]]

Si on regarde une carte mère de face, on voit un grand nombre de connecteurs, mais aussi des circuits électroniques soudés à la carte mère.

[[File:Architecture matérielle d'une carte mère.png|centre|vignette|upright=2.0|Architecture matérielle d'une carte mère]]

Les '''connecteurs''' sont là où on branche les périphériques, la carte graphique, le processeur, la mémoire, etc. Dans l'ensemble, toute carte mère contient les connecteurs suivants :
* Le processeur vient s’enchâsser dans la carte mère sur un connecteur particulier : le '''socket'''. Celui-ci varie suivant la carte mère et le processeur, ce qui est source d'incompatibilités.
* Les barrettes de mémoire RAM s’enchâssent dans un autre type de connecteurs: les '''slots mémoire'''.
* Les mémoires de masse disposent de leurs propres connecteurs : connecteurs P-ATA pour les anciens disques durs, et S-ATA pour les récents.
* Les périphériques (clavier, souris, USB, Firewire, ...) sont connectés sur un ensemble de connecteurs dédiés, localisés à l'arrière du boitier de l'unité centrale. 
* Les autres périphériques sont placés dans l'unité centrale et sont connectés via des connecteurs spécialisés. Ces périphériques sont des cartes imprimées, d'où leur nom de '''cartes filles'''. On peut notamment citer les cartes réseau, les cartes son, ou les cartes vidéo.

===Les ordinateurs portables===

[[File:Samsung QX-511 (2).JPG|vignette|Ordinateur portable Samsung QX-511 (2), pour illustration.]]

Un ordinateur portable est identique à un ordinateur de type PC. Si vous ouvrez votre ordinateur portable (attention à la garantie), vous retrouverez les mêmes composants qu'un PC à l'intérieur. Un point important est la présence d'une batterie à l'intérieur du PC portable, absente des PC fixes.

[[File:LG gram 14Z90Q mainboard with battery.jpg|centre|vignette|upright=2|LG gram 14Z90Q avec sa batterie.]]

Une fois la batterie et les circuits associés retiré, la seule différence notable est que tous les composants sont soudés sur la carte mère, au lieu d'être branchés sur des connecteurs, à part éventuellement la RAM et le disque dur.

[[File:LG gram 14Z90Q mainboard without battery.jpg|centre|vignette|upright=2|LG gram 14Z90Q sans sa batterie.]]

La RAM est parfois soudée sur la carte mère, d'autres fois sous la forme de barrettes de mémoire vive semblables à celles des PC. Dans le dernier cas, elle est connectée à des connecteurs spécifiques, ce qui permet de les changer/upgrader. Les PC portables sont parfois construits de manière à pouvoir changer la RAM facilement, en ouvrant un cache spécial, concu pour.

[[File:Lenovo G555 состав - Донор.JPG|centre|vignette|upright=2|Lenovo G555.]]

La conception d'un ordinateur portable est légèrement différente de celle d'un PC, pour des raisons thermiques. Un PC fixe a plus de place pour évacuer sa chaleur. Les ventilateurs peuvent plus facilement déplacer l'air dans le boitier, même si le flux d'air dans le boitier est éventuellement gêné par la carte graphique. Mais l'évacuation de la chaleur est assez efficace. Sur les PC portables, leur finesse fait que le trajet de l'air est beaucoup plus contraint. Évacuer la chaleur produite par l'ordinateur est plus complexe, ce qui demande d'utiliser des systèmes de refroidissement et de ventilation spécifiques.

Là où les PC fixes se débrouillent avec des radiateurs et des ventilateurs posés sur le processeur, les PC portables font autrement. Ils ne peuvent pas forcément mettre le ventilateur sur le processeur. A la place, ils mettent le ventilateur à côté, mais le processeur est surmonté par un mécanisme de transmission de la chaleur, qui transfère la chaleur du processeur vers le ventilateur.

[[File:Diagram - How a laptop cooling system works.png|centre|vignette|upright=2|Comment fonctionne le système de ventilation d'un ordinateur portable, en anglais.]]

Les difficultés pour dissiper la chaleur font que les ordinateurs portables utilisent souvent des composants peu performants, mais qui chauffent peu. En effet, nous verrons que plus un composant est puissant, plus il chauffe. La relation n'est pas parfaite, mais les processeurs haute performance chauffent plus que les modèles d'entrée ou milieu de gamme moins puissants. En conséquence, les PC portables sont souvent moins puissants que les PC fixes, même pour les modèles dit ''gaming''.

===Les serveurs et ''mainframes''===

Les grandes entreprises utilisent des ordinateurs de grande taille, très puissants, appelés des ''mainframes''. Ils sont souvent confondus avec les serveurs par le grand public, il y a une différence entre les deux. Un serveur est une fonction logicielle/réseau, pas un type d'ordinateur. Mais laissons cette différence de côté, ce qui est dit pour les ''mainframes'' sert pour les gros serveurs haute performance.

[[File:IBM Z15 mainframe.jpg|vignette|Exemple de ''mainframe''' de type IBM Z15.]]

Les anciens ''mainframes'' des années 50-80 avaient une taille pouvant être impressionnante, au point de prendre une pièce complète d'un bâtiment. Mais de nos jours, les ''mainframes'' tiennent dans une grosse armoire un peu haute. Les ''mainframes'' doivent rester allumé en permanence et ne doivent pas être éteint, sauf éventuellement quelques jours par an pour des opérations de maintenance. Ils utilisent pour cela des techniques spécifiques, avec beaucoup de redondance interne.

[[File:ACONIT hall grandes machines.jpg|centre|vignette|upright=2|''Mainframe'' ACONIT.]]

Les ''mainframes'' sont aussi conçus pour mutualiser au maximum leur utilisation, ils peuvent être utilisés par plusieurs utilisateurs à la suite, voire en même temps. Pour cela, les anciens ''mainframes'' étaient capables de faire tourner plusieurs applications distinctes l'une à la suite de l'autre, avec des commutations fréquentes entre logiciels. De nos jours, ils sont capables d'exécuter un grand nombre de tâches en même temps, grâce à la présence de plusieurs processeurs. Les ''mainframes'' modernes sont même capables de faire tourner plusieurs systèmes d'exploitation en même temps si besoin.

Les anciens ''mainframes'' étaient des ordinateurs assez simples, avec un processeur, de la mémoire RAM, un ou plusieurs disques durs, pas plus. Le ''mainframe'' était tellement énorme et cher que les entreprises n'en avaient qu'un seul pour toute l'entreprise. Les employés avaient sur leur bureau des terminaux, qui permettaient d'accéder à l'ordinateur central, mais n'étaient pas des ordinateurs. Les terminaux étaient des composants électroniques simples, avec un écran, un clavier et une souris, mais sans processeur. Ils envoyaient des données au ''mainframe'', ils en recevaient de sa part, mais tout traitement était réalisé sur le ''mainframe''. L'arrivée sur le marché des ordinateurs personnels, de type PC fixe/portable, a entrainé l'abandon de ce genre de pratique, tous les employés ont maintenant un ordinateur rien que pour eux.

{|
|-
! colspan=&quot;2&quot; | Exemples de terminaux
|-
|[[File:Terminal-in2-sm9400.jpg|centre|vignette|upright=1.5|Exemple de terminal. Notez la présence d'un écran et d'un clavier, mais l'asbence d'une unité centrale.]]
|[[File:Chromatics CT4100.jpg|vignette|upright=1.5|Autre exemple de terminal. Le clavier est couplé à un stylo CRT, qui remplacait la souris et agissait sur l'écran comme s'il était tactile.]]
|-
! colspan=&quot;2&quot; | Intérieur d'un terminal
|-
|[[File:CT1024 Monitor.jpg|vignette|upright=1.5|Terminal CT1024, sans le boitier extérieur.]]
|[[File:CT1024 Terminal System.jpg|vignette|upright=1.5|Terminal CT1024, description des composants interne.]]
|}

De nos jours, les ''mainframes'' contiennent en réalité plusieurs ordinateurs simples interconnectés via un réseau local. Un ''mainframe'' qui tient dans une armoire contient facilement une dizaine ou centaine de processeurs, plein de RAM, des disques durs séparés dans une armoire distincte, etc. Vu qu'ils communiquent uniquement via le réseau, ils n'ont pas d'interface, pas d'écran, 'entrée via clavier/souris. Le tout est commandé avec une console de commande, typiquement un ordinateur portable ou un terminal assez simple séparé de l'armoire, qui permet à un administrateur de faire des opérations de surveillance, configuration et maintenance. Il peut y avoir une console de commande pour plusieurs armoires séparées, la console peut même être dans un autre bâtiment et accéder au ''mainframe'' par le réseau.

[[File:IBM System Z9 (type 2094 inside).jpg|centre|vignette|upright=2|''Mainframe'' de type IBM System Z9. L'ordinateur portable sert de console pour qu'un administrateur fasse des opérations de surveillance, configuration et maintenance.]]

Les processeurs et la RAM sont typiquement installés sur des cartes amovibles, qui sont connectées au fond de l'armoire lors de l'installation. Il est même possible de retirer ou d'ajouter des cartes en fonctionnement, afin d'ajouter/retirer des processeurs, des disques durs, etc. Ce qui est très utile si un composant est en panne et qu'il faut le remplacer. 

[[File:IBM TotalStorage Exp400.jpg|centre|vignette|upright=2|IBM TotalStorage Exp400]]

==Un peu d'abstraction : qu'est-ce qu'un ordinateur ?==

Un ordinateur comprend donc un processeur, plusieurs mémoires, des cartes d'extension et une carte mère pour connecter le tout. Mais il s'agit là d'une description assez terre-à-terre de ce qu'est un ordinateur. Une autre description, plus abstraite, se base sur le fait qu'un ordinateur est une énorme calculatrice programmable. Elle permet d'expliquer pourquoi il y a une distinction entre processeur et mémoire, entre unité centrale et périphériques. Tout ce qui va suivre pourra vous paraitre assez abstrait, mais rassurez-vous : les prochains chapitres rendront tout cela plus concrets.

===La séparation entre entrées-sorties et traitement===

L'unité centrale peut être vue comme une énorme calculatrice ultra-puissante, qui exécute des commandes/opérations. Mais à elle seule, elle ne servirait à rien, il faut interagir avec par l'intermédiaire de plusieurs périphériques. Il existe deux types de périphériques, qui sont conceptuellement différents. Les périphériques comme le clavier ou la souris permettent d'envoyer des informations à l'ordinateur, d'agir sur celui-ci. A l'inverse, les écrans transmettent des informations dans le sens inverse : de l'ordinateur vers l'utilisateur. Les premiers sont appelés des '''entrées''', les seconds des '''sorties'''.

Dans un ordinateur, les informations sont représentées sous la forme de nombres. Toute donnée dans un ordinateur est codée avec un ou plusieurs nombres regroupés dans une donnée, un fichier, ou autre. Et la transmissions avec les entrées et sorties se fait là-encore avec des nombres. Par exemple, quand vous appuyez sur votre clavier, le clavier envoie un numéro de touche à l'unité centrale, qui indique quelle touche a été appuyée. L'image à afficher à l'écran est codée sous la forme d'une suite de nombres (un par pixel). L'image est envoyée à l'écran, qui traduit la suite de nombre en image à afficher. Les entrées traduisent des actions utilisateurs en nombres, on dit que les entrées encodent les actions utilisateur. Les sorties font la traduction inverse, elles transforment des suites de nombres en une action physique. On dit qu'elles décodent des informations.

Pour résumer, toute appareil électronique est composé par :
* Des '''entrées''' sur lesquelles l'utilisateur agit sur l'ordinateur. Les entrées transforment les actions de l'utilisateur en nombres, qui sont interprétés par l'ordinateur.
* Une '''unité de traitement''', qui manipule des nombres et fait des calculs/opérations dessus. Les nombres proviennent des entrées, du disque dur, ou d'autres sources, peu importe.
* Des '''sorties''', qui va récupèrent le résultat calculé par l'unité de traitement pour en faire quelque chose : écrire sur une imprimante ou sur un moniteur, émettre du son,...

[[File:Ordinateur théorique Simple 1.png|centre|vignette|upright=2|Ordinateur théorique Simple 1]]

L'unité de traitement proprement dite, celle qui fait les calculs, est couplée à une mémoire qui mémorise les opérandes et résultats des calculs. La séparation entre processeur et mémoire est nécessaire pour qu'un appareil électronique soit qualifié d'ordinateur. De nombreux appareils n'ont pas de séparation entre unité de traitement et mémoire, comme certaines vielles radios AM/FM.

[[File:Schéma de principe d'un ordinateur.png|centre|vignette|upright=2|Schéma de principe d'un ordinateur]]

===Un ordinateur est un appareil programmable===

Les appareils simples sont non-programmables, ce qui veut dire qu’ils sont conçus pour une utilisation particulière et qu’ils ne peuvent pas faire autre chose. Par exemple, les circuits électroniques d’un lecteur de DVD ne peuvent pas être transformé en lecteur audio ou en console de jeux... Les circuits non-programmables sont câblés une bonne fois pour toute, et on ne peut pas les modifier. On peut parfois reconfigurer le circuit, pour faire varier certains paramètres, via des interrupteurs ou des boutons, mais cela s’arrête là. Et cela pose un problème : à chaque problème qu'on veut résoudre en utilisant un automate, on doit recréer un nouveau circuit.

À l'inverse, un ordinateur n’est pas conçu pour une utilisation particulière, contrairement aux autres objets techniques. Il est possible de modifier leur fonction du jour au lendemain, on peut lui faire faire ce qu’on veut. On dit qu'ils sont '''programmables'''. Pour cela, il suffit d’utiliser un logiciel, une application, un programme (ces termes sont synonymes), qui fait ce que l'on souhaite. La totalité des logiciels présents sur un ordinateur sont des programmes comme les autres, même le système d'exploitation (Windows, Linux, ...) ne fait pas exception.

Un programme est une suite de d'instructions, chaque instruction effectuant une action dans l'ordinateur. Sur les ordinateurs modernes, la majorité de ces instructions effectuent une opération arithmétique, comme une addition, une multiplication, une soustraction, etc. Les ordinateurs modernes sont donc de grosses calculettes très puissantes, capables d'effectuer des millions d'opérations par secondes. Et qui dit opération dit nombres : un ordinateur gère nativement des nombres, qui sont codés en binaire sur la quasi-totalité des ordinateurs modernes.

Une instruction est représentée dans un ordinateur par une série de nombres : un nombre qui indique quelle opération/commande effectuer et des autres nombres pour coder les données (ou de quoi les retrouver dans l'ordinateur). L'ordinateur récupére les commandes une par une, les traduit en opération à effectuer, exécuter l'opération, et enregistre le résultat. Puis il recommence avec la commande suivante.

[[File:Ordinateur Théorique Complexe 1.png|centre|vignette|upright=3|Ordinateur Théorique Complexe. En jaune, le programme informatique, la liste de commande. Le rectangle gris est l'ordinateur proprement dit.]]

De nombreux appareils sont programmables, mais tous ne sont pas des ordinateurs. Par exemple, certains circuits programmables nommés FPGA n'en sont pas. Pour être qualifié d'ordinateur, un appareil programmable doit avoir un processeur séparé de la mémoire. De plus, il doit utiliser un '''codage numérique''', chose que nous allons aborder dans le chapitre suivant.

===Les ordinateurs à programme mémorisé ou programme externe===

Au tout début de l'informatique, on utilisait des cartes perforées en plastique, sur lesquelles on inscrivait le programme à exécuter, les données à traiter, bref : tout ce qu'on donnait à manger à l'ordinateur. Par la suite, les premiers ordinateurs grand public, comme les Amstrad ou les Commodore, utilisaient des cassettes audio magnétiques pour stocker les programmes. Dans le même style, les consoles de jeu utilisaient autrefois des cartouches de jeu, qui contenaient le programme du jeu à exécuter. Pour résumer, les anciens ordinateurs mémorisaient les programmes sur un support externe, lu par un périphérique. De tels ordinateurs sont dits à '''programme externe'''.

: D’anciens ordinateurs personnels, comme l’Amstrad ou le Commodore, permettaient de taper les programmes à exécuter à la main, au clavier, avant d’appuyer une touche pour les exécuter. Nul besoin de vous dire que les cassettes audio étaient plus pratiques.

Mais de nos jours, les programmes sont enregistrés sur le disque dur de l'ordinateur ou dans une mémoire intégrée à l'ordinateur. On dit qu'ils sont installés, ce qui est un mot bien compliqué pour dire que le programme est enregistré sur le disque dur de l’ordinateur. A défaut de disque dur, le programme/logiciel est enregistré dans une mémoire spécialisée pour le stockage. Par exemple, sur les cartes électroniques grand public de marque Arduino, les programmes sont envoyés à la carte via le port USB, mais les programmes sont enregistrés dans la carte Arduino, dans une mémoire FLASH dédiée. Disque dur ou non, le programme est mémorisé dans la mémoire de l'ordinateur. Il est possible d'installer ou de désinstaller les programmes en modifiant le contenu de la mémoire. Le terme utilisé est alors celui de '''programme stocké en mémoire'''.

Les programmes à installer sont disponibles soit sur un périphérique, comme un DVD ou une clé USB, soit sont téléchargés depuis internet. Les premiers PC fournissaient les logiciels sur des disquettes, qui contenaient un programme d'installation pour enregistrer le programme sur le disque dur de l'ordinateur. Par la suite, le support des logiciels a migré vers les CD et DVD, les logiciels devenant de plus en plus gros. De nos jours, la majorité des applications sont téléchargées depuis le net, l'usage de périphériques est devenu obsolète, même les consoles de jeu abandonnent cette méthode de distribution.

==Les générations d'ordinateurs : un historique rapide==

L'informatique a beaucoup évolué dans le temps. Et une bonne partie de cette évolution tient à l'évolution de l’électronique sous-jacente. Les ordinateurs actuels sont fabriqués avec des transistors, des petits composants électroniques qui servent d'interrupteur programmables, qu'on détaillera dans ce qui suit. Mais ça n'a pas toujours été le cas. Et cela permet de distinguer plusieurs '''générations d'ordinateurs'''.

===Les ordinateurs électro-mécaniques : les premiers ordinateurs===

Le tout premier ordinateur est le '''Z1''', un modèle unique inventé par Konrad Suze entre 1936 et 1938. Son processeur gérait non pas des nombres entiers, mais des nombres à virgule (des nombres dits flottants, pour être précis), encodés sur 22 bits. Le processeur du Z1 était capable de faire des additions et des soustractions, car il intégrait un circuit additionneur-soustracteur basique. Des circuits annexes permettaient de faire des multiplications et des divisions en enchainant des additions/soustractions successives. Il fonctionnait à une fréquence de 1 Hz, ce qui fait qu'il pouvait faire une addition/soustraction par seconde maximum.

[[File:Blue-punch-card-front.png|vignette|upright=0.5|Carte Perforée.]]

Niveau mémoire, la RAM de l'ordinateur était très limitée : seulement 16 nombres de 22 bits chacun. S'il s'agissait d'une mémoire électronique, les programmes étaient mémorisés sur une mémoire mécanique. Les programmes étaient enregistrés sur des cartes perforées, à savoir des cartes en papier dans lesquelles un 1 est codé par un trou dans le papier et un 0 par une absence de trou. Les programmes étaient exécutés par l'ordinateur quand on insérait la carte perforée dans le lecteur et qu'on appuyait sur un bouton.

[[File:German Museum of Technology, Berlin 2017 024.jpg|centre|vignette|upright=2|Réplique du Z1 au ''German Museum of Technology'' de Berlin, 2017.]]

Après sa destruction dans un bombardement, le Z1 a été reconstruit et amélioré, ce qui donné les deux ordinateurs Z2 et Z3. Quelques années plus tard, de nombreux ordinateurs ont été construits dans des laboratoires de recherche. Des grandes noms de l'histoire de l'informatique datent de cette époque : le Harvard Mark I et le Colossus Mark 1 (UK) ont tous deux été mis en service en 1944, par exemple. Ils ont servis pour les cryptanalystes pour casser les codes utilisés par les allemands pour leurs transmissions, pendant la seconde guerre mondiale.

Les ordinateurs cités dans le précédent paragraphe étaient tous des ordinateurs dit '''électro-mécaniques''', car ils mélangeaient des composants électroniques et des composants mécaniques (tout ce qui a trait aux cartes perforées, notamment). Les composants électroniques étaient soit des relais, soit des tubes à vides, les deux étant des interrupteurs commandables électriquement plus ou moins équivalents aux transistors. Les ordinateurs d'avant l'année 1944, étaient tous de ce type. Quelques ordinateurs des années 50 étaient de ce type, mais leur nombre n'a pas dépassé 30. Il faut dire qu'ils ont rapidement laissé la place à des ordinateurs purement électroniques, que nous allons voir dans ce qui suit..

===La première génération : les tubes à vide===

Les ordinateurs qui ont suivi les ordinateurs électromécaniques sont regroupés dans la '''première génération d'ordinateur'''. Ils étaient conçus avec des tubes à vide, ce qui les place entre les premiers ordinateurs électro-mécaniques et les ordinateurs utilisant des transistors. Les tubes à vide étaient assez encombrants, ils consommaient beaucoup de courant, ils chauffaient et étaient assez peu fiables. Ils tombaient en panne assez souvent. Et ils étaient assez simple à fabriquer, mais restaient malgré tout chers.

[[File:Elektronenroehren-auswahl.jpg|centre|vignette|upright=2|Tubes à vides.]]

Au vu de de la taille des  tubes à vide, les ordinateurs de l'époque étaient composé de plusieurs milliers de ces tubes, guère plus. Et malgré cela, un ordinateur prenait facilement un étage de bâtiment entier, ou au moins plusieurs pièces. La conséquence est que les ordinateurs de première génération étaient très simples, rudimentaires quand on les compare aux ordinateurs modernes. Ils ne géraient que quelques opérations simples : l'addition, la soustraction, pas grand chose de plus. A quelques exceptions près, ils ne géraient pas la multiplication et encore moins la division, cela aurait demandé trop de tubes à vides.

Une des toutes premières machines construite avec des tubes à vide était l'Atanasoff–Berry. Ce n'était pas un ordinateur, car elle ne pouvait pas exécuter de programme sans intervention humaine pour séquencer des opérations, mais c'était la première machine de calcul purement électronique, sans aucune pièce mécanique. Elle utilisait une mémoire RAM construite avec des condensateurs, ceux-ci étant placés sur des cylindres tournants. Les circuits de calcul étaient construits avec des tubes à vide et faisaient leur travail un bit à la fois. Elle fonctionnait à une fréquence de 60 Hz et pouvait faire 30 additions/soustractions par seconde. Les nombres étaient encodés sur 50 bits. 

[[File:Atanasoff Berry Computer.gif|centre|vignette|upright=2.5|Atanasoff–Berry.]]

L'arrivée de l'ENIAC en 1945 a changé la donne. Cet ordinateur a introduit plusieurs innovations majeures. La première est assez technique, il s'agit de la turing-complétude, elle a trait aux programmes qui peuvent être écrit pour un ordinateur, nous ne la détaillerons pas ici.

[[File:BabyArchitecture.png|vignette|Architecture de la Manchester Baby.]]

En 1948, le ''Manchester Baby'' a introduit une innovation extrêmement importante : le programme n'était plus mémorisé sur des cartes perforées, mais dans une mémoire électronique à l’intérieur de l'ordinateur lui-même. En clair, le ''Manchester Baby'' était le premier '''ordinateur à programme stocké en mémoire''' en français. Au-delà de ça, le Manchester Baby restait quand même très simple, c'était limite un prototype.

Niveau interface, l'ordinateur avait une console avec 32 boutons, des interrupteurs et un écran de sortie sur lequel afficher les résultats. A l'intérieur, il y avait un processeur et une RAM de 32 nombres de 32 bits, fabriquées avec des tubes Williams (abordés dans une annexe à la fin du cours). Le programme devait tenir dans la RAM, avec une instruction prenant autant de place qu'un nombre, ce qui limitait les programmes à 32 instructions maximum. Une instruction prenait donc 32 bits, 3 indiquaient quelle opération utiliser, 12 servait à indiquer où se trouvent les opérandes en RAM, les 16 restants sont inutilisés.

Il gérait 8 instructions en tout, mais ne gérait pas l'addition. Il gérait la soustraction, des instructions de branchement et d'accès mémoire, mais rien d'autre. Il pouvait cependant émuler l'addition à partir d'une soustraction et inversant l'opérande soustraite. C'était une architecture avec un registre unique de 32 bits, appelé l'accumulateur, avec une instruction STORE pour copier son contenu en RAM et une instruction LOAD pour copier du nombre de la RAM vers l'accumulateur. Les instructions étaient chargées dans un registre pour être exécutées, le processeur avait aussi un registre pour mémoriser la position de l'instruction suivante en RAM.

===La seconde génération : le remplacement des tubes à vides par des transistors===

[[File:IBM 7070.jpg|vignette|Cartes imprimées de l'IBM 704, avec des transistors et résistances dessus.]]

La '''seconde génération''' est celle des ordinateurs fabriqués avec des '''transistors''' isolés, reliés entre avec des fils électriques. Les transistors en question possèdent trois broches, des pattes métalliques sur lesquelles on connecte des fils électriques. Le transistor s'utilise le plus souvent comme un interrupteur commandé par sa troisième broche. Le courant qui traverse les deux premières broches passe ou ne passe pas selon ce qu'on met sur la troisième.

[[File:Transistor basic flow.svg|centre|vignette|Un transistor est un morceau de conducteur, dont la conductivité est contrôlée par sa troisième broche/borne.]]

Les ordinateurs de seconde génération avaient entre 1000 et 500 000 transistors. Les capacités des ordinateurs étaient donc nettement supérieures à celles des ordinateurs de première génération. Une part non négligeable des ordinateurs de seconde génération supportait l'opération de multiplication, absente sur les ordinateurs de première génération. Néanmoins, cela variait beaucoup selon les ordinateurs.

Un exemple assez hors du commun est celui du premier modèle de l'IBM 1620. Le tout premier modèle n'avait aucun circuit de calcul, il n'était même pas capable de faire une addition ou une multiplication. A la place, il utilisait une table d'addition et une table de multiplication en mémoire RAM. Les deux tables devaient être initialisées par le logiciel lors du démarrage de la machine. La table d'addition faisait une centaine de chiffre, la table de multiplication faisait le double. Le processeur de l'ordinateur gérait des instructions pour faire des additions ou des multiplications, mais ces opérations lisaient le résultat dans la table d'addition. Les calculs étaient fait chiffre par chiffre, avec un encodage partiellement décimal, partiellement binaire (des chiffres décimaux étaient encodés en binaire, nous en reparlerons quand nous parlerons du BCD) !

[[File:KL CoreMemory.jpg|vignette|Mémoire à tore de ferrite.]]

Les transistors n'étaient utilisés que pour le processeur et les circuits annexes. La mémoire n'était pas faite en transistors, pas à cette époque. La mémoire était une mémoire aujourd'hui abandonnée, appelée une '''mémoire à tores de ferrite'''. Elle sera détaillée dans un chapitre ultérieur. Mais sachez pour le moment qu'il s'agit d'une mémoire au support magnétique, les données étant stockées sur un support magnétique.

Transistors comme tubes à vide prenaient beaucoup de place, ce qui fait que les ordinateurs étaient assez gros. Concrètement, ils prenaient une pièce de bâtiment entière dans le meilleur des cas. C'était l'époque des gros ''mainframes'', reliés à des terminaux, peu puissants comparé aux standards actuels. Seules les grandes entreprises et les grands instituts de recherche pouvaient se payer les services de ce genre d'ordinateurs. Seuls les professionnels avaient accès à ce genre d'équipement.

===La troisième génération : le circuit intégré===

[[File:D8259AC-2.jpg|vignette|Exemple de circuit intégré.]]

La troisième génération est toujours fabriquée avec des transistors, mais dont la taille a été réduite. Avec l'évolution de la technologie, les transistors ont diminué en taille, de plus en plus. Ils sont devenus tellement petits qu'ils ont finit par être regroupés dans des '''circuits intégrés''', des circuits regroupent plusieurs transistors sur la même puce de silicium. Les circuits intégrés se présentent le plus souvent sous la forme de boitiers rectangulaires, comme illustré ci-contre. D'autres ont des boitiers de forme carrées, comme ceux que l'on peut trouver sur les barrettes de mémoire RAM, ou à l'intérieur des clés USB/ disques SSD.

Lors de cette génération, les processeurs étaient fournis en pièces détachées qu'il fallait relier entre elles. Le processeur était composé de plusieurs circuits intégrés séparés, impossible de mettre un processeur dans un seul boitier. Un exemple de processeur conçu en kit est la série des Intel 3000. Elle regroupe plusieurs circuits séparés aux noms à coucher dehors, mais dont vous comprendrez ce qu'ils veulent dire dans les chapitres adéquats : l'Intel 3001 est un séquenceur, l'Intel 3002 regroupe unité de calcul et registres, le 3003 est un circuit d'anticipation de retenue complémentaire du 3002, le 3212 est une mémoire tampon, le 3214 est une unité de gestion des interruptions, les 3216/3226 sont des interfaces de bus mémoire. On pourrait aussi citer la famille de circuits intégrés AMD Am2900.

Même si le processeur était en pièce détachées, utiliser une dizaine de circuits intégrés était nettement mieux que d'utiliser plusieurs milliers de transistors individuels. En conséquence, les ordinateurs ont vu leur taille grandement réduite, passant de pièces entières à une simple armoire, voire à quelques cartes intégrées superposées. De plus, le prix des circuits intégré était abordable, du moins comparé aux ordinateurs d'avant. Le prix des ordinateurs a alors grandement décru, permettant à des entreprises et administrations de taille modeste de s'équiper d'ordinateurs.

===La quatrième génération : le microprocesseur===

[[File:MOS6502.svg|vignette|Microprocesseur, ici un processeur MOS6502, de la quatrième génération.]]

Lors de la troisième génération, les circuits intégrés regroupaient plusieurs dizaines ou centaines de transistors, mais sont rapidement montés en gamme. De centaines de transistors, ils sont passé au milliers de transistors, puis au millions et maintenant au-delà du milliard. Les transistors étaient devenus tellement petits, tellement miniaturisés, qu'il était devenu possible de mettre un processeur entier dans un circuit intégré. C'est ainsi qu'est né le microprocesseur, à savoir un processeur qui tient tout entier dans un seul circuit imprimé. La quatrième génération d’ordinateur est celle des ordinateurs basés autour d'un microprocesseur.

Les tout premiers microprocesseurs étaient des processeurs à application militaire, comme le processeur du F-14 CADC ou celui de l'Air data computer. Le tout premier microprocesseur commercialisé au grand public est le 4004 d'Intel, sorti en 1971. L'intel 4004 comprenait environ 2300 transistors, avait une fréquence de 740 MHz, pouvait faire 46 opérations différentes, et manipulait des entiers de 4 bits. Il était au départ un processeur de commande, prévu pour être intégré dans la calculatrice Busicom calculator 141-P, mais il fut utilisé pour d'autres applications quelque temps plus tard. Immédiatement après le 4004, les premiers microprocesseurs 8 bits furent commercialisés. Le 4004 fut suivi par le 8008 et quelques autres processeurs 8 bits extrêmement connus, comme le 8080 d'Intel, le 68000 de Motorola, le 6502 ou le Z80.

Les microprocesseurs permirent encore uen fois de réduire la taille des ordinateurs, qui pouvaient tenir dans un boitier de PC, ou un boitier de console de jeu. Le prix des ordinateurs a aussi chuté en même temps que les transistors était miniaturisés. C'est cette invention qui permis l'invention des consoles de jeux et des mini-ordinateurs, à savoir les ordinateurs personnels. Sans miniaturisation, on n'aurait pas d'ordinateur personnel, pas de PC fixe ou portable.

==L'organisation du cours : les différents niveaux d'explication==

Le fonctionnement d'un ordinateur est assez complexe à expliquer car les explications peuvent se faire sur plusieurs niveaux. Par plusieurs niveaux, on veut dire qu'un ordinateur est composé de composants très simples, qui sont assemblés pour donner des composants eux-même plus complexes, qui sont eux-même regrouper, etc. Étudier tout cela demande de voir plusieurs niveaux, allant de transistors très petits à des processeurs multicœurs. Les niveaux les plus bas sont de l'électronique pur et dure, alors que ceux plus haut sont à mi-chemin entre électronique et informatique.

===Les niveaux d'abstraction en architecture des ordinateurs===

Les trois premiers niveaux sont de l'électronique pur et dure. Ils correspondent aux premiers chapitres du cours, qui porteront sur les circuits électroniques en général.
* Le premier niveau est celui des '''transistors''', des circuits intégrés, des ''wafer'' et autres circuits de très petite taille.
* Le second niveau est celui des '''portes logiques''', des circuits très basiques, très simples, à la base de tous les autres.
* Le troisième niveau est celui dit de la '''''Register Transfer Level''''', où un circuit électronique est construit à partir de circuits basiques, dont des registres et autres circuits dits combinatoires.
Les deux niveaux suivants sont de l'informatique proprement dit. C'est dans ces deux niveaux qu'on étudie les ordinateurs proprement dit, les circuits qu'il y a dedans et non l'électronique en général.
* Le quatrième niveau est celui de la '''microarchitecture''', qui étudie ce qu'il y a à l'intérieur d'un processeur, d'une mémoire, des périphériques et autres.
* Le cinquième niveau est celui de l''''architecture externe''', qui décrit l'interface du processeur, de la mémoire, d'un périphérique ou autre. Par décrire l'interface, on veut dire : comment un programmeur voit le processeur et la mémoire, comment il peut les manipuler. Une architecture externe unique peut avoir plusieurs microarchitecture, ce qui fait qu'on sépare les deux. Tout cela sera plus clair quand on passera aux chapitres sur le processeur et les mémoires.

Nous n'allons pas voir les 5 niveaux dans l'ordre, des transistors vers l'architecture externe. En réalité, nous allons procéder autrement. La première partie du cours portera sur les trois premiers niveaux, le reste sur les deux autres. Les 5 niveaux seront vus dans des chapitres séparés, du moins le plus possible. Au niveau pédagogique, tout est plus simple si on scinde les 5 niveaux. Bien sûr, il y a quelques explications qui demandent de voir plusieurs niveaux à la fois. Par exemple, dans le chapitre sur les mémoires caches, nous auront des explications portant sur la RTL, la microarchitecture du cache et son architecture externe. Mais le gros du cours tentera de séparer le plus possible les 5 niveaux.

===Les trois parties principales du cours===

Nous allons commencer par parler du binaire, avant de voir les portes logiques. Avec ces portes logiques, nous allons voir comment fabriquer des circuits basiques qui reviendront très souvent dans la suite du cours. Nous verrons les registres, les décodeurs, les additionneurs et plein d'autres circuits. Puis, nous reviendrons au niveau des transistors pour finir la première partie. La raison est que c'est plus simple de faire comme cela. Tout ce qui a trait aux transistors sert à expliquer comment fabriquer des portes logiques, et il faut expliquer les portes logiques pour voir le niveau de la RTL.

Une fois la première partie finie, nous allons voir les différents composants d'un ordinateur. Une première partie expliquera ce qu'il y a dans un ordinateur, quels sont ses composants. Nous y parlerons de l'architecture de base, de la hiérarchie mémoire, des tendances technologiques, et d'autres généralités qui serviront de base pour la suite. Puis, nous verrons dans l'ordre les bus électroniques, les mémoires RAM/ROM, le processeur, les périphériques, les mémoires de stockage (SSD et disques durs) et les mémoires caches. Pour chaque composant, nous allons voir leur architecture externe, avant de voir leur microarchitecture. La raison est que la microarchitecture ne peut se comprendre que quand on sait quelle architecture externe elle implémente.

Enfin, dans une troisième partie, nous allons voir les optimisations majeures présentes dans tous les ordinateurs modernes, avec une partie sur le pipeline et le parallélisme d'instruction, et une autre sur les architectures parallèles. Pour finir, les annexes de fin parlerons de sujets un peu à part.

&lt;noinclude&gt;
{{NavChapitre | book=Fonctionnement d'un ordinateur
           | next=L'encodage des données
           | nextText=L'encodage des données
}}
&lt;/noinclude&gt;</text>
      <sha1>3hjaevnmffac5d556i0ml29nih79ggz</sha1>
    </revision>
    <revision>
      <id>744126</id>
      <parentid>744125</parentid>
      <timestamp>2025-06-05T00:10:24Z</timestamp>
      <contributor>
        <username>Mewtow</username>
        <id>31375</id>
      </contributor>
      <minor />
      <comment>/* La première génération : les tubes à vide */</comment>
      <origin>744126</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="45359" sha1="tdmx3caxb12lhxqmkcte9dnjbr26c4r" xml:space="preserve">Pour commencer, nous allons voir qu'il existe de nombreux types d'ordinateurs. Le plus connu est certainement le PC, l'ordinateur personnel, que vous avez sans doute dans votre salon. Les ordinateurs portables sont un deuxième type d'ordinateur assez intuitif, que vous avez peut-être. Mais il y a aussi d'autres types d'ordinateurs auxquels vous n'avez jamais été confrontés.

==Les différents types d'ordinateurs==

Dans cette section, nous allons décrire rapidement les ordinateurs les plus courant, mais surtout voir ce qu'il y a à l'intérieur d'un ordinateur.

===L'ordinateur de type PC fixe===

De l'extérieur, l'ordinateur est composé d'une unité centrale sur laquelle on branche des périphériques.

[[File:Typical computer architecture systems.jpg|vignette|upright=1.5|Exemples de périphériques, connectés à une unité centrale (ici appelée à tort ''operating system'').]]

Les '''périphériques''' regroupent l'écran, la souris, le clavier, l'imprimante, et bien d'autres choses. Ils permettent à l'utilisateur d'interagir avec l'ordinateur : un clavier permet de saisir du texte sous dans un fichier, une souris enregistre des déplacements de la main en déplacement du curseur, un écran affiche des données d’images/vidéos, un haut-parleur émet du son, etc. Tout ce qui est branché sur un ordinateur est, formellement un périphérique.

L''''unité centrale''' est là où se trouvent tous les composants importants d'un ordinateur, ceux qui font des calculs, qui exécutent des logiciels, qui mémorisent vos données, etc. Voici ce à quoi ressemble l'intérieur de l'unité centrale. Trois sections sont visibles : l'alimentation électrique en haut à gauche, la carte mère en bas à gauche et en jaune/orange, les disques et lecteurs à droite des câbles. Et on voit aussi beaucoup de câbles.

[[File:Asus P5K-SEIntel E6320.jpg|centre|vignette|upright=2|Exemple d'unité centrale.]]

Tout en haut à gauche, se trouve l''''alimentation électrique''', qui convertit le courant de la prise électrique en un courant plus faible, utilisable par les autres composants. Elle émet de nombreux câbles assez gros, qui sont reliés au reste. Les PC actuels utilisent des alimentations électriques standardisées, qui fournissent trois tensions au reste de l'ordinateur : une tension de 12 Volts, une de 5 Volts, une de 3,3 Volts.

À droite, caché par la partie &quot;métallique&quot; du boitier, se trouvent les lecteurs de CD/DVD, et les disques durs. Les lecteurs CD-ROM ou DVD-ROM permettaient de lire des CD ou des DVD. Je parle au passé, car ils ont aujourd'hui disparu des ordinateurs modernes. Les '''disques durs''' sont des mémoires de stockage, qui mémorisent vos données de manière permanente. De nos jours, ils sont remplacés par des SSD, qui sont des disques durs électroniques, là où les disques durs proprement dit sont des mémoires magnétiques. Nous verrons la différence dans deux chapitres dédiés, un sur les disques durs, l'autre sur les SSD.

En bas à droite, se trouve la '''carte mère''' un support plat, en plastique ou en céramique, sur laquelle sont soudés/connectés les autres composants. Sur celle-ci, de nombreux composants sont soudés, d'autres sont branchés dessus avec des câbles, d'autres sont connectés dessus avec des connecteurs. Ils sont reliés entre eux par des fils conducteurs, le plus souvent du cuivre ou de l’aluminium, ce qui leur permet de s’échanger des données. Sur les cartes simples, ces fils sont intégrés dans la carte électronique, dans des creux du plastique. Ils portent le nom de pistes.

Avant, les disques durs, SSD et lecteurs de CD/DVD sont branchés dessus via des connecteurs dédiés, appelés des connecteurs S-ATA. De nos jours, ils sont branchés sur un autre connecteur, grâce à l'interface NVME. Toujours est-il qu'ils sont reliés à la carte mère par des câbles, ce qui montre que ce sont des sortes de périphériques interne. Ils sont placés dans le boitier, mais on aurait tout aussi bien pu les mettre à l'extérieur, vu qu'ils communiquent avec l'ordinateur par l'intermédiaire d'un câble ou d'un connecteur dédié.

Mais deux autres composants très importants sont eux placés sur la carte mère, directement. Ils ont chacun un connecteur dédié, sur lequel ils sont branchés directement, sans passer par l'intermédiaire d'un câble, mais sans être soudés non plus. Il s'agit du processeur et de la mémoire RAM, deux composants centraux des PC modernes.

[[File:Pentium III SL4CB.jpg|thumb|Processeur Pentium III.]]

Le '''processeur''' traite les données, les modifie, les manipule. Pour faire simple, il s’agit d’une grosse calculatrice hyper-puissante. Il comprend à la fois un circuit qui fait des calculs, et un circuit de contrôle qui s'occupe de séquencer les calculs dans l'ordre demandé. Il est souvent caché sous un radiateur, lui-même surmonté par un ventilateur. En effet, un processeur chauffe beaucoup, ce qui demande d'évacuer cette chaleur. Un chapitre entier expliquera pourquoi les processeurs chauffent, ainsi que les techniques utilisées pour limiter leur production de chaleur et leur consommation électrique.

La '''mémoire vive''' conserve des informations/données temporairement, tant que le processeur en a besoin. Elle prend la forme de barrettes de RAM, comme montré ci-dessous.

[[File:2 gb ddr2 667.jpg|centre|vignette|upright=2|Barrette de RAM.]]

Outre ces composants dits principaux, un ordinateur peut comprendre plusieurs composants moins importants, surtout présents sur les ordinateurs personnels. Ils sont techniquement facultatifs, mais sont très présents dans les ordinateurs personnels. Cependant, certains ordinateurs spécialisés s'en passent. Il s'agit des diverses '''cartes d'extension''' sont branchées sur la carte mère. Elles permettent d’accélérer certains calculs ou certaines applications, afin de décharger le processeur. Par exemple, la carte graphique s'occupe des calculs graphiques, qu'il s'agisse de graphismes 3D de jeux vidéos ou de l'affichage en 2D du bureau. Dans un autre registre, la carte son prend en charge le microphone et les haut-parleurs.

[[Fichier:Personal computer, exploded 4.svg|thumb|upright=1.0|Éclaté d'un ordinateur de type PC :&lt;br /&gt;
1 : Écran ;&lt;br /&gt;
2 : Carte mère ;&lt;br /&gt;
3 : Processeur ;&lt;br /&gt;
4 : Câble Parallel ATA ;&lt;br /&gt;
5 : Mémoire vive (RAM) ;&lt;br /&gt;
6 : Carte d'extension ;&lt;br /&gt;
7 : Alimentation électrique ;&lt;br /&gt;
8 : Lecteur de disque optique ;&lt;br /&gt;
9 : Disque dur ;&lt;br /&gt;
10 : Clavier ;&lt;br /&gt;
11 : Souris.]]

Si on regarde une carte mère de face, on voit un grand nombre de connecteurs, mais aussi des circuits électroniques soudés à la carte mère.

[[File:Architecture matérielle d'une carte mère.png|centre|vignette|upright=2.0|Architecture matérielle d'une carte mère]]

Les '''connecteurs''' sont là où on branche les périphériques, la carte graphique, le processeur, la mémoire, etc. Dans l'ensemble, toute carte mère contient les connecteurs suivants :
* Le processeur vient s’enchâsser dans la carte mère sur un connecteur particulier : le '''socket'''. Celui-ci varie suivant la carte mère et le processeur, ce qui est source d'incompatibilités.
* Les barrettes de mémoire RAM s’enchâssent dans un autre type de connecteurs: les '''slots mémoire'''.
* Les mémoires de masse disposent de leurs propres connecteurs : connecteurs P-ATA pour les anciens disques durs, et S-ATA pour les récents.
* Les périphériques (clavier, souris, USB, Firewire, ...) sont connectés sur un ensemble de connecteurs dédiés, localisés à l'arrière du boitier de l'unité centrale. 
* Les autres périphériques sont placés dans l'unité centrale et sont connectés via des connecteurs spécialisés. Ces périphériques sont des cartes imprimées, d'où leur nom de '''cartes filles'''. On peut notamment citer les cartes réseau, les cartes son, ou les cartes vidéo.

===Les ordinateurs portables===

[[File:Samsung QX-511 (2).JPG|vignette|Ordinateur portable Samsung QX-511 (2), pour illustration.]]

Un ordinateur portable est identique à un ordinateur de type PC. Si vous ouvrez votre ordinateur portable (attention à la garantie), vous retrouverez les mêmes composants qu'un PC à l'intérieur. Un point important est la présence d'une batterie à l'intérieur du PC portable, absente des PC fixes.

[[File:LG gram 14Z90Q mainboard with battery.jpg|centre|vignette|upright=2|LG gram 14Z90Q avec sa batterie.]]

Une fois la batterie et les circuits associés retiré, la seule différence notable est que tous les composants sont soudés sur la carte mère, au lieu d'être branchés sur des connecteurs, à part éventuellement la RAM et le disque dur.

[[File:LG gram 14Z90Q mainboard without battery.jpg|centre|vignette|upright=2|LG gram 14Z90Q sans sa batterie.]]

La RAM est parfois soudée sur la carte mère, d'autres fois sous la forme de barrettes de mémoire vive semblables à celles des PC. Dans le dernier cas, elle est connectée à des connecteurs spécifiques, ce qui permet de les changer/upgrader. Les PC portables sont parfois construits de manière à pouvoir changer la RAM facilement, en ouvrant un cache spécial, concu pour.

[[File:Lenovo G555 состав - Донор.JPG|centre|vignette|upright=2|Lenovo G555.]]

La conception d'un ordinateur portable est légèrement différente de celle d'un PC, pour des raisons thermiques. Un PC fixe a plus de place pour évacuer sa chaleur. Les ventilateurs peuvent plus facilement déplacer l'air dans le boitier, même si le flux d'air dans le boitier est éventuellement gêné par la carte graphique. Mais l'évacuation de la chaleur est assez efficace. Sur les PC portables, leur finesse fait que le trajet de l'air est beaucoup plus contraint. Évacuer la chaleur produite par l'ordinateur est plus complexe, ce qui demande d'utiliser des systèmes de refroidissement et de ventilation spécifiques.

Là où les PC fixes se débrouillent avec des radiateurs et des ventilateurs posés sur le processeur, les PC portables font autrement. Ils ne peuvent pas forcément mettre le ventilateur sur le processeur. A la place, ils mettent le ventilateur à côté, mais le processeur est surmonté par un mécanisme de transmission de la chaleur, qui transfère la chaleur du processeur vers le ventilateur.

[[File:Diagram - How a laptop cooling system works.png|centre|vignette|upright=2|Comment fonctionne le système de ventilation d'un ordinateur portable, en anglais.]]

Les difficultés pour dissiper la chaleur font que les ordinateurs portables utilisent souvent des composants peu performants, mais qui chauffent peu. En effet, nous verrons que plus un composant est puissant, plus il chauffe. La relation n'est pas parfaite, mais les processeurs haute performance chauffent plus que les modèles d'entrée ou milieu de gamme moins puissants. En conséquence, les PC portables sont souvent moins puissants que les PC fixes, même pour les modèles dit ''gaming''.

===Les serveurs et ''mainframes''===

Les grandes entreprises utilisent des ordinateurs de grande taille, très puissants, appelés des ''mainframes''. Ils sont souvent confondus avec les serveurs par le grand public, il y a une différence entre les deux. Un serveur est une fonction logicielle/réseau, pas un type d'ordinateur. Mais laissons cette différence de côté, ce qui est dit pour les ''mainframes'' sert pour les gros serveurs haute performance.

[[File:IBM Z15 mainframe.jpg|vignette|Exemple de ''mainframe''' de type IBM Z15.]]

Les anciens ''mainframes'' des années 50-80 avaient une taille pouvant être impressionnante, au point de prendre une pièce complète d'un bâtiment. Mais de nos jours, les ''mainframes'' tiennent dans une grosse armoire un peu haute. Les ''mainframes'' doivent rester allumé en permanence et ne doivent pas être éteint, sauf éventuellement quelques jours par an pour des opérations de maintenance. Ils utilisent pour cela des techniques spécifiques, avec beaucoup de redondance interne.

[[File:ACONIT hall grandes machines.jpg|centre|vignette|upright=2|''Mainframe'' ACONIT.]]

Les ''mainframes'' sont aussi conçus pour mutualiser au maximum leur utilisation, ils peuvent être utilisés par plusieurs utilisateurs à la suite, voire en même temps. Pour cela, les anciens ''mainframes'' étaient capables de faire tourner plusieurs applications distinctes l'une à la suite de l'autre, avec des commutations fréquentes entre logiciels. De nos jours, ils sont capables d'exécuter un grand nombre de tâches en même temps, grâce à la présence de plusieurs processeurs. Les ''mainframes'' modernes sont même capables de faire tourner plusieurs systèmes d'exploitation en même temps si besoin.

Les anciens ''mainframes'' étaient des ordinateurs assez simples, avec un processeur, de la mémoire RAM, un ou plusieurs disques durs, pas plus. Le ''mainframe'' était tellement énorme et cher que les entreprises n'en avaient qu'un seul pour toute l'entreprise. Les employés avaient sur leur bureau des terminaux, qui permettaient d'accéder à l'ordinateur central, mais n'étaient pas des ordinateurs. Les terminaux étaient des composants électroniques simples, avec un écran, un clavier et une souris, mais sans processeur. Ils envoyaient des données au ''mainframe'', ils en recevaient de sa part, mais tout traitement était réalisé sur le ''mainframe''. L'arrivée sur le marché des ordinateurs personnels, de type PC fixe/portable, a entrainé l'abandon de ce genre de pratique, tous les employés ont maintenant un ordinateur rien que pour eux.

{|
|-
! colspan=&quot;2&quot; | Exemples de terminaux
|-
|[[File:Terminal-in2-sm9400.jpg|centre|vignette|upright=1.5|Exemple de terminal. Notez la présence d'un écran et d'un clavier, mais l'asbence d'une unité centrale.]]
|[[File:Chromatics CT4100.jpg|vignette|upright=1.5|Autre exemple de terminal. Le clavier est couplé à un stylo CRT, qui remplacait la souris et agissait sur l'écran comme s'il était tactile.]]
|-
! colspan=&quot;2&quot; | Intérieur d'un terminal
|-
|[[File:CT1024 Monitor.jpg|vignette|upright=1.5|Terminal CT1024, sans le boitier extérieur.]]
|[[File:CT1024 Terminal System.jpg|vignette|upright=1.5|Terminal CT1024, description des composants interne.]]
|}

De nos jours, les ''mainframes'' contiennent en réalité plusieurs ordinateurs simples interconnectés via un réseau local. Un ''mainframe'' qui tient dans une armoire contient facilement une dizaine ou centaine de processeurs, plein de RAM, des disques durs séparés dans une armoire distincte, etc. Vu qu'ils communiquent uniquement via le réseau, ils n'ont pas d'interface, pas d'écran, 'entrée via clavier/souris. Le tout est commandé avec une console de commande, typiquement un ordinateur portable ou un terminal assez simple séparé de l'armoire, qui permet à un administrateur de faire des opérations de surveillance, configuration et maintenance. Il peut y avoir une console de commande pour plusieurs armoires séparées, la console peut même être dans un autre bâtiment et accéder au ''mainframe'' par le réseau.

[[File:IBM System Z9 (type 2094 inside).jpg|centre|vignette|upright=2|''Mainframe'' de type IBM System Z9. L'ordinateur portable sert de console pour qu'un administrateur fasse des opérations de surveillance, configuration et maintenance.]]

Les processeurs et la RAM sont typiquement installés sur des cartes amovibles, qui sont connectées au fond de l'armoire lors de l'installation. Il est même possible de retirer ou d'ajouter des cartes en fonctionnement, afin d'ajouter/retirer des processeurs, des disques durs, etc. Ce qui est très utile si un composant est en panne et qu'il faut le remplacer. 

[[File:IBM TotalStorage Exp400.jpg|centre|vignette|upright=2|IBM TotalStorage Exp400]]

==Un peu d'abstraction : qu'est-ce qu'un ordinateur ?==

Un ordinateur comprend donc un processeur, plusieurs mémoires, des cartes d'extension et une carte mère pour connecter le tout. Mais il s'agit là d'une description assez terre-à-terre de ce qu'est un ordinateur. Une autre description, plus abstraite, se base sur le fait qu'un ordinateur est une énorme calculatrice programmable. Elle permet d'expliquer pourquoi il y a une distinction entre processeur et mémoire, entre unité centrale et périphériques. Tout ce qui va suivre pourra vous paraitre assez abstrait, mais rassurez-vous : les prochains chapitres rendront tout cela plus concrets.

===La séparation entre entrées-sorties et traitement===

L'unité centrale peut être vue comme une énorme calculatrice ultra-puissante, qui exécute des commandes/opérations. Mais à elle seule, elle ne servirait à rien, il faut interagir avec par l'intermédiaire de plusieurs périphériques. Il existe deux types de périphériques, qui sont conceptuellement différents. Les périphériques comme le clavier ou la souris permettent d'envoyer des informations à l'ordinateur, d'agir sur celui-ci. A l'inverse, les écrans transmettent des informations dans le sens inverse : de l'ordinateur vers l'utilisateur. Les premiers sont appelés des '''entrées''', les seconds des '''sorties'''.

Dans un ordinateur, les informations sont représentées sous la forme de nombres. Toute donnée dans un ordinateur est codée avec un ou plusieurs nombres regroupés dans une donnée, un fichier, ou autre. Et la transmissions avec les entrées et sorties se fait là-encore avec des nombres. Par exemple, quand vous appuyez sur votre clavier, le clavier envoie un numéro de touche à l'unité centrale, qui indique quelle touche a été appuyée. L'image à afficher à l'écran est codée sous la forme d'une suite de nombres (un par pixel). L'image est envoyée à l'écran, qui traduit la suite de nombre en image à afficher. Les entrées traduisent des actions utilisateurs en nombres, on dit que les entrées encodent les actions utilisateur. Les sorties font la traduction inverse, elles transforment des suites de nombres en une action physique. On dit qu'elles décodent des informations.

Pour résumer, toute appareil électronique est composé par :
* Des '''entrées''' sur lesquelles l'utilisateur agit sur l'ordinateur. Les entrées transforment les actions de l'utilisateur en nombres, qui sont interprétés par l'ordinateur.
* Une '''unité de traitement''', qui manipule des nombres et fait des calculs/opérations dessus. Les nombres proviennent des entrées, du disque dur, ou d'autres sources, peu importe.
* Des '''sorties''', qui va récupèrent le résultat calculé par l'unité de traitement pour en faire quelque chose : écrire sur une imprimante ou sur un moniteur, émettre du son,...

[[File:Ordinateur théorique Simple 1.png|centre|vignette|upright=2|Ordinateur théorique Simple 1]]

L'unité de traitement proprement dite, celle qui fait les calculs, est couplée à une mémoire qui mémorise les opérandes et résultats des calculs. La séparation entre processeur et mémoire est nécessaire pour qu'un appareil électronique soit qualifié d'ordinateur. De nombreux appareils n'ont pas de séparation entre unité de traitement et mémoire, comme certaines vielles radios AM/FM.

[[File:Schéma de principe d'un ordinateur.png|centre|vignette|upright=2|Schéma de principe d'un ordinateur]]

===Un ordinateur est un appareil programmable===

Les appareils simples sont non-programmables, ce qui veut dire qu’ils sont conçus pour une utilisation particulière et qu’ils ne peuvent pas faire autre chose. Par exemple, les circuits électroniques d’un lecteur de DVD ne peuvent pas être transformé en lecteur audio ou en console de jeux... Les circuits non-programmables sont câblés une bonne fois pour toute, et on ne peut pas les modifier. On peut parfois reconfigurer le circuit, pour faire varier certains paramètres, via des interrupteurs ou des boutons, mais cela s’arrête là. Et cela pose un problème : à chaque problème qu'on veut résoudre en utilisant un automate, on doit recréer un nouveau circuit.

À l'inverse, un ordinateur n’est pas conçu pour une utilisation particulière, contrairement aux autres objets techniques. Il est possible de modifier leur fonction du jour au lendemain, on peut lui faire faire ce qu’on veut. On dit qu'ils sont '''programmables'''. Pour cela, il suffit d’utiliser un logiciel, une application, un programme (ces termes sont synonymes), qui fait ce que l'on souhaite. La totalité des logiciels présents sur un ordinateur sont des programmes comme les autres, même le système d'exploitation (Windows, Linux, ...) ne fait pas exception.

Un programme est une suite de d'instructions, chaque instruction effectuant une action dans l'ordinateur. Sur les ordinateurs modernes, la majorité de ces instructions effectuent une opération arithmétique, comme une addition, une multiplication, une soustraction, etc. Les ordinateurs modernes sont donc de grosses calculettes très puissantes, capables d'effectuer des millions d'opérations par secondes. Et qui dit opération dit nombres : un ordinateur gère nativement des nombres, qui sont codés en binaire sur la quasi-totalité des ordinateurs modernes.

Une instruction est représentée dans un ordinateur par une série de nombres : un nombre qui indique quelle opération/commande effectuer et des autres nombres pour coder les données (ou de quoi les retrouver dans l'ordinateur). L'ordinateur récupére les commandes une par une, les traduit en opération à effectuer, exécuter l'opération, et enregistre le résultat. Puis il recommence avec la commande suivante.

[[File:Ordinateur Théorique Complexe 1.png|centre|vignette|upright=3|Ordinateur Théorique Complexe. En jaune, le programme informatique, la liste de commande. Le rectangle gris est l'ordinateur proprement dit.]]

De nombreux appareils sont programmables, mais tous ne sont pas des ordinateurs. Par exemple, certains circuits programmables nommés FPGA n'en sont pas. Pour être qualifié d'ordinateur, un appareil programmable doit avoir un processeur séparé de la mémoire. De plus, il doit utiliser un '''codage numérique''', chose que nous allons aborder dans le chapitre suivant.

===Les ordinateurs à programme mémorisé ou programme externe===

Au tout début de l'informatique, on utilisait des cartes perforées en plastique, sur lesquelles on inscrivait le programme à exécuter, les données à traiter, bref : tout ce qu'on donnait à manger à l'ordinateur. Par la suite, les premiers ordinateurs grand public, comme les Amstrad ou les Commodore, utilisaient des cassettes audio magnétiques pour stocker les programmes. Dans le même style, les consoles de jeu utilisaient autrefois des cartouches de jeu, qui contenaient le programme du jeu à exécuter. Pour résumer, les anciens ordinateurs mémorisaient les programmes sur un support externe, lu par un périphérique. De tels ordinateurs sont dits à '''programme externe'''.

: D’anciens ordinateurs personnels, comme l’Amstrad ou le Commodore, permettaient de taper les programmes à exécuter à la main, au clavier, avant d’appuyer une touche pour les exécuter. Nul besoin de vous dire que les cassettes audio étaient plus pratiques.

Mais de nos jours, les programmes sont enregistrés sur le disque dur de l'ordinateur ou dans une mémoire intégrée à l'ordinateur. On dit qu'ils sont installés, ce qui est un mot bien compliqué pour dire que le programme est enregistré sur le disque dur de l’ordinateur. A défaut de disque dur, le programme/logiciel est enregistré dans une mémoire spécialisée pour le stockage. Par exemple, sur les cartes électroniques grand public de marque Arduino, les programmes sont envoyés à la carte via le port USB, mais les programmes sont enregistrés dans la carte Arduino, dans une mémoire FLASH dédiée. Disque dur ou non, le programme est mémorisé dans la mémoire de l'ordinateur. Il est possible d'installer ou de désinstaller les programmes en modifiant le contenu de la mémoire. Le terme utilisé est alors celui de '''programme stocké en mémoire'''.

Les programmes à installer sont disponibles soit sur un périphérique, comme un DVD ou une clé USB, soit sont téléchargés depuis internet. Les premiers PC fournissaient les logiciels sur des disquettes, qui contenaient un programme d'installation pour enregistrer le programme sur le disque dur de l'ordinateur. Par la suite, le support des logiciels a migré vers les CD et DVD, les logiciels devenant de plus en plus gros. De nos jours, la majorité des applications sont téléchargées depuis le net, l'usage de périphériques est devenu obsolète, même les consoles de jeu abandonnent cette méthode de distribution.

==Les générations d'ordinateurs : un historique rapide==

L'informatique a beaucoup évolué dans le temps. Et une bonne partie de cette évolution tient à l'évolution de l’électronique sous-jacente. Les ordinateurs actuels sont fabriqués avec des transistors, des petits composants électroniques qui servent d'interrupteur programmables, qu'on détaillera dans ce qui suit. Mais ça n'a pas toujours été le cas. Et cela permet de distinguer plusieurs '''générations d'ordinateurs'''.

===Les ordinateurs électro-mécaniques : les premiers ordinateurs===

Le tout premier ordinateur est le '''Z1''', un modèle unique inventé par Konrad Suze entre 1936 et 1938. Son processeur gérait non pas des nombres entiers, mais des nombres à virgule (des nombres dits flottants, pour être précis), encodés sur 22 bits. Le processeur du Z1 était capable de faire des additions et des soustractions, car il intégrait un circuit additionneur-soustracteur basique. Des circuits annexes permettaient de faire des multiplications et des divisions en enchainant des additions/soustractions successives. Il fonctionnait à une fréquence de 1 Hz, ce qui fait qu'il pouvait faire une addition/soustraction par seconde maximum.

[[File:Blue-punch-card-front.png|vignette|upright=0.5|Carte Perforée.]]

Niveau mémoire, la RAM de l'ordinateur était très limitée : seulement 16 nombres de 22 bits chacun. S'il s'agissait d'une mémoire électronique, les programmes étaient mémorisés sur une mémoire mécanique. Les programmes étaient enregistrés sur des cartes perforées, à savoir des cartes en papier dans lesquelles un 1 est codé par un trou dans le papier et un 0 par une absence de trou. Les programmes étaient exécutés par l'ordinateur quand on insérait la carte perforée dans le lecteur et qu'on appuyait sur un bouton.

[[File:German Museum of Technology, Berlin 2017 024.jpg|centre|vignette|upright=2|Réplique du Z1 au ''German Museum of Technology'' de Berlin, 2017.]]

Après sa destruction dans un bombardement, le Z1 a été reconstruit et amélioré, ce qui donné les deux ordinateurs Z2 et Z3. Quelques années plus tard, de nombreux ordinateurs ont été construits dans des laboratoires de recherche. Des grandes noms de l'histoire de l'informatique datent de cette époque : le Harvard Mark I et le Colossus Mark 1 (UK) ont tous deux été mis en service en 1944, par exemple. Ils ont servis pour les cryptanalystes pour casser les codes utilisés par les allemands pour leurs transmissions, pendant la seconde guerre mondiale.

Les ordinateurs cités dans le précédent paragraphe étaient tous des ordinateurs dit '''électro-mécaniques''', car ils mélangeaient des composants électroniques et des composants mécaniques (tout ce qui a trait aux cartes perforées, notamment). Les composants électroniques étaient soit des relais, soit des tubes à vides, les deux étant des interrupteurs commandables électriquement plus ou moins équivalents aux transistors. Les ordinateurs d'avant l'année 1944, étaient tous de ce type. Quelques ordinateurs des années 50 étaient de ce type, mais leur nombre n'a pas dépassé 30. Il faut dire qu'ils ont rapidement laissé la place à des ordinateurs purement électroniques, que nous allons voir dans ce qui suit..

===La première génération : les tubes à vide===

Les ordinateurs qui ont suivi les ordinateurs électromécaniques sont regroupés dans la '''première génération d'ordinateur'''. Ils étaient conçus avec des tubes à vide, ce qui les place entre les premiers ordinateurs électro-mécaniques et les ordinateurs utilisant des transistors. Les tubes à vide étaient assez encombrants, ils consommaient beaucoup de courant, ils chauffaient et étaient assez peu fiables. Ils tombaient en panne assez souvent. Et ils étaient assez simple à fabriquer, mais restaient malgré tout chers.

[[File:Elektronenroehren-auswahl.jpg|centre|vignette|upright=2|Tubes à vides.]]

Au vu de de la taille des  tubes à vide, les ordinateurs de l'époque étaient composé de plusieurs milliers de ces tubes, guère plus. Et malgré cela, un ordinateur prenait facilement un étage de bâtiment entier, ou au moins plusieurs pièces. La conséquence est que les ordinateurs de première génération étaient très simples, rudimentaires quand on les compare aux ordinateurs modernes. Ils ne géraient que quelques opérations simples : l'addition, la soustraction, pas grand chose de plus. A quelques exceptions près, ils ne géraient pas la multiplication et encore moins la division, cela aurait demandé trop de tubes à vides.

Une des toutes premières machines construite avec des tubes à vide était l'Atanasoff–Berry. Ce n'était pas un ordinateur, car elle ne pouvait pas exécuter de programme sans intervention humaine pour séquencer des opérations, mais c'était la première machine de calcul purement électronique, sans aucune pièce mécanique. Elle utilisait une mémoire RAM construite avec des condensateurs, ceux-ci étant placés sur des cylindres tournants. Les circuits de calcul étaient construits avec des tubes à vide et faisaient leur travail un bit à la fois. Elle fonctionnait à une fréquence de 60 Hz et pouvait faire 30 additions/soustractions par seconde. Les nombres étaient encodés sur 50 bits. 

[[File:Atanasoff Berry Computer.gif|centre|vignette|upright=2.5|Atanasoff–Berry.]]

L'arrivée de l'ENIAC en 1945 a changé la donne. Cet ordinateur a introduit plusieurs innovations majeures. La première est assez technique, il s'agit de la turing-complétude, elle a trait aux programmes qui peuvent être écrit pour un ordinateur, nous ne la détaillerons pas ici.

[[File:BabyArchitecture.png|vignette|Architecture de la Manchester Baby.]]

En 1948, le ''Manchester Baby'' a introduit une innovation extrêmement importante : le programme n'était plus mémorisé sur des cartes perforées, mais dans une mémoire électronique à l’intérieur de l'ordinateur lui-même. En clair, le ''Manchester Baby'' était le premier '''ordinateur à programme stocké en mémoire''' en français. Au-delà de ça, le Manchester Baby restait quand même très simple, c'était limite un prototype.

Niveau interface, l'ordinateur avait une console avec 32 boutons, des interrupteurs et un écran de sortie sur lequel afficher les résultats. A l'intérieur, il y avait un processeur et une RAM de 32 nombres de 32 bits, fabriquées avec des tubes Williams (abordés dans une annexe à la fin du cours). Le programme devait tenir dans la RAM, avec une instruction prenant autant de place qu'un nombre, ce qui limitait les programmes à 32 instructions maximum. Une instruction prenait donc 32 bits, 3 indiquaient quelle opération utiliser, 12 servait à indiquer où se trouvent les opérandes en RAM, les 16 restants sont inutilisés.

Il gérait 8 instructions en tout, mais ne gérait pas l'addition. Il gérait la soustraction, des instructions de branchement et d'accès mémoire, mais rien d'autre. Il pouvait cependant émuler l'addition à partir d'une soustraction et inversant l'opérande soustraite. C'était une architecture avec un registre unique de 32 bits, appelé l'accumulateur, avec une instruction STORE pour copier son contenu en RAM et une instruction LOAD pour copier du nombre de la RAM vers l'accumulateur. Les instructions étaient chargées dans un registre pour être exécutées, le processeur avait aussi un registre pour mémoriser la position de l'instruction suivante en RAM.

Le Manchester Mark 1 était une amélioration du Manchester Baby. Il utilisait 4500 tubes à vide. L'ordinateur gérait des nombres de 40 bits, les instructions étaient codées sur 20 bits. La RAM était toujours composée de 32 nombres, leur taille était simplement augmentée. Par contre, elle était complémentée par l’ancêtre du disque dur magnétique, à savoir un tambour magnétique, l’ancêtre du disque dur magnétique. Il contenait 40 pages, faisant chacune 32 nombres de 40 bits.

===La seconde génération : le remplacement des tubes à vides par des transistors===

[[File:IBM 7070.jpg|vignette|Cartes imprimées de l'IBM 704, avec des transistors et résistances dessus.]]

La '''seconde génération''' est celle des ordinateurs fabriqués avec des '''transistors''' isolés, reliés entre avec des fils électriques. Les transistors en question possèdent trois broches, des pattes métalliques sur lesquelles on connecte des fils électriques. Le transistor s'utilise le plus souvent comme un interrupteur commandé par sa troisième broche. Le courant qui traverse les deux premières broches passe ou ne passe pas selon ce qu'on met sur la troisième.

[[File:Transistor basic flow.svg|centre|vignette|Un transistor est un morceau de conducteur, dont la conductivité est contrôlée par sa troisième broche/borne.]]

Les ordinateurs de seconde génération avaient entre 1000 et 500 000 transistors. Les capacités des ordinateurs étaient donc nettement supérieures à celles des ordinateurs de première génération. Une part non négligeable des ordinateurs de seconde génération supportait l'opération de multiplication, absente sur les ordinateurs de première génération. Néanmoins, cela variait beaucoup selon les ordinateurs.

Un exemple assez hors du commun est celui du premier modèle de l'IBM 1620. Le tout premier modèle n'avait aucun circuit de calcul, il n'était même pas capable de faire une addition ou une multiplication. A la place, il utilisait une table d'addition et une table de multiplication en mémoire RAM. Les deux tables devaient être initialisées par le logiciel lors du démarrage de la machine. La table d'addition faisait une centaine de chiffre, la table de multiplication faisait le double. Le processeur de l'ordinateur gérait des instructions pour faire des additions ou des multiplications, mais ces opérations lisaient le résultat dans la table d'addition. Les calculs étaient fait chiffre par chiffre, avec un encodage partiellement décimal, partiellement binaire (des chiffres décimaux étaient encodés en binaire, nous en reparlerons quand nous parlerons du BCD) !

[[File:KL CoreMemory.jpg|vignette|Mémoire à tore de ferrite.]]

Les transistors n'étaient utilisés que pour le processeur et les circuits annexes. La mémoire n'était pas faite en transistors, pas à cette époque. La mémoire était une mémoire aujourd'hui abandonnée, appelée une '''mémoire à tores de ferrite'''. Elle sera détaillée dans un chapitre ultérieur. Mais sachez pour le moment qu'il s'agit d'une mémoire au support magnétique, les données étant stockées sur un support magnétique.

Transistors comme tubes à vide prenaient beaucoup de place, ce qui fait que les ordinateurs étaient assez gros. Concrètement, ils prenaient une pièce de bâtiment entière dans le meilleur des cas. C'était l'époque des gros ''mainframes'', reliés à des terminaux, peu puissants comparé aux standards actuels. Seules les grandes entreprises et les grands instituts de recherche pouvaient se payer les services de ce genre d'ordinateurs. Seuls les professionnels avaient accès à ce genre d'équipement.

===La troisième génération : le circuit intégré===

[[File:D8259AC-2.jpg|vignette|Exemple de circuit intégré.]]

La troisième génération est toujours fabriquée avec des transistors, mais dont la taille a été réduite. Avec l'évolution de la technologie, les transistors ont diminué en taille, de plus en plus. Ils sont devenus tellement petits qu'ils ont finit par être regroupés dans des '''circuits intégrés''', des circuits regroupent plusieurs transistors sur la même puce de silicium. Les circuits intégrés se présentent le plus souvent sous la forme de boitiers rectangulaires, comme illustré ci-contre. D'autres ont des boitiers de forme carrées, comme ceux que l'on peut trouver sur les barrettes de mémoire RAM, ou à l'intérieur des clés USB/ disques SSD.

Lors de cette génération, les processeurs étaient fournis en pièces détachées qu'il fallait relier entre elles. Le processeur était composé de plusieurs circuits intégrés séparés, impossible de mettre un processeur dans un seul boitier. Un exemple de processeur conçu en kit est la série des Intel 3000. Elle regroupe plusieurs circuits séparés aux noms à coucher dehors, mais dont vous comprendrez ce qu'ils veulent dire dans les chapitres adéquats : l'Intel 3001 est un séquenceur, l'Intel 3002 regroupe unité de calcul et registres, le 3003 est un circuit d'anticipation de retenue complémentaire du 3002, le 3212 est une mémoire tampon, le 3214 est une unité de gestion des interruptions, les 3216/3226 sont des interfaces de bus mémoire. On pourrait aussi citer la famille de circuits intégrés AMD Am2900.

Même si le processeur était en pièce détachées, utiliser une dizaine de circuits intégrés était nettement mieux que d'utiliser plusieurs milliers de transistors individuels. En conséquence, les ordinateurs ont vu leur taille grandement réduite, passant de pièces entières à une simple armoire, voire à quelques cartes intégrées superposées. De plus, le prix des circuits intégré était abordable, du moins comparé aux ordinateurs d'avant. Le prix des ordinateurs a alors grandement décru, permettant à des entreprises et administrations de taille modeste de s'équiper d'ordinateurs.

===La quatrième génération : le microprocesseur===

[[File:MOS6502.svg|vignette|Microprocesseur, ici un processeur MOS6502, de la quatrième génération.]]

Lors de la troisième génération, les circuits intégrés regroupaient plusieurs dizaines ou centaines de transistors, mais sont rapidement montés en gamme. De centaines de transistors, ils sont passé au milliers de transistors, puis au millions et maintenant au-delà du milliard. Les transistors étaient devenus tellement petits, tellement miniaturisés, qu'il était devenu possible de mettre un processeur entier dans un circuit intégré. C'est ainsi qu'est né le microprocesseur, à savoir un processeur qui tient tout entier dans un seul circuit imprimé. La quatrième génération d’ordinateur est celle des ordinateurs basés autour d'un microprocesseur.

Les tout premiers microprocesseurs étaient des processeurs à application militaire, comme le processeur du F-14 CADC ou celui de l'Air data computer. Le tout premier microprocesseur commercialisé au grand public est le 4004 d'Intel, sorti en 1971. L'intel 4004 comprenait environ 2300 transistors, avait une fréquence de 740 MHz, pouvait faire 46 opérations différentes, et manipulait des entiers de 4 bits. Il était au départ un processeur de commande, prévu pour être intégré dans la calculatrice Busicom calculator 141-P, mais il fut utilisé pour d'autres applications quelque temps plus tard. Immédiatement après le 4004, les premiers microprocesseurs 8 bits furent commercialisés. Le 4004 fut suivi par le 8008 et quelques autres processeurs 8 bits extrêmement connus, comme le 8080 d'Intel, le 68000 de Motorola, le 6502 ou le Z80.

Les microprocesseurs permirent encore uen fois de réduire la taille des ordinateurs, qui pouvaient tenir dans un boitier de PC, ou un boitier de console de jeu. Le prix des ordinateurs a aussi chuté en même temps que les transistors était miniaturisés. C'est cette invention qui permis l'invention des consoles de jeux et des mini-ordinateurs, à savoir les ordinateurs personnels. Sans miniaturisation, on n'aurait pas d'ordinateur personnel, pas de PC fixe ou portable.

==L'organisation du cours : les différents niveaux d'explication==

Le fonctionnement d'un ordinateur est assez complexe à expliquer car les explications peuvent se faire sur plusieurs niveaux. Par plusieurs niveaux, on veut dire qu'un ordinateur est composé de composants très simples, qui sont assemblés pour donner des composants eux-même plus complexes, qui sont eux-même regrouper, etc. Étudier tout cela demande de voir plusieurs niveaux, allant de transistors très petits à des processeurs multicœurs. Les niveaux les plus bas sont de l'électronique pur et dure, alors que ceux plus haut sont à mi-chemin entre électronique et informatique.

===Les niveaux d'abstraction en architecture des ordinateurs===

Les trois premiers niveaux sont de l'électronique pur et dure. Ils correspondent aux premiers chapitres du cours, qui porteront sur les circuits électroniques en général.
* Le premier niveau est celui des '''transistors''', des circuits intégrés, des ''wafer'' et autres circuits de très petite taille.
* Le second niveau est celui des '''portes logiques''', des circuits très basiques, très simples, à la base de tous les autres.
* Le troisième niveau est celui dit de la '''''Register Transfer Level''''', où un circuit électronique est construit à partir de circuits basiques, dont des registres et autres circuits dits combinatoires.
Les deux niveaux suivants sont de l'informatique proprement dit. C'est dans ces deux niveaux qu'on étudie les ordinateurs proprement dit, les circuits qu'il y a dedans et non l'électronique en général.
* Le quatrième niveau est celui de la '''microarchitecture''', qui étudie ce qu'il y a à l'intérieur d'un processeur, d'une mémoire, des périphériques et autres.
* Le cinquième niveau est celui de l''''architecture externe''', qui décrit l'interface du processeur, de la mémoire, d'un périphérique ou autre. Par décrire l'interface, on veut dire : comment un programmeur voit le processeur et la mémoire, comment il peut les manipuler. Une architecture externe unique peut avoir plusieurs microarchitecture, ce qui fait qu'on sépare les deux. Tout cela sera plus clair quand on passera aux chapitres sur le processeur et les mémoires.

Nous n'allons pas voir les 5 niveaux dans l'ordre, des transistors vers l'architecture externe. En réalité, nous allons procéder autrement. La première partie du cours portera sur les trois premiers niveaux, le reste sur les deux autres. Les 5 niveaux seront vus dans des chapitres séparés, du moins le plus possible. Au niveau pédagogique, tout est plus simple si on scinde les 5 niveaux. Bien sûr, il y a quelques explications qui demandent de voir plusieurs niveaux à la fois. Par exemple, dans le chapitre sur les mémoires caches, nous auront des explications portant sur la RTL, la microarchitecture du cache et son architecture externe. Mais le gros du cours tentera de séparer le plus possible les 5 niveaux.

===Les trois parties principales du cours===

Nous allons commencer par parler du binaire, avant de voir les portes logiques. Avec ces portes logiques, nous allons voir comment fabriquer des circuits basiques qui reviendront très souvent dans la suite du cours. Nous verrons les registres, les décodeurs, les additionneurs et plein d'autres circuits. Puis, nous reviendrons au niveau des transistors pour finir la première partie. La raison est que c'est plus simple de faire comme cela. Tout ce qui a trait aux transistors sert à expliquer comment fabriquer des portes logiques, et il faut expliquer les portes logiques pour voir le niveau de la RTL.

Une fois la première partie finie, nous allons voir les différents composants d'un ordinateur. Une première partie expliquera ce qu'il y a dans un ordinateur, quels sont ses composants. Nous y parlerons de l'architecture de base, de la hiérarchie mémoire, des tendances technologiques, et d'autres généralités qui serviront de base pour la suite. Puis, nous verrons dans l'ordre les bus électroniques, les mémoires RAM/ROM, le processeur, les périphériques, les mémoires de stockage (SSD et disques durs) et les mémoires caches. Pour chaque composant, nous allons voir leur architecture externe, avant de voir leur microarchitecture. La raison est que la microarchitecture ne peut se comprendre que quand on sait quelle architecture externe elle implémente.

Enfin, dans une troisième partie, nous allons voir les optimisations majeures présentes dans tous les ordinateurs modernes, avec une partie sur le pipeline et le parallélisme d'instruction, et une autre sur les architectures parallèles. Pour finir, les annexes de fin parlerons de sujets un peu à part.

&lt;noinclude&gt;
{{NavChapitre | book=Fonctionnement d'un ordinateur
           | next=L'encodage des données
           | nextText=L'encodage des données
}}
&lt;/noinclude&gt;</text>
      <sha1>tdmx3caxb12lhxqmkcte9dnjbr26c4r</sha1>
    </revision>
    <revision>
      <id>744127</id>
      <parentid>744126</parentid>
      <timestamp>2025-06-05T00:13:49Z</timestamp>
      <contributor>
        <username>Mewtow</username>
        <id>31375</id>
      </contributor>
      <minor />
      <comment>/* La première génération : les tubes à vide */</comment>
      <origin>744127</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="45700" sha1="hzau4c69s3ibjlwftntxfzak7yt1kd0" xml:space="preserve">Pour commencer, nous allons voir qu'il existe de nombreux types d'ordinateurs. Le plus connu est certainement le PC, l'ordinateur personnel, que vous avez sans doute dans votre salon. Les ordinateurs portables sont un deuxième type d'ordinateur assez intuitif, que vous avez peut-être. Mais il y a aussi d'autres types d'ordinateurs auxquels vous n'avez jamais été confrontés.

==Les différents types d'ordinateurs==

Dans cette section, nous allons décrire rapidement les ordinateurs les plus courant, mais surtout voir ce qu'il y a à l'intérieur d'un ordinateur.

===L'ordinateur de type PC fixe===

De l'extérieur, l'ordinateur est composé d'une unité centrale sur laquelle on branche des périphériques.

[[File:Typical computer architecture systems.jpg|vignette|upright=1.5|Exemples de périphériques, connectés à une unité centrale (ici appelée à tort ''operating system'').]]

Les '''périphériques''' regroupent l'écran, la souris, le clavier, l'imprimante, et bien d'autres choses. Ils permettent à l'utilisateur d'interagir avec l'ordinateur : un clavier permet de saisir du texte sous dans un fichier, une souris enregistre des déplacements de la main en déplacement du curseur, un écran affiche des données d’images/vidéos, un haut-parleur émet du son, etc. Tout ce qui est branché sur un ordinateur est, formellement un périphérique.

L''''unité centrale''' est là où se trouvent tous les composants importants d'un ordinateur, ceux qui font des calculs, qui exécutent des logiciels, qui mémorisent vos données, etc. Voici ce à quoi ressemble l'intérieur de l'unité centrale. Trois sections sont visibles : l'alimentation électrique en haut à gauche, la carte mère en bas à gauche et en jaune/orange, les disques et lecteurs à droite des câbles. Et on voit aussi beaucoup de câbles.

[[File:Asus P5K-SEIntel E6320.jpg|centre|vignette|upright=2|Exemple d'unité centrale.]]

Tout en haut à gauche, se trouve l''''alimentation électrique''', qui convertit le courant de la prise électrique en un courant plus faible, utilisable par les autres composants. Elle émet de nombreux câbles assez gros, qui sont reliés au reste. Les PC actuels utilisent des alimentations électriques standardisées, qui fournissent trois tensions au reste de l'ordinateur : une tension de 12 Volts, une de 5 Volts, une de 3,3 Volts.

À droite, caché par la partie &quot;métallique&quot; du boitier, se trouvent les lecteurs de CD/DVD, et les disques durs. Les lecteurs CD-ROM ou DVD-ROM permettaient de lire des CD ou des DVD. Je parle au passé, car ils ont aujourd'hui disparu des ordinateurs modernes. Les '''disques durs''' sont des mémoires de stockage, qui mémorisent vos données de manière permanente. De nos jours, ils sont remplacés par des SSD, qui sont des disques durs électroniques, là où les disques durs proprement dit sont des mémoires magnétiques. Nous verrons la différence dans deux chapitres dédiés, un sur les disques durs, l'autre sur les SSD.

En bas à droite, se trouve la '''carte mère''' un support plat, en plastique ou en céramique, sur laquelle sont soudés/connectés les autres composants. Sur celle-ci, de nombreux composants sont soudés, d'autres sont branchés dessus avec des câbles, d'autres sont connectés dessus avec des connecteurs. Ils sont reliés entre eux par des fils conducteurs, le plus souvent du cuivre ou de l’aluminium, ce qui leur permet de s’échanger des données. Sur les cartes simples, ces fils sont intégrés dans la carte électronique, dans des creux du plastique. Ils portent le nom de pistes.

Avant, les disques durs, SSD et lecteurs de CD/DVD sont branchés dessus via des connecteurs dédiés, appelés des connecteurs S-ATA. De nos jours, ils sont branchés sur un autre connecteur, grâce à l'interface NVME. Toujours est-il qu'ils sont reliés à la carte mère par des câbles, ce qui montre que ce sont des sortes de périphériques interne. Ils sont placés dans le boitier, mais on aurait tout aussi bien pu les mettre à l'extérieur, vu qu'ils communiquent avec l'ordinateur par l'intermédiaire d'un câble ou d'un connecteur dédié.

Mais deux autres composants très importants sont eux placés sur la carte mère, directement. Ils ont chacun un connecteur dédié, sur lequel ils sont branchés directement, sans passer par l'intermédiaire d'un câble, mais sans être soudés non plus. Il s'agit du processeur et de la mémoire RAM, deux composants centraux des PC modernes.

[[File:Pentium III SL4CB.jpg|thumb|Processeur Pentium III.]]

Le '''processeur''' traite les données, les modifie, les manipule. Pour faire simple, il s’agit d’une grosse calculatrice hyper-puissante. Il comprend à la fois un circuit qui fait des calculs, et un circuit de contrôle qui s'occupe de séquencer les calculs dans l'ordre demandé. Il est souvent caché sous un radiateur, lui-même surmonté par un ventilateur. En effet, un processeur chauffe beaucoup, ce qui demande d'évacuer cette chaleur. Un chapitre entier expliquera pourquoi les processeurs chauffent, ainsi que les techniques utilisées pour limiter leur production de chaleur et leur consommation électrique.

La '''mémoire vive''' conserve des informations/données temporairement, tant que le processeur en a besoin. Elle prend la forme de barrettes de RAM, comme montré ci-dessous.

[[File:2 gb ddr2 667.jpg|centre|vignette|upright=2|Barrette de RAM.]]

Outre ces composants dits principaux, un ordinateur peut comprendre plusieurs composants moins importants, surtout présents sur les ordinateurs personnels. Ils sont techniquement facultatifs, mais sont très présents dans les ordinateurs personnels. Cependant, certains ordinateurs spécialisés s'en passent. Il s'agit des diverses '''cartes d'extension''' sont branchées sur la carte mère. Elles permettent d’accélérer certains calculs ou certaines applications, afin de décharger le processeur. Par exemple, la carte graphique s'occupe des calculs graphiques, qu'il s'agisse de graphismes 3D de jeux vidéos ou de l'affichage en 2D du bureau. Dans un autre registre, la carte son prend en charge le microphone et les haut-parleurs.

[[Fichier:Personal computer, exploded 4.svg|thumb|upright=1.0|Éclaté d'un ordinateur de type PC :&lt;br /&gt;
1 : Écran ;&lt;br /&gt;
2 : Carte mère ;&lt;br /&gt;
3 : Processeur ;&lt;br /&gt;
4 : Câble Parallel ATA ;&lt;br /&gt;
5 : Mémoire vive (RAM) ;&lt;br /&gt;
6 : Carte d'extension ;&lt;br /&gt;
7 : Alimentation électrique ;&lt;br /&gt;
8 : Lecteur de disque optique ;&lt;br /&gt;
9 : Disque dur ;&lt;br /&gt;
10 : Clavier ;&lt;br /&gt;
11 : Souris.]]

Si on regarde une carte mère de face, on voit un grand nombre de connecteurs, mais aussi des circuits électroniques soudés à la carte mère.

[[File:Architecture matérielle d'une carte mère.png|centre|vignette|upright=2.0|Architecture matérielle d'une carte mère]]

Les '''connecteurs''' sont là où on branche les périphériques, la carte graphique, le processeur, la mémoire, etc. Dans l'ensemble, toute carte mère contient les connecteurs suivants :
* Le processeur vient s’enchâsser dans la carte mère sur un connecteur particulier : le '''socket'''. Celui-ci varie suivant la carte mère et le processeur, ce qui est source d'incompatibilités.
* Les barrettes de mémoire RAM s’enchâssent dans un autre type de connecteurs: les '''slots mémoire'''.
* Les mémoires de masse disposent de leurs propres connecteurs : connecteurs P-ATA pour les anciens disques durs, et S-ATA pour les récents.
* Les périphériques (clavier, souris, USB, Firewire, ...) sont connectés sur un ensemble de connecteurs dédiés, localisés à l'arrière du boitier de l'unité centrale. 
* Les autres périphériques sont placés dans l'unité centrale et sont connectés via des connecteurs spécialisés. Ces périphériques sont des cartes imprimées, d'où leur nom de '''cartes filles'''. On peut notamment citer les cartes réseau, les cartes son, ou les cartes vidéo.

===Les ordinateurs portables===

[[File:Samsung QX-511 (2).JPG|vignette|Ordinateur portable Samsung QX-511 (2), pour illustration.]]

Un ordinateur portable est identique à un ordinateur de type PC. Si vous ouvrez votre ordinateur portable (attention à la garantie), vous retrouverez les mêmes composants qu'un PC à l'intérieur. Un point important est la présence d'une batterie à l'intérieur du PC portable, absente des PC fixes.

[[File:LG gram 14Z90Q mainboard with battery.jpg|centre|vignette|upright=2|LG gram 14Z90Q avec sa batterie.]]

Une fois la batterie et les circuits associés retiré, la seule différence notable est que tous les composants sont soudés sur la carte mère, au lieu d'être branchés sur des connecteurs, à part éventuellement la RAM et le disque dur.

[[File:LG gram 14Z90Q mainboard without battery.jpg|centre|vignette|upright=2|LG gram 14Z90Q sans sa batterie.]]

La RAM est parfois soudée sur la carte mère, d'autres fois sous la forme de barrettes de mémoire vive semblables à celles des PC. Dans le dernier cas, elle est connectée à des connecteurs spécifiques, ce qui permet de les changer/upgrader. Les PC portables sont parfois construits de manière à pouvoir changer la RAM facilement, en ouvrant un cache spécial, concu pour.

[[File:Lenovo G555 состав - Донор.JPG|centre|vignette|upright=2|Lenovo G555.]]

La conception d'un ordinateur portable est légèrement différente de celle d'un PC, pour des raisons thermiques. Un PC fixe a plus de place pour évacuer sa chaleur. Les ventilateurs peuvent plus facilement déplacer l'air dans le boitier, même si le flux d'air dans le boitier est éventuellement gêné par la carte graphique. Mais l'évacuation de la chaleur est assez efficace. Sur les PC portables, leur finesse fait que le trajet de l'air est beaucoup plus contraint. Évacuer la chaleur produite par l'ordinateur est plus complexe, ce qui demande d'utiliser des systèmes de refroidissement et de ventilation spécifiques.

Là où les PC fixes se débrouillent avec des radiateurs et des ventilateurs posés sur le processeur, les PC portables font autrement. Ils ne peuvent pas forcément mettre le ventilateur sur le processeur. A la place, ils mettent le ventilateur à côté, mais le processeur est surmonté par un mécanisme de transmission de la chaleur, qui transfère la chaleur du processeur vers le ventilateur.

[[File:Diagram - How a laptop cooling system works.png|centre|vignette|upright=2|Comment fonctionne le système de ventilation d'un ordinateur portable, en anglais.]]

Les difficultés pour dissiper la chaleur font que les ordinateurs portables utilisent souvent des composants peu performants, mais qui chauffent peu. En effet, nous verrons que plus un composant est puissant, plus il chauffe. La relation n'est pas parfaite, mais les processeurs haute performance chauffent plus que les modèles d'entrée ou milieu de gamme moins puissants. En conséquence, les PC portables sont souvent moins puissants que les PC fixes, même pour les modèles dit ''gaming''.

===Les serveurs et ''mainframes''===

Les grandes entreprises utilisent des ordinateurs de grande taille, très puissants, appelés des ''mainframes''. Ils sont souvent confondus avec les serveurs par le grand public, il y a une différence entre les deux. Un serveur est une fonction logicielle/réseau, pas un type d'ordinateur. Mais laissons cette différence de côté, ce qui est dit pour les ''mainframes'' sert pour les gros serveurs haute performance.

[[File:IBM Z15 mainframe.jpg|vignette|Exemple de ''mainframe''' de type IBM Z15.]]

Les anciens ''mainframes'' des années 50-80 avaient une taille pouvant être impressionnante, au point de prendre une pièce complète d'un bâtiment. Mais de nos jours, les ''mainframes'' tiennent dans une grosse armoire un peu haute. Les ''mainframes'' doivent rester allumé en permanence et ne doivent pas être éteint, sauf éventuellement quelques jours par an pour des opérations de maintenance. Ils utilisent pour cela des techniques spécifiques, avec beaucoup de redondance interne.

[[File:ACONIT hall grandes machines.jpg|centre|vignette|upright=2|''Mainframe'' ACONIT.]]

Les ''mainframes'' sont aussi conçus pour mutualiser au maximum leur utilisation, ils peuvent être utilisés par plusieurs utilisateurs à la suite, voire en même temps. Pour cela, les anciens ''mainframes'' étaient capables de faire tourner plusieurs applications distinctes l'une à la suite de l'autre, avec des commutations fréquentes entre logiciels. De nos jours, ils sont capables d'exécuter un grand nombre de tâches en même temps, grâce à la présence de plusieurs processeurs. Les ''mainframes'' modernes sont même capables de faire tourner plusieurs systèmes d'exploitation en même temps si besoin.

Les anciens ''mainframes'' étaient des ordinateurs assez simples, avec un processeur, de la mémoire RAM, un ou plusieurs disques durs, pas plus. Le ''mainframe'' était tellement énorme et cher que les entreprises n'en avaient qu'un seul pour toute l'entreprise. Les employés avaient sur leur bureau des terminaux, qui permettaient d'accéder à l'ordinateur central, mais n'étaient pas des ordinateurs. Les terminaux étaient des composants électroniques simples, avec un écran, un clavier et une souris, mais sans processeur. Ils envoyaient des données au ''mainframe'', ils en recevaient de sa part, mais tout traitement était réalisé sur le ''mainframe''. L'arrivée sur le marché des ordinateurs personnels, de type PC fixe/portable, a entrainé l'abandon de ce genre de pratique, tous les employés ont maintenant un ordinateur rien que pour eux.

{|
|-
! colspan=&quot;2&quot; | Exemples de terminaux
|-
|[[File:Terminal-in2-sm9400.jpg|centre|vignette|upright=1.5|Exemple de terminal. Notez la présence d'un écran et d'un clavier, mais l'asbence d'une unité centrale.]]
|[[File:Chromatics CT4100.jpg|vignette|upright=1.5|Autre exemple de terminal. Le clavier est couplé à un stylo CRT, qui remplacait la souris et agissait sur l'écran comme s'il était tactile.]]
|-
! colspan=&quot;2&quot; | Intérieur d'un terminal
|-
|[[File:CT1024 Monitor.jpg|vignette|upright=1.5|Terminal CT1024, sans le boitier extérieur.]]
|[[File:CT1024 Terminal System.jpg|vignette|upright=1.5|Terminal CT1024, description des composants interne.]]
|}

De nos jours, les ''mainframes'' contiennent en réalité plusieurs ordinateurs simples interconnectés via un réseau local. Un ''mainframe'' qui tient dans une armoire contient facilement une dizaine ou centaine de processeurs, plein de RAM, des disques durs séparés dans une armoire distincte, etc. Vu qu'ils communiquent uniquement via le réseau, ils n'ont pas d'interface, pas d'écran, 'entrée via clavier/souris. Le tout est commandé avec une console de commande, typiquement un ordinateur portable ou un terminal assez simple séparé de l'armoire, qui permet à un administrateur de faire des opérations de surveillance, configuration et maintenance. Il peut y avoir une console de commande pour plusieurs armoires séparées, la console peut même être dans un autre bâtiment et accéder au ''mainframe'' par le réseau.

[[File:IBM System Z9 (type 2094 inside).jpg|centre|vignette|upright=2|''Mainframe'' de type IBM System Z9. L'ordinateur portable sert de console pour qu'un administrateur fasse des opérations de surveillance, configuration et maintenance.]]

Les processeurs et la RAM sont typiquement installés sur des cartes amovibles, qui sont connectées au fond de l'armoire lors de l'installation. Il est même possible de retirer ou d'ajouter des cartes en fonctionnement, afin d'ajouter/retirer des processeurs, des disques durs, etc. Ce qui est très utile si un composant est en panne et qu'il faut le remplacer. 

[[File:IBM TotalStorage Exp400.jpg|centre|vignette|upright=2|IBM TotalStorage Exp400]]

==Un peu d'abstraction : qu'est-ce qu'un ordinateur ?==

Un ordinateur comprend donc un processeur, plusieurs mémoires, des cartes d'extension et une carte mère pour connecter le tout. Mais il s'agit là d'une description assez terre-à-terre de ce qu'est un ordinateur. Une autre description, plus abstraite, se base sur le fait qu'un ordinateur est une énorme calculatrice programmable. Elle permet d'expliquer pourquoi il y a une distinction entre processeur et mémoire, entre unité centrale et périphériques. Tout ce qui va suivre pourra vous paraitre assez abstrait, mais rassurez-vous : les prochains chapitres rendront tout cela plus concrets.

===La séparation entre entrées-sorties et traitement===

L'unité centrale peut être vue comme une énorme calculatrice ultra-puissante, qui exécute des commandes/opérations. Mais à elle seule, elle ne servirait à rien, il faut interagir avec par l'intermédiaire de plusieurs périphériques. Il existe deux types de périphériques, qui sont conceptuellement différents. Les périphériques comme le clavier ou la souris permettent d'envoyer des informations à l'ordinateur, d'agir sur celui-ci. A l'inverse, les écrans transmettent des informations dans le sens inverse : de l'ordinateur vers l'utilisateur. Les premiers sont appelés des '''entrées''', les seconds des '''sorties'''.

Dans un ordinateur, les informations sont représentées sous la forme de nombres. Toute donnée dans un ordinateur est codée avec un ou plusieurs nombres regroupés dans une donnée, un fichier, ou autre. Et la transmissions avec les entrées et sorties se fait là-encore avec des nombres. Par exemple, quand vous appuyez sur votre clavier, le clavier envoie un numéro de touche à l'unité centrale, qui indique quelle touche a été appuyée. L'image à afficher à l'écran est codée sous la forme d'une suite de nombres (un par pixel). L'image est envoyée à l'écran, qui traduit la suite de nombre en image à afficher. Les entrées traduisent des actions utilisateurs en nombres, on dit que les entrées encodent les actions utilisateur. Les sorties font la traduction inverse, elles transforment des suites de nombres en une action physique. On dit qu'elles décodent des informations.

Pour résumer, toute appareil électronique est composé par :
* Des '''entrées''' sur lesquelles l'utilisateur agit sur l'ordinateur. Les entrées transforment les actions de l'utilisateur en nombres, qui sont interprétés par l'ordinateur.
* Une '''unité de traitement''', qui manipule des nombres et fait des calculs/opérations dessus. Les nombres proviennent des entrées, du disque dur, ou d'autres sources, peu importe.
* Des '''sorties''', qui va récupèrent le résultat calculé par l'unité de traitement pour en faire quelque chose : écrire sur une imprimante ou sur un moniteur, émettre du son,...

[[File:Ordinateur théorique Simple 1.png|centre|vignette|upright=2|Ordinateur théorique Simple 1]]

L'unité de traitement proprement dite, celle qui fait les calculs, est couplée à une mémoire qui mémorise les opérandes et résultats des calculs. La séparation entre processeur et mémoire est nécessaire pour qu'un appareil électronique soit qualifié d'ordinateur. De nombreux appareils n'ont pas de séparation entre unité de traitement et mémoire, comme certaines vielles radios AM/FM.

[[File:Schéma de principe d'un ordinateur.png|centre|vignette|upright=2|Schéma de principe d'un ordinateur]]

===Un ordinateur est un appareil programmable===

Les appareils simples sont non-programmables, ce qui veut dire qu’ils sont conçus pour une utilisation particulière et qu’ils ne peuvent pas faire autre chose. Par exemple, les circuits électroniques d’un lecteur de DVD ne peuvent pas être transformé en lecteur audio ou en console de jeux... Les circuits non-programmables sont câblés une bonne fois pour toute, et on ne peut pas les modifier. On peut parfois reconfigurer le circuit, pour faire varier certains paramètres, via des interrupteurs ou des boutons, mais cela s’arrête là. Et cela pose un problème : à chaque problème qu'on veut résoudre en utilisant un automate, on doit recréer un nouveau circuit.

À l'inverse, un ordinateur n’est pas conçu pour une utilisation particulière, contrairement aux autres objets techniques. Il est possible de modifier leur fonction du jour au lendemain, on peut lui faire faire ce qu’on veut. On dit qu'ils sont '''programmables'''. Pour cela, il suffit d’utiliser un logiciel, une application, un programme (ces termes sont synonymes), qui fait ce que l'on souhaite. La totalité des logiciels présents sur un ordinateur sont des programmes comme les autres, même le système d'exploitation (Windows, Linux, ...) ne fait pas exception.

Un programme est une suite de d'instructions, chaque instruction effectuant une action dans l'ordinateur. Sur les ordinateurs modernes, la majorité de ces instructions effectuent une opération arithmétique, comme une addition, une multiplication, une soustraction, etc. Les ordinateurs modernes sont donc de grosses calculettes très puissantes, capables d'effectuer des millions d'opérations par secondes. Et qui dit opération dit nombres : un ordinateur gère nativement des nombres, qui sont codés en binaire sur la quasi-totalité des ordinateurs modernes.

Une instruction est représentée dans un ordinateur par une série de nombres : un nombre qui indique quelle opération/commande effectuer et des autres nombres pour coder les données (ou de quoi les retrouver dans l'ordinateur). L'ordinateur récupére les commandes une par une, les traduit en opération à effectuer, exécuter l'opération, et enregistre le résultat. Puis il recommence avec la commande suivante.

[[File:Ordinateur Théorique Complexe 1.png|centre|vignette|upright=3|Ordinateur Théorique Complexe. En jaune, le programme informatique, la liste de commande. Le rectangle gris est l'ordinateur proprement dit.]]

De nombreux appareils sont programmables, mais tous ne sont pas des ordinateurs. Par exemple, certains circuits programmables nommés FPGA n'en sont pas. Pour être qualifié d'ordinateur, un appareil programmable doit avoir un processeur séparé de la mémoire. De plus, il doit utiliser un '''codage numérique''', chose que nous allons aborder dans le chapitre suivant.

===Les ordinateurs à programme mémorisé ou programme externe===

Au tout début de l'informatique, on utilisait des cartes perforées en plastique, sur lesquelles on inscrivait le programme à exécuter, les données à traiter, bref : tout ce qu'on donnait à manger à l'ordinateur. Par la suite, les premiers ordinateurs grand public, comme les Amstrad ou les Commodore, utilisaient des cassettes audio magnétiques pour stocker les programmes. Dans le même style, les consoles de jeu utilisaient autrefois des cartouches de jeu, qui contenaient le programme du jeu à exécuter. Pour résumer, les anciens ordinateurs mémorisaient les programmes sur un support externe, lu par un périphérique. De tels ordinateurs sont dits à '''programme externe'''.

: D’anciens ordinateurs personnels, comme l’Amstrad ou le Commodore, permettaient de taper les programmes à exécuter à la main, au clavier, avant d’appuyer une touche pour les exécuter. Nul besoin de vous dire que les cassettes audio étaient plus pratiques.

Mais de nos jours, les programmes sont enregistrés sur le disque dur de l'ordinateur ou dans une mémoire intégrée à l'ordinateur. On dit qu'ils sont installés, ce qui est un mot bien compliqué pour dire que le programme est enregistré sur le disque dur de l’ordinateur. A défaut de disque dur, le programme/logiciel est enregistré dans une mémoire spécialisée pour le stockage. Par exemple, sur les cartes électroniques grand public de marque Arduino, les programmes sont envoyés à la carte via le port USB, mais les programmes sont enregistrés dans la carte Arduino, dans une mémoire FLASH dédiée. Disque dur ou non, le programme est mémorisé dans la mémoire de l'ordinateur. Il est possible d'installer ou de désinstaller les programmes en modifiant le contenu de la mémoire. Le terme utilisé est alors celui de '''programme stocké en mémoire'''.

Les programmes à installer sont disponibles soit sur un périphérique, comme un DVD ou une clé USB, soit sont téléchargés depuis internet. Les premiers PC fournissaient les logiciels sur des disquettes, qui contenaient un programme d'installation pour enregistrer le programme sur le disque dur de l'ordinateur. Par la suite, le support des logiciels a migré vers les CD et DVD, les logiciels devenant de plus en plus gros. De nos jours, la majorité des applications sont téléchargées depuis le net, l'usage de périphériques est devenu obsolète, même les consoles de jeu abandonnent cette méthode de distribution.

==Les générations d'ordinateurs : un historique rapide==

L'informatique a beaucoup évolué dans le temps. Et une bonne partie de cette évolution tient à l'évolution de l’électronique sous-jacente. Les ordinateurs actuels sont fabriqués avec des transistors, des petits composants électroniques qui servent d'interrupteur programmables, qu'on détaillera dans ce qui suit. Mais ça n'a pas toujours été le cas. Et cela permet de distinguer plusieurs '''générations d'ordinateurs'''.

===Les ordinateurs électro-mécaniques : les premiers ordinateurs===

Le tout premier ordinateur est le '''Z1''', un modèle unique inventé par Konrad Suze entre 1936 et 1938. Son processeur gérait non pas des nombres entiers, mais des nombres à virgule (des nombres dits flottants, pour être précis), encodés sur 22 bits. Le processeur du Z1 était capable de faire des additions et des soustractions, car il intégrait un circuit additionneur-soustracteur basique. Des circuits annexes permettaient de faire des multiplications et des divisions en enchainant des additions/soustractions successives. Il fonctionnait à une fréquence de 1 Hz, ce qui fait qu'il pouvait faire une addition/soustraction par seconde maximum.

[[File:Blue-punch-card-front.png|vignette|upright=0.5|Carte Perforée.]]

Niveau mémoire, la RAM de l'ordinateur était très limitée : seulement 16 nombres de 22 bits chacun. S'il s'agissait d'une mémoire électronique, les programmes étaient mémorisés sur une mémoire mécanique. Les programmes étaient enregistrés sur des cartes perforées, à savoir des cartes en papier dans lesquelles un 1 est codé par un trou dans le papier et un 0 par une absence de trou. Les programmes étaient exécutés par l'ordinateur quand on insérait la carte perforée dans le lecteur et qu'on appuyait sur un bouton.

[[File:German Museum of Technology, Berlin 2017 024.jpg|centre|vignette|upright=2|Réplique du Z1 au ''German Museum of Technology'' de Berlin, 2017.]]

Après sa destruction dans un bombardement, le Z1 a été reconstruit et amélioré, ce qui donné les deux ordinateurs Z2 et Z3. Quelques années plus tard, de nombreux ordinateurs ont été construits dans des laboratoires de recherche. Des grandes noms de l'histoire de l'informatique datent de cette époque : le Harvard Mark I et le Colossus Mark 1 (UK) ont tous deux été mis en service en 1944, par exemple. Ils ont servis pour les cryptanalystes pour casser les codes utilisés par les allemands pour leurs transmissions, pendant la seconde guerre mondiale.

Les ordinateurs cités dans le précédent paragraphe étaient tous des ordinateurs dit '''électro-mécaniques''', car ils mélangeaient des composants électroniques et des composants mécaniques (tout ce qui a trait aux cartes perforées, notamment). Les composants électroniques étaient soit des relais, soit des tubes à vides, les deux étant des interrupteurs commandables électriquement plus ou moins équivalents aux transistors. Les ordinateurs d'avant l'année 1944, étaient tous de ce type. Quelques ordinateurs des années 50 étaient de ce type, mais leur nombre n'a pas dépassé 30. Il faut dire qu'ils ont rapidement laissé la place à des ordinateurs purement électroniques, que nous allons voir dans ce qui suit..

===La première génération : les tubes à vide===

Les ordinateurs qui ont suivi les ordinateurs électromécaniques sont regroupés dans la '''première génération d'ordinateur'''. Ils étaient conçus avec des tubes à vide, ce qui les place entre les premiers ordinateurs électro-mécaniques et les ordinateurs utilisant des transistors. Les tubes à vide étaient assez encombrants, ils consommaient beaucoup de courant, ils chauffaient et étaient assez peu fiables. Ils tombaient en panne assez souvent. Et ils étaient assez simple à fabriquer, mais restaient malgré tout chers.

[[File:Elektronenroehren-auswahl.jpg|centre|vignette|upright=2|Tubes à vides.]]

Au vu de de la taille des  tubes à vide, les ordinateurs de l'époque étaient composé de plusieurs milliers de ces tubes, guère plus. Et malgré cela, un ordinateur prenait facilement un étage de bâtiment entier, ou au moins plusieurs pièces. La conséquence est que les ordinateurs de première génération étaient très simples, rudimentaires quand on les compare aux ordinateurs modernes. Ils ne géraient que quelques opérations simples : l'addition, la soustraction, pas grand chose de plus. A quelques exceptions près, ils ne géraient pas la multiplication et encore moins la division, cela aurait demandé trop de tubes à vides.

Une des toutes premières machines construite avec des tubes à vide était l'Atanasoff–Berry. Ce n'était pas un ordinateur, car elle ne pouvait pas exécuter de programme sans intervention humaine pour séquencer des opérations, mais c'était la première machine de calcul purement électronique, sans aucune pièce mécanique. Elle utilisait une mémoire RAM construite avec des condensateurs, ceux-ci étant placés sur des cylindres tournants. Les circuits de calcul étaient construits avec des tubes à vide et faisaient leur travail un bit à la fois. Elle fonctionnait à une fréquence de 60 Hz et pouvait faire 30 additions/soustractions par seconde. Les nombres étaient encodés sur 50 bits. 

[[File:Atanasoff Berry Computer.gif|centre|vignette|upright=2.5|Atanasoff–Berry.]]

L'arrivée de l'ENIAC en 1945 a changé la donne. Cet ordinateur a introduit plusieurs innovations majeures. La première est assez technique, il s'agit de la turing-complétude, elle a trait aux programmes qui peuvent être écrit pour un ordinateur, nous ne la détaillerons pas ici.

[[File:BabyArchitecture.png|vignette|Architecture de la Manchester Baby.]]

En 1948, le ''Manchester Baby'' a introduit une innovation extrêmement importante : le programme n'était plus mémorisé sur des cartes perforées, mais dans une mémoire électronique à l’intérieur de l'ordinateur lui-même. En clair, le ''Manchester Baby'' était le premier '''ordinateur à programme stocké en mémoire''' en français. Au-delà de ça, le Manchester Baby restait quand même très simple, c'était limite un prototype.

Niveau interface, l'ordinateur avait une console avec 32 boutons, des interrupteurs et un écran de sortie sur lequel afficher les résultats. A l'intérieur, il y avait un processeur et une RAM de 32 nombres de 32 bits, fabriquées avec des tubes Williams (abordés dans une annexe à la fin du cours). Le programme devait tenir dans la RAM, avec une instruction prenant autant de place qu'un nombre, ce qui limitait les programmes à 32 instructions maximum. Une instruction prenait donc 32 bits, 3 indiquaient quelle opération utiliser, 12 servait à indiquer où se trouvent les opérandes en RAM, les 16 restants sont inutilisés.

Il gérait 8 instructions en tout, mais ne gérait pas l'addition. Il gérait la soustraction, des instructions de branchement et d'accès mémoire, mais rien d'autre. Il pouvait cependant émuler l'addition à partir d'une soustraction et inversant l'opérande soustraite. C'était une architecture avec un registre unique de 32 bits, appelé l'accumulateur, avec une instruction STORE pour copier son contenu en RAM et une instruction LOAD pour copier du nombre de la RAM vers l'accumulateur. Les instructions étaient chargées dans un registre pour être exécutées, le processeur avait aussi un registre pour mémoriser la position de l'instruction suivante en RAM.

Le Manchester Mark 1 était une amélioration du Manchester Baby. Il utilisait 4500 tubes à vide. L'ordinateur gérait des nombres de 40 bits, les instructions étaient codées sur 20 bits. La RAM était toujours composée de 32 nombres, leur taille était simplement augmentée. Par contre, elle était complémentée par l’ancêtre du disque dur magnétique, à savoir un tambour magnétique, l’ancêtre du disque dur magnétique. Il contenait 40 pages, faisant chacune 32 nombres de 40 bits. C'était là encore une architecture à accumulateur, elle intégrait aussi des registres d'indice. Et surtout : son processeur gérait l'addition et quelques opérations logiques (ET et OU), en plus de la soustraction et de la comparaison.

[[File:MM1Schematic French.svg|centre|vignette|upright=2.5|Architecture de la Manchester Mark 1.]]

===La seconde génération : le remplacement des tubes à vides par des transistors===

[[File:IBM 7070.jpg|vignette|Cartes imprimées de l'IBM 704, avec des transistors et résistances dessus.]]

La '''seconde génération''' est celle des ordinateurs fabriqués avec des '''transistors''' isolés, reliés entre avec des fils électriques. Les transistors en question possèdent trois broches, des pattes métalliques sur lesquelles on connecte des fils électriques. Le transistor s'utilise le plus souvent comme un interrupteur commandé par sa troisième broche. Le courant qui traverse les deux premières broches passe ou ne passe pas selon ce qu'on met sur la troisième.

[[File:Transistor basic flow.svg|centre|vignette|Un transistor est un morceau de conducteur, dont la conductivité est contrôlée par sa troisième broche/borne.]]

Les ordinateurs de seconde génération avaient entre 1000 et 500 000 transistors. Les capacités des ordinateurs étaient donc nettement supérieures à celles des ordinateurs de première génération. Une part non négligeable des ordinateurs de seconde génération supportait l'opération de multiplication, absente sur les ordinateurs de première génération. Néanmoins, cela variait beaucoup selon les ordinateurs.

Un exemple assez hors du commun est celui du premier modèle de l'IBM 1620. Le tout premier modèle n'avait aucun circuit de calcul, il n'était même pas capable de faire une addition ou une multiplication. A la place, il utilisait une table d'addition et une table de multiplication en mémoire RAM. Les deux tables devaient être initialisées par le logiciel lors du démarrage de la machine. La table d'addition faisait une centaine de chiffre, la table de multiplication faisait le double. Le processeur de l'ordinateur gérait des instructions pour faire des additions ou des multiplications, mais ces opérations lisaient le résultat dans la table d'addition. Les calculs étaient fait chiffre par chiffre, avec un encodage partiellement décimal, partiellement binaire (des chiffres décimaux étaient encodés en binaire, nous en reparlerons quand nous parlerons du BCD) !

[[File:KL CoreMemory.jpg|vignette|Mémoire à tore de ferrite.]]

Les transistors n'étaient utilisés que pour le processeur et les circuits annexes. La mémoire n'était pas faite en transistors, pas à cette époque. La mémoire était une mémoire aujourd'hui abandonnée, appelée une '''mémoire à tores de ferrite'''. Elle sera détaillée dans un chapitre ultérieur. Mais sachez pour le moment qu'il s'agit d'une mémoire au support magnétique, les données étant stockées sur un support magnétique.

Transistors comme tubes à vide prenaient beaucoup de place, ce qui fait que les ordinateurs étaient assez gros. Concrètement, ils prenaient une pièce de bâtiment entière dans le meilleur des cas. C'était l'époque des gros ''mainframes'', reliés à des terminaux, peu puissants comparé aux standards actuels. Seules les grandes entreprises et les grands instituts de recherche pouvaient se payer les services de ce genre d'ordinateurs. Seuls les professionnels avaient accès à ce genre d'équipement.

===La troisième génération : le circuit intégré===

[[File:D8259AC-2.jpg|vignette|Exemple de circuit intégré.]]

La troisième génération est toujours fabriquée avec des transistors, mais dont la taille a été réduite. Avec l'évolution de la technologie, les transistors ont diminué en taille, de plus en plus. Ils sont devenus tellement petits qu'ils ont finit par être regroupés dans des '''circuits intégrés''', des circuits regroupent plusieurs transistors sur la même puce de silicium. Les circuits intégrés se présentent le plus souvent sous la forme de boitiers rectangulaires, comme illustré ci-contre. D'autres ont des boitiers de forme carrées, comme ceux que l'on peut trouver sur les barrettes de mémoire RAM, ou à l'intérieur des clés USB/ disques SSD.

Lors de cette génération, les processeurs étaient fournis en pièces détachées qu'il fallait relier entre elles. Le processeur était composé de plusieurs circuits intégrés séparés, impossible de mettre un processeur dans un seul boitier. Un exemple de processeur conçu en kit est la série des Intel 3000. Elle regroupe plusieurs circuits séparés aux noms à coucher dehors, mais dont vous comprendrez ce qu'ils veulent dire dans les chapitres adéquats : l'Intel 3001 est un séquenceur, l'Intel 3002 regroupe unité de calcul et registres, le 3003 est un circuit d'anticipation de retenue complémentaire du 3002, le 3212 est une mémoire tampon, le 3214 est une unité de gestion des interruptions, les 3216/3226 sont des interfaces de bus mémoire. On pourrait aussi citer la famille de circuits intégrés AMD Am2900.

Même si le processeur était en pièce détachées, utiliser une dizaine de circuits intégrés était nettement mieux que d'utiliser plusieurs milliers de transistors individuels. En conséquence, les ordinateurs ont vu leur taille grandement réduite, passant de pièces entières à une simple armoire, voire à quelques cartes intégrées superposées. De plus, le prix des circuits intégré était abordable, du moins comparé aux ordinateurs d'avant. Le prix des ordinateurs a alors grandement décru, permettant à des entreprises et administrations de taille modeste de s'équiper d'ordinateurs.

===La quatrième génération : le microprocesseur===

[[File:MOS6502.svg|vignette|Microprocesseur, ici un processeur MOS6502, de la quatrième génération.]]

Lors de la troisième génération, les circuits intégrés regroupaient plusieurs dizaines ou centaines de transistors, mais sont rapidement montés en gamme. De centaines de transistors, ils sont passé au milliers de transistors, puis au millions et maintenant au-delà du milliard. Les transistors étaient devenus tellement petits, tellement miniaturisés, qu'il était devenu possible de mettre un processeur entier dans un circuit intégré. C'est ainsi qu'est né le microprocesseur, à savoir un processeur qui tient tout entier dans un seul circuit imprimé. La quatrième génération d’ordinateur est celle des ordinateurs basés autour d'un microprocesseur.

Les tout premiers microprocesseurs étaient des processeurs à application militaire, comme le processeur du F-14 CADC ou celui de l'Air data computer. Le tout premier microprocesseur commercialisé au grand public est le 4004 d'Intel, sorti en 1971. L'intel 4004 comprenait environ 2300 transistors, avait une fréquence de 740 MHz, pouvait faire 46 opérations différentes, et manipulait des entiers de 4 bits. Il était au départ un processeur de commande, prévu pour être intégré dans la calculatrice Busicom calculator 141-P, mais il fut utilisé pour d'autres applications quelque temps plus tard. Immédiatement après le 4004, les premiers microprocesseurs 8 bits furent commercialisés. Le 4004 fut suivi par le 8008 et quelques autres processeurs 8 bits extrêmement connus, comme le 8080 d'Intel, le 68000 de Motorola, le 6502 ou le Z80.

Les microprocesseurs permirent encore uen fois de réduire la taille des ordinateurs, qui pouvaient tenir dans un boitier de PC, ou un boitier de console de jeu. Le prix des ordinateurs a aussi chuté en même temps que les transistors était miniaturisés. C'est cette invention qui permis l'invention des consoles de jeux et des mini-ordinateurs, à savoir les ordinateurs personnels. Sans miniaturisation, on n'aurait pas d'ordinateur personnel, pas de PC fixe ou portable.

==L'organisation du cours : les différents niveaux d'explication==

Le fonctionnement d'un ordinateur est assez complexe à expliquer car les explications peuvent se faire sur plusieurs niveaux. Par plusieurs niveaux, on veut dire qu'un ordinateur est composé de composants très simples, qui sont assemblés pour donner des composants eux-même plus complexes, qui sont eux-même regrouper, etc. Étudier tout cela demande de voir plusieurs niveaux, allant de transistors très petits à des processeurs multicœurs. Les niveaux les plus bas sont de l'électronique pur et dure, alors que ceux plus haut sont à mi-chemin entre électronique et informatique.

===Les niveaux d'abstraction en architecture des ordinateurs===

Les trois premiers niveaux sont de l'électronique pur et dure. Ils correspondent aux premiers chapitres du cours, qui porteront sur les circuits électroniques en général.
* Le premier niveau est celui des '''transistors''', des circuits intégrés, des ''wafer'' et autres circuits de très petite taille.
* Le second niveau est celui des '''portes logiques''', des circuits très basiques, très simples, à la base de tous les autres.
* Le troisième niveau est celui dit de la '''''Register Transfer Level''''', où un circuit électronique est construit à partir de circuits basiques, dont des registres et autres circuits dits combinatoires.
Les deux niveaux suivants sont de l'informatique proprement dit. C'est dans ces deux niveaux qu'on étudie les ordinateurs proprement dit, les circuits qu'il y a dedans et non l'électronique en général.
* Le quatrième niveau est celui de la '''microarchitecture''', qui étudie ce qu'il y a à l'intérieur d'un processeur, d'une mémoire, des périphériques et autres.
* Le cinquième niveau est celui de l''''architecture externe''', qui décrit l'interface du processeur, de la mémoire, d'un périphérique ou autre. Par décrire l'interface, on veut dire : comment un programmeur voit le processeur et la mémoire, comment il peut les manipuler. Une architecture externe unique peut avoir plusieurs microarchitecture, ce qui fait qu'on sépare les deux. Tout cela sera plus clair quand on passera aux chapitres sur le processeur et les mémoires.

Nous n'allons pas voir les 5 niveaux dans l'ordre, des transistors vers l'architecture externe. En réalité, nous allons procéder autrement. La première partie du cours portera sur les trois premiers niveaux, le reste sur les deux autres. Les 5 niveaux seront vus dans des chapitres séparés, du moins le plus possible. Au niveau pédagogique, tout est plus simple si on scinde les 5 niveaux. Bien sûr, il y a quelques explications qui demandent de voir plusieurs niveaux à la fois. Par exemple, dans le chapitre sur les mémoires caches, nous auront des explications portant sur la RTL, la microarchitecture du cache et son architecture externe. Mais le gros du cours tentera de séparer le plus possible les 5 niveaux.

===Les trois parties principales du cours===

Nous allons commencer par parler du binaire, avant de voir les portes logiques. Avec ces portes logiques, nous allons voir comment fabriquer des circuits basiques qui reviendront très souvent dans la suite du cours. Nous verrons les registres, les décodeurs, les additionneurs et plein d'autres circuits. Puis, nous reviendrons au niveau des transistors pour finir la première partie. La raison est que c'est plus simple de faire comme cela. Tout ce qui a trait aux transistors sert à expliquer comment fabriquer des portes logiques, et il faut expliquer les portes logiques pour voir le niveau de la RTL.

Une fois la première partie finie, nous allons voir les différents composants d'un ordinateur. Une première partie expliquera ce qu'il y a dans un ordinateur, quels sont ses composants. Nous y parlerons de l'architecture de base, de la hiérarchie mémoire, des tendances technologiques, et d'autres généralités qui serviront de base pour la suite. Puis, nous verrons dans l'ordre les bus électroniques, les mémoires RAM/ROM, le processeur, les périphériques, les mémoires de stockage (SSD et disques durs) et les mémoires caches. Pour chaque composant, nous allons voir leur architecture externe, avant de voir leur microarchitecture. La raison est que la microarchitecture ne peut se comprendre que quand on sait quelle architecture externe elle implémente.

Enfin, dans une troisième partie, nous allons voir les optimisations majeures présentes dans tous les ordinateurs modernes, avec une partie sur le pipeline et le parallélisme d'instruction, et une autre sur les architectures parallèles. Pour finir, les annexes de fin parlerons de sujets un peu à part.

&lt;noinclude&gt;
{{NavChapitre | book=Fonctionnement d'un ordinateur
           | next=L'encodage des données
           | nextText=L'encodage des données
}}
&lt;/noinclude&gt;</text>
      <sha1>hzau4c69s3ibjlwftntxfzak7yt1kd0</sha1>
    </revision>
    <revision>
      <id>744128</id>
      <parentid>744127</parentid>
      <timestamp>2025-06-05T00:17:29Z</timestamp>
      <contributor>
        <username>Mewtow</username>
        <id>31375</id>
      </contributor>
      <minor />
      <comment>/* La première génération : les tubes à vide */</comment>
      <origin>744128</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="46078" sha1="mwglx04a5hy3odgjsavgin70kwnssi7" xml:space="preserve">Pour commencer, nous allons voir qu'il existe de nombreux types d'ordinateurs. Le plus connu est certainement le PC, l'ordinateur personnel, que vous avez sans doute dans votre salon. Les ordinateurs portables sont un deuxième type d'ordinateur assez intuitif, que vous avez peut-être. Mais il y a aussi d'autres types d'ordinateurs auxquels vous n'avez jamais été confrontés.

==Les différents types d'ordinateurs==

Dans cette section, nous allons décrire rapidement les ordinateurs les plus courant, mais surtout voir ce qu'il y a à l'intérieur d'un ordinateur.

===L'ordinateur de type PC fixe===

De l'extérieur, l'ordinateur est composé d'une unité centrale sur laquelle on branche des périphériques.

[[File:Typical computer architecture systems.jpg|vignette|upright=1.5|Exemples de périphériques, connectés à une unité centrale (ici appelée à tort ''operating system'').]]

Les '''périphériques''' regroupent l'écran, la souris, le clavier, l'imprimante, et bien d'autres choses. Ils permettent à l'utilisateur d'interagir avec l'ordinateur : un clavier permet de saisir du texte sous dans un fichier, une souris enregistre des déplacements de la main en déplacement du curseur, un écran affiche des données d’images/vidéos, un haut-parleur émet du son, etc. Tout ce qui est branché sur un ordinateur est, formellement un périphérique.

L''''unité centrale''' est là où se trouvent tous les composants importants d'un ordinateur, ceux qui font des calculs, qui exécutent des logiciels, qui mémorisent vos données, etc. Voici ce à quoi ressemble l'intérieur de l'unité centrale. Trois sections sont visibles : l'alimentation électrique en haut à gauche, la carte mère en bas à gauche et en jaune/orange, les disques et lecteurs à droite des câbles. Et on voit aussi beaucoup de câbles.

[[File:Asus P5K-SEIntel E6320.jpg|centre|vignette|upright=2|Exemple d'unité centrale.]]

Tout en haut à gauche, se trouve l''''alimentation électrique''', qui convertit le courant de la prise électrique en un courant plus faible, utilisable par les autres composants. Elle émet de nombreux câbles assez gros, qui sont reliés au reste. Les PC actuels utilisent des alimentations électriques standardisées, qui fournissent trois tensions au reste de l'ordinateur : une tension de 12 Volts, une de 5 Volts, une de 3,3 Volts.

À droite, caché par la partie &quot;métallique&quot; du boitier, se trouvent les lecteurs de CD/DVD, et les disques durs. Les lecteurs CD-ROM ou DVD-ROM permettaient de lire des CD ou des DVD. Je parle au passé, car ils ont aujourd'hui disparu des ordinateurs modernes. Les '''disques durs''' sont des mémoires de stockage, qui mémorisent vos données de manière permanente. De nos jours, ils sont remplacés par des SSD, qui sont des disques durs électroniques, là où les disques durs proprement dit sont des mémoires magnétiques. Nous verrons la différence dans deux chapitres dédiés, un sur les disques durs, l'autre sur les SSD.

En bas à droite, se trouve la '''carte mère''' un support plat, en plastique ou en céramique, sur laquelle sont soudés/connectés les autres composants. Sur celle-ci, de nombreux composants sont soudés, d'autres sont branchés dessus avec des câbles, d'autres sont connectés dessus avec des connecteurs. Ils sont reliés entre eux par des fils conducteurs, le plus souvent du cuivre ou de l’aluminium, ce qui leur permet de s’échanger des données. Sur les cartes simples, ces fils sont intégrés dans la carte électronique, dans des creux du plastique. Ils portent le nom de pistes.

Avant, les disques durs, SSD et lecteurs de CD/DVD sont branchés dessus via des connecteurs dédiés, appelés des connecteurs S-ATA. De nos jours, ils sont branchés sur un autre connecteur, grâce à l'interface NVME. Toujours est-il qu'ils sont reliés à la carte mère par des câbles, ce qui montre que ce sont des sortes de périphériques interne. Ils sont placés dans le boitier, mais on aurait tout aussi bien pu les mettre à l'extérieur, vu qu'ils communiquent avec l'ordinateur par l'intermédiaire d'un câble ou d'un connecteur dédié.

Mais deux autres composants très importants sont eux placés sur la carte mère, directement. Ils ont chacun un connecteur dédié, sur lequel ils sont branchés directement, sans passer par l'intermédiaire d'un câble, mais sans être soudés non plus. Il s'agit du processeur et de la mémoire RAM, deux composants centraux des PC modernes.

[[File:Pentium III SL4CB.jpg|thumb|Processeur Pentium III.]]

Le '''processeur''' traite les données, les modifie, les manipule. Pour faire simple, il s’agit d’une grosse calculatrice hyper-puissante. Il comprend à la fois un circuit qui fait des calculs, et un circuit de contrôle qui s'occupe de séquencer les calculs dans l'ordre demandé. Il est souvent caché sous un radiateur, lui-même surmonté par un ventilateur. En effet, un processeur chauffe beaucoup, ce qui demande d'évacuer cette chaleur. Un chapitre entier expliquera pourquoi les processeurs chauffent, ainsi que les techniques utilisées pour limiter leur production de chaleur et leur consommation électrique.

La '''mémoire vive''' conserve des informations/données temporairement, tant que le processeur en a besoin. Elle prend la forme de barrettes de RAM, comme montré ci-dessous.

[[File:2 gb ddr2 667.jpg|centre|vignette|upright=2|Barrette de RAM.]]

Outre ces composants dits principaux, un ordinateur peut comprendre plusieurs composants moins importants, surtout présents sur les ordinateurs personnels. Ils sont techniquement facultatifs, mais sont très présents dans les ordinateurs personnels. Cependant, certains ordinateurs spécialisés s'en passent. Il s'agit des diverses '''cartes d'extension''' sont branchées sur la carte mère. Elles permettent d’accélérer certains calculs ou certaines applications, afin de décharger le processeur. Par exemple, la carte graphique s'occupe des calculs graphiques, qu'il s'agisse de graphismes 3D de jeux vidéos ou de l'affichage en 2D du bureau. Dans un autre registre, la carte son prend en charge le microphone et les haut-parleurs.

[[Fichier:Personal computer, exploded 4.svg|thumb|upright=1.0|Éclaté d'un ordinateur de type PC :&lt;br /&gt;
1 : Écran ;&lt;br /&gt;
2 : Carte mère ;&lt;br /&gt;
3 : Processeur ;&lt;br /&gt;
4 : Câble Parallel ATA ;&lt;br /&gt;
5 : Mémoire vive (RAM) ;&lt;br /&gt;
6 : Carte d'extension ;&lt;br /&gt;
7 : Alimentation électrique ;&lt;br /&gt;
8 : Lecteur de disque optique ;&lt;br /&gt;
9 : Disque dur ;&lt;br /&gt;
10 : Clavier ;&lt;br /&gt;
11 : Souris.]]

Si on regarde une carte mère de face, on voit un grand nombre de connecteurs, mais aussi des circuits électroniques soudés à la carte mère.

[[File:Architecture matérielle d'une carte mère.png|centre|vignette|upright=2.0|Architecture matérielle d'une carte mère]]

Les '''connecteurs''' sont là où on branche les périphériques, la carte graphique, le processeur, la mémoire, etc. Dans l'ensemble, toute carte mère contient les connecteurs suivants :
* Le processeur vient s’enchâsser dans la carte mère sur un connecteur particulier : le '''socket'''. Celui-ci varie suivant la carte mère et le processeur, ce qui est source d'incompatibilités.
* Les barrettes de mémoire RAM s’enchâssent dans un autre type de connecteurs: les '''slots mémoire'''.
* Les mémoires de masse disposent de leurs propres connecteurs : connecteurs P-ATA pour les anciens disques durs, et S-ATA pour les récents.
* Les périphériques (clavier, souris, USB, Firewire, ...) sont connectés sur un ensemble de connecteurs dédiés, localisés à l'arrière du boitier de l'unité centrale. 
* Les autres périphériques sont placés dans l'unité centrale et sont connectés via des connecteurs spécialisés. Ces périphériques sont des cartes imprimées, d'où leur nom de '''cartes filles'''. On peut notamment citer les cartes réseau, les cartes son, ou les cartes vidéo.

===Les ordinateurs portables===

[[File:Samsung QX-511 (2).JPG|vignette|Ordinateur portable Samsung QX-511 (2), pour illustration.]]

Un ordinateur portable est identique à un ordinateur de type PC. Si vous ouvrez votre ordinateur portable (attention à la garantie), vous retrouverez les mêmes composants qu'un PC à l'intérieur. Un point important est la présence d'une batterie à l'intérieur du PC portable, absente des PC fixes.

[[File:LG gram 14Z90Q mainboard with battery.jpg|centre|vignette|upright=2|LG gram 14Z90Q avec sa batterie.]]

Une fois la batterie et les circuits associés retiré, la seule différence notable est que tous les composants sont soudés sur la carte mère, au lieu d'être branchés sur des connecteurs, à part éventuellement la RAM et le disque dur.

[[File:LG gram 14Z90Q mainboard without battery.jpg|centre|vignette|upright=2|LG gram 14Z90Q sans sa batterie.]]

La RAM est parfois soudée sur la carte mère, d'autres fois sous la forme de barrettes de mémoire vive semblables à celles des PC. Dans le dernier cas, elle est connectée à des connecteurs spécifiques, ce qui permet de les changer/upgrader. Les PC portables sont parfois construits de manière à pouvoir changer la RAM facilement, en ouvrant un cache spécial, concu pour.

[[File:Lenovo G555 состав - Донор.JPG|centre|vignette|upright=2|Lenovo G555.]]

La conception d'un ordinateur portable est légèrement différente de celle d'un PC, pour des raisons thermiques. Un PC fixe a plus de place pour évacuer sa chaleur. Les ventilateurs peuvent plus facilement déplacer l'air dans le boitier, même si le flux d'air dans le boitier est éventuellement gêné par la carte graphique. Mais l'évacuation de la chaleur est assez efficace. Sur les PC portables, leur finesse fait que le trajet de l'air est beaucoup plus contraint. Évacuer la chaleur produite par l'ordinateur est plus complexe, ce qui demande d'utiliser des systèmes de refroidissement et de ventilation spécifiques.

Là où les PC fixes se débrouillent avec des radiateurs et des ventilateurs posés sur le processeur, les PC portables font autrement. Ils ne peuvent pas forcément mettre le ventilateur sur le processeur. A la place, ils mettent le ventilateur à côté, mais le processeur est surmonté par un mécanisme de transmission de la chaleur, qui transfère la chaleur du processeur vers le ventilateur.

[[File:Diagram - How a laptop cooling system works.png|centre|vignette|upright=2|Comment fonctionne le système de ventilation d'un ordinateur portable, en anglais.]]

Les difficultés pour dissiper la chaleur font que les ordinateurs portables utilisent souvent des composants peu performants, mais qui chauffent peu. En effet, nous verrons que plus un composant est puissant, plus il chauffe. La relation n'est pas parfaite, mais les processeurs haute performance chauffent plus que les modèles d'entrée ou milieu de gamme moins puissants. En conséquence, les PC portables sont souvent moins puissants que les PC fixes, même pour les modèles dit ''gaming''.

===Les serveurs et ''mainframes''===

Les grandes entreprises utilisent des ordinateurs de grande taille, très puissants, appelés des ''mainframes''. Ils sont souvent confondus avec les serveurs par le grand public, il y a une différence entre les deux. Un serveur est une fonction logicielle/réseau, pas un type d'ordinateur. Mais laissons cette différence de côté, ce qui est dit pour les ''mainframes'' sert pour les gros serveurs haute performance.

[[File:IBM Z15 mainframe.jpg|vignette|Exemple de ''mainframe''' de type IBM Z15.]]

Les anciens ''mainframes'' des années 50-80 avaient une taille pouvant être impressionnante, au point de prendre une pièce complète d'un bâtiment. Mais de nos jours, les ''mainframes'' tiennent dans une grosse armoire un peu haute. Les ''mainframes'' doivent rester allumé en permanence et ne doivent pas être éteint, sauf éventuellement quelques jours par an pour des opérations de maintenance. Ils utilisent pour cela des techniques spécifiques, avec beaucoup de redondance interne.

[[File:ACONIT hall grandes machines.jpg|centre|vignette|upright=2|''Mainframe'' ACONIT.]]

Les ''mainframes'' sont aussi conçus pour mutualiser au maximum leur utilisation, ils peuvent être utilisés par plusieurs utilisateurs à la suite, voire en même temps. Pour cela, les anciens ''mainframes'' étaient capables de faire tourner plusieurs applications distinctes l'une à la suite de l'autre, avec des commutations fréquentes entre logiciels. De nos jours, ils sont capables d'exécuter un grand nombre de tâches en même temps, grâce à la présence de plusieurs processeurs. Les ''mainframes'' modernes sont même capables de faire tourner plusieurs systèmes d'exploitation en même temps si besoin.

Les anciens ''mainframes'' étaient des ordinateurs assez simples, avec un processeur, de la mémoire RAM, un ou plusieurs disques durs, pas plus. Le ''mainframe'' était tellement énorme et cher que les entreprises n'en avaient qu'un seul pour toute l'entreprise. Les employés avaient sur leur bureau des terminaux, qui permettaient d'accéder à l'ordinateur central, mais n'étaient pas des ordinateurs. Les terminaux étaient des composants électroniques simples, avec un écran, un clavier et une souris, mais sans processeur. Ils envoyaient des données au ''mainframe'', ils en recevaient de sa part, mais tout traitement était réalisé sur le ''mainframe''. L'arrivée sur le marché des ordinateurs personnels, de type PC fixe/portable, a entrainé l'abandon de ce genre de pratique, tous les employés ont maintenant un ordinateur rien que pour eux.

{|
|-
! colspan=&quot;2&quot; | Exemples de terminaux
|-
|[[File:Terminal-in2-sm9400.jpg|centre|vignette|upright=1.5|Exemple de terminal. Notez la présence d'un écran et d'un clavier, mais l'asbence d'une unité centrale.]]
|[[File:Chromatics CT4100.jpg|vignette|upright=1.5|Autre exemple de terminal. Le clavier est couplé à un stylo CRT, qui remplacait la souris et agissait sur l'écran comme s'il était tactile.]]
|-
! colspan=&quot;2&quot; | Intérieur d'un terminal
|-
|[[File:CT1024 Monitor.jpg|vignette|upright=1.5|Terminal CT1024, sans le boitier extérieur.]]
|[[File:CT1024 Terminal System.jpg|vignette|upright=1.5|Terminal CT1024, description des composants interne.]]
|}

De nos jours, les ''mainframes'' contiennent en réalité plusieurs ordinateurs simples interconnectés via un réseau local. Un ''mainframe'' qui tient dans une armoire contient facilement une dizaine ou centaine de processeurs, plein de RAM, des disques durs séparés dans une armoire distincte, etc. Vu qu'ils communiquent uniquement via le réseau, ils n'ont pas d'interface, pas d'écran, 'entrée via clavier/souris. Le tout est commandé avec une console de commande, typiquement un ordinateur portable ou un terminal assez simple séparé de l'armoire, qui permet à un administrateur de faire des opérations de surveillance, configuration et maintenance. Il peut y avoir une console de commande pour plusieurs armoires séparées, la console peut même être dans un autre bâtiment et accéder au ''mainframe'' par le réseau.

[[File:IBM System Z9 (type 2094 inside).jpg|centre|vignette|upright=2|''Mainframe'' de type IBM System Z9. L'ordinateur portable sert de console pour qu'un administrateur fasse des opérations de surveillance, configuration et maintenance.]]

Les processeurs et la RAM sont typiquement installés sur des cartes amovibles, qui sont connectées au fond de l'armoire lors de l'installation. Il est même possible de retirer ou d'ajouter des cartes en fonctionnement, afin d'ajouter/retirer des processeurs, des disques durs, etc. Ce qui est très utile si un composant est en panne et qu'il faut le remplacer. 

[[File:IBM TotalStorage Exp400.jpg|centre|vignette|upright=2|IBM TotalStorage Exp400]]

==Un peu d'abstraction : qu'est-ce qu'un ordinateur ?==

Un ordinateur comprend donc un processeur, plusieurs mémoires, des cartes d'extension et une carte mère pour connecter le tout. Mais il s'agit là d'une description assez terre-à-terre de ce qu'est un ordinateur. Une autre description, plus abstraite, se base sur le fait qu'un ordinateur est une énorme calculatrice programmable. Elle permet d'expliquer pourquoi il y a une distinction entre processeur et mémoire, entre unité centrale et périphériques. Tout ce qui va suivre pourra vous paraitre assez abstrait, mais rassurez-vous : les prochains chapitres rendront tout cela plus concrets.

===La séparation entre entrées-sorties et traitement===

L'unité centrale peut être vue comme une énorme calculatrice ultra-puissante, qui exécute des commandes/opérations. Mais à elle seule, elle ne servirait à rien, il faut interagir avec par l'intermédiaire de plusieurs périphériques. Il existe deux types de périphériques, qui sont conceptuellement différents. Les périphériques comme le clavier ou la souris permettent d'envoyer des informations à l'ordinateur, d'agir sur celui-ci. A l'inverse, les écrans transmettent des informations dans le sens inverse : de l'ordinateur vers l'utilisateur. Les premiers sont appelés des '''entrées''', les seconds des '''sorties'''.

Dans un ordinateur, les informations sont représentées sous la forme de nombres. Toute donnée dans un ordinateur est codée avec un ou plusieurs nombres regroupés dans une donnée, un fichier, ou autre. Et la transmissions avec les entrées et sorties se fait là-encore avec des nombres. Par exemple, quand vous appuyez sur votre clavier, le clavier envoie un numéro de touche à l'unité centrale, qui indique quelle touche a été appuyée. L'image à afficher à l'écran est codée sous la forme d'une suite de nombres (un par pixel). L'image est envoyée à l'écran, qui traduit la suite de nombre en image à afficher. Les entrées traduisent des actions utilisateurs en nombres, on dit que les entrées encodent les actions utilisateur. Les sorties font la traduction inverse, elles transforment des suites de nombres en une action physique. On dit qu'elles décodent des informations.

Pour résumer, toute appareil électronique est composé par :
* Des '''entrées''' sur lesquelles l'utilisateur agit sur l'ordinateur. Les entrées transforment les actions de l'utilisateur en nombres, qui sont interprétés par l'ordinateur.
* Une '''unité de traitement''', qui manipule des nombres et fait des calculs/opérations dessus. Les nombres proviennent des entrées, du disque dur, ou d'autres sources, peu importe.
* Des '''sorties''', qui va récupèrent le résultat calculé par l'unité de traitement pour en faire quelque chose : écrire sur une imprimante ou sur un moniteur, émettre du son,...

[[File:Ordinateur théorique Simple 1.png|centre|vignette|upright=2|Ordinateur théorique Simple 1]]

L'unité de traitement proprement dite, celle qui fait les calculs, est couplée à une mémoire qui mémorise les opérandes et résultats des calculs. La séparation entre processeur et mémoire est nécessaire pour qu'un appareil électronique soit qualifié d'ordinateur. De nombreux appareils n'ont pas de séparation entre unité de traitement et mémoire, comme certaines vielles radios AM/FM.

[[File:Schéma de principe d'un ordinateur.png|centre|vignette|upright=2|Schéma de principe d'un ordinateur]]

===Un ordinateur est un appareil programmable===

Les appareils simples sont non-programmables, ce qui veut dire qu’ils sont conçus pour une utilisation particulière et qu’ils ne peuvent pas faire autre chose. Par exemple, les circuits électroniques d’un lecteur de DVD ne peuvent pas être transformé en lecteur audio ou en console de jeux... Les circuits non-programmables sont câblés une bonne fois pour toute, et on ne peut pas les modifier. On peut parfois reconfigurer le circuit, pour faire varier certains paramètres, via des interrupteurs ou des boutons, mais cela s’arrête là. Et cela pose un problème : à chaque problème qu'on veut résoudre en utilisant un automate, on doit recréer un nouveau circuit.

À l'inverse, un ordinateur n’est pas conçu pour une utilisation particulière, contrairement aux autres objets techniques. Il est possible de modifier leur fonction du jour au lendemain, on peut lui faire faire ce qu’on veut. On dit qu'ils sont '''programmables'''. Pour cela, il suffit d’utiliser un logiciel, une application, un programme (ces termes sont synonymes), qui fait ce que l'on souhaite. La totalité des logiciels présents sur un ordinateur sont des programmes comme les autres, même le système d'exploitation (Windows, Linux, ...) ne fait pas exception.

Un programme est une suite de d'instructions, chaque instruction effectuant une action dans l'ordinateur. Sur les ordinateurs modernes, la majorité de ces instructions effectuent une opération arithmétique, comme une addition, une multiplication, une soustraction, etc. Les ordinateurs modernes sont donc de grosses calculettes très puissantes, capables d'effectuer des millions d'opérations par secondes. Et qui dit opération dit nombres : un ordinateur gère nativement des nombres, qui sont codés en binaire sur la quasi-totalité des ordinateurs modernes.

Une instruction est représentée dans un ordinateur par une série de nombres : un nombre qui indique quelle opération/commande effectuer et des autres nombres pour coder les données (ou de quoi les retrouver dans l'ordinateur). L'ordinateur récupére les commandes une par une, les traduit en opération à effectuer, exécuter l'opération, et enregistre le résultat. Puis il recommence avec la commande suivante.

[[File:Ordinateur Théorique Complexe 1.png|centre|vignette|upright=3|Ordinateur Théorique Complexe. En jaune, le programme informatique, la liste de commande. Le rectangle gris est l'ordinateur proprement dit.]]

De nombreux appareils sont programmables, mais tous ne sont pas des ordinateurs. Par exemple, certains circuits programmables nommés FPGA n'en sont pas. Pour être qualifié d'ordinateur, un appareil programmable doit avoir un processeur séparé de la mémoire. De plus, il doit utiliser un '''codage numérique''', chose que nous allons aborder dans le chapitre suivant.

===Les ordinateurs à programme mémorisé ou programme externe===

Au tout début de l'informatique, on utilisait des cartes perforées en plastique, sur lesquelles on inscrivait le programme à exécuter, les données à traiter, bref : tout ce qu'on donnait à manger à l'ordinateur. Par la suite, les premiers ordinateurs grand public, comme les Amstrad ou les Commodore, utilisaient des cassettes audio magnétiques pour stocker les programmes. Dans le même style, les consoles de jeu utilisaient autrefois des cartouches de jeu, qui contenaient le programme du jeu à exécuter. Pour résumer, les anciens ordinateurs mémorisaient les programmes sur un support externe, lu par un périphérique. De tels ordinateurs sont dits à '''programme externe'''.

: D’anciens ordinateurs personnels, comme l’Amstrad ou le Commodore, permettaient de taper les programmes à exécuter à la main, au clavier, avant d’appuyer une touche pour les exécuter. Nul besoin de vous dire que les cassettes audio étaient plus pratiques.

Mais de nos jours, les programmes sont enregistrés sur le disque dur de l'ordinateur ou dans une mémoire intégrée à l'ordinateur. On dit qu'ils sont installés, ce qui est un mot bien compliqué pour dire que le programme est enregistré sur le disque dur de l’ordinateur. A défaut de disque dur, le programme/logiciel est enregistré dans une mémoire spécialisée pour le stockage. Par exemple, sur les cartes électroniques grand public de marque Arduino, les programmes sont envoyés à la carte via le port USB, mais les programmes sont enregistrés dans la carte Arduino, dans une mémoire FLASH dédiée. Disque dur ou non, le programme est mémorisé dans la mémoire de l'ordinateur. Il est possible d'installer ou de désinstaller les programmes en modifiant le contenu de la mémoire. Le terme utilisé est alors celui de '''programme stocké en mémoire'''.

Les programmes à installer sont disponibles soit sur un périphérique, comme un DVD ou une clé USB, soit sont téléchargés depuis internet. Les premiers PC fournissaient les logiciels sur des disquettes, qui contenaient un programme d'installation pour enregistrer le programme sur le disque dur de l'ordinateur. Par la suite, le support des logiciels a migré vers les CD et DVD, les logiciels devenant de plus en plus gros. De nos jours, la majorité des applications sont téléchargées depuis le net, l'usage de périphériques est devenu obsolète, même les consoles de jeu abandonnent cette méthode de distribution.

==Les générations d'ordinateurs : un historique rapide==

L'informatique a beaucoup évolué dans le temps. Et une bonne partie de cette évolution tient à l'évolution de l’électronique sous-jacente. Les ordinateurs actuels sont fabriqués avec des transistors, des petits composants électroniques qui servent d'interrupteur programmables, qu'on détaillera dans ce qui suit. Mais ça n'a pas toujours été le cas. Et cela permet de distinguer plusieurs '''générations d'ordinateurs'''.

===Les ordinateurs électro-mécaniques : les premiers ordinateurs===

Le tout premier ordinateur est le '''Z1''', un modèle unique inventé par Konrad Suze entre 1936 et 1938. Son processeur gérait non pas des nombres entiers, mais des nombres à virgule (des nombres dits flottants, pour être précis), encodés sur 22 bits. Le processeur du Z1 était capable de faire des additions et des soustractions, car il intégrait un circuit additionneur-soustracteur basique. Des circuits annexes permettaient de faire des multiplications et des divisions en enchainant des additions/soustractions successives. Il fonctionnait à une fréquence de 1 Hz, ce qui fait qu'il pouvait faire une addition/soustraction par seconde maximum.

[[File:Blue-punch-card-front.png|vignette|upright=0.5|Carte Perforée.]]

Niveau mémoire, la RAM de l'ordinateur était très limitée : seulement 16 nombres de 22 bits chacun. S'il s'agissait d'une mémoire électronique, les programmes étaient mémorisés sur une mémoire mécanique. Les programmes étaient enregistrés sur des cartes perforées, à savoir des cartes en papier dans lesquelles un 1 est codé par un trou dans le papier et un 0 par une absence de trou. Les programmes étaient exécutés par l'ordinateur quand on insérait la carte perforée dans le lecteur et qu'on appuyait sur un bouton.

[[File:German Museum of Technology, Berlin 2017 024.jpg|centre|vignette|upright=2|Réplique du Z1 au ''German Museum of Technology'' de Berlin, 2017.]]

Après sa destruction dans un bombardement, le Z1 a été reconstruit et amélioré, ce qui donné les deux ordinateurs Z2 et Z3. Quelques années plus tard, de nombreux ordinateurs ont été construits dans des laboratoires de recherche. Des grandes noms de l'histoire de l'informatique datent de cette époque : le Harvard Mark I et le Colossus Mark 1 (UK) ont tous deux été mis en service en 1944, par exemple. Ils ont servis pour les cryptanalystes pour casser les codes utilisés par les allemands pour leurs transmissions, pendant la seconde guerre mondiale.

Les ordinateurs cités dans le précédent paragraphe étaient tous des ordinateurs dit '''électro-mécaniques''', car ils mélangeaient des composants électroniques et des composants mécaniques (tout ce qui a trait aux cartes perforées, notamment). Les composants électroniques étaient soit des relais, soit des tubes à vides, les deux étant des interrupteurs commandables électriquement plus ou moins équivalents aux transistors. Les ordinateurs d'avant l'année 1944, étaient tous de ce type. Quelques ordinateurs des années 50 étaient de ce type, mais leur nombre n'a pas dépassé 30. Il faut dire qu'ils ont rapidement laissé la place à des ordinateurs purement électroniques, que nous allons voir dans ce qui suit..

===La première génération : les tubes à vide===

Les ordinateurs qui ont suivi les ordinateurs électromécaniques sont regroupés dans la '''première génération d'ordinateur'''. Ils étaient conçus avec des tubes à vide, ce qui les place entre les premiers ordinateurs électro-mécaniques et les ordinateurs utilisant des transistors. Les tubes à vide étaient assez encombrants, ils consommaient beaucoup de courant, ils chauffaient et étaient assez peu fiables. Ils tombaient en panne assez souvent. Et ils étaient assez simple à fabriquer, mais restaient malgré tout chers.

[[File:Elektronenroehren-auswahl.jpg|centre|vignette|upright=2|Tubes à vides.]]

Au vu de de la taille des  tubes à vide, les ordinateurs de l'époque étaient composé de plusieurs milliers de ces tubes, guère plus. Et malgré cela, un ordinateur prenait facilement un étage de bâtiment entier, ou au moins plusieurs pièces. La conséquence est que les ordinateurs de première génération étaient très simples, rudimentaires quand on les compare aux ordinateurs modernes. Ils ne géraient que quelques opérations simples : l'addition, la soustraction, pas grand chose de plus. A quelques exceptions près, ils ne géraient pas la multiplication et encore moins la division, cela aurait demandé trop de tubes à vides.

Une des toutes premières machines construite avec des tubes à vide était l'Atanasoff–Berry. Ce n'était pas un ordinateur, car elle ne pouvait pas exécuter de programme sans intervention humaine pour séquencer des opérations, mais c'était la première machine de calcul purement électronique, sans aucune pièce mécanique. Elle utilisait une mémoire RAM construite avec des condensateurs, ceux-ci étant placés sur des cylindres tournants. Les circuits de calcul étaient construits avec des tubes à vide et faisaient leur travail un bit à la fois. Elle fonctionnait à une fréquence de 60 Hz et pouvait faire 30 additions/soustractions par seconde. Les nombres étaient encodés sur 50 bits. 

[[File:Atanasoff Berry Computer.gif|centre|vignette|upright=2.5|Atanasoff–Berry.]]

L'arrivée de l'ENIAC en 1945 a changé la donne. Cet ordinateur a introduit plusieurs innovations majeures. La première est assez technique, il s'agit de la turing-complétude, elle a trait aux programmes qui peuvent être écrit pour un ordinateur, nous ne la détaillerons pas ici.

[[File:BabyArchitecture.png|vignette|Architecture de la Manchester Baby.]]

En 1948, le ''Manchester Baby'' a introduit une innovation extrêmement importante : le programme n'était plus mémorisé sur des cartes perforées, mais dans une mémoire électronique à l’intérieur de l'ordinateur lui-même. En clair, le ''Manchester Baby'' était le premier '''ordinateur à programme stocké en mémoire''' en français. Au-delà de ça, le Manchester Baby restait quand même très simple, c'était limite un prototype.

Niveau interface, l'ordinateur avait une console avec 32 boutons, des interrupteurs et un écran de sortie sur lequel afficher les résultats. A l'intérieur, il y avait un processeur et une RAM de 32 nombres de 32 bits, fabriquées avec des tubes Williams (abordés dans une annexe à la fin du cours). Le programme devait tenir dans la RAM, avec une instruction prenant autant de place qu'un nombre, ce qui limitait les programmes à 32 instructions maximum. Une instruction prenait donc 32 bits, 3 indiquaient quelle opération utiliser, 12 servait à indiquer où se trouvent les opérandes en RAM, les 16 restants sont inutilisés.

Il gérait 8 instructions en tout, mais ne gérait pas l'addition. Il gérait la soustraction, des instructions de branchement et d'accès mémoire, mais rien d'autre. Il pouvait cependant émuler l'addition à partir d'une soustraction et inversant l'opérande soustraite. C'était une architecture avec un registre unique de 32 bits, appelé l'accumulateur, avec une instruction STORE pour copier son contenu en RAM et une instruction LOAD pour copier du nombre de la RAM vers l'accumulateur. Les instructions étaient chargées dans un registre pour être exécutées, le processeur avait aussi un registre pour mémoriser la position de l'instruction suivante en RAM.

Le Manchester Mark 1 était une amélioration du Manchester Baby. Il utilisait 4500 tubes à vide. L'ordinateur gérait des nombres de 40 bits, les instructions étaient codées sur 20 bits. La RAM était toujours composée de 32 nombres, leur taille était simplement augmentée. Par contre, elle était complémentée par l’ancêtre du disque dur magnétique, à savoir un tambour magnétique, l’ancêtre du disque dur magnétique. Il contenait 40 pages, faisant chacune 32 nombres de 40 bits. C'était là encore une architecture à accumulateur, elle intégrait aussi des registres d'indice. Et surtout : son processeur gérait l'addition et quelques opérations logiques (ET et OU), en plus de la soustraction et de la comparaison.

[[File:MM1Schematic French.svg|centre|vignette|upright=2.5|Architecture de la Manchester Mark 1.]]

Par la suite, les ordinateurs commerciaux ont vu le jour. Les ordinateurs précédents provenaient de projets de recherches, souvent publics. Mais les entreprises privées se sont mises à fabriquer des ordinateurs elle-mêmes, pour les vendre à d'autres entreprises. On peut notamment citer les ordinateurs comme le UNIVAC I, le Bull Gamma 3 ou les premiers ordinateurs IBM.

===La seconde génération : le remplacement des tubes à vides par des transistors===

[[File:IBM 7070.jpg|vignette|Cartes imprimées de l'IBM 704, avec des transistors et résistances dessus.]]

La '''seconde génération''' est celle des ordinateurs fabriqués avec des '''transistors''' isolés, reliés entre avec des fils électriques. Les transistors en question possèdent trois broches, des pattes métalliques sur lesquelles on connecte des fils électriques. Le transistor s'utilise le plus souvent comme un interrupteur commandé par sa troisième broche. Le courant qui traverse les deux premières broches passe ou ne passe pas selon ce qu'on met sur la troisième.

[[File:Transistor basic flow.svg|centre|vignette|Un transistor est un morceau de conducteur, dont la conductivité est contrôlée par sa troisième broche/borne.]]

Les ordinateurs de seconde génération avaient entre 1000 et 500 000 transistors. Les capacités des ordinateurs étaient donc nettement supérieures à celles des ordinateurs de première génération. Une part non négligeable des ordinateurs de seconde génération supportait l'opération de multiplication, absente sur les ordinateurs de première génération. Néanmoins, cela variait beaucoup selon les ordinateurs.

Un exemple assez hors du commun est celui du premier modèle de l'IBM 1620. Le tout premier modèle n'avait aucun circuit de calcul, il n'était même pas capable de faire une addition ou une multiplication. A la place, il utilisait une table d'addition et une table de multiplication en mémoire RAM. Les deux tables devaient être initialisées par le logiciel lors du démarrage de la machine. La table d'addition faisait une centaine de chiffre, la table de multiplication faisait le double. Le processeur de l'ordinateur gérait des instructions pour faire des additions ou des multiplications, mais ces opérations lisaient le résultat dans la table d'addition. Les calculs étaient fait chiffre par chiffre, avec un encodage partiellement décimal, partiellement binaire (des chiffres décimaux étaient encodés en binaire, nous en reparlerons quand nous parlerons du BCD) !

[[File:KL CoreMemory.jpg|vignette|Mémoire à tore de ferrite.]]

Les transistors n'étaient utilisés que pour le processeur et les circuits annexes. La mémoire n'était pas faite en transistors, pas à cette époque. La mémoire était une mémoire aujourd'hui abandonnée, appelée une '''mémoire à tores de ferrite'''. Elle sera détaillée dans un chapitre ultérieur. Mais sachez pour le moment qu'il s'agit d'une mémoire au support magnétique, les données étant stockées sur un support magnétique.

Transistors comme tubes à vide prenaient beaucoup de place, ce qui fait que les ordinateurs étaient assez gros. Concrètement, ils prenaient une pièce de bâtiment entière dans le meilleur des cas. C'était l'époque des gros ''mainframes'', reliés à des terminaux, peu puissants comparé aux standards actuels. Seules les grandes entreprises et les grands instituts de recherche pouvaient se payer les services de ce genre d'ordinateurs. Seuls les professionnels avaient accès à ce genre d'équipement.

===La troisième génération : le circuit intégré===

[[File:D8259AC-2.jpg|vignette|Exemple de circuit intégré.]]

La troisième génération est toujours fabriquée avec des transistors, mais dont la taille a été réduite. Avec l'évolution de la technologie, les transistors ont diminué en taille, de plus en plus. Ils sont devenus tellement petits qu'ils ont finit par être regroupés dans des '''circuits intégrés''', des circuits regroupent plusieurs transistors sur la même puce de silicium. Les circuits intégrés se présentent le plus souvent sous la forme de boitiers rectangulaires, comme illustré ci-contre. D'autres ont des boitiers de forme carrées, comme ceux que l'on peut trouver sur les barrettes de mémoire RAM, ou à l'intérieur des clés USB/ disques SSD.

Lors de cette génération, les processeurs étaient fournis en pièces détachées qu'il fallait relier entre elles. Le processeur était composé de plusieurs circuits intégrés séparés, impossible de mettre un processeur dans un seul boitier. Un exemple de processeur conçu en kit est la série des Intel 3000. Elle regroupe plusieurs circuits séparés aux noms à coucher dehors, mais dont vous comprendrez ce qu'ils veulent dire dans les chapitres adéquats : l'Intel 3001 est un séquenceur, l'Intel 3002 regroupe unité de calcul et registres, le 3003 est un circuit d'anticipation de retenue complémentaire du 3002, le 3212 est une mémoire tampon, le 3214 est une unité de gestion des interruptions, les 3216/3226 sont des interfaces de bus mémoire. On pourrait aussi citer la famille de circuits intégrés AMD Am2900.

Même si le processeur était en pièce détachées, utiliser une dizaine de circuits intégrés était nettement mieux que d'utiliser plusieurs milliers de transistors individuels. En conséquence, les ordinateurs ont vu leur taille grandement réduite, passant de pièces entières à une simple armoire, voire à quelques cartes intégrées superposées. De plus, le prix des circuits intégré était abordable, du moins comparé aux ordinateurs d'avant. Le prix des ordinateurs a alors grandement décru, permettant à des entreprises et administrations de taille modeste de s'équiper d'ordinateurs.

===La quatrième génération : le microprocesseur===

[[File:MOS6502.svg|vignette|Microprocesseur, ici un processeur MOS6502, de la quatrième génération.]]

Lors de la troisième génération, les circuits intégrés regroupaient plusieurs dizaines ou centaines de transistors, mais sont rapidement montés en gamme. De centaines de transistors, ils sont passé au milliers de transistors, puis au millions et maintenant au-delà du milliard. Les transistors étaient devenus tellement petits, tellement miniaturisés, qu'il était devenu possible de mettre un processeur entier dans un circuit intégré. C'est ainsi qu'est né le microprocesseur, à savoir un processeur qui tient tout entier dans un seul circuit imprimé. La quatrième génération d’ordinateur est celle des ordinateurs basés autour d'un microprocesseur.

Les tout premiers microprocesseurs étaient des processeurs à application militaire, comme le processeur du F-14 CADC ou celui de l'Air data computer. Le tout premier microprocesseur commercialisé au grand public est le 4004 d'Intel, sorti en 1971. L'intel 4004 comprenait environ 2300 transistors, avait une fréquence de 740 MHz, pouvait faire 46 opérations différentes, et manipulait des entiers de 4 bits. Il était au départ un processeur de commande, prévu pour être intégré dans la calculatrice Busicom calculator 141-P, mais il fut utilisé pour d'autres applications quelque temps plus tard. Immédiatement après le 4004, les premiers microprocesseurs 8 bits furent commercialisés. Le 4004 fut suivi par le 8008 et quelques autres processeurs 8 bits extrêmement connus, comme le 8080 d'Intel, le 68000 de Motorola, le 6502 ou le Z80.

Les microprocesseurs permirent encore uen fois de réduire la taille des ordinateurs, qui pouvaient tenir dans un boitier de PC, ou un boitier de console de jeu. Le prix des ordinateurs a aussi chuté en même temps que les transistors était miniaturisés. C'est cette invention qui permis l'invention des consoles de jeux et des mini-ordinateurs, à savoir les ordinateurs personnels. Sans miniaturisation, on n'aurait pas d'ordinateur personnel, pas de PC fixe ou portable.

==L'organisation du cours : les différents niveaux d'explication==

Le fonctionnement d'un ordinateur est assez complexe à expliquer car les explications peuvent se faire sur plusieurs niveaux. Par plusieurs niveaux, on veut dire qu'un ordinateur est composé de composants très simples, qui sont assemblés pour donner des composants eux-même plus complexes, qui sont eux-même regrouper, etc. Étudier tout cela demande de voir plusieurs niveaux, allant de transistors très petits à des processeurs multicœurs. Les niveaux les plus bas sont de l'électronique pur et dure, alors que ceux plus haut sont à mi-chemin entre électronique et informatique.

===Les niveaux d'abstraction en architecture des ordinateurs===

Les trois premiers niveaux sont de l'électronique pur et dure. Ils correspondent aux premiers chapitres du cours, qui porteront sur les circuits électroniques en général.
* Le premier niveau est celui des '''transistors''', des circuits intégrés, des ''wafer'' et autres circuits de très petite taille.
* Le second niveau est celui des '''portes logiques''', des circuits très basiques, très simples, à la base de tous les autres.
* Le troisième niveau est celui dit de la '''''Register Transfer Level''''', où un circuit électronique est construit à partir de circuits basiques, dont des registres et autres circuits dits combinatoires.
Les deux niveaux suivants sont de l'informatique proprement dit. C'est dans ces deux niveaux qu'on étudie les ordinateurs proprement dit, les circuits qu'il y a dedans et non l'électronique en général.
* Le quatrième niveau est celui de la '''microarchitecture''', qui étudie ce qu'il y a à l'intérieur d'un processeur, d'une mémoire, des périphériques et autres.
* Le cinquième niveau est celui de l''''architecture externe''', qui décrit l'interface du processeur, de la mémoire, d'un périphérique ou autre. Par décrire l'interface, on veut dire : comment un programmeur voit le processeur et la mémoire, comment il peut les manipuler. Une architecture externe unique peut avoir plusieurs microarchitecture, ce qui fait qu'on sépare les deux. Tout cela sera plus clair quand on passera aux chapitres sur le processeur et les mémoires.

Nous n'allons pas voir les 5 niveaux dans l'ordre, des transistors vers l'architecture externe. En réalité, nous allons procéder autrement. La première partie du cours portera sur les trois premiers niveaux, le reste sur les deux autres. Les 5 niveaux seront vus dans des chapitres séparés, du moins le plus possible. Au niveau pédagogique, tout est plus simple si on scinde les 5 niveaux. Bien sûr, il y a quelques explications qui demandent de voir plusieurs niveaux à la fois. Par exemple, dans le chapitre sur les mémoires caches, nous auront des explications portant sur la RTL, la microarchitecture du cache et son architecture externe. Mais le gros du cours tentera de séparer le plus possible les 5 niveaux.

===Les trois parties principales du cours===

Nous allons commencer par parler du binaire, avant de voir les portes logiques. Avec ces portes logiques, nous allons voir comment fabriquer des circuits basiques qui reviendront très souvent dans la suite du cours. Nous verrons les registres, les décodeurs, les additionneurs et plein d'autres circuits. Puis, nous reviendrons au niveau des transistors pour finir la première partie. La raison est que c'est plus simple de faire comme cela. Tout ce qui a trait aux transistors sert à expliquer comment fabriquer des portes logiques, et il faut expliquer les portes logiques pour voir le niveau de la RTL.

Une fois la première partie finie, nous allons voir les différents composants d'un ordinateur. Une première partie expliquera ce qu'il y a dans un ordinateur, quels sont ses composants. Nous y parlerons de l'architecture de base, de la hiérarchie mémoire, des tendances technologiques, et d'autres généralités qui serviront de base pour la suite. Puis, nous verrons dans l'ordre les bus électroniques, les mémoires RAM/ROM, le processeur, les périphériques, les mémoires de stockage (SSD et disques durs) et les mémoires caches. Pour chaque composant, nous allons voir leur architecture externe, avant de voir leur microarchitecture. La raison est que la microarchitecture ne peut se comprendre que quand on sait quelle architecture externe elle implémente.

Enfin, dans une troisième partie, nous allons voir les optimisations majeures présentes dans tous les ordinateurs modernes, avec une partie sur le pipeline et le parallélisme d'instruction, et une autre sur les architectures parallèles. Pour finir, les annexes de fin parlerons de sujets un peu à part.

&lt;noinclude&gt;
{{NavChapitre | book=Fonctionnement d'un ordinateur
           | next=L'encodage des données
           | nextText=L'encodage des données
}}
&lt;/noinclude&gt;</text>
      <sha1>mwglx04a5hy3odgjsavgin70kwnssi7</sha1>
    </revision>
    <revision>
      <id>744129</id>
      <parentid>744128</parentid>
      <timestamp>2025-06-05T00:22:44Z</timestamp>
      <contributor>
        <username>Mewtow</username>
        <id>31375</id>
      </contributor>
      <minor />
      <comment>/* La première génération : les tubes à vide */</comment>
      <origin>744129</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="46310" sha1="lnbwgcmwthhgsd8khvznl4e1marsntc" xml:space="preserve">Pour commencer, nous allons voir qu'il existe de nombreux types d'ordinateurs. Le plus connu est certainement le PC, l'ordinateur personnel, que vous avez sans doute dans votre salon. Les ordinateurs portables sont un deuxième type d'ordinateur assez intuitif, que vous avez peut-être. Mais il y a aussi d'autres types d'ordinateurs auxquels vous n'avez jamais été confrontés.

==Les différents types d'ordinateurs==

Dans cette section, nous allons décrire rapidement les ordinateurs les plus courant, mais surtout voir ce qu'il y a à l'intérieur d'un ordinateur.

===L'ordinateur de type PC fixe===

De l'extérieur, l'ordinateur est composé d'une unité centrale sur laquelle on branche des périphériques.

[[File:Typical computer architecture systems.jpg|vignette|upright=1.5|Exemples de périphériques, connectés à une unité centrale (ici appelée à tort ''operating system'').]]

Les '''périphériques''' regroupent l'écran, la souris, le clavier, l'imprimante, et bien d'autres choses. Ils permettent à l'utilisateur d'interagir avec l'ordinateur : un clavier permet de saisir du texte sous dans un fichier, une souris enregistre des déplacements de la main en déplacement du curseur, un écran affiche des données d’images/vidéos, un haut-parleur émet du son, etc. Tout ce qui est branché sur un ordinateur est, formellement un périphérique.

L''''unité centrale''' est là où se trouvent tous les composants importants d'un ordinateur, ceux qui font des calculs, qui exécutent des logiciels, qui mémorisent vos données, etc. Voici ce à quoi ressemble l'intérieur de l'unité centrale. Trois sections sont visibles : l'alimentation électrique en haut à gauche, la carte mère en bas à gauche et en jaune/orange, les disques et lecteurs à droite des câbles. Et on voit aussi beaucoup de câbles.

[[File:Asus P5K-SEIntel E6320.jpg|centre|vignette|upright=2|Exemple d'unité centrale.]]

Tout en haut à gauche, se trouve l''''alimentation électrique''', qui convertit le courant de la prise électrique en un courant plus faible, utilisable par les autres composants. Elle émet de nombreux câbles assez gros, qui sont reliés au reste. Les PC actuels utilisent des alimentations électriques standardisées, qui fournissent trois tensions au reste de l'ordinateur : une tension de 12 Volts, une de 5 Volts, une de 3,3 Volts.

À droite, caché par la partie &quot;métallique&quot; du boitier, se trouvent les lecteurs de CD/DVD, et les disques durs. Les lecteurs CD-ROM ou DVD-ROM permettaient de lire des CD ou des DVD. Je parle au passé, car ils ont aujourd'hui disparu des ordinateurs modernes. Les '''disques durs''' sont des mémoires de stockage, qui mémorisent vos données de manière permanente. De nos jours, ils sont remplacés par des SSD, qui sont des disques durs électroniques, là où les disques durs proprement dit sont des mémoires magnétiques. Nous verrons la différence dans deux chapitres dédiés, un sur les disques durs, l'autre sur les SSD.

En bas à droite, se trouve la '''carte mère''' un support plat, en plastique ou en céramique, sur laquelle sont soudés/connectés les autres composants. Sur celle-ci, de nombreux composants sont soudés, d'autres sont branchés dessus avec des câbles, d'autres sont connectés dessus avec des connecteurs. Ils sont reliés entre eux par des fils conducteurs, le plus souvent du cuivre ou de l’aluminium, ce qui leur permet de s’échanger des données. Sur les cartes simples, ces fils sont intégrés dans la carte électronique, dans des creux du plastique. Ils portent le nom de pistes.

Avant, les disques durs, SSD et lecteurs de CD/DVD sont branchés dessus via des connecteurs dédiés, appelés des connecteurs S-ATA. De nos jours, ils sont branchés sur un autre connecteur, grâce à l'interface NVME. Toujours est-il qu'ils sont reliés à la carte mère par des câbles, ce qui montre que ce sont des sortes de périphériques interne. Ils sont placés dans le boitier, mais on aurait tout aussi bien pu les mettre à l'extérieur, vu qu'ils communiquent avec l'ordinateur par l'intermédiaire d'un câble ou d'un connecteur dédié.

Mais deux autres composants très importants sont eux placés sur la carte mère, directement. Ils ont chacun un connecteur dédié, sur lequel ils sont branchés directement, sans passer par l'intermédiaire d'un câble, mais sans être soudés non plus. Il s'agit du processeur et de la mémoire RAM, deux composants centraux des PC modernes.

[[File:Pentium III SL4CB.jpg|thumb|Processeur Pentium III.]]

Le '''processeur''' traite les données, les modifie, les manipule. Pour faire simple, il s’agit d’une grosse calculatrice hyper-puissante. Il comprend à la fois un circuit qui fait des calculs, et un circuit de contrôle qui s'occupe de séquencer les calculs dans l'ordre demandé. Il est souvent caché sous un radiateur, lui-même surmonté par un ventilateur. En effet, un processeur chauffe beaucoup, ce qui demande d'évacuer cette chaleur. Un chapitre entier expliquera pourquoi les processeurs chauffent, ainsi que les techniques utilisées pour limiter leur production de chaleur et leur consommation électrique.

La '''mémoire vive''' conserve des informations/données temporairement, tant que le processeur en a besoin. Elle prend la forme de barrettes de RAM, comme montré ci-dessous.

[[File:2 gb ddr2 667.jpg|centre|vignette|upright=2|Barrette de RAM.]]

Outre ces composants dits principaux, un ordinateur peut comprendre plusieurs composants moins importants, surtout présents sur les ordinateurs personnels. Ils sont techniquement facultatifs, mais sont très présents dans les ordinateurs personnels. Cependant, certains ordinateurs spécialisés s'en passent. Il s'agit des diverses '''cartes d'extension''' sont branchées sur la carte mère. Elles permettent d’accélérer certains calculs ou certaines applications, afin de décharger le processeur. Par exemple, la carte graphique s'occupe des calculs graphiques, qu'il s'agisse de graphismes 3D de jeux vidéos ou de l'affichage en 2D du bureau. Dans un autre registre, la carte son prend en charge le microphone et les haut-parleurs.

[[Fichier:Personal computer, exploded 4.svg|thumb|upright=1.0|Éclaté d'un ordinateur de type PC :&lt;br /&gt;
1 : Écran ;&lt;br /&gt;
2 : Carte mère ;&lt;br /&gt;
3 : Processeur ;&lt;br /&gt;
4 : Câble Parallel ATA ;&lt;br /&gt;
5 : Mémoire vive (RAM) ;&lt;br /&gt;
6 : Carte d'extension ;&lt;br /&gt;
7 : Alimentation électrique ;&lt;br /&gt;
8 : Lecteur de disque optique ;&lt;br /&gt;
9 : Disque dur ;&lt;br /&gt;
10 : Clavier ;&lt;br /&gt;
11 : Souris.]]

Si on regarde une carte mère de face, on voit un grand nombre de connecteurs, mais aussi des circuits électroniques soudés à la carte mère.

[[File:Architecture matérielle d'une carte mère.png|centre|vignette|upright=2.0|Architecture matérielle d'une carte mère]]

Les '''connecteurs''' sont là où on branche les périphériques, la carte graphique, le processeur, la mémoire, etc. Dans l'ensemble, toute carte mère contient les connecteurs suivants :
* Le processeur vient s’enchâsser dans la carte mère sur un connecteur particulier : le '''socket'''. Celui-ci varie suivant la carte mère et le processeur, ce qui est source d'incompatibilités.
* Les barrettes de mémoire RAM s’enchâssent dans un autre type de connecteurs: les '''slots mémoire'''.
* Les mémoires de masse disposent de leurs propres connecteurs : connecteurs P-ATA pour les anciens disques durs, et S-ATA pour les récents.
* Les périphériques (clavier, souris, USB, Firewire, ...) sont connectés sur un ensemble de connecteurs dédiés, localisés à l'arrière du boitier de l'unité centrale. 
* Les autres périphériques sont placés dans l'unité centrale et sont connectés via des connecteurs spécialisés. Ces périphériques sont des cartes imprimées, d'où leur nom de '''cartes filles'''. On peut notamment citer les cartes réseau, les cartes son, ou les cartes vidéo.

===Les ordinateurs portables===

[[File:Samsung QX-511 (2).JPG|vignette|Ordinateur portable Samsung QX-511 (2), pour illustration.]]

Un ordinateur portable est identique à un ordinateur de type PC. Si vous ouvrez votre ordinateur portable (attention à la garantie), vous retrouverez les mêmes composants qu'un PC à l'intérieur. Un point important est la présence d'une batterie à l'intérieur du PC portable, absente des PC fixes.

[[File:LG gram 14Z90Q mainboard with battery.jpg|centre|vignette|upright=2|LG gram 14Z90Q avec sa batterie.]]

Une fois la batterie et les circuits associés retiré, la seule différence notable est que tous les composants sont soudés sur la carte mère, au lieu d'être branchés sur des connecteurs, à part éventuellement la RAM et le disque dur.

[[File:LG gram 14Z90Q mainboard without battery.jpg|centre|vignette|upright=2|LG gram 14Z90Q sans sa batterie.]]

La RAM est parfois soudée sur la carte mère, d'autres fois sous la forme de barrettes de mémoire vive semblables à celles des PC. Dans le dernier cas, elle est connectée à des connecteurs spécifiques, ce qui permet de les changer/upgrader. Les PC portables sont parfois construits de manière à pouvoir changer la RAM facilement, en ouvrant un cache spécial, concu pour.

[[File:Lenovo G555 состав - Донор.JPG|centre|vignette|upright=2|Lenovo G555.]]

La conception d'un ordinateur portable est légèrement différente de celle d'un PC, pour des raisons thermiques. Un PC fixe a plus de place pour évacuer sa chaleur. Les ventilateurs peuvent plus facilement déplacer l'air dans le boitier, même si le flux d'air dans le boitier est éventuellement gêné par la carte graphique. Mais l'évacuation de la chaleur est assez efficace. Sur les PC portables, leur finesse fait que le trajet de l'air est beaucoup plus contraint. Évacuer la chaleur produite par l'ordinateur est plus complexe, ce qui demande d'utiliser des systèmes de refroidissement et de ventilation spécifiques.

Là où les PC fixes se débrouillent avec des radiateurs et des ventilateurs posés sur le processeur, les PC portables font autrement. Ils ne peuvent pas forcément mettre le ventilateur sur le processeur. A la place, ils mettent le ventilateur à côté, mais le processeur est surmonté par un mécanisme de transmission de la chaleur, qui transfère la chaleur du processeur vers le ventilateur.

[[File:Diagram - How a laptop cooling system works.png|centre|vignette|upright=2|Comment fonctionne le système de ventilation d'un ordinateur portable, en anglais.]]

Les difficultés pour dissiper la chaleur font que les ordinateurs portables utilisent souvent des composants peu performants, mais qui chauffent peu. En effet, nous verrons que plus un composant est puissant, plus il chauffe. La relation n'est pas parfaite, mais les processeurs haute performance chauffent plus que les modèles d'entrée ou milieu de gamme moins puissants. En conséquence, les PC portables sont souvent moins puissants que les PC fixes, même pour les modèles dit ''gaming''.

===Les serveurs et ''mainframes''===

Les grandes entreprises utilisent des ordinateurs de grande taille, très puissants, appelés des ''mainframes''. Ils sont souvent confondus avec les serveurs par le grand public, il y a une différence entre les deux. Un serveur est une fonction logicielle/réseau, pas un type d'ordinateur. Mais laissons cette différence de côté, ce qui est dit pour les ''mainframes'' sert pour les gros serveurs haute performance.

[[File:IBM Z15 mainframe.jpg|vignette|Exemple de ''mainframe''' de type IBM Z15.]]

Les anciens ''mainframes'' des années 50-80 avaient une taille pouvant être impressionnante, au point de prendre une pièce complète d'un bâtiment. Mais de nos jours, les ''mainframes'' tiennent dans une grosse armoire un peu haute. Les ''mainframes'' doivent rester allumé en permanence et ne doivent pas être éteint, sauf éventuellement quelques jours par an pour des opérations de maintenance. Ils utilisent pour cela des techniques spécifiques, avec beaucoup de redondance interne.

[[File:ACONIT hall grandes machines.jpg|centre|vignette|upright=2|''Mainframe'' ACONIT.]]

Les ''mainframes'' sont aussi conçus pour mutualiser au maximum leur utilisation, ils peuvent être utilisés par plusieurs utilisateurs à la suite, voire en même temps. Pour cela, les anciens ''mainframes'' étaient capables de faire tourner plusieurs applications distinctes l'une à la suite de l'autre, avec des commutations fréquentes entre logiciels. De nos jours, ils sont capables d'exécuter un grand nombre de tâches en même temps, grâce à la présence de plusieurs processeurs. Les ''mainframes'' modernes sont même capables de faire tourner plusieurs systèmes d'exploitation en même temps si besoin.

Les anciens ''mainframes'' étaient des ordinateurs assez simples, avec un processeur, de la mémoire RAM, un ou plusieurs disques durs, pas plus. Le ''mainframe'' était tellement énorme et cher que les entreprises n'en avaient qu'un seul pour toute l'entreprise. Les employés avaient sur leur bureau des terminaux, qui permettaient d'accéder à l'ordinateur central, mais n'étaient pas des ordinateurs. Les terminaux étaient des composants électroniques simples, avec un écran, un clavier et une souris, mais sans processeur. Ils envoyaient des données au ''mainframe'', ils en recevaient de sa part, mais tout traitement était réalisé sur le ''mainframe''. L'arrivée sur le marché des ordinateurs personnels, de type PC fixe/portable, a entrainé l'abandon de ce genre de pratique, tous les employés ont maintenant un ordinateur rien que pour eux.

{|
|-
! colspan=&quot;2&quot; | Exemples de terminaux
|-
|[[File:Terminal-in2-sm9400.jpg|centre|vignette|upright=1.5|Exemple de terminal. Notez la présence d'un écran et d'un clavier, mais l'asbence d'une unité centrale.]]
|[[File:Chromatics CT4100.jpg|vignette|upright=1.5|Autre exemple de terminal. Le clavier est couplé à un stylo CRT, qui remplacait la souris et agissait sur l'écran comme s'il était tactile.]]
|-
! colspan=&quot;2&quot; | Intérieur d'un terminal
|-
|[[File:CT1024 Monitor.jpg|vignette|upright=1.5|Terminal CT1024, sans le boitier extérieur.]]
|[[File:CT1024 Terminal System.jpg|vignette|upright=1.5|Terminal CT1024, description des composants interne.]]
|}

De nos jours, les ''mainframes'' contiennent en réalité plusieurs ordinateurs simples interconnectés via un réseau local. Un ''mainframe'' qui tient dans une armoire contient facilement une dizaine ou centaine de processeurs, plein de RAM, des disques durs séparés dans une armoire distincte, etc. Vu qu'ils communiquent uniquement via le réseau, ils n'ont pas d'interface, pas d'écran, 'entrée via clavier/souris. Le tout est commandé avec une console de commande, typiquement un ordinateur portable ou un terminal assez simple séparé de l'armoire, qui permet à un administrateur de faire des opérations de surveillance, configuration et maintenance. Il peut y avoir une console de commande pour plusieurs armoires séparées, la console peut même être dans un autre bâtiment et accéder au ''mainframe'' par le réseau.

[[File:IBM System Z9 (type 2094 inside).jpg|centre|vignette|upright=2|''Mainframe'' de type IBM System Z9. L'ordinateur portable sert de console pour qu'un administrateur fasse des opérations de surveillance, configuration et maintenance.]]

Les processeurs et la RAM sont typiquement installés sur des cartes amovibles, qui sont connectées au fond de l'armoire lors de l'installation. Il est même possible de retirer ou d'ajouter des cartes en fonctionnement, afin d'ajouter/retirer des processeurs, des disques durs, etc. Ce qui est très utile si un composant est en panne et qu'il faut le remplacer. 

[[File:IBM TotalStorage Exp400.jpg|centre|vignette|upright=2|IBM TotalStorage Exp400]]

==Un peu d'abstraction : qu'est-ce qu'un ordinateur ?==

Un ordinateur comprend donc un processeur, plusieurs mémoires, des cartes d'extension et une carte mère pour connecter le tout. Mais il s'agit là d'une description assez terre-à-terre de ce qu'est un ordinateur. Une autre description, plus abstraite, se base sur le fait qu'un ordinateur est une énorme calculatrice programmable. Elle permet d'expliquer pourquoi il y a une distinction entre processeur et mémoire, entre unité centrale et périphériques. Tout ce qui va suivre pourra vous paraitre assez abstrait, mais rassurez-vous : les prochains chapitres rendront tout cela plus concrets.

===La séparation entre entrées-sorties et traitement===

L'unité centrale peut être vue comme une énorme calculatrice ultra-puissante, qui exécute des commandes/opérations. Mais à elle seule, elle ne servirait à rien, il faut interagir avec par l'intermédiaire de plusieurs périphériques. Il existe deux types de périphériques, qui sont conceptuellement différents. Les périphériques comme le clavier ou la souris permettent d'envoyer des informations à l'ordinateur, d'agir sur celui-ci. A l'inverse, les écrans transmettent des informations dans le sens inverse : de l'ordinateur vers l'utilisateur. Les premiers sont appelés des '''entrées''', les seconds des '''sorties'''.

Dans un ordinateur, les informations sont représentées sous la forme de nombres. Toute donnée dans un ordinateur est codée avec un ou plusieurs nombres regroupés dans une donnée, un fichier, ou autre. Et la transmissions avec les entrées et sorties se fait là-encore avec des nombres. Par exemple, quand vous appuyez sur votre clavier, le clavier envoie un numéro de touche à l'unité centrale, qui indique quelle touche a été appuyée. L'image à afficher à l'écran est codée sous la forme d'une suite de nombres (un par pixel). L'image est envoyée à l'écran, qui traduit la suite de nombre en image à afficher. Les entrées traduisent des actions utilisateurs en nombres, on dit que les entrées encodent les actions utilisateur. Les sorties font la traduction inverse, elles transforment des suites de nombres en une action physique. On dit qu'elles décodent des informations.

Pour résumer, toute appareil électronique est composé par :
* Des '''entrées''' sur lesquelles l'utilisateur agit sur l'ordinateur. Les entrées transforment les actions de l'utilisateur en nombres, qui sont interprétés par l'ordinateur.
* Une '''unité de traitement''', qui manipule des nombres et fait des calculs/opérations dessus. Les nombres proviennent des entrées, du disque dur, ou d'autres sources, peu importe.
* Des '''sorties''', qui va récupèrent le résultat calculé par l'unité de traitement pour en faire quelque chose : écrire sur une imprimante ou sur un moniteur, émettre du son,...

[[File:Ordinateur théorique Simple 1.png|centre|vignette|upright=2|Ordinateur théorique Simple 1]]

L'unité de traitement proprement dite, celle qui fait les calculs, est couplée à une mémoire qui mémorise les opérandes et résultats des calculs. La séparation entre processeur et mémoire est nécessaire pour qu'un appareil électronique soit qualifié d'ordinateur. De nombreux appareils n'ont pas de séparation entre unité de traitement et mémoire, comme certaines vielles radios AM/FM.

[[File:Schéma de principe d'un ordinateur.png|centre|vignette|upright=2|Schéma de principe d'un ordinateur]]

===Un ordinateur est un appareil programmable===

Les appareils simples sont non-programmables, ce qui veut dire qu’ils sont conçus pour une utilisation particulière et qu’ils ne peuvent pas faire autre chose. Par exemple, les circuits électroniques d’un lecteur de DVD ne peuvent pas être transformé en lecteur audio ou en console de jeux... Les circuits non-programmables sont câblés une bonne fois pour toute, et on ne peut pas les modifier. On peut parfois reconfigurer le circuit, pour faire varier certains paramètres, via des interrupteurs ou des boutons, mais cela s’arrête là. Et cela pose un problème : à chaque problème qu'on veut résoudre en utilisant un automate, on doit recréer un nouveau circuit.

À l'inverse, un ordinateur n’est pas conçu pour une utilisation particulière, contrairement aux autres objets techniques. Il est possible de modifier leur fonction du jour au lendemain, on peut lui faire faire ce qu’on veut. On dit qu'ils sont '''programmables'''. Pour cela, il suffit d’utiliser un logiciel, une application, un programme (ces termes sont synonymes), qui fait ce que l'on souhaite. La totalité des logiciels présents sur un ordinateur sont des programmes comme les autres, même le système d'exploitation (Windows, Linux, ...) ne fait pas exception.

Un programme est une suite de d'instructions, chaque instruction effectuant une action dans l'ordinateur. Sur les ordinateurs modernes, la majorité de ces instructions effectuent une opération arithmétique, comme une addition, une multiplication, une soustraction, etc. Les ordinateurs modernes sont donc de grosses calculettes très puissantes, capables d'effectuer des millions d'opérations par secondes. Et qui dit opération dit nombres : un ordinateur gère nativement des nombres, qui sont codés en binaire sur la quasi-totalité des ordinateurs modernes.

Une instruction est représentée dans un ordinateur par une série de nombres : un nombre qui indique quelle opération/commande effectuer et des autres nombres pour coder les données (ou de quoi les retrouver dans l'ordinateur). L'ordinateur récupére les commandes une par une, les traduit en opération à effectuer, exécuter l'opération, et enregistre le résultat. Puis il recommence avec la commande suivante.

[[File:Ordinateur Théorique Complexe 1.png|centre|vignette|upright=3|Ordinateur Théorique Complexe. En jaune, le programme informatique, la liste de commande. Le rectangle gris est l'ordinateur proprement dit.]]

De nombreux appareils sont programmables, mais tous ne sont pas des ordinateurs. Par exemple, certains circuits programmables nommés FPGA n'en sont pas. Pour être qualifié d'ordinateur, un appareil programmable doit avoir un processeur séparé de la mémoire. De plus, il doit utiliser un '''codage numérique''', chose que nous allons aborder dans le chapitre suivant.

===Les ordinateurs à programme mémorisé ou programme externe===

Au tout début de l'informatique, on utilisait des cartes perforées en plastique, sur lesquelles on inscrivait le programme à exécuter, les données à traiter, bref : tout ce qu'on donnait à manger à l'ordinateur. Par la suite, les premiers ordinateurs grand public, comme les Amstrad ou les Commodore, utilisaient des cassettes audio magnétiques pour stocker les programmes. Dans le même style, les consoles de jeu utilisaient autrefois des cartouches de jeu, qui contenaient le programme du jeu à exécuter. Pour résumer, les anciens ordinateurs mémorisaient les programmes sur un support externe, lu par un périphérique. De tels ordinateurs sont dits à '''programme externe'''.

: D’anciens ordinateurs personnels, comme l’Amstrad ou le Commodore, permettaient de taper les programmes à exécuter à la main, au clavier, avant d’appuyer une touche pour les exécuter. Nul besoin de vous dire que les cassettes audio étaient plus pratiques.

Mais de nos jours, les programmes sont enregistrés sur le disque dur de l'ordinateur ou dans une mémoire intégrée à l'ordinateur. On dit qu'ils sont installés, ce qui est un mot bien compliqué pour dire que le programme est enregistré sur le disque dur de l’ordinateur. A défaut de disque dur, le programme/logiciel est enregistré dans une mémoire spécialisée pour le stockage. Par exemple, sur les cartes électroniques grand public de marque Arduino, les programmes sont envoyés à la carte via le port USB, mais les programmes sont enregistrés dans la carte Arduino, dans une mémoire FLASH dédiée. Disque dur ou non, le programme est mémorisé dans la mémoire de l'ordinateur. Il est possible d'installer ou de désinstaller les programmes en modifiant le contenu de la mémoire. Le terme utilisé est alors celui de '''programme stocké en mémoire'''.

Les programmes à installer sont disponibles soit sur un périphérique, comme un DVD ou une clé USB, soit sont téléchargés depuis internet. Les premiers PC fournissaient les logiciels sur des disquettes, qui contenaient un programme d'installation pour enregistrer le programme sur le disque dur de l'ordinateur. Par la suite, le support des logiciels a migré vers les CD et DVD, les logiciels devenant de plus en plus gros. De nos jours, la majorité des applications sont téléchargées depuis le net, l'usage de périphériques est devenu obsolète, même les consoles de jeu abandonnent cette méthode de distribution.

==Les générations d'ordinateurs : un historique rapide==

L'informatique a beaucoup évolué dans le temps. Et une bonne partie de cette évolution tient à l'évolution de l’électronique sous-jacente. Les ordinateurs actuels sont fabriqués avec des transistors, des petits composants électroniques qui servent d'interrupteur programmables, qu'on détaillera dans ce qui suit. Mais ça n'a pas toujours été le cas. Et cela permet de distinguer plusieurs '''générations d'ordinateurs'''.

===Les ordinateurs électro-mécaniques : les premiers ordinateurs===

Le tout premier ordinateur est le '''Z1''', un modèle unique inventé par Konrad Suze entre 1936 et 1938. Son processeur gérait non pas des nombres entiers, mais des nombres à virgule (des nombres dits flottants, pour être précis), encodés sur 22 bits. Le processeur du Z1 était capable de faire des additions et des soustractions, car il intégrait un circuit additionneur-soustracteur basique. Des circuits annexes permettaient de faire des multiplications et des divisions en enchainant des additions/soustractions successives. Il fonctionnait à une fréquence de 1 Hz, ce qui fait qu'il pouvait faire une addition/soustraction par seconde maximum.

[[File:Blue-punch-card-front.png|vignette|upright=0.5|Carte Perforée.]]

Niveau mémoire, la RAM de l'ordinateur était très limitée : seulement 16 nombres de 22 bits chacun. S'il s'agissait d'une mémoire électronique, les programmes étaient mémorisés sur une mémoire mécanique. Les programmes étaient enregistrés sur des cartes perforées, à savoir des cartes en papier dans lesquelles un 1 est codé par un trou dans le papier et un 0 par une absence de trou. Les programmes étaient exécutés par l'ordinateur quand on insérait la carte perforée dans le lecteur et qu'on appuyait sur un bouton.

[[File:German Museum of Technology, Berlin 2017 024.jpg|centre|vignette|upright=2|Réplique du Z1 au ''German Museum of Technology'' de Berlin, 2017.]]

Après sa destruction dans un bombardement, le Z1 a été reconstruit et amélioré, ce qui donné les deux ordinateurs Z2 et Z3. Quelques années plus tard, de nombreux ordinateurs ont été construits dans des laboratoires de recherche. Des grandes noms de l'histoire de l'informatique datent de cette époque : le Harvard Mark I et le Colossus Mark 1 (UK) ont tous deux été mis en service en 1944, par exemple. Ils ont servis pour les cryptanalystes pour casser les codes utilisés par les allemands pour leurs transmissions, pendant la seconde guerre mondiale.

Les ordinateurs cités dans le précédent paragraphe étaient tous des ordinateurs dit '''électro-mécaniques''', car ils mélangeaient des composants électroniques et des composants mécaniques (tout ce qui a trait aux cartes perforées, notamment). Les composants électroniques étaient soit des relais, soit des tubes à vides, les deux étant des interrupteurs commandables électriquement plus ou moins équivalents aux transistors. Les ordinateurs d'avant l'année 1944, étaient tous de ce type. Quelques ordinateurs des années 50 étaient de ce type, mais leur nombre n'a pas dépassé 30. Il faut dire qu'ils ont rapidement laissé la place à des ordinateurs purement électroniques, que nous allons voir dans ce qui suit..

===La première génération : les tubes à vide===

Les ordinateurs qui ont suivi les ordinateurs électromécaniques sont regroupés dans la '''première génération d'ordinateur'''. Ils étaient conçus avec des tubes à vide, ce qui les place entre les premiers ordinateurs électro-mécaniques et les ordinateurs utilisant des transistors. Les tubes à vide étaient assez encombrants, ils consommaient beaucoup de courant, ils chauffaient et étaient assez peu fiables. Ils tombaient en panne assez souvent. Et ils étaient assez simple à fabriquer, mais restaient malgré tout chers.

[[File:Elektronenroehren-auswahl.jpg|centre|vignette|upright=2|Tubes à vides.]]

Au vu de de la taille des  tubes à vide, les ordinateurs de l'époque étaient composé de plusieurs milliers de ces tubes, guère plus. Et malgré cela, un ordinateur prenait facilement un étage de bâtiment entier, ou au moins plusieurs pièces. La conséquence est que les ordinateurs de première génération étaient très simples, rudimentaires quand on les compare aux ordinateurs modernes. Ils ne géraient que quelques opérations simples : l'addition, la soustraction, pas grand chose de plus. A quelques exceptions près, ils ne géraient pas la multiplication et encore moins la division, cela aurait demandé trop de tubes à vides.

Une des toutes premières machines construite avec des tubes à vide était l'Atanasoff–Berry. Ce n'était pas un ordinateur, car elle ne pouvait pas exécuter de programme sans intervention humaine pour séquencer des opérations, mais c'était la première machine de calcul purement électronique, sans aucune pièce mécanique. Elle utilisait une mémoire RAM construite avec des condensateurs, ceux-ci étant placés sur des cylindres tournants. Les circuits de calcul étaient construits avec des tubes à vide et faisaient leur travail un bit à la fois. Elle fonctionnait à une fréquence de 60 Hz et pouvait faire 30 additions/soustractions par seconde. Les nombres étaient encodés sur 50 bits. 

[[File:Atanasoff Berry Computer.gif|centre|vignette|upright=2.5|Atanasoff–Berry.]]

L'arrivée de l'ENIAC en 1945 a changé la donne. Cet ordinateur a introduit plusieurs innovations majeures. La première est assez technique, il s'agit de la turing-complétude, elle a trait aux programmes qui peuvent être écrit pour un ordinateur, nous ne la détaillerons pas ici.

[[File:BabyArchitecture.png|vignette|Architecture de la Manchester Baby.]]

En 1948, le ''Manchester Baby'' a introduit une innovation extrêmement importante : le programme n'était plus mémorisé sur des cartes perforées, mais dans une mémoire électronique à l’intérieur de l'ordinateur lui-même. En clair, le ''Manchester Baby'' était le premier '''ordinateur à programme stocké en mémoire''' en français. Au-delà de ça, le Manchester Baby restait quand même très simple, c'était limite un prototype.

Niveau interface, l'ordinateur avait une console avec 32 boutons, des interrupteurs et un écran de sortie sur lequel afficher les résultats. A l'intérieur, il y avait un processeur et une RAM de 32 nombres de 32 bits, fabriquées avec des tubes Williams (abordés dans une annexe à la fin du cours). Le programme devait tenir dans la RAM, avec une instruction prenant autant de place qu'un nombre, ce qui limitait les programmes à 32 instructions maximum. Une instruction prenait donc 32 bits, 3 indiquaient quelle opération utiliser, 12 servait à indiquer où se trouvent les opérandes en RAM, les 16 restants sont inutilisés.

Il gérait 8 instructions en tout, mais ne gérait pas l'addition. Il gérait la soustraction, des instructions de branchement et d'accès mémoire, mais rien d'autre. Il pouvait cependant émuler l'addition à partir d'une soustraction et inversant l'opérande soustraite. C'était une architecture avec un registre unique de 32 bits, appelé l'accumulateur, avec une instruction STORE pour copier son contenu en RAM et une instruction LOAD pour copier du nombre de la RAM vers l'accumulateur. Les instructions étaient chargées dans un registre pour être exécutées, le processeur avait aussi un registre pour mémoriser la position de l'instruction suivante en RAM.

Le Manchester Mark 1 était une amélioration du Manchester Baby. Il utilisait 4500 tubes à vide. L'ordinateur gérait des nombres de 40 bits, les instructions étaient codées sur 20 bits. La RAM était toujours composée de 32 nombres, leur taille était simplement augmentée. Par contre, elle était complémentée par l’ancêtre du disque dur magnétique, à savoir un tambour magnétique, l’ancêtre du disque dur magnétique. Il contenait 40 pages, faisant chacune 32 nombres de 40 bits. C'était là encore une architecture à accumulateur, elle intégrait aussi des registres d'indice. Et surtout : son processeur gérait l'addition et quelques opérations logiques (ET et OU), en plus de la soustraction et de la comparaison.

[[File:MM1Schematic French.svg|centre|vignette|upright=2.5|Architecture de la Manchester Mark 1.]]

Par la suite, les ordinateurs commerciaux ont vu le jour. Les ordinateurs précédents provenaient de projets de recherches, souvent publics. Mais les entreprises privées se sont mises à fabriquer des ordinateurs elle-mêmes, pour les vendre à d'autres entreprises. On peut notamment citer les ordinateurs comme le UNIVAC I, le Bull Gamma 3 ou les premiers ordinateurs IBM. La performance de ces ordinateurs était nettement plus importante que leurs prédécesseurs, avec des fréquences de l'ordre de la centaine de kilo-hertz. Par exemple, le Bull Gamma 3 allait à 281 kHz, l'IBM 650 allait à 50 Khz.

===La seconde génération : le remplacement des tubes à vides par des transistors===

[[File:IBM 7070.jpg|vignette|Cartes imprimées de l'IBM 704, avec des transistors et résistances dessus.]]

La '''seconde génération''' est celle des ordinateurs fabriqués avec des '''transistors''' isolés, reliés entre avec des fils électriques. Les transistors en question possèdent trois broches, des pattes métalliques sur lesquelles on connecte des fils électriques. Le transistor s'utilise le plus souvent comme un interrupteur commandé par sa troisième broche. Le courant qui traverse les deux premières broches passe ou ne passe pas selon ce qu'on met sur la troisième.

[[File:Transistor basic flow.svg|centre|vignette|Un transistor est un morceau de conducteur, dont la conductivité est contrôlée par sa troisième broche/borne.]]

Les ordinateurs de seconde génération avaient entre 1000 et 500 000 transistors. Les capacités des ordinateurs étaient donc nettement supérieures à celles des ordinateurs de première génération. Une part non négligeable des ordinateurs de seconde génération supportait l'opération de multiplication, absente sur les ordinateurs de première génération. Néanmoins, cela variait beaucoup selon les ordinateurs.

Un exemple assez hors du commun est celui du premier modèle de l'IBM 1620. Le tout premier modèle n'avait aucun circuit de calcul, il n'était même pas capable de faire une addition ou une multiplication. A la place, il utilisait une table d'addition et une table de multiplication en mémoire RAM. Les deux tables devaient être initialisées par le logiciel lors du démarrage de la machine. La table d'addition faisait une centaine de chiffre, la table de multiplication faisait le double. Le processeur de l'ordinateur gérait des instructions pour faire des additions ou des multiplications, mais ces opérations lisaient le résultat dans la table d'addition. Les calculs étaient fait chiffre par chiffre, avec un encodage partiellement décimal, partiellement binaire (des chiffres décimaux étaient encodés en binaire, nous en reparlerons quand nous parlerons du BCD) !

[[File:KL CoreMemory.jpg|vignette|Mémoire à tore de ferrite.]]

Les transistors n'étaient utilisés que pour le processeur et les circuits annexes. La mémoire n'était pas faite en transistors, pas à cette époque. La mémoire était une mémoire aujourd'hui abandonnée, appelée une '''mémoire à tores de ferrite'''. Elle sera détaillée dans un chapitre ultérieur. Mais sachez pour le moment qu'il s'agit d'une mémoire au support magnétique, les données étant stockées sur un support magnétique.

Transistors comme tubes à vide prenaient beaucoup de place, ce qui fait que les ordinateurs étaient assez gros. Concrètement, ils prenaient une pièce de bâtiment entière dans le meilleur des cas. C'était l'époque des gros ''mainframes'', reliés à des terminaux, peu puissants comparé aux standards actuels. Seules les grandes entreprises et les grands instituts de recherche pouvaient se payer les services de ce genre d'ordinateurs. Seuls les professionnels avaient accès à ce genre d'équipement.

===La troisième génération : le circuit intégré===

[[File:D8259AC-2.jpg|vignette|Exemple de circuit intégré.]]

La troisième génération est toujours fabriquée avec des transistors, mais dont la taille a été réduite. Avec l'évolution de la technologie, les transistors ont diminué en taille, de plus en plus. Ils sont devenus tellement petits qu'ils ont finit par être regroupés dans des '''circuits intégrés''', des circuits regroupent plusieurs transistors sur la même puce de silicium. Les circuits intégrés se présentent le plus souvent sous la forme de boitiers rectangulaires, comme illustré ci-contre. D'autres ont des boitiers de forme carrées, comme ceux que l'on peut trouver sur les barrettes de mémoire RAM, ou à l'intérieur des clés USB/ disques SSD.

Lors de cette génération, les processeurs étaient fournis en pièces détachées qu'il fallait relier entre elles. Le processeur était composé de plusieurs circuits intégrés séparés, impossible de mettre un processeur dans un seul boitier. Un exemple de processeur conçu en kit est la série des Intel 3000. Elle regroupe plusieurs circuits séparés aux noms à coucher dehors, mais dont vous comprendrez ce qu'ils veulent dire dans les chapitres adéquats : l'Intel 3001 est un séquenceur, l'Intel 3002 regroupe unité de calcul et registres, le 3003 est un circuit d'anticipation de retenue complémentaire du 3002, le 3212 est une mémoire tampon, le 3214 est une unité de gestion des interruptions, les 3216/3226 sont des interfaces de bus mémoire. On pourrait aussi citer la famille de circuits intégrés AMD Am2900.

Même si le processeur était en pièce détachées, utiliser une dizaine de circuits intégrés était nettement mieux que d'utiliser plusieurs milliers de transistors individuels. En conséquence, les ordinateurs ont vu leur taille grandement réduite, passant de pièces entières à une simple armoire, voire à quelques cartes intégrées superposées. De plus, le prix des circuits intégré était abordable, du moins comparé aux ordinateurs d'avant. Le prix des ordinateurs a alors grandement décru, permettant à des entreprises et administrations de taille modeste de s'équiper d'ordinateurs.

===La quatrième génération : le microprocesseur===

[[File:MOS6502.svg|vignette|Microprocesseur, ici un processeur MOS6502, de la quatrième génération.]]

Lors de la troisième génération, les circuits intégrés regroupaient plusieurs dizaines ou centaines de transistors, mais sont rapidement montés en gamme. De centaines de transistors, ils sont passé au milliers de transistors, puis au millions et maintenant au-delà du milliard. Les transistors étaient devenus tellement petits, tellement miniaturisés, qu'il était devenu possible de mettre un processeur entier dans un circuit intégré. C'est ainsi qu'est né le microprocesseur, à savoir un processeur qui tient tout entier dans un seul circuit imprimé. La quatrième génération d’ordinateur est celle des ordinateurs basés autour d'un microprocesseur.

Les tout premiers microprocesseurs étaient des processeurs à application militaire, comme le processeur du F-14 CADC ou celui de l'Air data computer. Le tout premier microprocesseur commercialisé au grand public est le 4004 d'Intel, sorti en 1971. L'intel 4004 comprenait environ 2300 transistors, avait une fréquence de 740 MHz, pouvait faire 46 opérations différentes, et manipulait des entiers de 4 bits. Il était au départ un processeur de commande, prévu pour être intégré dans la calculatrice Busicom calculator 141-P, mais il fut utilisé pour d'autres applications quelque temps plus tard. Immédiatement après le 4004, les premiers microprocesseurs 8 bits furent commercialisés. Le 4004 fut suivi par le 8008 et quelques autres processeurs 8 bits extrêmement connus, comme le 8080 d'Intel, le 68000 de Motorola, le 6502 ou le Z80.

Les microprocesseurs permirent encore uen fois de réduire la taille des ordinateurs, qui pouvaient tenir dans un boitier de PC, ou un boitier de console de jeu. Le prix des ordinateurs a aussi chuté en même temps que les transistors était miniaturisés. C'est cette invention qui permis l'invention des consoles de jeux et des mini-ordinateurs, à savoir les ordinateurs personnels. Sans miniaturisation, on n'aurait pas d'ordinateur personnel, pas de PC fixe ou portable.

==L'organisation du cours : les différents niveaux d'explication==

Le fonctionnement d'un ordinateur est assez complexe à expliquer car les explications peuvent se faire sur plusieurs niveaux. Par plusieurs niveaux, on veut dire qu'un ordinateur est composé de composants très simples, qui sont assemblés pour donner des composants eux-même plus complexes, qui sont eux-même regrouper, etc. Étudier tout cela demande de voir plusieurs niveaux, allant de transistors très petits à des processeurs multicœurs. Les niveaux les plus bas sont de l'électronique pur et dure, alors que ceux plus haut sont à mi-chemin entre électronique et informatique.

===Les niveaux d'abstraction en architecture des ordinateurs===

Les trois premiers niveaux sont de l'électronique pur et dure. Ils correspondent aux premiers chapitres du cours, qui porteront sur les circuits électroniques en général.
* Le premier niveau est celui des '''transistors''', des circuits intégrés, des ''wafer'' et autres circuits de très petite taille.
* Le second niveau est celui des '''portes logiques''', des circuits très basiques, très simples, à la base de tous les autres.
* Le troisième niveau est celui dit de la '''''Register Transfer Level''''', où un circuit électronique est construit à partir de circuits basiques, dont des registres et autres circuits dits combinatoires.
Les deux niveaux suivants sont de l'informatique proprement dit. C'est dans ces deux niveaux qu'on étudie les ordinateurs proprement dit, les circuits qu'il y a dedans et non l'électronique en général.
* Le quatrième niveau est celui de la '''microarchitecture''', qui étudie ce qu'il y a à l'intérieur d'un processeur, d'une mémoire, des périphériques et autres.
* Le cinquième niveau est celui de l''''architecture externe''', qui décrit l'interface du processeur, de la mémoire, d'un périphérique ou autre. Par décrire l'interface, on veut dire : comment un programmeur voit le processeur et la mémoire, comment il peut les manipuler. Une architecture externe unique peut avoir plusieurs microarchitecture, ce qui fait qu'on sépare les deux. Tout cela sera plus clair quand on passera aux chapitres sur le processeur et les mémoires.

Nous n'allons pas voir les 5 niveaux dans l'ordre, des transistors vers l'architecture externe. En réalité, nous allons procéder autrement. La première partie du cours portera sur les trois premiers niveaux, le reste sur les deux autres. Les 5 niveaux seront vus dans des chapitres séparés, du moins le plus possible. Au niveau pédagogique, tout est plus simple si on scinde les 5 niveaux. Bien sûr, il y a quelques explications qui demandent de voir plusieurs niveaux à la fois. Par exemple, dans le chapitre sur les mémoires caches, nous auront des explications portant sur la RTL, la microarchitecture du cache et son architecture externe. Mais le gros du cours tentera de séparer le plus possible les 5 niveaux.

===Les trois parties principales du cours===

Nous allons commencer par parler du binaire, avant de voir les portes logiques. Avec ces portes logiques, nous allons voir comment fabriquer des circuits basiques qui reviendront très souvent dans la suite du cours. Nous verrons les registres, les décodeurs, les additionneurs et plein d'autres circuits. Puis, nous reviendrons au niveau des transistors pour finir la première partie. La raison est que c'est plus simple de faire comme cela. Tout ce qui a trait aux transistors sert à expliquer comment fabriquer des portes logiques, et il faut expliquer les portes logiques pour voir le niveau de la RTL.

Une fois la première partie finie, nous allons voir les différents composants d'un ordinateur. Une première partie expliquera ce qu'il y a dans un ordinateur, quels sont ses composants. Nous y parlerons de l'architecture de base, de la hiérarchie mémoire, des tendances technologiques, et d'autres généralités qui serviront de base pour la suite. Puis, nous verrons dans l'ordre les bus électroniques, les mémoires RAM/ROM, le processeur, les périphériques, les mémoires de stockage (SSD et disques durs) et les mémoires caches. Pour chaque composant, nous allons voir leur architecture externe, avant de voir leur microarchitecture. La raison est que la microarchitecture ne peut se comprendre que quand on sait quelle architecture externe elle implémente.

Enfin, dans une troisième partie, nous allons voir les optimisations majeures présentes dans tous les ordinateurs modernes, avec une partie sur le pipeline et le parallélisme d'instruction, et une autre sur les architectures parallèles. Pour finir, les annexes de fin parlerons de sujets un peu à part.

&lt;noinclude&gt;
{{NavChapitre | book=Fonctionnement d'un ordinateur
           | next=L'encodage des données
           | nextText=L'encodage des données
}}
&lt;/noinclude&gt;</text>
      <sha1>lnbwgcmwthhgsd8khvznl4e1marsntc</sha1>
    </revision>
    <revision>
      <id>744130</id>
      <parentid>744129</parentid>
      <timestamp>2025-06-05T00:23:58Z</timestamp>
      <contributor>
        <username>Mewtow</username>
        <id>31375</id>
      </contributor>
      <minor />
      <comment>/* La première génération : les tubes à vide */</comment>
      <origin>744130</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="46345" sha1="f91ql4v28q5ie7267l7v63qxawnjsdr" xml:space="preserve">Pour commencer, nous allons voir qu'il existe de nombreux types d'ordinateurs. Le plus connu est certainement le PC, l'ordinateur personnel, que vous avez sans doute dans votre salon. Les ordinateurs portables sont un deuxième type d'ordinateur assez intuitif, que vous avez peut-être. Mais il y a aussi d'autres types d'ordinateurs auxquels vous n'avez jamais été confrontés.

==Les différents types d'ordinateurs==

Dans cette section, nous allons décrire rapidement les ordinateurs les plus courant, mais surtout voir ce qu'il y a à l'intérieur d'un ordinateur.

===L'ordinateur de type PC fixe===

De l'extérieur, l'ordinateur est composé d'une unité centrale sur laquelle on branche des périphériques.

[[File:Typical computer architecture systems.jpg|vignette|upright=1.5|Exemples de périphériques, connectés à une unité centrale (ici appelée à tort ''operating system'').]]

Les '''périphériques''' regroupent l'écran, la souris, le clavier, l'imprimante, et bien d'autres choses. Ils permettent à l'utilisateur d'interagir avec l'ordinateur : un clavier permet de saisir du texte sous dans un fichier, une souris enregistre des déplacements de la main en déplacement du curseur, un écran affiche des données d’images/vidéos, un haut-parleur émet du son, etc. Tout ce qui est branché sur un ordinateur est, formellement un périphérique.

L''''unité centrale''' est là où se trouvent tous les composants importants d'un ordinateur, ceux qui font des calculs, qui exécutent des logiciels, qui mémorisent vos données, etc. Voici ce à quoi ressemble l'intérieur de l'unité centrale. Trois sections sont visibles : l'alimentation électrique en haut à gauche, la carte mère en bas à gauche et en jaune/orange, les disques et lecteurs à droite des câbles. Et on voit aussi beaucoup de câbles.

[[File:Asus P5K-SEIntel E6320.jpg|centre|vignette|upright=2|Exemple d'unité centrale.]]

Tout en haut à gauche, se trouve l''''alimentation électrique''', qui convertit le courant de la prise électrique en un courant plus faible, utilisable par les autres composants. Elle émet de nombreux câbles assez gros, qui sont reliés au reste. Les PC actuels utilisent des alimentations électriques standardisées, qui fournissent trois tensions au reste de l'ordinateur : une tension de 12 Volts, une de 5 Volts, une de 3,3 Volts.

À droite, caché par la partie &quot;métallique&quot; du boitier, se trouvent les lecteurs de CD/DVD, et les disques durs. Les lecteurs CD-ROM ou DVD-ROM permettaient de lire des CD ou des DVD. Je parle au passé, car ils ont aujourd'hui disparu des ordinateurs modernes. Les '''disques durs''' sont des mémoires de stockage, qui mémorisent vos données de manière permanente. De nos jours, ils sont remplacés par des SSD, qui sont des disques durs électroniques, là où les disques durs proprement dit sont des mémoires magnétiques. Nous verrons la différence dans deux chapitres dédiés, un sur les disques durs, l'autre sur les SSD.

En bas à droite, se trouve la '''carte mère''' un support plat, en plastique ou en céramique, sur laquelle sont soudés/connectés les autres composants. Sur celle-ci, de nombreux composants sont soudés, d'autres sont branchés dessus avec des câbles, d'autres sont connectés dessus avec des connecteurs. Ils sont reliés entre eux par des fils conducteurs, le plus souvent du cuivre ou de l’aluminium, ce qui leur permet de s’échanger des données. Sur les cartes simples, ces fils sont intégrés dans la carte électronique, dans des creux du plastique. Ils portent le nom de pistes.

Avant, les disques durs, SSD et lecteurs de CD/DVD sont branchés dessus via des connecteurs dédiés, appelés des connecteurs S-ATA. De nos jours, ils sont branchés sur un autre connecteur, grâce à l'interface NVME. Toujours est-il qu'ils sont reliés à la carte mère par des câbles, ce qui montre que ce sont des sortes de périphériques interne. Ils sont placés dans le boitier, mais on aurait tout aussi bien pu les mettre à l'extérieur, vu qu'ils communiquent avec l'ordinateur par l'intermédiaire d'un câble ou d'un connecteur dédié.

Mais deux autres composants très importants sont eux placés sur la carte mère, directement. Ils ont chacun un connecteur dédié, sur lequel ils sont branchés directement, sans passer par l'intermédiaire d'un câble, mais sans être soudés non plus. Il s'agit du processeur et de la mémoire RAM, deux composants centraux des PC modernes.

[[File:Pentium III SL4CB.jpg|thumb|Processeur Pentium III.]]

Le '''processeur''' traite les données, les modifie, les manipule. Pour faire simple, il s’agit d’une grosse calculatrice hyper-puissante. Il comprend à la fois un circuit qui fait des calculs, et un circuit de contrôle qui s'occupe de séquencer les calculs dans l'ordre demandé. Il est souvent caché sous un radiateur, lui-même surmonté par un ventilateur. En effet, un processeur chauffe beaucoup, ce qui demande d'évacuer cette chaleur. Un chapitre entier expliquera pourquoi les processeurs chauffent, ainsi que les techniques utilisées pour limiter leur production de chaleur et leur consommation électrique.

La '''mémoire vive''' conserve des informations/données temporairement, tant que le processeur en a besoin. Elle prend la forme de barrettes de RAM, comme montré ci-dessous.

[[File:2 gb ddr2 667.jpg|centre|vignette|upright=2|Barrette de RAM.]]

Outre ces composants dits principaux, un ordinateur peut comprendre plusieurs composants moins importants, surtout présents sur les ordinateurs personnels. Ils sont techniquement facultatifs, mais sont très présents dans les ordinateurs personnels. Cependant, certains ordinateurs spécialisés s'en passent. Il s'agit des diverses '''cartes d'extension''' sont branchées sur la carte mère. Elles permettent d’accélérer certains calculs ou certaines applications, afin de décharger le processeur. Par exemple, la carte graphique s'occupe des calculs graphiques, qu'il s'agisse de graphismes 3D de jeux vidéos ou de l'affichage en 2D du bureau. Dans un autre registre, la carte son prend en charge le microphone et les haut-parleurs.

[[Fichier:Personal computer, exploded 4.svg|thumb|upright=1.0|Éclaté d'un ordinateur de type PC :&lt;br /&gt;
1 : Écran ;&lt;br /&gt;
2 : Carte mère ;&lt;br /&gt;
3 : Processeur ;&lt;br /&gt;
4 : Câble Parallel ATA ;&lt;br /&gt;
5 : Mémoire vive (RAM) ;&lt;br /&gt;
6 : Carte d'extension ;&lt;br /&gt;
7 : Alimentation électrique ;&lt;br /&gt;
8 : Lecteur de disque optique ;&lt;br /&gt;
9 : Disque dur ;&lt;br /&gt;
10 : Clavier ;&lt;br /&gt;
11 : Souris.]]

Si on regarde une carte mère de face, on voit un grand nombre de connecteurs, mais aussi des circuits électroniques soudés à la carte mère.

[[File:Architecture matérielle d'une carte mère.png|centre|vignette|upright=2.0|Architecture matérielle d'une carte mère]]

Les '''connecteurs''' sont là où on branche les périphériques, la carte graphique, le processeur, la mémoire, etc. Dans l'ensemble, toute carte mère contient les connecteurs suivants :
* Le processeur vient s’enchâsser dans la carte mère sur un connecteur particulier : le '''socket'''. Celui-ci varie suivant la carte mère et le processeur, ce qui est source d'incompatibilités.
* Les barrettes de mémoire RAM s’enchâssent dans un autre type de connecteurs: les '''slots mémoire'''.
* Les mémoires de masse disposent de leurs propres connecteurs : connecteurs P-ATA pour les anciens disques durs, et S-ATA pour les récents.
* Les périphériques (clavier, souris, USB, Firewire, ...) sont connectés sur un ensemble de connecteurs dédiés, localisés à l'arrière du boitier de l'unité centrale. 
* Les autres périphériques sont placés dans l'unité centrale et sont connectés via des connecteurs spécialisés. Ces périphériques sont des cartes imprimées, d'où leur nom de '''cartes filles'''. On peut notamment citer les cartes réseau, les cartes son, ou les cartes vidéo.

===Les ordinateurs portables===

[[File:Samsung QX-511 (2).JPG|vignette|Ordinateur portable Samsung QX-511 (2), pour illustration.]]

Un ordinateur portable est identique à un ordinateur de type PC. Si vous ouvrez votre ordinateur portable (attention à la garantie), vous retrouverez les mêmes composants qu'un PC à l'intérieur. Un point important est la présence d'une batterie à l'intérieur du PC portable, absente des PC fixes.

[[File:LG gram 14Z90Q mainboard with battery.jpg|centre|vignette|upright=2|LG gram 14Z90Q avec sa batterie.]]

Une fois la batterie et les circuits associés retiré, la seule différence notable est que tous les composants sont soudés sur la carte mère, au lieu d'être branchés sur des connecteurs, à part éventuellement la RAM et le disque dur.

[[File:LG gram 14Z90Q mainboard without battery.jpg|centre|vignette|upright=2|LG gram 14Z90Q sans sa batterie.]]

La RAM est parfois soudée sur la carte mère, d'autres fois sous la forme de barrettes de mémoire vive semblables à celles des PC. Dans le dernier cas, elle est connectée à des connecteurs spécifiques, ce qui permet de les changer/upgrader. Les PC portables sont parfois construits de manière à pouvoir changer la RAM facilement, en ouvrant un cache spécial, concu pour.

[[File:Lenovo G555 состав - Донор.JPG|centre|vignette|upright=2|Lenovo G555.]]

La conception d'un ordinateur portable est légèrement différente de celle d'un PC, pour des raisons thermiques. Un PC fixe a plus de place pour évacuer sa chaleur. Les ventilateurs peuvent plus facilement déplacer l'air dans le boitier, même si le flux d'air dans le boitier est éventuellement gêné par la carte graphique. Mais l'évacuation de la chaleur est assez efficace. Sur les PC portables, leur finesse fait que le trajet de l'air est beaucoup plus contraint. Évacuer la chaleur produite par l'ordinateur est plus complexe, ce qui demande d'utiliser des systèmes de refroidissement et de ventilation spécifiques.

Là où les PC fixes se débrouillent avec des radiateurs et des ventilateurs posés sur le processeur, les PC portables font autrement. Ils ne peuvent pas forcément mettre le ventilateur sur le processeur. A la place, ils mettent le ventilateur à côté, mais le processeur est surmonté par un mécanisme de transmission de la chaleur, qui transfère la chaleur du processeur vers le ventilateur.

[[File:Diagram - How a laptop cooling system works.png|centre|vignette|upright=2|Comment fonctionne le système de ventilation d'un ordinateur portable, en anglais.]]

Les difficultés pour dissiper la chaleur font que les ordinateurs portables utilisent souvent des composants peu performants, mais qui chauffent peu. En effet, nous verrons que plus un composant est puissant, plus il chauffe. La relation n'est pas parfaite, mais les processeurs haute performance chauffent plus que les modèles d'entrée ou milieu de gamme moins puissants. En conséquence, les PC portables sont souvent moins puissants que les PC fixes, même pour les modèles dit ''gaming''.

===Les serveurs et ''mainframes''===

Les grandes entreprises utilisent des ordinateurs de grande taille, très puissants, appelés des ''mainframes''. Ils sont souvent confondus avec les serveurs par le grand public, il y a une différence entre les deux. Un serveur est une fonction logicielle/réseau, pas un type d'ordinateur. Mais laissons cette différence de côté, ce qui est dit pour les ''mainframes'' sert pour les gros serveurs haute performance.

[[File:IBM Z15 mainframe.jpg|vignette|Exemple de ''mainframe''' de type IBM Z15.]]

Les anciens ''mainframes'' des années 50-80 avaient une taille pouvant être impressionnante, au point de prendre une pièce complète d'un bâtiment. Mais de nos jours, les ''mainframes'' tiennent dans une grosse armoire un peu haute. Les ''mainframes'' doivent rester allumé en permanence et ne doivent pas être éteint, sauf éventuellement quelques jours par an pour des opérations de maintenance. Ils utilisent pour cela des techniques spécifiques, avec beaucoup de redondance interne.

[[File:ACONIT hall grandes machines.jpg|centre|vignette|upright=2|''Mainframe'' ACONIT.]]

Les ''mainframes'' sont aussi conçus pour mutualiser au maximum leur utilisation, ils peuvent être utilisés par plusieurs utilisateurs à la suite, voire en même temps. Pour cela, les anciens ''mainframes'' étaient capables de faire tourner plusieurs applications distinctes l'une à la suite de l'autre, avec des commutations fréquentes entre logiciels. De nos jours, ils sont capables d'exécuter un grand nombre de tâches en même temps, grâce à la présence de plusieurs processeurs. Les ''mainframes'' modernes sont même capables de faire tourner plusieurs systèmes d'exploitation en même temps si besoin.

Les anciens ''mainframes'' étaient des ordinateurs assez simples, avec un processeur, de la mémoire RAM, un ou plusieurs disques durs, pas plus. Le ''mainframe'' était tellement énorme et cher que les entreprises n'en avaient qu'un seul pour toute l'entreprise. Les employés avaient sur leur bureau des terminaux, qui permettaient d'accéder à l'ordinateur central, mais n'étaient pas des ordinateurs. Les terminaux étaient des composants électroniques simples, avec un écran, un clavier et une souris, mais sans processeur. Ils envoyaient des données au ''mainframe'', ils en recevaient de sa part, mais tout traitement était réalisé sur le ''mainframe''. L'arrivée sur le marché des ordinateurs personnels, de type PC fixe/portable, a entrainé l'abandon de ce genre de pratique, tous les employés ont maintenant un ordinateur rien que pour eux.

{|
|-
! colspan=&quot;2&quot; | Exemples de terminaux
|-
|[[File:Terminal-in2-sm9400.jpg|centre|vignette|upright=1.5|Exemple de terminal. Notez la présence d'un écran et d'un clavier, mais l'asbence d'une unité centrale.]]
|[[File:Chromatics CT4100.jpg|vignette|upright=1.5|Autre exemple de terminal. Le clavier est couplé à un stylo CRT, qui remplacait la souris et agissait sur l'écran comme s'il était tactile.]]
|-
! colspan=&quot;2&quot; | Intérieur d'un terminal
|-
|[[File:CT1024 Monitor.jpg|vignette|upright=1.5|Terminal CT1024, sans le boitier extérieur.]]
|[[File:CT1024 Terminal System.jpg|vignette|upright=1.5|Terminal CT1024, description des composants interne.]]
|}

De nos jours, les ''mainframes'' contiennent en réalité plusieurs ordinateurs simples interconnectés via un réseau local. Un ''mainframe'' qui tient dans une armoire contient facilement une dizaine ou centaine de processeurs, plein de RAM, des disques durs séparés dans une armoire distincte, etc. Vu qu'ils communiquent uniquement via le réseau, ils n'ont pas d'interface, pas d'écran, 'entrée via clavier/souris. Le tout est commandé avec une console de commande, typiquement un ordinateur portable ou un terminal assez simple séparé de l'armoire, qui permet à un administrateur de faire des opérations de surveillance, configuration et maintenance. Il peut y avoir une console de commande pour plusieurs armoires séparées, la console peut même être dans un autre bâtiment et accéder au ''mainframe'' par le réseau.

[[File:IBM System Z9 (type 2094 inside).jpg|centre|vignette|upright=2|''Mainframe'' de type IBM System Z9. L'ordinateur portable sert de console pour qu'un administrateur fasse des opérations de surveillance, configuration et maintenance.]]

Les processeurs et la RAM sont typiquement installés sur des cartes amovibles, qui sont connectées au fond de l'armoire lors de l'installation. Il est même possible de retirer ou d'ajouter des cartes en fonctionnement, afin d'ajouter/retirer des processeurs, des disques durs, etc. Ce qui est très utile si un composant est en panne et qu'il faut le remplacer. 

[[File:IBM TotalStorage Exp400.jpg|centre|vignette|upright=2|IBM TotalStorage Exp400]]

==Un peu d'abstraction : qu'est-ce qu'un ordinateur ?==

Un ordinateur comprend donc un processeur, plusieurs mémoires, des cartes d'extension et une carte mère pour connecter le tout. Mais il s'agit là d'une description assez terre-à-terre de ce qu'est un ordinateur. Une autre description, plus abstraite, se base sur le fait qu'un ordinateur est une énorme calculatrice programmable. Elle permet d'expliquer pourquoi il y a une distinction entre processeur et mémoire, entre unité centrale et périphériques. Tout ce qui va suivre pourra vous paraitre assez abstrait, mais rassurez-vous : les prochains chapitres rendront tout cela plus concrets.

===La séparation entre entrées-sorties et traitement===

L'unité centrale peut être vue comme une énorme calculatrice ultra-puissante, qui exécute des commandes/opérations. Mais à elle seule, elle ne servirait à rien, il faut interagir avec par l'intermédiaire de plusieurs périphériques. Il existe deux types de périphériques, qui sont conceptuellement différents. Les périphériques comme le clavier ou la souris permettent d'envoyer des informations à l'ordinateur, d'agir sur celui-ci. A l'inverse, les écrans transmettent des informations dans le sens inverse : de l'ordinateur vers l'utilisateur. Les premiers sont appelés des '''entrées''', les seconds des '''sorties'''.

Dans un ordinateur, les informations sont représentées sous la forme de nombres. Toute donnée dans un ordinateur est codée avec un ou plusieurs nombres regroupés dans une donnée, un fichier, ou autre. Et la transmissions avec les entrées et sorties se fait là-encore avec des nombres. Par exemple, quand vous appuyez sur votre clavier, le clavier envoie un numéro de touche à l'unité centrale, qui indique quelle touche a été appuyée. L'image à afficher à l'écran est codée sous la forme d'une suite de nombres (un par pixel). L'image est envoyée à l'écran, qui traduit la suite de nombre en image à afficher. Les entrées traduisent des actions utilisateurs en nombres, on dit que les entrées encodent les actions utilisateur. Les sorties font la traduction inverse, elles transforment des suites de nombres en une action physique. On dit qu'elles décodent des informations.

Pour résumer, toute appareil électronique est composé par :
* Des '''entrées''' sur lesquelles l'utilisateur agit sur l'ordinateur. Les entrées transforment les actions de l'utilisateur en nombres, qui sont interprétés par l'ordinateur.
* Une '''unité de traitement''', qui manipule des nombres et fait des calculs/opérations dessus. Les nombres proviennent des entrées, du disque dur, ou d'autres sources, peu importe.
* Des '''sorties''', qui va récupèrent le résultat calculé par l'unité de traitement pour en faire quelque chose : écrire sur une imprimante ou sur un moniteur, émettre du son,...

[[File:Ordinateur théorique Simple 1.png|centre|vignette|upright=2|Ordinateur théorique Simple 1]]

L'unité de traitement proprement dite, celle qui fait les calculs, est couplée à une mémoire qui mémorise les opérandes et résultats des calculs. La séparation entre processeur et mémoire est nécessaire pour qu'un appareil électronique soit qualifié d'ordinateur. De nombreux appareils n'ont pas de séparation entre unité de traitement et mémoire, comme certaines vielles radios AM/FM.

[[File:Schéma de principe d'un ordinateur.png|centre|vignette|upright=2|Schéma de principe d'un ordinateur]]

===Un ordinateur est un appareil programmable===

Les appareils simples sont non-programmables, ce qui veut dire qu’ils sont conçus pour une utilisation particulière et qu’ils ne peuvent pas faire autre chose. Par exemple, les circuits électroniques d’un lecteur de DVD ne peuvent pas être transformé en lecteur audio ou en console de jeux... Les circuits non-programmables sont câblés une bonne fois pour toute, et on ne peut pas les modifier. On peut parfois reconfigurer le circuit, pour faire varier certains paramètres, via des interrupteurs ou des boutons, mais cela s’arrête là. Et cela pose un problème : à chaque problème qu'on veut résoudre en utilisant un automate, on doit recréer un nouveau circuit.

À l'inverse, un ordinateur n’est pas conçu pour une utilisation particulière, contrairement aux autres objets techniques. Il est possible de modifier leur fonction du jour au lendemain, on peut lui faire faire ce qu’on veut. On dit qu'ils sont '''programmables'''. Pour cela, il suffit d’utiliser un logiciel, une application, un programme (ces termes sont synonymes), qui fait ce que l'on souhaite. La totalité des logiciels présents sur un ordinateur sont des programmes comme les autres, même le système d'exploitation (Windows, Linux, ...) ne fait pas exception.

Un programme est une suite de d'instructions, chaque instruction effectuant une action dans l'ordinateur. Sur les ordinateurs modernes, la majorité de ces instructions effectuent une opération arithmétique, comme une addition, une multiplication, une soustraction, etc. Les ordinateurs modernes sont donc de grosses calculettes très puissantes, capables d'effectuer des millions d'opérations par secondes. Et qui dit opération dit nombres : un ordinateur gère nativement des nombres, qui sont codés en binaire sur la quasi-totalité des ordinateurs modernes.

Une instruction est représentée dans un ordinateur par une série de nombres : un nombre qui indique quelle opération/commande effectuer et des autres nombres pour coder les données (ou de quoi les retrouver dans l'ordinateur). L'ordinateur récupére les commandes une par une, les traduit en opération à effectuer, exécuter l'opération, et enregistre le résultat. Puis il recommence avec la commande suivante.

[[File:Ordinateur Théorique Complexe 1.png|centre|vignette|upright=3|Ordinateur Théorique Complexe. En jaune, le programme informatique, la liste de commande. Le rectangle gris est l'ordinateur proprement dit.]]

De nombreux appareils sont programmables, mais tous ne sont pas des ordinateurs. Par exemple, certains circuits programmables nommés FPGA n'en sont pas. Pour être qualifié d'ordinateur, un appareil programmable doit avoir un processeur séparé de la mémoire. De plus, il doit utiliser un '''codage numérique''', chose que nous allons aborder dans le chapitre suivant.

===Les ordinateurs à programme mémorisé ou programme externe===

Au tout début de l'informatique, on utilisait des cartes perforées en plastique, sur lesquelles on inscrivait le programme à exécuter, les données à traiter, bref : tout ce qu'on donnait à manger à l'ordinateur. Par la suite, les premiers ordinateurs grand public, comme les Amstrad ou les Commodore, utilisaient des cassettes audio magnétiques pour stocker les programmes. Dans le même style, les consoles de jeu utilisaient autrefois des cartouches de jeu, qui contenaient le programme du jeu à exécuter. Pour résumer, les anciens ordinateurs mémorisaient les programmes sur un support externe, lu par un périphérique. De tels ordinateurs sont dits à '''programme externe'''.

: D’anciens ordinateurs personnels, comme l’Amstrad ou le Commodore, permettaient de taper les programmes à exécuter à la main, au clavier, avant d’appuyer une touche pour les exécuter. Nul besoin de vous dire que les cassettes audio étaient plus pratiques.

Mais de nos jours, les programmes sont enregistrés sur le disque dur de l'ordinateur ou dans une mémoire intégrée à l'ordinateur. On dit qu'ils sont installés, ce qui est un mot bien compliqué pour dire que le programme est enregistré sur le disque dur de l’ordinateur. A défaut de disque dur, le programme/logiciel est enregistré dans une mémoire spécialisée pour le stockage. Par exemple, sur les cartes électroniques grand public de marque Arduino, les programmes sont envoyés à la carte via le port USB, mais les programmes sont enregistrés dans la carte Arduino, dans une mémoire FLASH dédiée. Disque dur ou non, le programme est mémorisé dans la mémoire de l'ordinateur. Il est possible d'installer ou de désinstaller les programmes en modifiant le contenu de la mémoire. Le terme utilisé est alors celui de '''programme stocké en mémoire'''.

Les programmes à installer sont disponibles soit sur un périphérique, comme un DVD ou une clé USB, soit sont téléchargés depuis internet. Les premiers PC fournissaient les logiciels sur des disquettes, qui contenaient un programme d'installation pour enregistrer le programme sur le disque dur de l'ordinateur. Par la suite, le support des logiciels a migré vers les CD et DVD, les logiciels devenant de plus en plus gros. De nos jours, la majorité des applications sont téléchargées depuis le net, l'usage de périphériques est devenu obsolète, même les consoles de jeu abandonnent cette méthode de distribution.

==Les générations d'ordinateurs : un historique rapide==

L'informatique a beaucoup évolué dans le temps. Et une bonne partie de cette évolution tient à l'évolution de l’électronique sous-jacente. Les ordinateurs actuels sont fabriqués avec des transistors, des petits composants électroniques qui servent d'interrupteur programmables, qu'on détaillera dans ce qui suit. Mais ça n'a pas toujours été le cas. Et cela permet de distinguer plusieurs '''générations d'ordinateurs'''.

===Les ordinateurs électro-mécaniques : les premiers ordinateurs===

Le tout premier ordinateur est le '''Z1''', un modèle unique inventé par Konrad Suze entre 1936 et 1938. Son processeur gérait non pas des nombres entiers, mais des nombres à virgule (des nombres dits flottants, pour être précis), encodés sur 22 bits. Le processeur du Z1 était capable de faire des additions et des soustractions, car il intégrait un circuit additionneur-soustracteur basique. Des circuits annexes permettaient de faire des multiplications et des divisions en enchainant des additions/soustractions successives. Il fonctionnait à une fréquence de 1 Hz, ce qui fait qu'il pouvait faire une addition/soustraction par seconde maximum.

[[File:Blue-punch-card-front.png|vignette|upright=0.5|Carte Perforée.]]

Niveau mémoire, la RAM de l'ordinateur était très limitée : seulement 16 nombres de 22 bits chacun. S'il s'agissait d'une mémoire électronique, les programmes étaient mémorisés sur une mémoire mécanique. Les programmes étaient enregistrés sur des cartes perforées, à savoir des cartes en papier dans lesquelles un 1 est codé par un trou dans le papier et un 0 par une absence de trou. Les programmes étaient exécutés par l'ordinateur quand on insérait la carte perforée dans le lecteur et qu'on appuyait sur un bouton.

[[File:German Museum of Technology, Berlin 2017 024.jpg|centre|vignette|upright=2|Réplique du Z1 au ''German Museum of Technology'' de Berlin, 2017.]]

Après sa destruction dans un bombardement, le Z1 a été reconstruit et amélioré, ce qui donné les deux ordinateurs Z2 et Z3. Quelques années plus tard, de nombreux ordinateurs ont été construits dans des laboratoires de recherche. Des grandes noms de l'histoire de l'informatique datent de cette époque : le Harvard Mark I et le Colossus Mark 1 (UK) ont tous deux été mis en service en 1944, par exemple. Ils ont servis pour les cryptanalystes pour casser les codes utilisés par les allemands pour leurs transmissions, pendant la seconde guerre mondiale.

Les ordinateurs cités dans le précédent paragraphe étaient tous des ordinateurs dit '''électro-mécaniques''', car ils mélangeaient des composants électroniques et des composants mécaniques (tout ce qui a trait aux cartes perforées, notamment). Les composants électroniques étaient soit des relais, soit des tubes à vides, les deux étant des interrupteurs commandables électriquement plus ou moins équivalents aux transistors. Les ordinateurs d'avant l'année 1944, étaient tous de ce type. Quelques ordinateurs des années 50 étaient de ce type, mais leur nombre n'a pas dépassé 30. Il faut dire qu'ils ont rapidement laissé la place à des ordinateurs purement électroniques, que nous allons voir dans ce qui suit..

===La première génération : les tubes à vide===

Les ordinateurs qui ont suivi les ordinateurs électromécaniques sont regroupés dans la '''première génération d'ordinateur'''. Ils étaient conçus avec des tubes à vide, ce qui les place entre les premiers ordinateurs électro-mécaniques et les ordinateurs utilisant des transistors. Les tubes à vide étaient assez encombrants, ils consommaient beaucoup de courant, ils chauffaient et étaient assez peu fiables. Ils tombaient en panne assez souvent. Et ils étaient assez simple à fabriquer, mais restaient malgré tout chers.

[[File:Elektronenroehren-auswahl.jpg|centre|vignette|upright=2|Tubes à vides.]]

Au vu de de la taille des  tubes à vide, les ordinateurs de l'époque étaient composé de plusieurs milliers de ces tubes, guère plus. Et malgré cela, un ordinateur prenait facilement un étage de bâtiment entier, ou au moins plusieurs pièces. La conséquence est que les ordinateurs de première génération étaient très simples, rudimentaires quand on les compare aux ordinateurs modernes. Ils ne géraient que quelques opérations simples : l'addition, la soustraction, pas grand chose de plus. A quelques exceptions près, ils ne géraient pas la multiplication et encore moins la division, cela aurait demandé trop de tubes à vides.

Une des toutes premières machines construite avec des tubes à vide était l'Atanasoff–Berry. Ce n'était pas un ordinateur, car elle ne pouvait pas exécuter de programme sans intervention humaine pour séquencer des opérations, mais c'était la première machine de calcul purement électronique, sans aucune pièce mécanique. Elle utilisait une mémoire RAM construite avec des condensateurs, ceux-ci étant placés sur des cylindres tournants. Les circuits de calcul étaient construits avec des tubes à vide et faisaient leur travail un bit à la fois. Elle fonctionnait à une fréquence de 60 Hz et pouvait faire 30 additions/soustractions par seconde. Les nombres étaient encodés sur 50 bits. 

[[File:Atanasoff Berry Computer.gif|centre|vignette|upright=2.5|Atanasoff–Berry.]]

L'arrivée de l'ENIAC en 1945 a changé la donne. Cet ordinateur a introduit plusieurs innovations majeures. La première est assez technique, il s'agit de la turing-complétude, elle a trait aux programmes qui peuvent être écrit pour un ordinateur, nous ne la détaillerons pas ici.

[[File:BabyArchitecture.png|vignette|Architecture de la Manchester Baby.]]

En 1948, le ''Manchester Baby'' a introduit une innovation extrêmement importante : le programme n'était plus mémorisé sur des cartes perforées, mais dans une mémoire électronique à l’intérieur de l'ordinateur lui-même. En clair, le ''Manchester Baby'' était le premier '''ordinateur à programme stocké en mémoire''' en français. Au-delà de ça, le Manchester Baby restait quand même très simple, c'était limite un prototype.

Niveau interface, l'ordinateur avait une console avec 32 boutons, des interrupteurs et un écran de sortie sur lequel afficher les résultats. A l'intérieur, il y avait un processeur et une RAM de 32 nombres de 32 bits, fabriquées avec des tubes Williams (abordés dans une annexe à la fin du cours). Le programme devait tenir dans la RAM, avec une instruction prenant autant de place qu'un nombre, ce qui limitait les programmes à 32 instructions maximum. Une instruction prenait donc 32 bits, 3 indiquaient quelle opération utiliser, 12 servait à indiquer où se trouvent les opérandes en RAM, les 16 restants sont inutilisés.

Le processeur avait un registre unique de 32 bits, appelé l'accumulateur. Pour gérer l'accumulateur, il avait une instruction STORE pour copier son contenu en RAM et une instruction LOAD pour copier du nombre de la RAM vers l'accumulateur. Les instructions étaient chargées dans un registre d'instruction pour être exécutées, le processeur avait aussi un registre pour mémoriser la position de l'instruction suivante en RAM. Il gérait 8 instructions en tout, mais ne gérait pas l'addition. Il gérait la soustraction, des instructions de branchement et d'accès mémoire, mais rien d'autre. Il pouvait cependant émuler l'addition à partir d'une soustraction et inversant l'opérande soustraite.

Le Manchester Mark 1 était une amélioration du Manchester Baby. Il utilisait 4500 tubes à vide. L'ordinateur gérait des nombres de 40 bits, les instructions étaient codées sur 20 bits. La RAM était toujours composée de 32 nombres, leur taille était simplement augmentée. Par contre, elle était complémentée par l’ancêtre du disque dur magnétique, à savoir un tambour magnétique, l’ancêtre du disque dur magnétique. Il contenait 40 pages, faisant chacune 32 nombres de 40 bits. C'était là encore une architecture à accumulateur, elle intégrait aussi des registres d'indice. Et surtout : son processeur gérait l'addition et quelques opérations logiques (ET et OU), en plus de la soustraction et de la comparaison.

[[File:MM1Schematic French.svg|centre|vignette|upright=2.5|Architecture de la Manchester Mark 1.]]

Par la suite, les ordinateurs commerciaux ont vu le jour. Les ordinateurs précédents provenaient de projets de recherches, souvent publics. Mais les entreprises privées se sont mises à fabriquer des ordinateurs elle-mêmes, pour les vendre à d'autres entreprises. On peut notamment citer les ordinateurs comme le UNIVAC I, le Bull Gamma 3 ou les premiers ordinateurs IBM. La performance de ces ordinateurs était nettement plus importante que leurs prédécesseurs, avec des fréquences de l'ordre de la centaine de kilo-hertz. Par exemple, le Bull Gamma 3 allait à 281 kHz, l'IBM 650 allait à 50 Khz.

===La seconde génération : le remplacement des tubes à vides par des transistors===

[[File:IBM 7070.jpg|vignette|Cartes imprimées de l'IBM 704, avec des transistors et résistances dessus.]]

La '''seconde génération''' est celle des ordinateurs fabriqués avec des '''transistors''' isolés, reliés entre avec des fils électriques. Les transistors en question possèdent trois broches, des pattes métalliques sur lesquelles on connecte des fils électriques. Le transistor s'utilise le plus souvent comme un interrupteur commandé par sa troisième broche. Le courant qui traverse les deux premières broches passe ou ne passe pas selon ce qu'on met sur la troisième.

[[File:Transistor basic flow.svg|centre|vignette|Un transistor est un morceau de conducteur, dont la conductivité est contrôlée par sa troisième broche/borne.]]

Les ordinateurs de seconde génération avaient entre 1000 et 500 000 transistors. Les capacités des ordinateurs étaient donc nettement supérieures à celles des ordinateurs de première génération. Une part non négligeable des ordinateurs de seconde génération supportait l'opération de multiplication, absente sur les ordinateurs de première génération. Néanmoins, cela variait beaucoup selon les ordinateurs.

Un exemple assez hors du commun est celui du premier modèle de l'IBM 1620. Le tout premier modèle n'avait aucun circuit de calcul, il n'était même pas capable de faire une addition ou une multiplication. A la place, il utilisait une table d'addition et une table de multiplication en mémoire RAM. Les deux tables devaient être initialisées par le logiciel lors du démarrage de la machine. La table d'addition faisait une centaine de chiffre, la table de multiplication faisait le double. Le processeur de l'ordinateur gérait des instructions pour faire des additions ou des multiplications, mais ces opérations lisaient le résultat dans la table d'addition. Les calculs étaient fait chiffre par chiffre, avec un encodage partiellement décimal, partiellement binaire (des chiffres décimaux étaient encodés en binaire, nous en reparlerons quand nous parlerons du BCD) !

[[File:KL CoreMemory.jpg|vignette|Mémoire à tore de ferrite.]]

Les transistors n'étaient utilisés que pour le processeur et les circuits annexes. La mémoire n'était pas faite en transistors, pas à cette époque. La mémoire était une mémoire aujourd'hui abandonnée, appelée une '''mémoire à tores de ferrite'''. Elle sera détaillée dans un chapitre ultérieur. Mais sachez pour le moment qu'il s'agit d'une mémoire au support magnétique, les données étant stockées sur un support magnétique.

Transistors comme tubes à vide prenaient beaucoup de place, ce qui fait que les ordinateurs étaient assez gros. Concrètement, ils prenaient une pièce de bâtiment entière dans le meilleur des cas. C'était l'époque des gros ''mainframes'', reliés à des terminaux, peu puissants comparé aux standards actuels. Seules les grandes entreprises et les grands instituts de recherche pouvaient se payer les services de ce genre d'ordinateurs. Seuls les professionnels avaient accès à ce genre d'équipement.

===La troisième génération : le circuit intégré===

[[File:D8259AC-2.jpg|vignette|Exemple de circuit intégré.]]

La troisième génération est toujours fabriquée avec des transistors, mais dont la taille a été réduite. Avec l'évolution de la technologie, les transistors ont diminué en taille, de plus en plus. Ils sont devenus tellement petits qu'ils ont finit par être regroupés dans des '''circuits intégrés''', des circuits regroupent plusieurs transistors sur la même puce de silicium. Les circuits intégrés se présentent le plus souvent sous la forme de boitiers rectangulaires, comme illustré ci-contre. D'autres ont des boitiers de forme carrées, comme ceux que l'on peut trouver sur les barrettes de mémoire RAM, ou à l'intérieur des clés USB/ disques SSD.

Lors de cette génération, les processeurs étaient fournis en pièces détachées qu'il fallait relier entre elles. Le processeur était composé de plusieurs circuits intégrés séparés, impossible de mettre un processeur dans un seul boitier. Un exemple de processeur conçu en kit est la série des Intel 3000. Elle regroupe plusieurs circuits séparés aux noms à coucher dehors, mais dont vous comprendrez ce qu'ils veulent dire dans les chapitres adéquats : l'Intel 3001 est un séquenceur, l'Intel 3002 regroupe unité de calcul et registres, le 3003 est un circuit d'anticipation de retenue complémentaire du 3002, le 3212 est une mémoire tampon, le 3214 est une unité de gestion des interruptions, les 3216/3226 sont des interfaces de bus mémoire. On pourrait aussi citer la famille de circuits intégrés AMD Am2900.

Même si le processeur était en pièce détachées, utiliser une dizaine de circuits intégrés était nettement mieux que d'utiliser plusieurs milliers de transistors individuels. En conséquence, les ordinateurs ont vu leur taille grandement réduite, passant de pièces entières à une simple armoire, voire à quelques cartes intégrées superposées. De plus, le prix des circuits intégré était abordable, du moins comparé aux ordinateurs d'avant. Le prix des ordinateurs a alors grandement décru, permettant à des entreprises et administrations de taille modeste de s'équiper d'ordinateurs.

===La quatrième génération : le microprocesseur===

[[File:MOS6502.svg|vignette|Microprocesseur, ici un processeur MOS6502, de la quatrième génération.]]

Lors de la troisième génération, les circuits intégrés regroupaient plusieurs dizaines ou centaines de transistors, mais sont rapidement montés en gamme. De centaines de transistors, ils sont passé au milliers de transistors, puis au millions et maintenant au-delà du milliard. Les transistors étaient devenus tellement petits, tellement miniaturisés, qu'il était devenu possible de mettre un processeur entier dans un circuit intégré. C'est ainsi qu'est né le microprocesseur, à savoir un processeur qui tient tout entier dans un seul circuit imprimé. La quatrième génération d’ordinateur est celle des ordinateurs basés autour d'un microprocesseur.

Les tout premiers microprocesseurs étaient des processeurs à application militaire, comme le processeur du F-14 CADC ou celui de l'Air data computer. Le tout premier microprocesseur commercialisé au grand public est le 4004 d'Intel, sorti en 1971. L'intel 4004 comprenait environ 2300 transistors, avait une fréquence de 740 MHz, pouvait faire 46 opérations différentes, et manipulait des entiers de 4 bits. Il était au départ un processeur de commande, prévu pour être intégré dans la calculatrice Busicom calculator 141-P, mais il fut utilisé pour d'autres applications quelque temps plus tard. Immédiatement après le 4004, les premiers microprocesseurs 8 bits furent commercialisés. Le 4004 fut suivi par le 8008 et quelques autres processeurs 8 bits extrêmement connus, comme le 8080 d'Intel, le 68000 de Motorola, le 6502 ou le Z80.

Les microprocesseurs permirent encore uen fois de réduire la taille des ordinateurs, qui pouvaient tenir dans un boitier de PC, ou un boitier de console de jeu. Le prix des ordinateurs a aussi chuté en même temps que les transistors était miniaturisés. C'est cette invention qui permis l'invention des consoles de jeux et des mini-ordinateurs, à savoir les ordinateurs personnels. Sans miniaturisation, on n'aurait pas d'ordinateur personnel, pas de PC fixe ou portable.

==L'organisation du cours : les différents niveaux d'explication==

Le fonctionnement d'un ordinateur est assez complexe à expliquer car les explications peuvent se faire sur plusieurs niveaux. Par plusieurs niveaux, on veut dire qu'un ordinateur est composé de composants très simples, qui sont assemblés pour donner des composants eux-même plus complexes, qui sont eux-même regrouper, etc. Étudier tout cela demande de voir plusieurs niveaux, allant de transistors très petits à des processeurs multicœurs. Les niveaux les plus bas sont de l'électronique pur et dure, alors que ceux plus haut sont à mi-chemin entre électronique et informatique.

===Les niveaux d'abstraction en architecture des ordinateurs===

Les trois premiers niveaux sont de l'électronique pur et dure. Ils correspondent aux premiers chapitres du cours, qui porteront sur les circuits électroniques en général.
* Le premier niveau est celui des '''transistors''', des circuits intégrés, des ''wafer'' et autres circuits de très petite taille.
* Le second niveau est celui des '''portes logiques''', des circuits très basiques, très simples, à la base de tous les autres.
* Le troisième niveau est celui dit de la '''''Register Transfer Level''''', où un circuit électronique est construit à partir de circuits basiques, dont des registres et autres circuits dits combinatoires.
Les deux niveaux suivants sont de l'informatique proprement dit. C'est dans ces deux niveaux qu'on étudie les ordinateurs proprement dit, les circuits qu'il y a dedans et non l'électronique en général.
* Le quatrième niveau est celui de la '''microarchitecture''', qui étudie ce qu'il y a à l'intérieur d'un processeur, d'une mémoire, des périphériques et autres.
* Le cinquième niveau est celui de l''''architecture externe''', qui décrit l'interface du processeur, de la mémoire, d'un périphérique ou autre. Par décrire l'interface, on veut dire : comment un programmeur voit le processeur et la mémoire, comment il peut les manipuler. Une architecture externe unique peut avoir plusieurs microarchitecture, ce qui fait qu'on sépare les deux. Tout cela sera plus clair quand on passera aux chapitres sur le processeur et les mémoires.

Nous n'allons pas voir les 5 niveaux dans l'ordre, des transistors vers l'architecture externe. En réalité, nous allons procéder autrement. La première partie du cours portera sur les trois premiers niveaux, le reste sur les deux autres. Les 5 niveaux seront vus dans des chapitres séparés, du moins le plus possible. Au niveau pédagogique, tout est plus simple si on scinde les 5 niveaux. Bien sûr, il y a quelques explications qui demandent de voir plusieurs niveaux à la fois. Par exemple, dans le chapitre sur les mémoires caches, nous auront des explications portant sur la RTL, la microarchitecture du cache et son architecture externe. Mais le gros du cours tentera de séparer le plus possible les 5 niveaux.

===Les trois parties principales du cours===

Nous allons commencer par parler du binaire, avant de voir les portes logiques. Avec ces portes logiques, nous allons voir comment fabriquer des circuits basiques qui reviendront très souvent dans la suite du cours. Nous verrons les registres, les décodeurs, les additionneurs et plein d'autres circuits. Puis, nous reviendrons au niveau des transistors pour finir la première partie. La raison est que c'est plus simple de faire comme cela. Tout ce qui a trait aux transistors sert à expliquer comment fabriquer des portes logiques, et il faut expliquer les portes logiques pour voir le niveau de la RTL.

Une fois la première partie finie, nous allons voir les différents composants d'un ordinateur. Une première partie expliquera ce qu'il y a dans un ordinateur, quels sont ses composants. Nous y parlerons de l'architecture de base, de la hiérarchie mémoire, des tendances technologiques, et d'autres généralités qui serviront de base pour la suite. Puis, nous verrons dans l'ordre les bus électroniques, les mémoires RAM/ROM, le processeur, les périphériques, les mémoires de stockage (SSD et disques durs) et les mémoires caches. Pour chaque composant, nous allons voir leur architecture externe, avant de voir leur microarchitecture. La raison est que la microarchitecture ne peut se comprendre que quand on sait quelle architecture externe elle implémente.

Enfin, dans une troisième partie, nous allons voir les optimisations majeures présentes dans tous les ordinateurs modernes, avec une partie sur le pipeline et le parallélisme d'instruction, et une autre sur les architectures parallèles. Pour finir, les annexes de fin parlerons de sujets un peu à part.

&lt;noinclude&gt;
{{NavChapitre | book=Fonctionnement d'un ordinateur
           | next=L'encodage des données
           | nextText=L'encodage des données
}}
&lt;/noinclude&gt;</text>
      <sha1>f91ql4v28q5ie7267l7v63qxawnjsdr</sha1>
    </revision>
    <revision>
      <id>744131</id>
      <parentid>744130</parentid>
      <timestamp>2025-06-05T00:29:01Z</timestamp>
      <contributor>
        <username>Mewtow</username>
        <id>31375</id>
      </contributor>
      <minor />
      <comment>/* La première génération : les tubes à vide */</comment>
      <origin>744131</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="45746" sha1="m4b7m5cmn8l1lky27oqluha19apwlpp" xml:space="preserve">Pour commencer, nous allons voir qu'il existe de nombreux types d'ordinateurs. Le plus connu est certainement le PC, l'ordinateur personnel, que vous avez sans doute dans votre salon. Les ordinateurs portables sont un deuxième type d'ordinateur assez intuitif, que vous avez peut-être. Mais il y a aussi d'autres types d'ordinateurs auxquels vous n'avez jamais été confrontés.

==Les différents types d'ordinateurs==

Dans cette section, nous allons décrire rapidement les ordinateurs les plus courant, mais surtout voir ce qu'il y a à l'intérieur d'un ordinateur.

===L'ordinateur de type PC fixe===

De l'extérieur, l'ordinateur est composé d'une unité centrale sur laquelle on branche des périphériques.

[[File:Typical computer architecture systems.jpg|vignette|upright=1.5|Exemples de périphériques, connectés à une unité centrale (ici appelée à tort ''operating system'').]]

Les '''périphériques''' regroupent l'écran, la souris, le clavier, l'imprimante, et bien d'autres choses. Ils permettent à l'utilisateur d'interagir avec l'ordinateur : un clavier permet de saisir du texte sous dans un fichier, une souris enregistre des déplacements de la main en déplacement du curseur, un écran affiche des données d’images/vidéos, un haut-parleur émet du son, etc. Tout ce qui est branché sur un ordinateur est, formellement un périphérique.

L''''unité centrale''' est là où se trouvent tous les composants importants d'un ordinateur, ceux qui font des calculs, qui exécutent des logiciels, qui mémorisent vos données, etc. Voici ce à quoi ressemble l'intérieur de l'unité centrale. Trois sections sont visibles : l'alimentation électrique en haut à gauche, la carte mère en bas à gauche et en jaune/orange, les disques et lecteurs à droite des câbles. Et on voit aussi beaucoup de câbles.

[[File:Asus P5K-SEIntel E6320.jpg|centre|vignette|upright=2|Exemple d'unité centrale.]]

Tout en haut à gauche, se trouve l''''alimentation électrique''', qui convertit le courant de la prise électrique en un courant plus faible, utilisable par les autres composants. Elle émet de nombreux câbles assez gros, qui sont reliés au reste. Les PC actuels utilisent des alimentations électriques standardisées, qui fournissent trois tensions au reste de l'ordinateur : une tension de 12 Volts, une de 5 Volts, une de 3,3 Volts.

À droite, caché par la partie &quot;métallique&quot; du boitier, se trouvent les lecteurs de CD/DVD, et les disques durs. Les lecteurs CD-ROM ou DVD-ROM permettaient de lire des CD ou des DVD. Je parle au passé, car ils ont aujourd'hui disparu des ordinateurs modernes. Les '''disques durs''' sont des mémoires de stockage, qui mémorisent vos données de manière permanente. De nos jours, ils sont remplacés par des SSD, qui sont des disques durs électroniques, là où les disques durs proprement dit sont des mémoires magnétiques. Nous verrons la différence dans deux chapitres dédiés, un sur les disques durs, l'autre sur les SSD.

En bas à droite, se trouve la '''carte mère''' un support plat, en plastique ou en céramique, sur laquelle sont soudés/connectés les autres composants. Sur celle-ci, de nombreux composants sont soudés, d'autres sont branchés dessus avec des câbles, d'autres sont connectés dessus avec des connecteurs. Ils sont reliés entre eux par des fils conducteurs, le plus souvent du cuivre ou de l’aluminium, ce qui leur permet de s’échanger des données. Sur les cartes simples, ces fils sont intégrés dans la carte électronique, dans des creux du plastique. Ils portent le nom de pistes.

Avant, les disques durs, SSD et lecteurs de CD/DVD sont branchés dessus via des connecteurs dédiés, appelés des connecteurs S-ATA. De nos jours, ils sont branchés sur un autre connecteur, grâce à l'interface NVME. Toujours est-il qu'ils sont reliés à la carte mère par des câbles, ce qui montre que ce sont des sortes de périphériques interne. Ils sont placés dans le boitier, mais on aurait tout aussi bien pu les mettre à l'extérieur, vu qu'ils communiquent avec l'ordinateur par l'intermédiaire d'un câble ou d'un connecteur dédié.

Mais deux autres composants très importants sont eux placés sur la carte mère, directement. Ils ont chacun un connecteur dédié, sur lequel ils sont branchés directement, sans passer par l'intermédiaire d'un câble, mais sans être soudés non plus. Il s'agit du processeur et de la mémoire RAM, deux composants centraux des PC modernes.

[[File:Pentium III SL4CB.jpg|thumb|Processeur Pentium III.]]

Le '''processeur''' traite les données, les modifie, les manipule. Pour faire simple, il s’agit d’une grosse calculatrice hyper-puissante. Il comprend à la fois un circuit qui fait des calculs, et un circuit de contrôle qui s'occupe de séquencer les calculs dans l'ordre demandé. Il est souvent caché sous un radiateur, lui-même surmonté par un ventilateur. En effet, un processeur chauffe beaucoup, ce qui demande d'évacuer cette chaleur. Un chapitre entier expliquera pourquoi les processeurs chauffent, ainsi que les techniques utilisées pour limiter leur production de chaleur et leur consommation électrique.

La '''mémoire vive''' conserve des informations/données temporairement, tant que le processeur en a besoin. Elle prend la forme de barrettes de RAM, comme montré ci-dessous.

[[File:2 gb ddr2 667.jpg|centre|vignette|upright=2|Barrette de RAM.]]

Outre ces composants dits principaux, un ordinateur peut comprendre plusieurs composants moins importants, surtout présents sur les ordinateurs personnels. Ils sont techniquement facultatifs, mais sont très présents dans les ordinateurs personnels. Cependant, certains ordinateurs spécialisés s'en passent. Il s'agit des diverses '''cartes d'extension''' sont branchées sur la carte mère. Elles permettent d’accélérer certains calculs ou certaines applications, afin de décharger le processeur. Par exemple, la carte graphique s'occupe des calculs graphiques, qu'il s'agisse de graphismes 3D de jeux vidéos ou de l'affichage en 2D du bureau. Dans un autre registre, la carte son prend en charge le microphone et les haut-parleurs.

[[Fichier:Personal computer, exploded 4.svg|thumb|upright=1.0|Éclaté d'un ordinateur de type PC :&lt;br /&gt;
1 : Écran ;&lt;br /&gt;
2 : Carte mère ;&lt;br /&gt;
3 : Processeur ;&lt;br /&gt;
4 : Câble Parallel ATA ;&lt;br /&gt;
5 : Mémoire vive (RAM) ;&lt;br /&gt;
6 : Carte d'extension ;&lt;br /&gt;
7 : Alimentation électrique ;&lt;br /&gt;
8 : Lecteur de disque optique ;&lt;br /&gt;
9 : Disque dur ;&lt;br /&gt;
10 : Clavier ;&lt;br /&gt;
11 : Souris.]]

Si on regarde une carte mère de face, on voit un grand nombre de connecteurs, mais aussi des circuits électroniques soudés à la carte mère.

[[File:Architecture matérielle d'une carte mère.png|centre|vignette|upright=2.0|Architecture matérielle d'une carte mère]]

Les '''connecteurs''' sont là où on branche les périphériques, la carte graphique, le processeur, la mémoire, etc. Dans l'ensemble, toute carte mère contient les connecteurs suivants :
* Le processeur vient s’enchâsser dans la carte mère sur un connecteur particulier : le '''socket'''. Celui-ci varie suivant la carte mère et le processeur, ce qui est source d'incompatibilités.
* Les barrettes de mémoire RAM s’enchâssent dans un autre type de connecteurs: les '''slots mémoire'''.
* Les mémoires de masse disposent de leurs propres connecteurs : connecteurs P-ATA pour les anciens disques durs, et S-ATA pour les récents.
* Les périphériques (clavier, souris, USB, Firewire, ...) sont connectés sur un ensemble de connecteurs dédiés, localisés à l'arrière du boitier de l'unité centrale. 
* Les autres périphériques sont placés dans l'unité centrale et sont connectés via des connecteurs spécialisés. Ces périphériques sont des cartes imprimées, d'où leur nom de '''cartes filles'''. On peut notamment citer les cartes réseau, les cartes son, ou les cartes vidéo.

===Les ordinateurs portables===

[[File:Samsung QX-511 (2).JPG|vignette|Ordinateur portable Samsung QX-511 (2), pour illustration.]]

Un ordinateur portable est identique à un ordinateur de type PC. Si vous ouvrez votre ordinateur portable (attention à la garantie), vous retrouverez les mêmes composants qu'un PC à l'intérieur. Un point important est la présence d'une batterie à l'intérieur du PC portable, absente des PC fixes.

[[File:LG gram 14Z90Q mainboard with battery.jpg|centre|vignette|upright=2|LG gram 14Z90Q avec sa batterie.]]

Une fois la batterie et les circuits associés retiré, la seule différence notable est que tous les composants sont soudés sur la carte mère, au lieu d'être branchés sur des connecteurs, à part éventuellement la RAM et le disque dur.

[[File:LG gram 14Z90Q mainboard without battery.jpg|centre|vignette|upright=2|LG gram 14Z90Q sans sa batterie.]]

La RAM est parfois soudée sur la carte mère, d'autres fois sous la forme de barrettes de mémoire vive semblables à celles des PC. Dans le dernier cas, elle est connectée à des connecteurs spécifiques, ce qui permet de les changer/upgrader. Les PC portables sont parfois construits de manière à pouvoir changer la RAM facilement, en ouvrant un cache spécial, concu pour.

[[File:Lenovo G555 состав - Донор.JPG|centre|vignette|upright=2|Lenovo G555.]]

La conception d'un ordinateur portable est légèrement différente de celle d'un PC, pour des raisons thermiques. Un PC fixe a plus de place pour évacuer sa chaleur. Les ventilateurs peuvent plus facilement déplacer l'air dans le boitier, même si le flux d'air dans le boitier est éventuellement gêné par la carte graphique. Mais l'évacuation de la chaleur est assez efficace. Sur les PC portables, leur finesse fait que le trajet de l'air est beaucoup plus contraint. Évacuer la chaleur produite par l'ordinateur est plus complexe, ce qui demande d'utiliser des systèmes de refroidissement et de ventilation spécifiques.

Là où les PC fixes se débrouillent avec des radiateurs et des ventilateurs posés sur le processeur, les PC portables font autrement. Ils ne peuvent pas forcément mettre le ventilateur sur le processeur. A la place, ils mettent le ventilateur à côté, mais le processeur est surmonté par un mécanisme de transmission de la chaleur, qui transfère la chaleur du processeur vers le ventilateur.

[[File:Diagram - How a laptop cooling system works.png|centre|vignette|upright=2|Comment fonctionne le système de ventilation d'un ordinateur portable, en anglais.]]

Les difficultés pour dissiper la chaleur font que les ordinateurs portables utilisent souvent des composants peu performants, mais qui chauffent peu. En effet, nous verrons que plus un composant est puissant, plus il chauffe. La relation n'est pas parfaite, mais les processeurs haute performance chauffent plus que les modèles d'entrée ou milieu de gamme moins puissants. En conséquence, les PC portables sont souvent moins puissants que les PC fixes, même pour les modèles dit ''gaming''.

===Les serveurs et ''mainframes''===

Les grandes entreprises utilisent des ordinateurs de grande taille, très puissants, appelés des ''mainframes''. Ils sont souvent confondus avec les serveurs par le grand public, il y a une différence entre les deux. Un serveur est une fonction logicielle/réseau, pas un type d'ordinateur. Mais laissons cette différence de côté, ce qui est dit pour les ''mainframes'' sert pour les gros serveurs haute performance.

[[File:IBM Z15 mainframe.jpg|vignette|Exemple de ''mainframe''' de type IBM Z15.]]

Les anciens ''mainframes'' des années 50-80 avaient une taille pouvant être impressionnante, au point de prendre une pièce complète d'un bâtiment. Mais de nos jours, les ''mainframes'' tiennent dans une grosse armoire un peu haute. Les ''mainframes'' doivent rester allumé en permanence et ne doivent pas être éteint, sauf éventuellement quelques jours par an pour des opérations de maintenance. Ils utilisent pour cela des techniques spécifiques, avec beaucoup de redondance interne.

[[File:ACONIT hall grandes machines.jpg|centre|vignette|upright=2|''Mainframe'' ACONIT.]]

Les ''mainframes'' sont aussi conçus pour mutualiser au maximum leur utilisation, ils peuvent être utilisés par plusieurs utilisateurs à la suite, voire en même temps. Pour cela, les anciens ''mainframes'' étaient capables de faire tourner plusieurs applications distinctes l'une à la suite de l'autre, avec des commutations fréquentes entre logiciels. De nos jours, ils sont capables d'exécuter un grand nombre de tâches en même temps, grâce à la présence de plusieurs processeurs. Les ''mainframes'' modernes sont même capables de faire tourner plusieurs systèmes d'exploitation en même temps si besoin.

Les anciens ''mainframes'' étaient des ordinateurs assez simples, avec un processeur, de la mémoire RAM, un ou plusieurs disques durs, pas plus. Le ''mainframe'' était tellement énorme et cher que les entreprises n'en avaient qu'un seul pour toute l'entreprise. Les employés avaient sur leur bureau des terminaux, qui permettaient d'accéder à l'ordinateur central, mais n'étaient pas des ordinateurs. Les terminaux étaient des composants électroniques simples, avec un écran, un clavier et une souris, mais sans processeur. Ils envoyaient des données au ''mainframe'', ils en recevaient de sa part, mais tout traitement était réalisé sur le ''mainframe''. L'arrivée sur le marché des ordinateurs personnels, de type PC fixe/portable, a entrainé l'abandon de ce genre de pratique, tous les employés ont maintenant un ordinateur rien que pour eux.

{|
|-
! colspan=&quot;2&quot; | Exemples de terminaux
|-
|[[File:Terminal-in2-sm9400.jpg|centre|vignette|upright=1.5|Exemple de terminal. Notez la présence d'un écran et d'un clavier, mais l'asbence d'une unité centrale.]]
|[[File:Chromatics CT4100.jpg|vignette|upright=1.5|Autre exemple de terminal. Le clavier est couplé à un stylo CRT, qui remplacait la souris et agissait sur l'écran comme s'il était tactile.]]
|-
! colspan=&quot;2&quot; | Intérieur d'un terminal
|-
|[[File:CT1024 Monitor.jpg|vignette|upright=1.5|Terminal CT1024, sans le boitier extérieur.]]
|[[File:CT1024 Terminal System.jpg|vignette|upright=1.5|Terminal CT1024, description des composants interne.]]
|}

De nos jours, les ''mainframes'' contiennent en réalité plusieurs ordinateurs simples interconnectés via un réseau local. Un ''mainframe'' qui tient dans une armoire contient facilement une dizaine ou centaine de processeurs, plein de RAM, des disques durs séparés dans une armoire distincte, etc. Vu qu'ils communiquent uniquement via le réseau, ils n'ont pas d'interface, pas d'écran, 'entrée via clavier/souris. Le tout est commandé avec une console de commande, typiquement un ordinateur portable ou un terminal assez simple séparé de l'armoire, qui permet à un administrateur de faire des opérations de surveillance, configuration et maintenance. Il peut y avoir une console de commande pour plusieurs armoires séparées, la console peut même être dans un autre bâtiment et accéder au ''mainframe'' par le réseau.

[[File:IBM System Z9 (type 2094 inside).jpg|centre|vignette|upright=2|''Mainframe'' de type IBM System Z9. L'ordinateur portable sert de console pour qu'un administrateur fasse des opérations de surveillance, configuration et maintenance.]]

Les processeurs et la RAM sont typiquement installés sur des cartes amovibles, qui sont connectées au fond de l'armoire lors de l'installation. Il est même possible de retirer ou d'ajouter des cartes en fonctionnement, afin d'ajouter/retirer des processeurs, des disques durs, etc. Ce qui est très utile si un composant est en panne et qu'il faut le remplacer. 

[[File:IBM TotalStorage Exp400.jpg|centre|vignette|upright=2|IBM TotalStorage Exp400]]

==Un peu d'abstraction : qu'est-ce qu'un ordinateur ?==

Un ordinateur comprend donc un processeur, plusieurs mémoires, des cartes d'extension et une carte mère pour connecter le tout. Mais il s'agit là d'une description assez terre-à-terre de ce qu'est un ordinateur. Une autre description, plus abstraite, se base sur le fait qu'un ordinateur est une énorme calculatrice programmable. Elle permet d'expliquer pourquoi il y a une distinction entre processeur et mémoire, entre unité centrale et périphériques. Tout ce qui va suivre pourra vous paraitre assez abstrait, mais rassurez-vous : les prochains chapitres rendront tout cela plus concrets.

===La séparation entre entrées-sorties et traitement===

L'unité centrale peut être vue comme une énorme calculatrice ultra-puissante, qui exécute des commandes/opérations. Mais à elle seule, elle ne servirait à rien, il faut interagir avec par l'intermédiaire de plusieurs périphériques. Il existe deux types de périphériques, qui sont conceptuellement différents. Les périphériques comme le clavier ou la souris permettent d'envoyer des informations à l'ordinateur, d'agir sur celui-ci. A l'inverse, les écrans transmettent des informations dans le sens inverse : de l'ordinateur vers l'utilisateur. Les premiers sont appelés des '''entrées''', les seconds des '''sorties'''.

Dans un ordinateur, les informations sont représentées sous la forme de nombres. Toute donnée dans un ordinateur est codée avec un ou plusieurs nombres regroupés dans une donnée, un fichier, ou autre. Et la transmissions avec les entrées et sorties se fait là-encore avec des nombres. Par exemple, quand vous appuyez sur votre clavier, le clavier envoie un numéro de touche à l'unité centrale, qui indique quelle touche a été appuyée. L'image à afficher à l'écran est codée sous la forme d'une suite de nombres (un par pixel). L'image est envoyée à l'écran, qui traduit la suite de nombre en image à afficher. Les entrées traduisent des actions utilisateurs en nombres, on dit que les entrées encodent les actions utilisateur. Les sorties font la traduction inverse, elles transforment des suites de nombres en une action physique. On dit qu'elles décodent des informations.

Pour résumer, toute appareil électronique est composé par :
* Des '''entrées''' sur lesquelles l'utilisateur agit sur l'ordinateur. Les entrées transforment les actions de l'utilisateur en nombres, qui sont interprétés par l'ordinateur.
* Une '''unité de traitement''', qui manipule des nombres et fait des calculs/opérations dessus. Les nombres proviennent des entrées, du disque dur, ou d'autres sources, peu importe.
* Des '''sorties''', qui va récupèrent le résultat calculé par l'unité de traitement pour en faire quelque chose : écrire sur une imprimante ou sur un moniteur, émettre du son,...

[[File:Ordinateur théorique Simple 1.png|centre|vignette|upright=2|Ordinateur théorique Simple 1]]

L'unité de traitement proprement dite, celle qui fait les calculs, est couplée à une mémoire qui mémorise les opérandes et résultats des calculs. La séparation entre processeur et mémoire est nécessaire pour qu'un appareil électronique soit qualifié d'ordinateur. De nombreux appareils n'ont pas de séparation entre unité de traitement et mémoire, comme certaines vielles radios AM/FM.

[[File:Schéma de principe d'un ordinateur.png|centre|vignette|upright=2|Schéma de principe d'un ordinateur]]

===Un ordinateur est un appareil programmable===

Les appareils simples sont non-programmables, ce qui veut dire qu’ils sont conçus pour une utilisation particulière et qu’ils ne peuvent pas faire autre chose. Par exemple, les circuits électroniques d’un lecteur de DVD ne peuvent pas être transformé en lecteur audio ou en console de jeux... Les circuits non-programmables sont câblés une bonne fois pour toute, et on ne peut pas les modifier. On peut parfois reconfigurer le circuit, pour faire varier certains paramètres, via des interrupteurs ou des boutons, mais cela s’arrête là. Et cela pose un problème : à chaque problème qu'on veut résoudre en utilisant un automate, on doit recréer un nouveau circuit.

À l'inverse, un ordinateur n’est pas conçu pour une utilisation particulière, contrairement aux autres objets techniques. Il est possible de modifier leur fonction du jour au lendemain, on peut lui faire faire ce qu’on veut. On dit qu'ils sont '''programmables'''. Pour cela, il suffit d’utiliser un logiciel, une application, un programme (ces termes sont synonymes), qui fait ce que l'on souhaite. La totalité des logiciels présents sur un ordinateur sont des programmes comme les autres, même le système d'exploitation (Windows, Linux, ...) ne fait pas exception.

Un programme est une suite de d'instructions, chaque instruction effectuant une action dans l'ordinateur. Sur les ordinateurs modernes, la majorité de ces instructions effectuent une opération arithmétique, comme une addition, une multiplication, une soustraction, etc. Les ordinateurs modernes sont donc de grosses calculettes très puissantes, capables d'effectuer des millions d'opérations par secondes. Et qui dit opération dit nombres : un ordinateur gère nativement des nombres, qui sont codés en binaire sur la quasi-totalité des ordinateurs modernes.

Une instruction est représentée dans un ordinateur par une série de nombres : un nombre qui indique quelle opération/commande effectuer et des autres nombres pour coder les données (ou de quoi les retrouver dans l'ordinateur). L'ordinateur récupére les commandes une par une, les traduit en opération à effectuer, exécuter l'opération, et enregistre le résultat. Puis il recommence avec la commande suivante.

[[File:Ordinateur Théorique Complexe 1.png|centre|vignette|upright=3|Ordinateur Théorique Complexe. En jaune, le programme informatique, la liste de commande. Le rectangle gris est l'ordinateur proprement dit.]]

De nombreux appareils sont programmables, mais tous ne sont pas des ordinateurs. Par exemple, certains circuits programmables nommés FPGA n'en sont pas. Pour être qualifié d'ordinateur, un appareil programmable doit avoir un processeur séparé de la mémoire. De plus, il doit utiliser un '''codage numérique''', chose que nous allons aborder dans le chapitre suivant.

===Les ordinateurs à programme mémorisé ou programme externe===

Au tout début de l'informatique, on utilisait des cartes perforées en plastique, sur lesquelles on inscrivait le programme à exécuter, les données à traiter, bref : tout ce qu'on donnait à manger à l'ordinateur. Par la suite, les premiers ordinateurs grand public, comme les Amstrad ou les Commodore, utilisaient des cassettes audio magnétiques pour stocker les programmes. Dans le même style, les consoles de jeu utilisaient autrefois des cartouches de jeu, qui contenaient le programme du jeu à exécuter. Pour résumer, les anciens ordinateurs mémorisaient les programmes sur un support externe, lu par un périphérique. De tels ordinateurs sont dits à '''programme externe'''.

: D’anciens ordinateurs personnels, comme l’Amstrad ou le Commodore, permettaient de taper les programmes à exécuter à la main, au clavier, avant d’appuyer une touche pour les exécuter. Nul besoin de vous dire que les cassettes audio étaient plus pratiques.

Mais de nos jours, les programmes sont enregistrés sur le disque dur de l'ordinateur ou dans une mémoire intégrée à l'ordinateur. On dit qu'ils sont installés, ce qui est un mot bien compliqué pour dire que le programme est enregistré sur le disque dur de l’ordinateur. A défaut de disque dur, le programme/logiciel est enregistré dans une mémoire spécialisée pour le stockage. Par exemple, sur les cartes électroniques grand public de marque Arduino, les programmes sont envoyés à la carte via le port USB, mais les programmes sont enregistrés dans la carte Arduino, dans une mémoire FLASH dédiée. Disque dur ou non, le programme est mémorisé dans la mémoire de l'ordinateur. Il est possible d'installer ou de désinstaller les programmes en modifiant le contenu de la mémoire. Le terme utilisé est alors celui de '''programme stocké en mémoire'''.

Les programmes à installer sont disponibles soit sur un périphérique, comme un DVD ou une clé USB, soit sont téléchargés depuis internet. Les premiers PC fournissaient les logiciels sur des disquettes, qui contenaient un programme d'installation pour enregistrer le programme sur le disque dur de l'ordinateur. Par la suite, le support des logiciels a migré vers les CD et DVD, les logiciels devenant de plus en plus gros. De nos jours, la majorité des applications sont téléchargées depuis le net, l'usage de périphériques est devenu obsolète, même les consoles de jeu abandonnent cette méthode de distribution.

==Les générations d'ordinateurs : un historique rapide==

L'informatique a beaucoup évolué dans le temps. Et une bonne partie de cette évolution tient à l'évolution de l’électronique sous-jacente. Les ordinateurs actuels sont fabriqués avec des transistors, des petits composants électroniques qui servent d'interrupteur programmables, qu'on détaillera dans ce qui suit. Mais ça n'a pas toujours été le cas. Et cela permet de distinguer plusieurs '''générations d'ordinateurs'''.

===Les ordinateurs électro-mécaniques : les premiers ordinateurs===

Le tout premier ordinateur est le '''Z1''', un modèle unique inventé par Konrad Suze entre 1936 et 1938. Son processeur gérait non pas des nombres entiers, mais des nombres à virgule (des nombres dits flottants, pour être précis), encodés sur 22 bits. Le processeur du Z1 était capable de faire des additions et des soustractions, car il intégrait un circuit additionneur-soustracteur basique. Des circuits annexes permettaient de faire des multiplications et des divisions en enchainant des additions/soustractions successives. Il fonctionnait à une fréquence de 1 Hz, ce qui fait qu'il pouvait faire une addition/soustraction par seconde maximum.

[[File:Blue-punch-card-front.png|vignette|upright=0.5|Carte Perforée.]]

Niveau mémoire, la RAM de l'ordinateur était très limitée : seulement 16 nombres de 22 bits chacun. S'il s'agissait d'une mémoire électronique, les programmes étaient mémorisés sur une mémoire mécanique. Les programmes étaient enregistrés sur des cartes perforées, à savoir des cartes en papier dans lesquelles un 1 est codé par un trou dans le papier et un 0 par une absence de trou. Les programmes étaient exécutés par l'ordinateur quand on insérait la carte perforée dans le lecteur et qu'on appuyait sur un bouton.

[[File:German Museum of Technology, Berlin 2017 024.jpg|centre|vignette|upright=2|Réplique du Z1 au ''German Museum of Technology'' de Berlin, 2017.]]

Après sa destruction dans un bombardement, le Z1 a été reconstruit et amélioré, ce qui donné les deux ordinateurs Z2 et Z3. Quelques années plus tard, de nombreux ordinateurs ont été construits dans des laboratoires de recherche. Des grandes noms de l'histoire de l'informatique datent de cette époque : le Harvard Mark I et le Colossus Mark 1 (UK) ont tous deux été mis en service en 1944, par exemple. Ils ont servis pour les cryptanalystes pour casser les codes utilisés par les allemands pour leurs transmissions, pendant la seconde guerre mondiale.

Les ordinateurs cités dans le précédent paragraphe étaient tous des ordinateurs dit '''électro-mécaniques''', car ils mélangeaient des composants électroniques et des composants mécaniques (tout ce qui a trait aux cartes perforées, notamment). Les composants électroniques étaient soit des relais, soit des tubes à vides, les deux étant des interrupteurs commandables électriquement plus ou moins équivalents aux transistors. Les ordinateurs d'avant l'année 1944, étaient tous de ce type. Quelques ordinateurs des années 50 étaient de ce type, mais leur nombre n'a pas dépassé 30. Il faut dire qu'ils ont rapidement laissé la place à des ordinateurs purement électroniques, que nous allons voir dans ce qui suit..

===La première génération : les tubes à vide===

Les ordinateurs qui ont suivi les ordinateurs électromécaniques sont regroupés dans la '''première génération d'ordinateur'''. Ils étaient conçus avec des tubes à vide, ce qui les place entre les premiers ordinateurs électro-mécaniques et les ordinateurs utilisant des transistors. Les tubes à vide étaient assez encombrants, ils consommaient beaucoup de courant, ils chauffaient et étaient assez peu fiables. Ils tombaient en panne assez souvent. Et ils étaient assez simple à fabriquer, mais restaient malgré tout chers.

[[File:Elektronenroehren-auswahl.jpg|centre|vignette|upright=2|Tubes à vides.]]

Au vu de de la taille des  tubes à vide, les ordinateurs de l'époque étaient composé de plusieurs milliers de ces tubes, guère plus. Et malgré cela, un ordinateur prenait facilement un étage de bâtiment entier, ou au moins plusieurs pièces. La conséquence est que les ordinateurs de première génération étaient très simples, rudimentaires quand on les compare aux ordinateurs modernes. Ils ne géraient que quelques opérations simples : l'addition, la soustraction, pas grand chose de plus. A quelques exceptions près, ils ne géraient pas la multiplication et encore moins la division, cela aurait demandé trop de tubes à vides.

Une des toutes premières machines construite avec des tubes à vide était l'Atanasoff–Berry. Ce n'était pas un ordinateur, car elle ne pouvait pas exécuter de programme sans intervention humaine pour séquencer des opérations, mais c'était la première machine de calcul purement électronique, sans aucune pièce mécanique. Elle utilisait une mémoire RAM construite avec des condensateurs, ceux-ci étant placés sur des cylindres tournants. Les circuits de calcul étaient construits avec des tubes à vide et faisaient leur travail un bit à la fois. Elle fonctionnait à une fréquence de 60 Hz et pouvait faire 30 additions/soustractions par seconde. Les nombres étaient encodés sur 50 bits. 

[[File:Atanasoff Berry Computer.gif|centre|vignette|upright=2.5|Atanasoff–Berry.]]

L'arrivée de l'ENIAC en 1945 a changé la donne. Cet ordinateur a introduit plusieurs innovations majeures. La première est assez technique, il s'agit de la turing-complétude, elle a trait aux programmes qui peuvent être écrit pour un ordinateur, nous ne la détaillerons pas ici.

[[File:BabyArchitecture.png|vignette|Architecture de la Manchester Baby.]]

En 1948, le ''Manchester Baby'' a introduit une innovation extrêmement importante : le programme n'était plus mémorisé sur des cartes perforées, mais dans une mémoire électronique à l’intérieur de l'ordinateur lui-même. En clair, le ''Manchester Baby'' était le premier '''ordinateur à programme stocké en mémoire''' en français. Au-delà de ça, le Manchester Baby restait quand même très simple, c'était limite un prototype.

Niveau interface, l'ordinateur avait une console avec 32 boutons, des interrupteurs et un écran de sortie sur lequel afficher les résultats. A l'intérieur, il y avait un processeur et une RAM de 32 nombres de 32 bits, fabriquées avec des tubes Williams (abordés dans une annexe à la fin du cours). Le programme devait tenir dans la RAM, avec une instruction prenant autant de place qu'un nombre, ce qui limitait les programmes à 32 instructions maximum. Le processeur gérait 8 instructions en tout, mais ne gérait pas l'addition. Il gérait la soustraction, des instructions de branchement et d'accès mémoire, mais rien d'autre. Il pouvait cependant émuler l'addition à partir d'une soustraction et inversant l'opérande soustraite.

Le Manchester Mark 1 était une amélioration du Manchester Baby. Il utilisait 4500 tubes à vide. L'ordinateur gérait des nombres de 40 bits, les instructions étaient codées sur 20 bits. La RAM était toujours composée de 32 nombres, leur taille était simplement augmentée. Par contre, elle était complémentée par l’ancêtre du disque dur magnétique, à savoir un tambour magnétique, l’ancêtre du disque dur magnétique. Il contenait 40 pages, faisant chacune 32 nombres de 40 bits. C'était là encore une architecture à accumulateur, elle intégrait aussi des registres d'indice. Et surtout : son processeur gérait l'addition et quelques opérations logiques (ET et OU), en plus de la soustraction et de la comparaison.

[[File:MM1Schematic French.svg|centre|vignette|upright=2.5|Architecture de la Manchester Mark 1.]]

Par la suite, les ordinateurs commerciaux ont vu le jour. Les ordinateurs précédents provenaient de projets de recherches, souvent publics. Mais les entreprises privées se sont mises à fabriquer des ordinateurs elle-mêmes, pour les vendre à d'autres entreprises. On peut notamment citer les ordinateurs comme le UNIVAC I, le Bull Gamma 3 ou les premiers ordinateurs IBM. La performance de ces ordinateurs était nettement plus importante que leurs prédécesseurs, avec des fréquences de l'ordre de la centaine de kilo-hertz. Par exemple, le Bull Gamma 3 allait à 281 kHz, l'IBM 650 allait à 50 Khz.

===La seconde génération : le remplacement des tubes à vides par des transistors===

[[File:IBM 7070.jpg|vignette|Cartes imprimées de l'IBM 704, avec des transistors et résistances dessus.]]

La '''seconde génération''' est celle des ordinateurs fabriqués avec des '''transistors''' isolés, reliés entre avec des fils électriques. Les transistors en question possèdent trois broches, des pattes métalliques sur lesquelles on connecte des fils électriques. Le transistor s'utilise le plus souvent comme un interrupteur commandé par sa troisième broche. Le courant qui traverse les deux premières broches passe ou ne passe pas selon ce qu'on met sur la troisième.

[[File:Transistor basic flow.svg|centre|vignette|Un transistor est un morceau de conducteur, dont la conductivité est contrôlée par sa troisième broche/borne.]]

Les ordinateurs de seconde génération avaient entre 1000 et 500 000 transistors. Les capacités des ordinateurs étaient donc nettement supérieures à celles des ordinateurs de première génération. Une part non négligeable des ordinateurs de seconde génération supportait l'opération de multiplication, absente sur les ordinateurs de première génération. Néanmoins, cela variait beaucoup selon les ordinateurs.

Un exemple assez hors du commun est celui du premier modèle de l'IBM 1620. Le tout premier modèle n'avait aucun circuit de calcul, il n'était même pas capable de faire une addition ou une multiplication. A la place, il utilisait une table d'addition et une table de multiplication en mémoire RAM. Les deux tables devaient être initialisées par le logiciel lors du démarrage de la machine. La table d'addition faisait une centaine de chiffre, la table de multiplication faisait le double. Le processeur de l'ordinateur gérait des instructions pour faire des additions ou des multiplications, mais ces opérations lisaient le résultat dans la table d'addition. Les calculs étaient fait chiffre par chiffre, avec un encodage partiellement décimal, partiellement binaire (des chiffres décimaux étaient encodés en binaire, nous en reparlerons quand nous parlerons du BCD) !

[[File:KL CoreMemory.jpg|vignette|Mémoire à tore de ferrite.]]

Les transistors n'étaient utilisés que pour le processeur et les circuits annexes. La mémoire n'était pas faite en transistors, pas à cette époque. La mémoire était une mémoire aujourd'hui abandonnée, appelée une '''mémoire à tores de ferrite'''. Elle sera détaillée dans un chapitre ultérieur. Mais sachez pour le moment qu'il s'agit d'une mémoire au support magnétique, les données étant stockées sur un support magnétique.

Transistors comme tubes à vide prenaient beaucoup de place, ce qui fait que les ordinateurs étaient assez gros. Concrètement, ils prenaient une pièce de bâtiment entière dans le meilleur des cas. C'était l'époque des gros ''mainframes'', reliés à des terminaux, peu puissants comparé aux standards actuels. Seules les grandes entreprises et les grands instituts de recherche pouvaient se payer les services de ce genre d'ordinateurs. Seuls les professionnels avaient accès à ce genre d'équipement.

===La troisième génération : le circuit intégré===

[[File:D8259AC-2.jpg|vignette|Exemple de circuit intégré.]]

La troisième génération est toujours fabriquée avec des transistors, mais dont la taille a été réduite. Avec l'évolution de la technologie, les transistors ont diminué en taille, de plus en plus. Ils sont devenus tellement petits qu'ils ont finit par être regroupés dans des '''circuits intégrés''', des circuits regroupent plusieurs transistors sur la même puce de silicium. Les circuits intégrés se présentent le plus souvent sous la forme de boitiers rectangulaires, comme illustré ci-contre. D'autres ont des boitiers de forme carrées, comme ceux que l'on peut trouver sur les barrettes de mémoire RAM, ou à l'intérieur des clés USB/ disques SSD.

Lors de cette génération, les processeurs étaient fournis en pièces détachées qu'il fallait relier entre elles. Le processeur était composé de plusieurs circuits intégrés séparés, impossible de mettre un processeur dans un seul boitier. Un exemple de processeur conçu en kit est la série des Intel 3000. Elle regroupe plusieurs circuits séparés aux noms à coucher dehors, mais dont vous comprendrez ce qu'ils veulent dire dans les chapitres adéquats : l'Intel 3001 est un séquenceur, l'Intel 3002 regroupe unité de calcul et registres, le 3003 est un circuit d'anticipation de retenue complémentaire du 3002, le 3212 est une mémoire tampon, le 3214 est une unité de gestion des interruptions, les 3216/3226 sont des interfaces de bus mémoire. On pourrait aussi citer la famille de circuits intégrés AMD Am2900.

Même si le processeur était en pièce détachées, utiliser une dizaine de circuits intégrés était nettement mieux que d'utiliser plusieurs milliers de transistors individuels. En conséquence, les ordinateurs ont vu leur taille grandement réduite, passant de pièces entières à une simple armoire, voire à quelques cartes intégrées superposées. De plus, le prix des circuits intégré était abordable, du moins comparé aux ordinateurs d'avant. Le prix des ordinateurs a alors grandement décru, permettant à des entreprises et administrations de taille modeste de s'équiper d'ordinateurs.

===La quatrième génération : le microprocesseur===

[[File:MOS6502.svg|vignette|Microprocesseur, ici un processeur MOS6502, de la quatrième génération.]]

Lors de la troisième génération, les circuits intégrés regroupaient plusieurs dizaines ou centaines de transistors, mais sont rapidement montés en gamme. De centaines de transistors, ils sont passé au milliers de transistors, puis au millions et maintenant au-delà du milliard. Les transistors étaient devenus tellement petits, tellement miniaturisés, qu'il était devenu possible de mettre un processeur entier dans un circuit intégré. C'est ainsi qu'est né le microprocesseur, à savoir un processeur qui tient tout entier dans un seul circuit imprimé. La quatrième génération d’ordinateur est celle des ordinateurs basés autour d'un microprocesseur.

Les tout premiers microprocesseurs étaient des processeurs à application militaire, comme le processeur du F-14 CADC ou celui de l'Air data computer. Le tout premier microprocesseur commercialisé au grand public est le 4004 d'Intel, sorti en 1971. L'intel 4004 comprenait environ 2300 transistors, avait une fréquence de 740 MHz, pouvait faire 46 opérations différentes, et manipulait des entiers de 4 bits. Il était au départ un processeur de commande, prévu pour être intégré dans la calculatrice Busicom calculator 141-P, mais il fut utilisé pour d'autres applications quelque temps plus tard. Immédiatement après le 4004, les premiers microprocesseurs 8 bits furent commercialisés. Le 4004 fut suivi par le 8008 et quelques autres processeurs 8 bits extrêmement connus, comme le 8080 d'Intel, le 68000 de Motorola, le 6502 ou le Z80.

Les microprocesseurs permirent encore uen fois de réduire la taille des ordinateurs, qui pouvaient tenir dans un boitier de PC, ou un boitier de console de jeu. Le prix des ordinateurs a aussi chuté en même temps que les transistors était miniaturisés. C'est cette invention qui permis l'invention des consoles de jeux et des mini-ordinateurs, à savoir les ordinateurs personnels. Sans miniaturisation, on n'aurait pas d'ordinateur personnel, pas de PC fixe ou portable.

==L'organisation du cours : les différents niveaux d'explication==

Le fonctionnement d'un ordinateur est assez complexe à expliquer car les explications peuvent se faire sur plusieurs niveaux. Par plusieurs niveaux, on veut dire qu'un ordinateur est composé de composants très simples, qui sont assemblés pour donner des composants eux-même plus complexes, qui sont eux-même regrouper, etc. Étudier tout cela demande de voir plusieurs niveaux, allant de transistors très petits à des processeurs multicœurs. Les niveaux les plus bas sont de l'électronique pur et dure, alors que ceux plus haut sont à mi-chemin entre électronique et informatique.

===Les niveaux d'abstraction en architecture des ordinateurs===

Les trois premiers niveaux sont de l'électronique pur et dure. Ils correspondent aux premiers chapitres du cours, qui porteront sur les circuits électroniques en général.
* Le premier niveau est celui des '''transistors''', des circuits intégrés, des ''wafer'' et autres circuits de très petite taille.
* Le second niveau est celui des '''portes logiques''', des circuits très basiques, très simples, à la base de tous les autres.
* Le troisième niveau est celui dit de la '''''Register Transfer Level''''', où un circuit électronique est construit à partir de circuits basiques, dont des registres et autres circuits dits combinatoires.
Les deux niveaux suivants sont de l'informatique proprement dit. C'est dans ces deux niveaux qu'on étudie les ordinateurs proprement dit, les circuits qu'il y a dedans et non l'électronique en général.
* Le quatrième niveau est celui de la '''microarchitecture''', qui étudie ce qu'il y a à l'intérieur d'un processeur, d'une mémoire, des périphériques et autres.
* Le cinquième niveau est celui de l''''architecture externe''', qui décrit l'interface du processeur, de la mémoire, d'un périphérique ou autre. Par décrire l'interface, on veut dire : comment un programmeur voit le processeur et la mémoire, comment il peut les manipuler. Une architecture externe unique peut avoir plusieurs microarchitecture, ce qui fait qu'on sépare les deux. Tout cela sera plus clair quand on passera aux chapitres sur le processeur et les mémoires.

Nous n'allons pas voir les 5 niveaux dans l'ordre, des transistors vers l'architecture externe. En réalité, nous allons procéder autrement. La première partie du cours portera sur les trois premiers niveaux, le reste sur les deux autres. Les 5 niveaux seront vus dans des chapitres séparés, du moins le plus possible. Au niveau pédagogique, tout est plus simple si on scinde les 5 niveaux. Bien sûr, il y a quelques explications qui demandent de voir plusieurs niveaux à la fois. Par exemple, dans le chapitre sur les mémoires caches, nous auront des explications portant sur la RTL, la microarchitecture du cache et son architecture externe. Mais le gros du cours tentera de séparer le plus possible les 5 niveaux.

===Les trois parties principales du cours===

Nous allons commencer par parler du binaire, avant de voir les portes logiques. Avec ces portes logiques, nous allons voir comment fabriquer des circuits basiques qui reviendront très souvent dans la suite du cours. Nous verrons les registres, les décodeurs, les additionneurs et plein d'autres circuits. Puis, nous reviendrons au niveau des transistors pour finir la première partie. La raison est que c'est plus simple de faire comme cela. Tout ce qui a trait aux transistors sert à expliquer comment fabriquer des portes logiques, et il faut expliquer les portes logiques pour voir le niveau de la RTL.

Une fois la première partie finie, nous allons voir les différents composants d'un ordinateur. Une première partie expliquera ce qu'il y a dans un ordinateur, quels sont ses composants. Nous y parlerons de l'architecture de base, de la hiérarchie mémoire, des tendances technologiques, et d'autres généralités qui serviront de base pour la suite. Puis, nous verrons dans l'ordre les bus électroniques, les mémoires RAM/ROM, le processeur, les périphériques, les mémoires de stockage (SSD et disques durs) et les mémoires caches. Pour chaque composant, nous allons voir leur architecture externe, avant de voir leur microarchitecture. La raison est que la microarchitecture ne peut se comprendre que quand on sait quelle architecture externe elle implémente.

Enfin, dans une troisième partie, nous allons voir les optimisations majeures présentes dans tous les ordinateurs modernes, avec une partie sur le pipeline et le parallélisme d'instruction, et une autre sur les architectures parallèles. Pour finir, les annexes de fin parlerons de sujets un peu à part.

&lt;noinclude&gt;
{{NavChapitre | book=Fonctionnement d'un ordinateur
           | next=L'encodage des données
           | nextText=L'encodage des données
}}
&lt;/noinclude&gt;</text>
      <sha1>m4b7m5cmn8l1lky27oqluha19apwlpp</sha1>
    </revision>
    <revision>
      <id>744135</id>
      <parentid>744131</parentid>
      <timestamp>2025-06-05T00:33:30Z</timestamp>
      <contributor>
        <username>Mewtow</username>
        <id>31375</id>
      </contributor>
      <minor />
      <comment>/* La première génération : les tubes à vide */</comment>
      <origin>744135</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="45624" sha1="aj4qnxthtqvfiae6oag69gwdwc96eva" xml:space="preserve">Pour commencer, nous allons voir qu'il existe de nombreux types d'ordinateurs. Le plus connu est certainement le PC, l'ordinateur personnel, que vous avez sans doute dans votre salon. Les ordinateurs portables sont un deuxième type d'ordinateur assez intuitif, que vous avez peut-être. Mais il y a aussi d'autres types d'ordinateurs auxquels vous n'avez jamais été confrontés.

==Les différents types d'ordinateurs==

Dans cette section, nous allons décrire rapidement les ordinateurs les plus courant, mais surtout voir ce qu'il y a à l'intérieur d'un ordinateur.

===L'ordinateur de type PC fixe===

De l'extérieur, l'ordinateur est composé d'une unité centrale sur laquelle on branche des périphériques.

[[File:Typical computer architecture systems.jpg|vignette|upright=1.5|Exemples de périphériques, connectés à une unité centrale (ici appelée à tort ''operating system'').]]

Les '''périphériques''' regroupent l'écran, la souris, le clavier, l'imprimante, et bien d'autres choses. Ils permettent à l'utilisateur d'interagir avec l'ordinateur : un clavier permet de saisir du texte sous dans un fichier, une souris enregistre des déplacements de la main en déplacement du curseur, un écran affiche des données d’images/vidéos, un haut-parleur émet du son, etc. Tout ce qui est branché sur un ordinateur est, formellement un périphérique.

L''''unité centrale''' est là où se trouvent tous les composants importants d'un ordinateur, ceux qui font des calculs, qui exécutent des logiciels, qui mémorisent vos données, etc. Voici ce à quoi ressemble l'intérieur de l'unité centrale. Trois sections sont visibles : l'alimentation électrique en haut à gauche, la carte mère en bas à gauche et en jaune/orange, les disques et lecteurs à droite des câbles. Et on voit aussi beaucoup de câbles.

[[File:Asus P5K-SEIntel E6320.jpg|centre|vignette|upright=2|Exemple d'unité centrale.]]

Tout en haut à gauche, se trouve l''''alimentation électrique''', qui convertit le courant de la prise électrique en un courant plus faible, utilisable par les autres composants. Elle émet de nombreux câbles assez gros, qui sont reliés au reste. Les PC actuels utilisent des alimentations électriques standardisées, qui fournissent trois tensions au reste de l'ordinateur : une tension de 12 Volts, une de 5 Volts, une de 3,3 Volts.

À droite, caché par la partie &quot;métallique&quot; du boitier, se trouvent les lecteurs de CD/DVD, et les disques durs. Les lecteurs CD-ROM ou DVD-ROM permettaient de lire des CD ou des DVD. Je parle au passé, car ils ont aujourd'hui disparu des ordinateurs modernes. Les '''disques durs''' sont des mémoires de stockage, qui mémorisent vos données de manière permanente. De nos jours, ils sont remplacés par des SSD, qui sont des disques durs électroniques, là où les disques durs proprement dit sont des mémoires magnétiques. Nous verrons la différence dans deux chapitres dédiés, un sur les disques durs, l'autre sur les SSD.

En bas à droite, se trouve la '''carte mère''' un support plat, en plastique ou en céramique, sur laquelle sont soudés/connectés les autres composants. Sur celle-ci, de nombreux composants sont soudés, d'autres sont branchés dessus avec des câbles, d'autres sont connectés dessus avec des connecteurs. Ils sont reliés entre eux par des fils conducteurs, le plus souvent du cuivre ou de l’aluminium, ce qui leur permet de s’échanger des données. Sur les cartes simples, ces fils sont intégrés dans la carte électronique, dans des creux du plastique. Ils portent le nom de pistes.

Avant, les disques durs, SSD et lecteurs de CD/DVD sont branchés dessus via des connecteurs dédiés, appelés des connecteurs S-ATA. De nos jours, ils sont branchés sur un autre connecteur, grâce à l'interface NVME. Toujours est-il qu'ils sont reliés à la carte mère par des câbles, ce qui montre que ce sont des sortes de périphériques interne. Ils sont placés dans le boitier, mais on aurait tout aussi bien pu les mettre à l'extérieur, vu qu'ils communiquent avec l'ordinateur par l'intermédiaire d'un câble ou d'un connecteur dédié.

Mais deux autres composants très importants sont eux placés sur la carte mère, directement. Ils ont chacun un connecteur dédié, sur lequel ils sont branchés directement, sans passer par l'intermédiaire d'un câble, mais sans être soudés non plus. Il s'agit du processeur et de la mémoire RAM, deux composants centraux des PC modernes.

[[File:Pentium III SL4CB.jpg|thumb|Processeur Pentium III.]]

Le '''processeur''' traite les données, les modifie, les manipule. Pour faire simple, il s’agit d’une grosse calculatrice hyper-puissante. Il comprend à la fois un circuit qui fait des calculs, et un circuit de contrôle qui s'occupe de séquencer les calculs dans l'ordre demandé. Il est souvent caché sous un radiateur, lui-même surmonté par un ventilateur. En effet, un processeur chauffe beaucoup, ce qui demande d'évacuer cette chaleur. Un chapitre entier expliquera pourquoi les processeurs chauffent, ainsi que les techniques utilisées pour limiter leur production de chaleur et leur consommation électrique.

La '''mémoire vive''' conserve des informations/données temporairement, tant que le processeur en a besoin. Elle prend la forme de barrettes de RAM, comme montré ci-dessous.

[[File:2 gb ddr2 667.jpg|centre|vignette|upright=2|Barrette de RAM.]]

Outre ces composants dits principaux, un ordinateur peut comprendre plusieurs composants moins importants, surtout présents sur les ordinateurs personnels. Ils sont techniquement facultatifs, mais sont très présents dans les ordinateurs personnels. Cependant, certains ordinateurs spécialisés s'en passent. Il s'agit des diverses '''cartes d'extension''' sont branchées sur la carte mère. Elles permettent d’accélérer certains calculs ou certaines applications, afin de décharger le processeur. Par exemple, la carte graphique s'occupe des calculs graphiques, qu'il s'agisse de graphismes 3D de jeux vidéos ou de l'affichage en 2D du bureau. Dans un autre registre, la carte son prend en charge le microphone et les haut-parleurs.

[[Fichier:Personal computer, exploded 4.svg|thumb|upright=1.0|Éclaté d'un ordinateur de type PC :&lt;br /&gt;
1 : Écran ;&lt;br /&gt;
2 : Carte mère ;&lt;br /&gt;
3 : Processeur ;&lt;br /&gt;
4 : Câble Parallel ATA ;&lt;br /&gt;
5 : Mémoire vive (RAM) ;&lt;br /&gt;
6 : Carte d'extension ;&lt;br /&gt;
7 : Alimentation électrique ;&lt;br /&gt;
8 : Lecteur de disque optique ;&lt;br /&gt;
9 : Disque dur ;&lt;br /&gt;
10 : Clavier ;&lt;br /&gt;
11 : Souris.]]

Si on regarde une carte mère de face, on voit un grand nombre de connecteurs, mais aussi des circuits électroniques soudés à la carte mère.

[[File:Architecture matérielle d'une carte mère.png|centre|vignette|upright=2.0|Architecture matérielle d'une carte mère]]

Les '''connecteurs''' sont là où on branche les périphériques, la carte graphique, le processeur, la mémoire, etc. Dans l'ensemble, toute carte mère contient les connecteurs suivants :
* Le processeur vient s’enchâsser dans la carte mère sur un connecteur particulier : le '''socket'''. Celui-ci varie suivant la carte mère et le processeur, ce qui est source d'incompatibilités.
* Les barrettes de mémoire RAM s’enchâssent dans un autre type de connecteurs: les '''slots mémoire'''.
* Les mémoires de masse disposent de leurs propres connecteurs : connecteurs P-ATA pour les anciens disques durs, et S-ATA pour les récents.
* Les périphériques (clavier, souris, USB, Firewire, ...) sont connectés sur un ensemble de connecteurs dédiés, localisés à l'arrière du boitier de l'unité centrale. 
* Les autres périphériques sont placés dans l'unité centrale et sont connectés via des connecteurs spécialisés. Ces périphériques sont des cartes imprimées, d'où leur nom de '''cartes filles'''. On peut notamment citer les cartes réseau, les cartes son, ou les cartes vidéo.

===Les ordinateurs portables===

[[File:Samsung QX-511 (2).JPG|vignette|Ordinateur portable Samsung QX-511 (2), pour illustration.]]

Un ordinateur portable est identique à un ordinateur de type PC. Si vous ouvrez votre ordinateur portable (attention à la garantie), vous retrouverez les mêmes composants qu'un PC à l'intérieur. Un point important est la présence d'une batterie à l'intérieur du PC portable, absente des PC fixes.

[[File:LG gram 14Z90Q mainboard with battery.jpg|centre|vignette|upright=2|LG gram 14Z90Q avec sa batterie.]]

Une fois la batterie et les circuits associés retiré, la seule différence notable est que tous les composants sont soudés sur la carte mère, au lieu d'être branchés sur des connecteurs, à part éventuellement la RAM et le disque dur.

[[File:LG gram 14Z90Q mainboard without battery.jpg|centre|vignette|upright=2|LG gram 14Z90Q sans sa batterie.]]

La RAM est parfois soudée sur la carte mère, d'autres fois sous la forme de barrettes de mémoire vive semblables à celles des PC. Dans le dernier cas, elle est connectée à des connecteurs spécifiques, ce qui permet de les changer/upgrader. Les PC portables sont parfois construits de manière à pouvoir changer la RAM facilement, en ouvrant un cache spécial, concu pour.

[[File:Lenovo G555 состав - Донор.JPG|centre|vignette|upright=2|Lenovo G555.]]

La conception d'un ordinateur portable est légèrement différente de celle d'un PC, pour des raisons thermiques. Un PC fixe a plus de place pour évacuer sa chaleur. Les ventilateurs peuvent plus facilement déplacer l'air dans le boitier, même si le flux d'air dans le boitier est éventuellement gêné par la carte graphique. Mais l'évacuation de la chaleur est assez efficace. Sur les PC portables, leur finesse fait que le trajet de l'air est beaucoup plus contraint. Évacuer la chaleur produite par l'ordinateur est plus complexe, ce qui demande d'utiliser des systèmes de refroidissement et de ventilation spécifiques.

Là où les PC fixes se débrouillent avec des radiateurs et des ventilateurs posés sur le processeur, les PC portables font autrement. Ils ne peuvent pas forcément mettre le ventilateur sur le processeur. A la place, ils mettent le ventilateur à côté, mais le processeur est surmonté par un mécanisme de transmission de la chaleur, qui transfère la chaleur du processeur vers le ventilateur.

[[File:Diagram - How a laptop cooling system works.png|centre|vignette|upright=2|Comment fonctionne le système de ventilation d'un ordinateur portable, en anglais.]]

Les difficultés pour dissiper la chaleur font que les ordinateurs portables utilisent souvent des composants peu performants, mais qui chauffent peu. En effet, nous verrons que plus un composant est puissant, plus il chauffe. La relation n'est pas parfaite, mais les processeurs haute performance chauffent plus que les modèles d'entrée ou milieu de gamme moins puissants. En conséquence, les PC portables sont souvent moins puissants que les PC fixes, même pour les modèles dit ''gaming''.

===Les serveurs et ''mainframes''===

Les grandes entreprises utilisent des ordinateurs de grande taille, très puissants, appelés des ''mainframes''. Ils sont souvent confondus avec les serveurs par le grand public, il y a une différence entre les deux. Un serveur est une fonction logicielle/réseau, pas un type d'ordinateur. Mais laissons cette différence de côté, ce qui est dit pour les ''mainframes'' sert pour les gros serveurs haute performance.

[[File:IBM Z15 mainframe.jpg|vignette|Exemple de ''mainframe''' de type IBM Z15.]]

Les anciens ''mainframes'' des années 50-80 avaient une taille pouvant être impressionnante, au point de prendre une pièce complète d'un bâtiment. Mais de nos jours, les ''mainframes'' tiennent dans une grosse armoire un peu haute. Les ''mainframes'' doivent rester allumé en permanence et ne doivent pas être éteint, sauf éventuellement quelques jours par an pour des opérations de maintenance. Ils utilisent pour cela des techniques spécifiques, avec beaucoup de redondance interne.

[[File:ACONIT hall grandes machines.jpg|centre|vignette|upright=2|''Mainframe'' ACONIT.]]

Les ''mainframes'' sont aussi conçus pour mutualiser au maximum leur utilisation, ils peuvent être utilisés par plusieurs utilisateurs à la suite, voire en même temps. Pour cela, les anciens ''mainframes'' étaient capables de faire tourner plusieurs applications distinctes l'une à la suite de l'autre, avec des commutations fréquentes entre logiciels. De nos jours, ils sont capables d'exécuter un grand nombre de tâches en même temps, grâce à la présence de plusieurs processeurs. Les ''mainframes'' modernes sont même capables de faire tourner plusieurs systèmes d'exploitation en même temps si besoin.

Les anciens ''mainframes'' étaient des ordinateurs assez simples, avec un processeur, de la mémoire RAM, un ou plusieurs disques durs, pas plus. Le ''mainframe'' était tellement énorme et cher que les entreprises n'en avaient qu'un seul pour toute l'entreprise. Les employés avaient sur leur bureau des terminaux, qui permettaient d'accéder à l'ordinateur central, mais n'étaient pas des ordinateurs. Les terminaux étaient des composants électroniques simples, avec un écran, un clavier et une souris, mais sans processeur. Ils envoyaient des données au ''mainframe'', ils en recevaient de sa part, mais tout traitement était réalisé sur le ''mainframe''. L'arrivée sur le marché des ordinateurs personnels, de type PC fixe/portable, a entrainé l'abandon de ce genre de pratique, tous les employés ont maintenant un ordinateur rien que pour eux.

{|
|-
! colspan=&quot;2&quot; | Exemples de terminaux
|-
|[[File:Terminal-in2-sm9400.jpg|centre|vignette|upright=1.5|Exemple de terminal. Notez la présence d'un écran et d'un clavier, mais l'asbence d'une unité centrale.]]
|[[File:Chromatics CT4100.jpg|vignette|upright=1.5|Autre exemple de terminal. Le clavier est couplé à un stylo CRT, qui remplacait la souris et agissait sur l'écran comme s'il était tactile.]]
|-
! colspan=&quot;2&quot; | Intérieur d'un terminal
|-
|[[File:CT1024 Monitor.jpg|vignette|upright=1.5|Terminal CT1024, sans le boitier extérieur.]]
|[[File:CT1024 Terminal System.jpg|vignette|upright=1.5|Terminal CT1024, description des composants interne.]]
|}

De nos jours, les ''mainframes'' contiennent en réalité plusieurs ordinateurs simples interconnectés via un réseau local. Un ''mainframe'' qui tient dans une armoire contient facilement une dizaine ou centaine de processeurs, plein de RAM, des disques durs séparés dans une armoire distincte, etc. Vu qu'ils communiquent uniquement via le réseau, ils n'ont pas d'interface, pas d'écran, 'entrée via clavier/souris. Le tout est commandé avec une console de commande, typiquement un ordinateur portable ou un terminal assez simple séparé de l'armoire, qui permet à un administrateur de faire des opérations de surveillance, configuration et maintenance. Il peut y avoir une console de commande pour plusieurs armoires séparées, la console peut même être dans un autre bâtiment et accéder au ''mainframe'' par le réseau.

[[File:IBM System Z9 (type 2094 inside).jpg|centre|vignette|upright=2|''Mainframe'' de type IBM System Z9. L'ordinateur portable sert de console pour qu'un administrateur fasse des opérations de surveillance, configuration et maintenance.]]

Les processeurs et la RAM sont typiquement installés sur des cartes amovibles, qui sont connectées au fond de l'armoire lors de l'installation. Il est même possible de retirer ou d'ajouter des cartes en fonctionnement, afin d'ajouter/retirer des processeurs, des disques durs, etc. Ce qui est très utile si un composant est en panne et qu'il faut le remplacer. 

[[File:IBM TotalStorage Exp400.jpg|centre|vignette|upright=2|IBM TotalStorage Exp400]]

==Un peu d'abstraction : qu'est-ce qu'un ordinateur ?==

Un ordinateur comprend donc un processeur, plusieurs mémoires, des cartes d'extension et une carte mère pour connecter le tout. Mais il s'agit là d'une description assez terre-à-terre de ce qu'est un ordinateur. Une autre description, plus abstraite, se base sur le fait qu'un ordinateur est une énorme calculatrice programmable. Elle permet d'expliquer pourquoi il y a une distinction entre processeur et mémoire, entre unité centrale et périphériques. Tout ce qui va suivre pourra vous paraitre assez abstrait, mais rassurez-vous : les prochains chapitres rendront tout cela plus concrets.

===La séparation entre entrées-sorties et traitement===

L'unité centrale peut être vue comme une énorme calculatrice ultra-puissante, qui exécute des commandes/opérations. Mais à elle seule, elle ne servirait à rien, il faut interagir avec par l'intermédiaire de plusieurs périphériques. Il existe deux types de périphériques, qui sont conceptuellement différents. Les périphériques comme le clavier ou la souris permettent d'envoyer des informations à l'ordinateur, d'agir sur celui-ci. A l'inverse, les écrans transmettent des informations dans le sens inverse : de l'ordinateur vers l'utilisateur. Les premiers sont appelés des '''entrées''', les seconds des '''sorties'''.

Dans un ordinateur, les informations sont représentées sous la forme de nombres. Toute donnée dans un ordinateur est codée avec un ou plusieurs nombres regroupés dans une donnée, un fichier, ou autre. Et la transmissions avec les entrées et sorties se fait là-encore avec des nombres. Par exemple, quand vous appuyez sur votre clavier, le clavier envoie un numéro de touche à l'unité centrale, qui indique quelle touche a été appuyée. L'image à afficher à l'écran est codée sous la forme d'une suite de nombres (un par pixel). L'image est envoyée à l'écran, qui traduit la suite de nombre en image à afficher. Les entrées traduisent des actions utilisateurs en nombres, on dit que les entrées encodent les actions utilisateur. Les sorties font la traduction inverse, elles transforment des suites de nombres en une action physique. On dit qu'elles décodent des informations.

Pour résumer, toute appareil électronique est composé par :
* Des '''entrées''' sur lesquelles l'utilisateur agit sur l'ordinateur. Les entrées transforment les actions de l'utilisateur en nombres, qui sont interprétés par l'ordinateur.
* Une '''unité de traitement''', qui manipule des nombres et fait des calculs/opérations dessus. Les nombres proviennent des entrées, du disque dur, ou d'autres sources, peu importe.
* Des '''sorties''', qui va récupèrent le résultat calculé par l'unité de traitement pour en faire quelque chose : écrire sur une imprimante ou sur un moniteur, émettre du son,...

[[File:Ordinateur théorique Simple 1.png|centre|vignette|upright=2|Ordinateur théorique Simple 1]]

L'unité de traitement proprement dite, celle qui fait les calculs, est couplée à une mémoire qui mémorise les opérandes et résultats des calculs. La séparation entre processeur et mémoire est nécessaire pour qu'un appareil électronique soit qualifié d'ordinateur. De nombreux appareils n'ont pas de séparation entre unité de traitement et mémoire, comme certaines vielles radios AM/FM.

[[File:Schéma de principe d'un ordinateur.png|centre|vignette|upright=2|Schéma de principe d'un ordinateur]]

===Un ordinateur est un appareil programmable===

Les appareils simples sont non-programmables, ce qui veut dire qu’ils sont conçus pour une utilisation particulière et qu’ils ne peuvent pas faire autre chose. Par exemple, les circuits électroniques d’un lecteur de DVD ne peuvent pas être transformé en lecteur audio ou en console de jeux... Les circuits non-programmables sont câblés une bonne fois pour toute, et on ne peut pas les modifier. On peut parfois reconfigurer le circuit, pour faire varier certains paramètres, via des interrupteurs ou des boutons, mais cela s’arrête là. Et cela pose un problème : à chaque problème qu'on veut résoudre en utilisant un automate, on doit recréer un nouveau circuit.

À l'inverse, un ordinateur n’est pas conçu pour une utilisation particulière, contrairement aux autres objets techniques. Il est possible de modifier leur fonction du jour au lendemain, on peut lui faire faire ce qu’on veut. On dit qu'ils sont '''programmables'''. Pour cela, il suffit d’utiliser un logiciel, une application, un programme (ces termes sont synonymes), qui fait ce que l'on souhaite. La totalité des logiciels présents sur un ordinateur sont des programmes comme les autres, même le système d'exploitation (Windows, Linux, ...) ne fait pas exception.

Un programme est une suite de d'instructions, chaque instruction effectuant une action dans l'ordinateur. Sur les ordinateurs modernes, la majorité de ces instructions effectuent une opération arithmétique, comme une addition, une multiplication, une soustraction, etc. Les ordinateurs modernes sont donc de grosses calculettes très puissantes, capables d'effectuer des millions d'opérations par secondes. Et qui dit opération dit nombres : un ordinateur gère nativement des nombres, qui sont codés en binaire sur la quasi-totalité des ordinateurs modernes.

Une instruction est représentée dans un ordinateur par une série de nombres : un nombre qui indique quelle opération/commande effectuer et des autres nombres pour coder les données (ou de quoi les retrouver dans l'ordinateur). L'ordinateur récupére les commandes une par une, les traduit en opération à effectuer, exécuter l'opération, et enregistre le résultat. Puis il recommence avec la commande suivante.

[[File:Ordinateur Théorique Complexe 1.png|centre|vignette|upright=3|Ordinateur Théorique Complexe. En jaune, le programme informatique, la liste de commande. Le rectangle gris est l'ordinateur proprement dit.]]

De nombreux appareils sont programmables, mais tous ne sont pas des ordinateurs. Par exemple, certains circuits programmables nommés FPGA n'en sont pas. Pour être qualifié d'ordinateur, un appareil programmable doit avoir un processeur séparé de la mémoire. De plus, il doit utiliser un '''codage numérique''', chose que nous allons aborder dans le chapitre suivant.

===Les ordinateurs à programme mémorisé ou programme externe===

Au tout début de l'informatique, on utilisait des cartes perforées en plastique, sur lesquelles on inscrivait le programme à exécuter, les données à traiter, bref : tout ce qu'on donnait à manger à l'ordinateur. Par la suite, les premiers ordinateurs grand public, comme les Amstrad ou les Commodore, utilisaient des cassettes audio magnétiques pour stocker les programmes. Dans le même style, les consoles de jeu utilisaient autrefois des cartouches de jeu, qui contenaient le programme du jeu à exécuter. Pour résumer, les anciens ordinateurs mémorisaient les programmes sur un support externe, lu par un périphérique. De tels ordinateurs sont dits à '''programme externe'''.

: D’anciens ordinateurs personnels, comme l’Amstrad ou le Commodore, permettaient de taper les programmes à exécuter à la main, au clavier, avant d’appuyer une touche pour les exécuter. Nul besoin de vous dire que les cassettes audio étaient plus pratiques.

Mais de nos jours, les programmes sont enregistrés sur le disque dur de l'ordinateur ou dans une mémoire intégrée à l'ordinateur. On dit qu'ils sont installés, ce qui est un mot bien compliqué pour dire que le programme est enregistré sur le disque dur de l’ordinateur. A défaut de disque dur, le programme/logiciel est enregistré dans une mémoire spécialisée pour le stockage. Par exemple, sur les cartes électroniques grand public de marque Arduino, les programmes sont envoyés à la carte via le port USB, mais les programmes sont enregistrés dans la carte Arduino, dans une mémoire FLASH dédiée. Disque dur ou non, le programme est mémorisé dans la mémoire de l'ordinateur. Il est possible d'installer ou de désinstaller les programmes en modifiant le contenu de la mémoire. Le terme utilisé est alors celui de '''programme stocké en mémoire'''.

Les programmes à installer sont disponibles soit sur un périphérique, comme un DVD ou une clé USB, soit sont téléchargés depuis internet. Les premiers PC fournissaient les logiciels sur des disquettes, qui contenaient un programme d'installation pour enregistrer le programme sur le disque dur de l'ordinateur. Par la suite, le support des logiciels a migré vers les CD et DVD, les logiciels devenant de plus en plus gros. De nos jours, la majorité des applications sont téléchargées depuis le net, l'usage de périphériques est devenu obsolète, même les consoles de jeu abandonnent cette méthode de distribution.

==Les générations d'ordinateurs : un historique rapide==

L'informatique a beaucoup évolué dans le temps. Et une bonne partie de cette évolution tient à l'évolution de l’électronique sous-jacente. Les ordinateurs actuels sont fabriqués avec des transistors, des petits composants électroniques qui servent d'interrupteur programmables, qu'on détaillera dans ce qui suit. Mais ça n'a pas toujours été le cas. Et cela permet de distinguer plusieurs '''générations d'ordinateurs'''.

===Les ordinateurs électro-mécaniques : les premiers ordinateurs===

Le tout premier ordinateur est le '''Z1''', un modèle unique inventé par Konrad Suze entre 1936 et 1938. Son processeur gérait non pas des nombres entiers, mais des nombres à virgule (des nombres dits flottants, pour être précis), encodés sur 22 bits. Le processeur du Z1 était capable de faire des additions et des soustractions, car il intégrait un circuit additionneur-soustracteur basique. Des circuits annexes permettaient de faire des multiplications et des divisions en enchainant des additions/soustractions successives. Il fonctionnait à une fréquence de 1 Hz, ce qui fait qu'il pouvait faire une addition/soustraction par seconde maximum.

[[File:Blue-punch-card-front.png|vignette|upright=0.5|Carte Perforée.]]

Niveau mémoire, la RAM de l'ordinateur était très limitée : seulement 16 nombres de 22 bits chacun. S'il s'agissait d'une mémoire électronique, les programmes étaient mémorisés sur une mémoire mécanique. Les programmes étaient enregistrés sur des cartes perforées, à savoir des cartes en papier dans lesquelles un 1 est codé par un trou dans le papier et un 0 par une absence de trou. Les programmes étaient exécutés par l'ordinateur quand on insérait la carte perforée dans le lecteur et qu'on appuyait sur un bouton.

[[File:German Museum of Technology, Berlin 2017 024.jpg|centre|vignette|upright=2|Réplique du Z1 au ''German Museum of Technology'' de Berlin, 2017.]]

Après sa destruction dans un bombardement, le Z1 a été reconstruit et amélioré, ce qui donné les deux ordinateurs Z2 et Z3. Quelques années plus tard, de nombreux ordinateurs ont été construits dans des laboratoires de recherche. Des grandes noms de l'histoire de l'informatique datent de cette époque : le Harvard Mark I et le Colossus Mark 1 (UK) ont tous deux été mis en service en 1944, par exemple. Ils ont servis pour les cryptanalystes pour casser les codes utilisés par les allemands pour leurs transmissions, pendant la seconde guerre mondiale.

Les ordinateurs cités dans le précédent paragraphe étaient tous des ordinateurs dit '''électro-mécaniques''', car ils mélangeaient des composants électroniques et des composants mécaniques (tout ce qui a trait aux cartes perforées, notamment). Les composants électroniques étaient soit des relais, soit des tubes à vides, les deux étant des interrupteurs commandables électriquement plus ou moins équivalents aux transistors. Les ordinateurs d'avant l'année 1944, étaient tous de ce type. Quelques ordinateurs des années 50 étaient de ce type, mais leur nombre n'a pas dépassé 30. Il faut dire qu'ils ont rapidement laissé la place à des ordinateurs purement électroniques, que nous allons voir dans ce qui suit..

===La première génération : les tubes à vide===

Les ordinateurs qui ont suivi les ordinateurs électromécaniques sont regroupés dans la '''première génération d'ordinateur'''. Ils étaient conçus avec des tubes à vide, ce qui les place entre les premiers ordinateurs électro-mécaniques et les ordinateurs utilisant des transistors. Les tubes à vide étaient assez encombrants, ils consommaient beaucoup de courant, ils chauffaient et étaient assez peu fiables. Ils tombaient en panne assez souvent. Et ils étaient assez simple à fabriquer, mais restaient malgré tout chers.

[[File:Elektronenroehren-auswahl.jpg|centre|vignette|upright=2|Tubes à vides.]]

Au vu de de la taille des  tubes à vide, les ordinateurs de l'époque étaient composé de plusieurs milliers de ces tubes, guère plus. Et malgré cela, un ordinateur prenait facilement un étage de bâtiment entier, ou au moins plusieurs pièces. La conséquence est que les ordinateurs de première génération étaient très simples, rudimentaires quand on les compare aux ordinateurs modernes. Ils ne géraient que quelques opérations simples : l'addition, la soustraction, pas grand chose de plus. A quelques exceptions près, ils ne géraient pas la multiplication et encore moins la division, cela aurait demandé trop de tubes à vides.

Une des toutes premières machines construite avec des tubes à vide était l'Atanasoff–Berry. Ce n'était pas un ordinateur, car elle ne pouvait pas exécuter de programme sans intervention humaine pour séquencer des opérations, mais c'était la première machine de calcul purement électronique, sans aucune pièce mécanique. Elle utilisait une mémoire RAM construite avec des condensateurs, ceux-ci étant placés sur des cylindres tournants. Les circuits de calcul étaient construits avec des tubes à vide et faisaient leur travail un bit à la fois. Elle fonctionnait à une fréquence de 60 Hz et pouvait faire 30 additions/soustractions par seconde. Les nombres étaient encodés sur 50 bits. 

[[File:Atanasoff Berry Computer.gif|centre|vignette|upright=2.5|Atanasoff–Berry.]]

L'arrivée de l'ENIAC en 1945 a changé la donne. Cet ordinateur a introduit plusieurs innovations majeures. La première est assez technique, il s'agit de la turing-complétude, elle a trait aux programmes qui peuvent être écrit pour un ordinateur, nous ne la détaillerons pas ici.

[[File:BabyArchitecture.png|vignette|Architecture de la Manchester Baby.]]

En 1948, le ''Manchester Baby'' a introduit une innovation extrêmement importante : le programme n'était plus mémorisé sur des cartes perforées, mais dans une mémoire électronique à l’intérieur de l'ordinateur lui-même. En clair, le ''Manchester Baby'' était le premier '''ordinateur à programme stocké en mémoire''' en français. Au-delà de ça, le Manchester Baby restait quand même très simple, c'était limite un prototype.

Niveau interface, l'ordinateur avait une console avec 32 boutons, des interrupteurs et un écran de sortie sur lequel afficher les résultats. A l'intérieur, il y avait un processeur et une RAM de 32 nombres de 32 bits, fabriquées avec des tubes Williams (abordés dans une annexe à la fin du cours). Une instruction prenant autant de place qu'un nombre en RAM, ce qui limitait les programmes à 32 instructions maximum. Le processeur gérait 8 instructions en tout, mais la seule instruction de calcul qu'il gérait était la soustraction. L'addition n'était pas supportée. Il pouvait cependant émuler l'addition à partir d'une soustraction et inversant l'opérande soustraite.

Le Manchester Mark 1 était une amélioration du Manchester Baby. Il utilisait 4500 tubes à vide. L'ordinateur gérait des nombres de 40 bits, mais les instructions étaient codées sur 20 bits. La RAM avait la même taille, à savoir 32 nombres, leur taille était simplement augmentée. Par contre, la RAM était complémentée par l’ancêtre du disque dur magnétique, à savoir un tambour magnétique, l’ancêtre du disque dur magnétique. Il contenait 40 pages, chacune ayant la même taille que la RAM. Contrairement à la Manchester Baby, son processeur gérait l'addition et quelques opérations logiques (ET et OU), en plus de la soustraction et de la comparaison.

[[File:MM1Schematic French.svg|centre|vignette|upright=2.5|Architecture de la Manchester Mark 1.]]

Par la suite, les ordinateurs commerciaux ont vu le jour. Les ordinateurs précédents provenaient de projets de recherches, souvent publics. Mais les entreprises privées se sont mises à fabriquer des ordinateurs elle-mêmes, pour les vendre à d'autres entreprises. On peut notamment citer les ordinateurs comme le UNIVAC I, le Bull Gamma 3 ou les premiers ordinateurs IBM. La performance de ces ordinateurs était nettement plus importante que leurs prédécesseurs, avec des fréquences de l'ordre de la centaine de kilo-hertz. Par exemple, le Bull Gamma 3 allait à 281 kHz, l'IBM 650 allait à 50 Khz.

===La seconde génération : le remplacement des tubes à vides par des transistors===

[[File:IBM 7070.jpg|vignette|Cartes imprimées de l'IBM 704, avec des transistors et résistances dessus.]]

La '''seconde génération''' est celle des ordinateurs fabriqués avec des '''transistors''' isolés, reliés entre avec des fils électriques. Les transistors en question possèdent trois broches, des pattes métalliques sur lesquelles on connecte des fils électriques. Le transistor s'utilise le plus souvent comme un interrupteur commandé par sa troisième broche. Le courant qui traverse les deux premières broches passe ou ne passe pas selon ce qu'on met sur la troisième.

[[File:Transistor basic flow.svg|centre|vignette|Un transistor est un morceau de conducteur, dont la conductivité est contrôlée par sa troisième broche/borne.]]

Les ordinateurs de seconde génération avaient entre 1000 et 500 000 transistors. Les capacités des ordinateurs étaient donc nettement supérieures à celles des ordinateurs de première génération. Une part non négligeable des ordinateurs de seconde génération supportait l'opération de multiplication, absente sur les ordinateurs de première génération. Néanmoins, cela variait beaucoup selon les ordinateurs.

Un exemple assez hors du commun est celui du premier modèle de l'IBM 1620. Le tout premier modèle n'avait aucun circuit de calcul, il n'était même pas capable de faire une addition ou une multiplication. A la place, il utilisait une table d'addition et une table de multiplication en mémoire RAM. Les deux tables devaient être initialisées par le logiciel lors du démarrage de la machine. La table d'addition faisait une centaine de chiffre, la table de multiplication faisait le double. Le processeur de l'ordinateur gérait des instructions pour faire des additions ou des multiplications, mais ces opérations lisaient le résultat dans la table d'addition. Les calculs étaient fait chiffre par chiffre, avec un encodage partiellement décimal, partiellement binaire (des chiffres décimaux étaient encodés en binaire, nous en reparlerons quand nous parlerons du BCD) !

[[File:KL CoreMemory.jpg|vignette|Mémoire à tore de ferrite.]]

Les transistors n'étaient utilisés que pour le processeur et les circuits annexes. La mémoire n'était pas faite en transistors, pas à cette époque. La mémoire était une mémoire aujourd'hui abandonnée, appelée une '''mémoire à tores de ferrite'''. Elle sera détaillée dans un chapitre ultérieur. Mais sachez pour le moment qu'il s'agit d'une mémoire au support magnétique, les données étant stockées sur un support magnétique.

Transistors comme tubes à vide prenaient beaucoup de place, ce qui fait que les ordinateurs étaient assez gros. Concrètement, ils prenaient une pièce de bâtiment entière dans le meilleur des cas. C'était l'époque des gros ''mainframes'', reliés à des terminaux, peu puissants comparé aux standards actuels. Seules les grandes entreprises et les grands instituts de recherche pouvaient se payer les services de ce genre d'ordinateurs. Seuls les professionnels avaient accès à ce genre d'équipement.

===La troisième génération : le circuit intégré===

[[File:D8259AC-2.jpg|vignette|Exemple de circuit intégré.]]

La troisième génération est toujours fabriquée avec des transistors, mais dont la taille a été réduite. Avec l'évolution de la technologie, les transistors ont diminué en taille, de plus en plus. Ils sont devenus tellement petits qu'ils ont finit par être regroupés dans des '''circuits intégrés''', des circuits regroupent plusieurs transistors sur la même puce de silicium. Les circuits intégrés se présentent le plus souvent sous la forme de boitiers rectangulaires, comme illustré ci-contre. D'autres ont des boitiers de forme carrées, comme ceux que l'on peut trouver sur les barrettes de mémoire RAM, ou à l'intérieur des clés USB/ disques SSD.

Lors de cette génération, les processeurs étaient fournis en pièces détachées qu'il fallait relier entre elles. Le processeur était composé de plusieurs circuits intégrés séparés, impossible de mettre un processeur dans un seul boitier. Un exemple de processeur conçu en kit est la série des Intel 3000. Elle regroupe plusieurs circuits séparés aux noms à coucher dehors, mais dont vous comprendrez ce qu'ils veulent dire dans les chapitres adéquats : l'Intel 3001 est un séquenceur, l'Intel 3002 regroupe unité de calcul et registres, le 3003 est un circuit d'anticipation de retenue complémentaire du 3002, le 3212 est une mémoire tampon, le 3214 est une unité de gestion des interruptions, les 3216/3226 sont des interfaces de bus mémoire. On pourrait aussi citer la famille de circuits intégrés AMD Am2900.

Même si le processeur était en pièce détachées, utiliser une dizaine de circuits intégrés était nettement mieux que d'utiliser plusieurs milliers de transistors individuels. En conséquence, les ordinateurs ont vu leur taille grandement réduite, passant de pièces entières à une simple armoire, voire à quelques cartes intégrées superposées. De plus, le prix des circuits intégré était abordable, du moins comparé aux ordinateurs d'avant. Le prix des ordinateurs a alors grandement décru, permettant à des entreprises et administrations de taille modeste de s'équiper d'ordinateurs.

===La quatrième génération : le microprocesseur===

[[File:MOS6502.svg|vignette|Microprocesseur, ici un processeur MOS6502, de la quatrième génération.]]

Lors de la troisième génération, les circuits intégrés regroupaient plusieurs dizaines ou centaines de transistors, mais sont rapidement montés en gamme. De centaines de transistors, ils sont passé au milliers de transistors, puis au millions et maintenant au-delà du milliard. Les transistors étaient devenus tellement petits, tellement miniaturisés, qu'il était devenu possible de mettre un processeur entier dans un circuit intégré. C'est ainsi qu'est né le microprocesseur, à savoir un processeur qui tient tout entier dans un seul circuit imprimé. La quatrième génération d’ordinateur est celle des ordinateurs basés autour d'un microprocesseur.

Les tout premiers microprocesseurs étaient des processeurs à application militaire, comme le processeur du F-14 CADC ou celui de l'Air data computer. Le tout premier microprocesseur commercialisé au grand public est le 4004 d'Intel, sorti en 1971. L'intel 4004 comprenait environ 2300 transistors, avait une fréquence de 740 MHz, pouvait faire 46 opérations différentes, et manipulait des entiers de 4 bits. Il était au départ un processeur de commande, prévu pour être intégré dans la calculatrice Busicom calculator 141-P, mais il fut utilisé pour d'autres applications quelque temps plus tard. Immédiatement après le 4004, les premiers microprocesseurs 8 bits furent commercialisés. Le 4004 fut suivi par le 8008 et quelques autres processeurs 8 bits extrêmement connus, comme le 8080 d'Intel, le 68000 de Motorola, le 6502 ou le Z80.

Les microprocesseurs permirent encore uen fois de réduire la taille des ordinateurs, qui pouvaient tenir dans un boitier de PC, ou un boitier de console de jeu. Le prix des ordinateurs a aussi chuté en même temps que les transistors était miniaturisés. C'est cette invention qui permis l'invention des consoles de jeux et des mini-ordinateurs, à savoir les ordinateurs personnels. Sans miniaturisation, on n'aurait pas d'ordinateur personnel, pas de PC fixe ou portable.

==L'organisation du cours : les différents niveaux d'explication==

Le fonctionnement d'un ordinateur est assez complexe à expliquer car les explications peuvent se faire sur plusieurs niveaux. Par plusieurs niveaux, on veut dire qu'un ordinateur est composé de composants très simples, qui sont assemblés pour donner des composants eux-même plus complexes, qui sont eux-même regrouper, etc. Étudier tout cela demande de voir plusieurs niveaux, allant de transistors très petits à des processeurs multicœurs. Les niveaux les plus bas sont de l'électronique pur et dure, alors que ceux plus haut sont à mi-chemin entre électronique et informatique.

===Les niveaux d'abstraction en architecture des ordinateurs===

Les trois premiers niveaux sont de l'électronique pur et dure. Ils correspondent aux premiers chapitres du cours, qui porteront sur les circuits électroniques en général.
* Le premier niveau est celui des '''transistors''', des circuits intégrés, des ''wafer'' et autres circuits de très petite taille.
* Le second niveau est celui des '''portes logiques''', des circuits très basiques, très simples, à la base de tous les autres.
* Le troisième niveau est celui dit de la '''''Register Transfer Level''''', où un circuit électronique est construit à partir de circuits basiques, dont des registres et autres circuits dits combinatoires.
Les deux niveaux suivants sont de l'informatique proprement dit. C'est dans ces deux niveaux qu'on étudie les ordinateurs proprement dit, les circuits qu'il y a dedans et non l'électronique en général.
* Le quatrième niveau est celui de la '''microarchitecture''', qui étudie ce qu'il y a à l'intérieur d'un processeur, d'une mémoire, des périphériques et autres.
* Le cinquième niveau est celui de l''''architecture externe''', qui décrit l'interface du processeur, de la mémoire, d'un périphérique ou autre. Par décrire l'interface, on veut dire : comment un programmeur voit le processeur et la mémoire, comment il peut les manipuler. Une architecture externe unique peut avoir plusieurs microarchitecture, ce qui fait qu'on sépare les deux. Tout cela sera plus clair quand on passera aux chapitres sur le processeur et les mémoires.

Nous n'allons pas voir les 5 niveaux dans l'ordre, des transistors vers l'architecture externe. En réalité, nous allons procéder autrement. La première partie du cours portera sur les trois premiers niveaux, le reste sur les deux autres. Les 5 niveaux seront vus dans des chapitres séparés, du moins le plus possible. Au niveau pédagogique, tout est plus simple si on scinde les 5 niveaux. Bien sûr, il y a quelques explications qui demandent de voir plusieurs niveaux à la fois. Par exemple, dans le chapitre sur les mémoires caches, nous auront des explications portant sur la RTL, la microarchitecture du cache et son architecture externe. Mais le gros du cours tentera de séparer le plus possible les 5 niveaux.

===Les trois parties principales du cours===

Nous allons commencer par parler du binaire, avant de voir les portes logiques. Avec ces portes logiques, nous allons voir comment fabriquer des circuits basiques qui reviendront très souvent dans la suite du cours. Nous verrons les registres, les décodeurs, les additionneurs et plein d'autres circuits. Puis, nous reviendrons au niveau des transistors pour finir la première partie. La raison est que c'est plus simple de faire comme cela. Tout ce qui a trait aux transistors sert à expliquer comment fabriquer des portes logiques, et il faut expliquer les portes logiques pour voir le niveau de la RTL.

Une fois la première partie finie, nous allons voir les différents composants d'un ordinateur. Une première partie expliquera ce qu'il y a dans un ordinateur, quels sont ses composants. Nous y parlerons de l'architecture de base, de la hiérarchie mémoire, des tendances technologiques, et d'autres généralités qui serviront de base pour la suite. Puis, nous verrons dans l'ordre les bus électroniques, les mémoires RAM/ROM, le processeur, les périphériques, les mémoires de stockage (SSD et disques durs) et les mémoires caches. Pour chaque composant, nous allons voir leur architecture externe, avant de voir leur microarchitecture. La raison est que la microarchitecture ne peut se comprendre que quand on sait quelle architecture externe elle implémente.

Enfin, dans une troisième partie, nous allons voir les optimisations majeures présentes dans tous les ordinateurs modernes, avec une partie sur le pipeline et le parallélisme d'instruction, et une autre sur les architectures parallèles. Pour finir, les annexes de fin parlerons de sujets un peu à part.

&lt;noinclude&gt;
{{NavChapitre | book=Fonctionnement d'un ordinateur
           | next=L'encodage des données
           | nextText=L'encodage des données
}}
&lt;/noinclude&gt;</text>
      <sha1>aj4qnxthtqvfiae6oag69gwdwc96eva</sha1>
    </revision>
    <revision>
      <id>744138</id>
      <parentid>744135</parentid>
      <timestamp>2025-06-05T00:34:29Z</timestamp>
      <contributor>
        <username>Mewtow</username>
        <id>31375</id>
      </contributor>
      <minor />
      <comment>/* La première génération : les tubes à vide */</comment>
      <origin>744138</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="45524" sha1="kjthz6twxty9jy27mzllwa4qntd0ci4" xml:space="preserve">Pour commencer, nous allons voir qu'il existe de nombreux types d'ordinateurs. Le plus connu est certainement le PC, l'ordinateur personnel, que vous avez sans doute dans votre salon. Les ordinateurs portables sont un deuxième type d'ordinateur assez intuitif, que vous avez peut-être. Mais il y a aussi d'autres types d'ordinateurs auxquels vous n'avez jamais été confrontés.

==Les différents types d'ordinateurs==

Dans cette section, nous allons décrire rapidement les ordinateurs les plus courant, mais surtout voir ce qu'il y a à l'intérieur d'un ordinateur.

===L'ordinateur de type PC fixe===

De l'extérieur, l'ordinateur est composé d'une unité centrale sur laquelle on branche des périphériques.

[[File:Typical computer architecture systems.jpg|vignette|upright=1.5|Exemples de périphériques, connectés à une unité centrale (ici appelée à tort ''operating system'').]]

Les '''périphériques''' regroupent l'écran, la souris, le clavier, l'imprimante, et bien d'autres choses. Ils permettent à l'utilisateur d'interagir avec l'ordinateur : un clavier permet de saisir du texte sous dans un fichier, une souris enregistre des déplacements de la main en déplacement du curseur, un écran affiche des données d’images/vidéos, un haut-parleur émet du son, etc. Tout ce qui est branché sur un ordinateur est, formellement un périphérique.

L''''unité centrale''' est là où se trouvent tous les composants importants d'un ordinateur, ceux qui font des calculs, qui exécutent des logiciels, qui mémorisent vos données, etc. Voici ce à quoi ressemble l'intérieur de l'unité centrale. Trois sections sont visibles : l'alimentation électrique en haut à gauche, la carte mère en bas à gauche et en jaune/orange, les disques et lecteurs à droite des câbles. Et on voit aussi beaucoup de câbles.

[[File:Asus P5K-SEIntel E6320.jpg|centre|vignette|upright=2|Exemple d'unité centrale.]]

Tout en haut à gauche, se trouve l''''alimentation électrique''', qui convertit le courant de la prise électrique en un courant plus faible, utilisable par les autres composants. Elle émet de nombreux câbles assez gros, qui sont reliés au reste. Les PC actuels utilisent des alimentations électriques standardisées, qui fournissent trois tensions au reste de l'ordinateur : une tension de 12 Volts, une de 5 Volts, une de 3,3 Volts.

À droite, caché par la partie &quot;métallique&quot; du boitier, se trouvent les lecteurs de CD/DVD, et les disques durs. Les lecteurs CD-ROM ou DVD-ROM permettaient de lire des CD ou des DVD. Je parle au passé, car ils ont aujourd'hui disparu des ordinateurs modernes. Les '''disques durs''' sont des mémoires de stockage, qui mémorisent vos données de manière permanente. De nos jours, ils sont remplacés par des SSD, qui sont des disques durs électroniques, là où les disques durs proprement dit sont des mémoires magnétiques. Nous verrons la différence dans deux chapitres dédiés, un sur les disques durs, l'autre sur les SSD.

En bas à droite, se trouve la '''carte mère''' un support plat, en plastique ou en céramique, sur laquelle sont soudés/connectés les autres composants. Sur celle-ci, de nombreux composants sont soudés, d'autres sont branchés dessus avec des câbles, d'autres sont connectés dessus avec des connecteurs. Ils sont reliés entre eux par des fils conducteurs, le plus souvent du cuivre ou de l’aluminium, ce qui leur permet de s’échanger des données. Sur les cartes simples, ces fils sont intégrés dans la carte électronique, dans des creux du plastique. Ils portent le nom de pistes.

Avant, les disques durs, SSD et lecteurs de CD/DVD sont branchés dessus via des connecteurs dédiés, appelés des connecteurs S-ATA. De nos jours, ils sont branchés sur un autre connecteur, grâce à l'interface NVME. Toujours est-il qu'ils sont reliés à la carte mère par des câbles, ce qui montre que ce sont des sortes de périphériques interne. Ils sont placés dans le boitier, mais on aurait tout aussi bien pu les mettre à l'extérieur, vu qu'ils communiquent avec l'ordinateur par l'intermédiaire d'un câble ou d'un connecteur dédié.

Mais deux autres composants très importants sont eux placés sur la carte mère, directement. Ils ont chacun un connecteur dédié, sur lequel ils sont branchés directement, sans passer par l'intermédiaire d'un câble, mais sans être soudés non plus. Il s'agit du processeur et de la mémoire RAM, deux composants centraux des PC modernes.

[[File:Pentium III SL4CB.jpg|thumb|Processeur Pentium III.]]

Le '''processeur''' traite les données, les modifie, les manipule. Pour faire simple, il s’agit d’une grosse calculatrice hyper-puissante. Il comprend à la fois un circuit qui fait des calculs, et un circuit de contrôle qui s'occupe de séquencer les calculs dans l'ordre demandé. Il est souvent caché sous un radiateur, lui-même surmonté par un ventilateur. En effet, un processeur chauffe beaucoup, ce qui demande d'évacuer cette chaleur. Un chapitre entier expliquera pourquoi les processeurs chauffent, ainsi que les techniques utilisées pour limiter leur production de chaleur et leur consommation électrique.

La '''mémoire vive''' conserve des informations/données temporairement, tant que le processeur en a besoin. Elle prend la forme de barrettes de RAM, comme montré ci-dessous.

[[File:2 gb ddr2 667.jpg|centre|vignette|upright=2|Barrette de RAM.]]

Outre ces composants dits principaux, un ordinateur peut comprendre plusieurs composants moins importants, surtout présents sur les ordinateurs personnels. Ils sont techniquement facultatifs, mais sont très présents dans les ordinateurs personnels. Cependant, certains ordinateurs spécialisés s'en passent. Il s'agit des diverses '''cartes d'extension''' sont branchées sur la carte mère. Elles permettent d’accélérer certains calculs ou certaines applications, afin de décharger le processeur. Par exemple, la carte graphique s'occupe des calculs graphiques, qu'il s'agisse de graphismes 3D de jeux vidéos ou de l'affichage en 2D du bureau. Dans un autre registre, la carte son prend en charge le microphone et les haut-parleurs.

[[Fichier:Personal computer, exploded 4.svg|thumb|upright=1.0|Éclaté d'un ordinateur de type PC :&lt;br /&gt;
1 : Écran ;&lt;br /&gt;
2 : Carte mère ;&lt;br /&gt;
3 : Processeur ;&lt;br /&gt;
4 : Câble Parallel ATA ;&lt;br /&gt;
5 : Mémoire vive (RAM) ;&lt;br /&gt;
6 : Carte d'extension ;&lt;br /&gt;
7 : Alimentation électrique ;&lt;br /&gt;
8 : Lecteur de disque optique ;&lt;br /&gt;
9 : Disque dur ;&lt;br /&gt;
10 : Clavier ;&lt;br /&gt;
11 : Souris.]]

Si on regarde une carte mère de face, on voit un grand nombre de connecteurs, mais aussi des circuits électroniques soudés à la carte mère.

[[File:Architecture matérielle d'une carte mère.png|centre|vignette|upright=2.0|Architecture matérielle d'une carte mère]]

Les '''connecteurs''' sont là où on branche les périphériques, la carte graphique, le processeur, la mémoire, etc. Dans l'ensemble, toute carte mère contient les connecteurs suivants :
* Le processeur vient s’enchâsser dans la carte mère sur un connecteur particulier : le '''socket'''. Celui-ci varie suivant la carte mère et le processeur, ce qui est source d'incompatibilités.
* Les barrettes de mémoire RAM s’enchâssent dans un autre type de connecteurs: les '''slots mémoire'''.
* Les mémoires de masse disposent de leurs propres connecteurs : connecteurs P-ATA pour les anciens disques durs, et S-ATA pour les récents.
* Les périphériques (clavier, souris, USB, Firewire, ...) sont connectés sur un ensemble de connecteurs dédiés, localisés à l'arrière du boitier de l'unité centrale. 
* Les autres périphériques sont placés dans l'unité centrale et sont connectés via des connecteurs spécialisés. Ces périphériques sont des cartes imprimées, d'où leur nom de '''cartes filles'''. On peut notamment citer les cartes réseau, les cartes son, ou les cartes vidéo.

===Les ordinateurs portables===

[[File:Samsung QX-511 (2).JPG|vignette|Ordinateur portable Samsung QX-511 (2), pour illustration.]]

Un ordinateur portable est identique à un ordinateur de type PC. Si vous ouvrez votre ordinateur portable (attention à la garantie), vous retrouverez les mêmes composants qu'un PC à l'intérieur. Un point important est la présence d'une batterie à l'intérieur du PC portable, absente des PC fixes.

[[File:LG gram 14Z90Q mainboard with battery.jpg|centre|vignette|upright=2|LG gram 14Z90Q avec sa batterie.]]

Une fois la batterie et les circuits associés retiré, la seule différence notable est que tous les composants sont soudés sur la carte mère, au lieu d'être branchés sur des connecteurs, à part éventuellement la RAM et le disque dur.

[[File:LG gram 14Z90Q mainboard without battery.jpg|centre|vignette|upright=2|LG gram 14Z90Q sans sa batterie.]]

La RAM est parfois soudée sur la carte mère, d'autres fois sous la forme de barrettes de mémoire vive semblables à celles des PC. Dans le dernier cas, elle est connectée à des connecteurs spécifiques, ce qui permet de les changer/upgrader. Les PC portables sont parfois construits de manière à pouvoir changer la RAM facilement, en ouvrant un cache spécial, concu pour.

[[File:Lenovo G555 состав - Донор.JPG|centre|vignette|upright=2|Lenovo G555.]]

La conception d'un ordinateur portable est légèrement différente de celle d'un PC, pour des raisons thermiques. Un PC fixe a plus de place pour évacuer sa chaleur. Les ventilateurs peuvent plus facilement déplacer l'air dans le boitier, même si le flux d'air dans le boitier est éventuellement gêné par la carte graphique. Mais l'évacuation de la chaleur est assez efficace. Sur les PC portables, leur finesse fait que le trajet de l'air est beaucoup plus contraint. Évacuer la chaleur produite par l'ordinateur est plus complexe, ce qui demande d'utiliser des systèmes de refroidissement et de ventilation spécifiques.

Là où les PC fixes se débrouillent avec des radiateurs et des ventilateurs posés sur le processeur, les PC portables font autrement. Ils ne peuvent pas forcément mettre le ventilateur sur le processeur. A la place, ils mettent le ventilateur à côté, mais le processeur est surmonté par un mécanisme de transmission de la chaleur, qui transfère la chaleur du processeur vers le ventilateur.

[[File:Diagram - How a laptop cooling system works.png|centre|vignette|upright=2|Comment fonctionne le système de ventilation d'un ordinateur portable, en anglais.]]

Les difficultés pour dissiper la chaleur font que les ordinateurs portables utilisent souvent des composants peu performants, mais qui chauffent peu. En effet, nous verrons que plus un composant est puissant, plus il chauffe. La relation n'est pas parfaite, mais les processeurs haute performance chauffent plus que les modèles d'entrée ou milieu de gamme moins puissants. En conséquence, les PC portables sont souvent moins puissants que les PC fixes, même pour les modèles dit ''gaming''.

===Les serveurs et ''mainframes''===

Les grandes entreprises utilisent des ordinateurs de grande taille, très puissants, appelés des ''mainframes''. Ils sont souvent confondus avec les serveurs par le grand public, il y a une différence entre les deux. Un serveur est une fonction logicielle/réseau, pas un type d'ordinateur. Mais laissons cette différence de côté, ce qui est dit pour les ''mainframes'' sert pour les gros serveurs haute performance.

[[File:IBM Z15 mainframe.jpg|vignette|Exemple de ''mainframe''' de type IBM Z15.]]

Les anciens ''mainframes'' des années 50-80 avaient une taille pouvant être impressionnante, au point de prendre une pièce complète d'un bâtiment. Mais de nos jours, les ''mainframes'' tiennent dans une grosse armoire un peu haute. Les ''mainframes'' doivent rester allumé en permanence et ne doivent pas être éteint, sauf éventuellement quelques jours par an pour des opérations de maintenance. Ils utilisent pour cela des techniques spécifiques, avec beaucoup de redondance interne.

[[File:ACONIT hall grandes machines.jpg|centre|vignette|upright=2|''Mainframe'' ACONIT.]]

Les ''mainframes'' sont aussi conçus pour mutualiser au maximum leur utilisation, ils peuvent être utilisés par plusieurs utilisateurs à la suite, voire en même temps. Pour cela, les anciens ''mainframes'' étaient capables de faire tourner plusieurs applications distinctes l'une à la suite de l'autre, avec des commutations fréquentes entre logiciels. De nos jours, ils sont capables d'exécuter un grand nombre de tâches en même temps, grâce à la présence de plusieurs processeurs. Les ''mainframes'' modernes sont même capables de faire tourner plusieurs systèmes d'exploitation en même temps si besoin.

Les anciens ''mainframes'' étaient des ordinateurs assez simples, avec un processeur, de la mémoire RAM, un ou plusieurs disques durs, pas plus. Le ''mainframe'' était tellement énorme et cher que les entreprises n'en avaient qu'un seul pour toute l'entreprise. Les employés avaient sur leur bureau des terminaux, qui permettaient d'accéder à l'ordinateur central, mais n'étaient pas des ordinateurs. Les terminaux étaient des composants électroniques simples, avec un écran, un clavier et une souris, mais sans processeur. Ils envoyaient des données au ''mainframe'', ils en recevaient de sa part, mais tout traitement était réalisé sur le ''mainframe''. L'arrivée sur le marché des ordinateurs personnels, de type PC fixe/portable, a entrainé l'abandon de ce genre de pratique, tous les employés ont maintenant un ordinateur rien que pour eux.

{|
|-
! colspan=&quot;2&quot; | Exemples de terminaux
|-
|[[File:Terminal-in2-sm9400.jpg|centre|vignette|upright=1.5|Exemple de terminal. Notez la présence d'un écran et d'un clavier, mais l'asbence d'une unité centrale.]]
|[[File:Chromatics CT4100.jpg|vignette|upright=1.5|Autre exemple de terminal. Le clavier est couplé à un stylo CRT, qui remplacait la souris et agissait sur l'écran comme s'il était tactile.]]
|-
! colspan=&quot;2&quot; | Intérieur d'un terminal
|-
|[[File:CT1024 Monitor.jpg|vignette|upright=1.5|Terminal CT1024, sans le boitier extérieur.]]
|[[File:CT1024 Terminal System.jpg|vignette|upright=1.5|Terminal CT1024, description des composants interne.]]
|}

De nos jours, les ''mainframes'' contiennent en réalité plusieurs ordinateurs simples interconnectés via un réseau local. Un ''mainframe'' qui tient dans une armoire contient facilement une dizaine ou centaine de processeurs, plein de RAM, des disques durs séparés dans une armoire distincte, etc. Vu qu'ils communiquent uniquement via le réseau, ils n'ont pas d'interface, pas d'écran, 'entrée via clavier/souris. Le tout est commandé avec une console de commande, typiquement un ordinateur portable ou un terminal assez simple séparé de l'armoire, qui permet à un administrateur de faire des opérations de surveillance, configuration et maintenance. Il peut y avoir une console de commande pour plusieurs armoires séparées, la console peut même être dans un autre bâtiment et accéder au ''mainframe'' par le réseau.

[[File:IBM System Z9 (type 2094 inside).jpg|centre|vignette|upright=2|''Mainframe'' de type IBM System Z9. L'ordinateur portable sert de console pour qu'un administrateur fasse des opérations de surveillance, configuration et maintenance.]]

Les processeurs et la RAM sont typiquement installés sur des cartes amovibles, qui sont connectées au fond de l'armoire lors de l'installation. Il est même possible de retirer ou d'ajouter des cartes en fonctionnement, afin d'ajouter/retirer des processeurs, des disques durs, etc. Ce qui est très utile si un composant est en panne et qu'il faut le remplacer. 

[[File:IBM TotalStorage Exp400.jpg|centre|vignette|upright=2|IBM TotalStorage Exp400]]

==Un peu d'abstraction : qu'est-ce qu'un ordinateur ?==

Un ordinateur comprend donc un processeur, plusieurs mémoires, des cartes d'extension et une carte mère pour connecter le tout. Mais il s'agit là d'une description assez terre-à-terre de ce qu'est un ordinateur. Une autre description, plus abstraite, se base sur le fait qu'un ordinateur est une énorme calculatrice programmable. Elle permet d'expliquer pourquoi il y a une distinction entre processeur et mémoire, entre unité centrale et périphériques. Tout ce qui va suivre pourra vous paraitre assez abstrait, mais rassurez-vous : les prochains chapitres rendront tout cela plus concrets.

===La séparation entre entrées-sorties et traitement===

L'unité centrale peut être vue comme une énorme calculatrice ultra-puissante, qui exécute des commandes/opérations. Mais à elle seule, elle ne servirait à rien, il faut interagir avec par l'intermédiaire de plusieurs périphériques. Il existe deux types de périphériques, qui sont conceptuellement différents. Les périphériques comme le clavier ou la souris permettent d'envoyer des informations à l'ordinateur, d'agir sur celui-ci. A l'inverse, les écrans transmettent des informations dans le sens inverse : de l'ordinateur vers l'utilisateur. Les premiers sont appelés des '''entrées''', les seconds des '''sorties'''.

Dans un ordinateur, les informations sont représentées sous la forme de nombres. Toute donnée dans un ordinateur est codée avec un ou plusieurs nombres regroupés dans une donnée, un fichier, ou autre. Et la transmissions avec les entrées et sorties se fait là-encore avec des nombres. Par exemple, quand vous appuyez sur votre clavier, le clavier envoie un numéro de touche à l'unité centrale, qui indique quelle touche a été appuyée. L'image à afficher à l'écran est codée sous la forme d'une suite de nombres (un par pixel). L'image est envoyée à l'écran, qui traduit la suite de nombre en image à afficher. Les entrées traduisent des actions utilisateurs en nombres, on dit que les entrées encodent les actions utilisateur. Les sorties font la traduction inverse, elles transforment des suites de nombres en une action physique. On dit qu'elles décodent des informations.

Pour résumer, toute appareil électronique est composé par :
* Des '''entrées''' sur lesquelles l'utilisateur agit sur l'ordinateur. Les entrées transforment les actions de l'utilisateur en nombres, qui sont interprétés par l'ordinateur.
* Une '''unité de traitement''', qui manipule des nombres et fait des calculs/opérations dessus. Les nombres proviennent des entrées, du disque dur, ou d'autres sources, peu importe.
* Des '''sorties''', qui va récupèrent le résultat calculé par l'unité de traitement pour en faire quelque chose : écrire sur une imprimante ou sur un moniteur, émettre du son,...

[[File:Ordinateur théorique Simple 1.png|centre|vignette|upright=2|Ordinateur théorique Simple 1]]

L'unité de traitement proprement dite, celle qui fait les calculs, est couplée à une mémoire qui mémorise les opérandes et résultats des calculs. La séparation entre processeur et mémoire est nécessaire pour qu'un appareil électronique soit qualifié d'ordinateur. De nombreux appareils n'ont pas de séparation entre unité de traitement et mémoire, comme certaines vielles radios AM/FM.

[[File:Schéma de principe d'un ordinateur.png|centre|vignette|upright=2|Schéma de principe d'un ordinateur]]

===Un ordinateur est un appareil programmable===

Les appareils simples sont non-programmables, ce qui veut dire qu’ils sont conçus pour une utilisation particulière et qu’ils ne peuvent pas faire autre chose. Par exemple, les circuits électroniques d’un lecteur de DVD ne peuvent pas être transformé en lecteur audio ou en console de jeux... Les circuits non-programmables sont câblés une bonne fois pour toute, et on ne peut pas les modifier. On peut parfois reconfigurer le circuit, pour faire varier certains paramètres, via des interrupteurs ou des boutons, mais cela s’arrête là. Et cela pose un problème : à chaque problème qu'on veut résoudre en utilisant un automate, on doit recréer un nouveau circuit.

À l'inverse, un ordinateur n’est pas conçu pour une utilisation particulière, contrairement aux autres objets techniques. Il est possible de modifier leur fonction du jour au lendemain, on peut lui faire faire ce qu’on veut. On dit qu'ils sont '''programmables'''. Pour cela, il suffit d’utiliser un logiciel, une application, un programme (ces termes sont synonymes), qui fait ce que l'on souhaite. La totalité des logiciels présents sur un ordinateur sont des programmes comme les autres, même le système d'exploitation (Windows, Linux, ...) ne fait pas exception.

Un programme est une suite de d'instructions, chaque instruction effectuant une action dans l'ordinateur. Sur les ordinateurs modernes, la majorité de ces instructions effectuent une opération arithmétique, comme une addition, une multiplication, une soustraction, etc. Les ordinateurs modernes sont donc de grosses calculettes très puissantes, capables d'effectuer des millions d'opérations par secondes. Et qui dit opération dit nombres : un ordinateur gère nativement des nombres, qui sont codés en binaire sur la quasi-totalité des ordinateurs modernes.

Une instruction est représentée dans un ordinateur par une série de nombres : un nombre qui indique quelle opération/commande effectuer et des autres nombres pour coder les données (ou de quoi les retrouver dans l'ordinateur). L'ordinateur récupére les commandes une par une, les traduit en opération à effectuer, exécuter l'opération, et enregistre le résultat. Puis il recommence avec la commande suivante.

[[File:Ordinateur Théorique Complexe 1.png|centre|vignette|upright=3|Ordinateur Théorique Complexe. En jaune, le programme informatique, la liste de commande. Le rectangle gris est l'ordinateur proprement dit.]]

De nombreux appareils sont programmables, mais tous ne sont pas des ordinateurs. Par exemple, certains circuits programmables nommés FPGA n'en sont pas. Pour être qualifié d'ordinateur, un appareil programmable doit avoir un processeur séparé de la mémoire. De plus, il doit utiliser un '''codage numérique''', chose que nous allons aborder dans le chapitre suivant.

===Les ordinateurs à programme mémorisé ou programme externe===

Au tout début de l'informatique, on utilisait des cartes perforées en plastique, sur lesquelles on inscrivait le programme à exécuter, les données à traiter, bref : tout ce qu'on donnait à manger à l'ordinateur. Par la suite, les premiers ordinateurs grand public, comme les Amstrad ou les Commodore, utilisaient des cassettes audio magnétiques pour stocker les programmes. Dans le même style, les consoles de jeu utilisaient autrefois des cartouches de jeu, qui contenaient le programme du jeu à exécuter. Pour résumer, les anciens ordinateurs mémorisaient les programmes sur un support externe, lu par un périphérique. De tels ordinateurs sont dits à '''programme externe'''.

: D’anciens ordinateurs personnels, comme l’Amstrad ou le Commodore, permettaient de taper les programmes à exécuter à la main, au clavier, avant d’appuyer une touche pour les exécuter. Nul besoin de vous dire que les cassettes audio étaient plus pratiques.

Mais de nos jours, les programmes sont enregistrés sur le disque dur de l'ordinateur ou dans une mémoire intégrée à l'ordinateur. On dit qu'ils sont installés, ce qui est un mot bien compliqué pour dire que le programme est enregistré sur le disque dur de l’ordinateur. A défaut de disque dur, le programme/logiciel est enregistré dans une mémoire spécialisée pour le stockage. Par exemple, sur les cartes électroniques grand public de marque Arduino, les programmes sont envoyés à la carte via le port USB, mais les programmes sont enregistrés dans la carte Arduino, dans une mémoire FLASH dédiée. Disque dur ou non, le programme est mémorisé dans la mémoire de l'ordinateur. Il est possible d'installer ou de désinstaller les programmes en modifiant le contenu de la mémoire. Le terme utilisé est alors celui de '''programme stocké en mémoire'''.

Les programmes à installer sont disponibles soit sur un périphérique, comme un DVD ou une clé USB, soit sont téléchargés depuis internet. Les premiers PC fournissaient les logiciels sur des disquettes, qui contenaient un programme d'installation pour enregistrer le programme sur le disque dur de l'ordinateur. Par la suite, le support des logiciels a migré vers les CD et DVD, les logiciels devenant de plus en plus gros. De nos jours, la majorité des applications sont téléchargées depuis le net, l'usage de périphériques est devenu obsolète, même les consoles de jeu abandonnent cette méthode de distribution.

==Les générations d'ordinateurs : un historique rapide==

L'informatique a beaucoup évolué dans le temps. Et une bonne partie de cette évolution tient à l'évolution de l’électronique sous-jacente. Les ordinateurs actuels sont fabriqués avec des transistors, des petits composants électroniques qui servent d'interrupteur programmables, qu'on détaillera dans ce qui suit. Mais ça n'a pas toujours été le cas. Et cela permet de distinguer plusieurs '''générations d'ordinateurs'''.

===Les ordinateurs électro-mécaniques : les premiers ordinateurs===

Le tout premier ordinateur est le '''Z1''', un modèle unique inventé par Konrad Suze entre 1936 et 1938. Son processeur gérait non pas des nombres entiers, mais des nombres à virgule (des nombres dits flottants, pour être précis), encodés sur 22 bits. Le processeur du Z1 était capable de faire des additions et des soustractions, car il intégrait un circuit additionneur-soustracteur basique. Des circuits annexes permettaient de faire des multiplications et des divisions en enchainant des additions/soustractions successives. Il fonctionnait à une fréquence de 1 Hz, ce qui fait qu'il pouvait faire une addition/soustraction par seconde maximum.

[[File:Blue-punch-card-front.png|vignette|upright=0.5|Carte Perforée.]]

Niveau mémoire, la RAM de l'ordinateur était très limitée : seulement 16 nombres de 22 bits chacun. S'il s'agissait d'une mémoire électronique, les programmes étaient mémorisés sur une mémoire mécanique. Les programmes étaient enregistrés sur des cartes perforées, à savoir des cartes en papier dans lesquelles un 1 est codé par un trou dans le papier et un 0 par une absence de trou. Les programmes étaient exécutés par l'ordinateur quand on insérait la carte perforée dans le lecteur et qu'on appuyait sur un bouton.

[[File:German Museum of Technology, Berlin 2017 024.jpg|centre|vignette|upright=2|Réplique du Z1 au ''German Museum of Technology'' de Berlin, 2017.]]

Après sa destruction dans un bombardement, le Z1 a été reconstruit et amélioré, ce qui donné les deux ordinateurs Z2 et Z3. Quelques années plus tard, de nombreux ordinateurs ont été construits dans des laboratoires de recherche. Des grandes noms de l'histoire de l'informatique datent de cette époque : le Harvard Mark I et le Colossus Mark 1 (UK) ont tous deux été mis en service en 1944, par exemple. Ils ont servis pour les cryptanalystes pour casser les codes utilisés par les allemands pour leurs transmissions, pendant la seconde guerre mondiale.

Les ordinateurs cités dans le précédent paragraphe étaient tous des ordinateurs dit '''électro-mécaniques''', car ils mélangeaient des composants électroniques et des composants mécaniques (tout ce qui a trait aux cartes perforées, notamment). Les composants électroniques étaient soit des relais, soit des tubes à vides, les deux étant des interrupteurs commandables électriquement plus ou moins équivalents aux transistors. Les ordinateurs d'avant l'année 1944, étaient tous de ce type. Quelques ordinateurs des années 50 étaient de ce type, mais leur nombre n'a pas dépassé 30. Il faut dire qu'ils ont rapidement laissé la place à des ordinateurs purement électroniques, que nous allons voir dans ce qui suit..

===La première génération : les tubes à vide===

Les ordinateurs qui ont suivi les ordinateurs électromécaniques sont regroupés dans la '''première génération d'ordinateur'''. Ils étaient conçus avec des tubes à vide, ce qui les place entre les premiers ordinateurs électro-mécaniques et les ordinateurs utilisant des transistors. Les tubes à vide étaient assez encombrants, ils consommaient beaucoup de courant, ils chauffaient et étaient assez peu fiables. Ils tombaient en panne assez souvent. Et ils étaient assez simple à fabriquer, mais restaient malgré tout chers.

[[File:Elektronenroehren-auswahl.jpg|centre|vignette|upright=2|Tubes à vides.]]

Au vu de de la taille des  tubes à vide, les ordinateurs de l'époque étaient composé de plusieurs milliers de ces tubes, guère plus. Et malgré cela, un ordinateur prenait facilement un étage de bâtiment entier, ou au moins plusieurs pièces. La conséquence est que les ordinateurs de première génération étaient très simples, rudimentaires quand on les compare aux ordinateurs modernes. Ils ne géraient que quelques opérations simples : l'addition, la soustraction, pas grand chose de plus. A quelques exceptions près, ils ne géraient pas la multiplication et encore moins la division, cela aurait demandé trop de tubes à vides.

Une des toutes premières machines construite avec des tubes à vide était l'Atanasoff–Berry. Ce n'était pas un ordinateur, car elle ne pouvait pas exécuter de programme sans intervention humaine pour séquencer des opérations, mais c'était la première machine de calcul purement électronique, sans aucune pièce mécanique. Elle utilisait une mémoire RAM construite avec des condensateurs, ceux-ci étant placés sur des cylindres tournants. Les circuits de calcul étaient construits avec des tubes à vide et faisaient leur travail un bit à la fois. Elle fonctionnait à une fréquence de 60 Hz et pouvait faire 30 additions/soustractions par seconde. Les nombres étaient encodés sur 50 bits. 

[[File:Atanasoff Berry Computer.gif|centre|vignette|upright=2.5|Atanasoff–Berry.]]

L'arrivée de l'ENIAC en 1945 a changé la donne. Cet ordinateur a introduit plusieurs innovations majeures. La première est assez technique, il s'agit de la turing-complétude, elle a trait aux programmes qui peuvent être écrit pour un ordinateur, nous ne la détaillerons pas ici.

[[File:BabyArchitecture.png|vignette|Architecture de la Manchester Baby.]]

En 1948, le ''Manchester Baby'' a introduit une innovation extrêmement importante : le programme n'était plus mémorisé sur des cartes perforées, mais dans une mémoire électronique à l’intérieur de l'ordinateur lui-même. En clair, le ''Manchester Baby'' était le premier '''ordinateur à programme stocké en mémoire''' en français. Au-delà de ça, le Manchester Baby restait quand même très simple, c'était limite un prototype.

Niveau interface, l'ordinateur avait une console avec 32 boutons, des interrupteurs et un écran de sortie sur lequel afficher les résultats. A l'intérieur, il y avait un processeur et une RAM de 32 nombres de 32 bits, fabriquées avec des tubes Williams (abordés dans une annexe à la fin du cours). Une instruction prenant autant de place qu'un nombre en RAM, ce qui limitait les programmes à 32 instructions maximum. Le processeur gérait 8 instructions en tout, mais la seule instruction de calcul qu'il gérait était la soustraction. L'addition n'était pas supportée. Il pouvait cependant émuler l'addition à partir d'une soustraction et inversant l'opérande soustraite.

Le Manchester Mark 1 était une amélioration du Manchester Baby. Il utilisait 4500 tubes à vide. L'ordinateur gérait des nombres de 40 bits, mais les instructions étaient codées sur 20 bits. La RAM avait la même taille, à savoir 32 nombres, leur taille était simplement augmentée. Par contre, la RAM était complémentée par l’ancêtre du disque dur magnétique, à savoir un tambour magnétique, l’ancêtre du disque dur magnétique. Il contenait 40 pages, chacune ayant la même taille que la RAM. Contrairement à la Manchester Baby, son processeur gérait l'addition et quelques opérations logiques (ET et OU), en plus de la soustraction et de la comparaison.

Par la suite, les ordinateurs commerciaux ont vu le jour. Les ordinateurs précédents provenaient de projets de recherches, souvent publics. Mais les entreprises privées se sont mises à fabriquer des ordinateurs elle-mêmes, pour les vendre à d'autres entreprises. On peut notamment citer les ordinateurs comme le UNIVAC I, le Bull Gamma 3 ou les premiers ordinateurs IBM. La performance de ces ordinateurs était nettement plus importante que leurs prédécesseurs, avec des fréquences de l'ordre de la centaine de kilo-hertz. Par exemple, le Bull Gamma 3 allait à 281 kHz, l'IBM 650 allait à 50 Khz.

===La seconde génération : le remplacement des tubes à vides par des transistors===

[[File:IBM 7070.jpg|vignette|Cartes imprimées de l'IBM 704, avec des transistors et résistances dessus.]]

La '''seconde génération''' est celle des ordinateurs fabriqués avec des '''transistors''' isolés, reliés entre avec des fils électriques. Les transistors en question possèdent trois broches, des pattes métalliques sur lesquelles on connecte des fils électriques. Le transistor s'utilise le plus souvent comme un interrupteur commandé par sa troisième broche. Le courant qui traverse les deux premières broches passe ou ne passe pas selon ce qu'on met sur la troisième.

[[File:Transistor basic flow.svg|centre|vignette|Un transistor est un morceau de conducteur, dont la conductivité est contrôlée par sa troisième broche/borne.]]

Les ordinateurs de seconde génération avaient entre 1000 et 500 000 transistors. Les capacités des ordinateurs étaient donc nettement supérieures à celles des ordinateurs de première génération. Une part non négligeable des ordinateurs de seconde génération supportait l'opération de multiplication, absente sur les ordinateurs de première génération. Néanmoins, cela variait beaucoup selon les ordinateurs.

Un exemple assez hors du commun est celui du premier modèle de l'IBM 1620. Le tout premier modèle n'avait aucun circuit de calcul, il n'était même pas capable de faire une addition ou une multiplication. A la place, il utilisait une table d'addition et une table de multiplication en mémoire RAM. Les deux tables devaient être initialisées par le logiciel lors du démarrage de la machine. La table d'addition faisait une centaine de chiffre, la table de multiplication faisait le double. Le processeur de l'ordinateur gérait des instructions pour faire des additions ou des multiplications, mais ces opérations lisaient le résultat dans la table d'addition. Les calculs étaient fait chiffre par chiffre, avec un encodage partiellement décimal, partiellement binaire (des chiffres décimaux étaient encodés en binaire, nous en reparlerons quand nous parlerons du BCD) !

[[File:KL CoreMemory.jpg|vignette|Mémoire à tore de ferrite.]]

Les transistors n'étaient utilisés que pour le processeur et les circuits annexes. La mémoire n'était pas faite en transistors, pas à cette époque. La mémoire était une mémoire aujourd'hui abandonnée, appelée une '''mémoire à tores de ferrite'''. Elle sera détaillée dans un chapitre ultérieur. Mais sachez pour le moment qu'il s'agit d'une mémoire au support magnétique, les données étant stockées sur un support magnétique.

Transistors comme tubes à vide prenaient beaucoup de place, ce qui fait que les ordinateurs étaient assez gros. Concrètement, ils prenaient une pièce de bâtiment entière dans le meilleur des cas. C'était l'époque des gros ''mainframes'', reliés à des terminaux, peu puissants comparé aux standards actuels. Seules les grandes entreprises et les grands instituts de recherche pouvaient se payer les services de ce genre d'ordinateurs. Seuls les professionnels avaient accès à ce genre d'équipement.

===La troisième génération : le circuit intégré===

[[File:D8259AC-2.jpg|vignette|Exemple de circuit intégré.]]

La troisième génération est toujours fabriquée avec des transistors, mais dont la taille a été réduite. Avec l'évolution de la technologie, les transistors ont diminué en taille, de plus en plus. Ils sont devenus tellement petits qu'ils ont finit par être regroupés dans des '''circuits intégrés''', des circuits regroupent plusieurs transistors sur la même puce de silicium. Les circuits intégrés se présentent le plus souvent sous la forme de boitiers rectangulaires, comme illustré ci-contre. D'autres ont des boitiers de forme carrées, comme ceux que l'on peut trouver sur les barrettes de mémoire RAM, ou à l'intérieur des clés USB/ disques SSD.

Lors de cette génération, les processeurs étaient fournis en pièces détachées qu'il fallait relier entre elles. Le processeur était composé de plusieurs circuits intégrés séparés, impossible de mettre un processeur dans un seul boitier. Un exemple de processeur conçu en kit est la série des Intel 3000. Elle regroupe plusieurs circuits séparés aux noms à coucher dehors, mais dont vous comprendrez ce qu'ils veulent dire dans les chapitres adéquats : l'Intel 3001 est un séquenceur, l'Intel 3002 regroupe unité de calcul et registres, le 3003 est un circuit d'anticipation de retenue complémentaire du 3002, le 3212 est une mémoire tampon, le 3214 est une unité de gestion des interruptions, les 3216/3226 sont des interfaces de bus mémoire. On pourrait aussi citer la famille de circuits intégrés AMD Am2900.

Même si le processeur était en pièce détachées, utiliser une dizaine de circuits intégrés était nettement mieux que d'utiliser plusieurs milliers de transistors individuels. En conséquence, les ordinateurs ont vu leur taille grandement réduite, passant de pièces entières à une simple armoire, voire à quelques cartes intégrées superposées. De plus, le prix des circuits intégré était abordable, du moins comparé aux ordinateurs d'avant. Le prix des ordinateurs a alors grandement décru, permettant à des entreprises et administrations de taille modeste de s'équiper d'ordinateurs.

===La quatrième génération : le microprocesseur===

[[File:MOS6502.svg|vignette|Microprocesseur, ici un processeur MOS6502, de la quatrième génération.]]

Lors de la troisième génération, les circuits intégrés regroupaient plusieurs dizaines ou centaines de transistors, mais sont rapidement montés en gamme. De centaines de transistors, ils sont passé au milliers de transistors, puis au millions et maintenant au-delà du milliard. Les transistors étaient devenus tellement petits, tellement miniaturisés, qu'il était devenu possible de mettre un processeur entier dans un circuit intégré. C'est ainsi qu'est né le microprocesseur, à savoir un processeur qui tient tout entier dans un seul circuit imprimé. La quatrième génération d’ordinateur est celle des ordinateurs basés autour d'un microprocesseur.

Les tout premiers microprocesseurs étaient des processeurs à application militaire, comme le processeur du F-14 CADC ou celui de l'Air data computer. Le tout premier microprocesseur commercialisé au grand public est le 4004 d'Intel, sorti en 1971. L'intel 4004 comprenait environ 2300 transistors, avait une fréquence de 740 MHz, pouvait faire 46 opérations différentes, et manipulait des entiers de 4 bits. Il était au départ un processeur de commande, prévu pour être intégré dans la calculatrice Busicom calculator 141-P, mais il fut utilisé pour d'autres applications quelque temps plus tard. Immédiatement après le 4004, les premiers microprocesseurs 8 bits furent commercialisés. Le 4004 fut suivi par le 8008 et quelques autres processeurs 8 bits extrêmement connus, comme le 8080 d'Intel, le 68000 de Motorola, le 6502 ou le Z80.

Les microprocesseurs permirent encore uen fois de réduire la taille des ordinateurs, qui pouvaient tenir dans un boitier de PC, ou un boitier de console de jeu. Le prix des ordinateurs a aussi chuté en même temps que les transistors était miniaturisés. C'est cette invention qui permis l'invention des consoles de jeux et des mini-ordinateurs, à savoir les ordinateurs personnels. Sans miniaturisation, on n'aurait pas d'ordinateur personnel, pas de PC fixe ou portable.

==L'organisation du cours : les différents niveaux d'explication==

Le fonctionnement d'un ordinateur est assez complexe à expliquer car les explications peuvent se faire sur plusieurs niveaux. Par plusieurs niveaux, on veut dire qu'un ordinateur est composé de composants très simples, qui sont assemblés pour donner des composants eux-même plus complexes, qui sont eux-même regrouper, etc. Étudier tout cela demande de voir plusieurs niveaux, allant de transistors très petits à des processeurs multicœurs. Les niveaux les plus bas sont de l'électronique pur et dure, alors que ceux plus haut sont à mi-chemin entre électronique et informatique.

===Les niveaux d'abstraction en architecture des ordinateurs===

Les trois premiers niveaux sont de l'électronique pur et dure. Ils correspondent aux premiers chapitres du cours, qui porteront sur les circuits électroniques en général.
* Le premier niveau est celui des '''transistors''', des circuits intégrés, des ''wafer'' et autres circuits de très petite taille.
* Le second niveau est celui des '''portes logiques''', des circuits très basiques, très simples, à la base de tous les autres.
* Le troisième niveau est celui dit de la '''''Register Transfer Level''''', où un circuit électronique est construit à partir de circuits basiques, dont des registres et autres circuits dits combinatoires.
Les deux niveaux suivants sont de l'informatique proprement dit. C'est dans ces deux niveaux qu'on étudie les ordinateurs proprement dit, les circuits qu'il y a dedans et non l'électronique en général.
* Le quatrième niveau est celui de la '''microarchitecture''', qui étudie ce qu'il y a à l'intérieur d'un processeur, d'une mémoire, des périphériques et autres.
* Le cinquième niveau est celui de l''''architecture externe''', qui décrit l'interface du processeur, de la mémoire, d'un périphérique ou autre. Par décrire l'interface, on veut dire : comment un programmeur voit le processeur et la mémoire, comment il peut les manipuler. Une architecture externe unique peut avoir plusieurs microarchitecture, ce qui fait qu'on sépare les deux. Tout cela sera plus clair quand on passera aux chapitres sur le processeur et les mémoires.

Nous n'allons pas voir les 5 niveaux dans l'ordre, des transistors vers l'architecture externe. En réalité, nous allons procéder autrement. La première partie du cours portera sur les trois premiers niveaux, le reste sur les deux autres. Les 5 niveaux seront vus dans des chapitres séparés, du moins le plus possible. Au niveau pédagogique, tout est plus simple si on scinde les 5 niveaux. Bien sûr, il y a quelques explications qui demandent de voir plusieurs niveaux à la fois. Par exemple, dans le chapitre sur les mémoires caches, nous auront des explications portant sur la RTL, la microarchitecture du cache et son architecture externe. Mais le gros du cours tentera de séparer le plus possible les 5 niveaux.

===Les trois parties principales du cours===

Nous allons commencer par parler du binaire, avant de voir les portes logiques. Avec ces portes logiques, nous allons voir comment fabriquer des circuits basiques qui reviendront très souvent dans la suite du cours. Nous verrons les registres, les décodeurs, les additionneurs et plein d'autres circuits. Puis, nous reviendrons au niveau des transistors pour finir la première partie. La raison est que c'est plus simple de faire comme cela. Tout ce qui a trait aux transistors sert à expliquer comment fabriquer des portes logiques, et il faut expliquer les portes logiques pour voir le niveau de la RTL.

Une fois la première partie finie, nous allons voir les différents composants d'un ordinateur. Une première partie expliquera ce qu'il y a dans un ordinateur, quels sont ses composants. Nous y parlerons de l'architecture de base, de la hiérarchie mémoire, des tendances technologiques, et d'autres généralités qui serviront de base pour la suite. Puis, nous verrons dans l'ordre les bus électroniques, les mémoires RAM/ROM, le processeur, les périphériques, les mémoires de stockage (SSD et disques durs) et les mémoires caches. Pour chaque composant, nous allons voir leur architecture externe, avant de voir leur microarchitecture. La raison est que la microarchitecture ne peut se comprendre que quand on sait quelle architecture externe elle implémente.

Enfin, dans une troisième partie, nous allons voir les optimisations majeures présentes dans tous les ordinateurs modernes, avec une partie sur le pipeline et le parallélisme d'instruction, et une autre sur les architectures parallèles. Pour finir, les annexes de fin parlerons de sujets un peu à part.

&lt;noinclude&gt;
{{NavChapitre | book=Fonctionnement d'un ordinateur
           | next=L'encodage des données
           | nextText=L'encodage des données
}}
&lt;/noinclude&gt;</text>
      <sha1>kjthz6twxty9jy27mzllwa4qntd0ci4</sha1>
    </revision>
    <revision>
      <id>744142</id>
      <parentid>744138</parentid>
      <timestamp>2025-06-05T00:44:05Z</timestamp>
      <contributor>
        <username>Mewtow</username>
        <id>31375</id>
      </contributor>
      <minor />
      <comment>/* Les générations d'ordinateurs : un historique rapide */</comment>
      <origin>744142</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="45525" sha1="krr1qhs0tc9ch5ex5gx2owdu5kxt08l" xml:space="preserve">Pour commencer, nous allons voir qu'il existe de nombreux types d'ordinateurs. Le plus connu est certainement le PC, l'ordinateur personnel, que vous avez sans doute dans votre salon. Les ordinateurs portables sont un deuxième type d'ordinateur assez intuitif, que vous avez peut-être. Mais il y a aussi d'autres types d'ordinateurs auxquels vous n'avez jamais été confrontés.

==Les différents types d'ordinateurs==

Dans cette section, nous allons décrire rapidement les ordinateurs les plus courant, mais surtout voir ce qu'il y a à l'intérieur d'un ordinateur.

===L'ordinateur de type PC fixe===

De l'extérieur, l'ordinateur est composé d'une unité centrale sur laquelle on branche des périphériques.

[[File:Typical computer architecture systems.jpg|vignette|upright=1.5|Exemples de périphériques, connectés à une unité centrale (ici appelée à tort ''operating system'').]]

Les '''périphériques''' regroupent l'écran, la souris, le clavier, l'imprimante, et bien d'autres choses. Ils permettent à l'utilisateur d'interagir avec l'ordinateur : un clavier permet de saisir du texte sous dans un fichier, une souris enregistre des déplacements de la main en déplacement du curseur, un écran affiche des données d’images/vidéos, un haut-parleur émet du son, etc. Tout ce qui est branché sur un ordinateur est, formellement un périphérique.

L''''unité centrale''' est là où se trouvent tous les composants importants d'un ordinateur, ceux qui font des calculs, qui exécutent des logiciels, qui mémorisent vos données, etc. Voici ce à quoi ressemble l'intérieur de l'unité centrale. Trois sections sont visibles : l'alimentation électrique en haut à gauche, la carte mère en bas à gauche et en jaune/orange, les disques et lecteurs à droite des câbles. Et on voit aussi beaucoup de câbles.

[[File:Asus P5K-SEIntel E6320.jpg|centre|vignette|upright=2|Exemple d'unité centrale.]]

Tout en haut à gauche, se trouve l''''alimentation électrique''', qui convertit le courant de la prise électrique en un courant plus faible, utilisable par les autres composants. Elle émet de nombreux câbles assez gros, qui sont reliés au reste. Les PC actuels utilisent des alimentations électriques standardisées, qui fournissent trois tensions au reste de l'ordinateur : une tension de 12 Volts, une de 5 Volts, une de 3,3 Volts.

À droite, caché par la partie &quot;métallique&quot; du boitier, se trouvent les lecteurs de CD/DVD, et les disques durs. Les lecteurs CD-ROM ou DVD-ROM permettaient de lire des CD ou des DVD. Je parle au passé, car ils ont aujourd'hui disparu des ordinateurs modernes. Les '''disques durs''' sont des mémoires de stockage, qui mémorisent vos données de manière permanente. De nos jours, ils sont remplacés par des SSD, qui sont des disques durs électroniques, là où les disques durs proprement dit sont des mémoires magnétiques. Nous verrons la différence dans deux chapitres dédiés, un sur les disques durs, l'autre sur les SSD.

En bas à droite, se trouve la '''carte mère''' un support plat, en plastique ou en céramique, sur laquelle sont soudés/connectés les autres composants. Sur celle-ci, de nombreux composants sont soudés, d'autres sont branchés dessus avec des câbles, d'autres sont connectés dessus avec des connecteurs. Ils sont reliés entre eux par des fils conducteurs, le plus souvent du cuivre ou de l’aluminium, ce qui leur permet de s’échanger des données. Sur les cartes simples, ces fils sont intégrés dans la carte électronique, dans des creux du plastique. Ils portent le nom de pistes.

Avant, les disques durs, SSD et lecteurs de CD/DVD sont branchés dessus via des connecteurs dédiés, appelés des connecteurs S-ATA. De nos jours, ils sont branchés sur un autre connecteur, grâce à l'interface NVME. Toujours est-il qu'ils sont reliés à la carte mère par des câbles, ce qui montre que ce sont des sortes de périphériques interne. Ils sont placés dans le boitier, mais on aurait tout aussi bien pu les mettre à l'extérieur, vu qu'ils communiquent avec l'ordinateur par l'intermédiaire d'un câble ou d'un connecteur dédié.

Mais deux autres composants très importants sont eux placés sur la carte mère, directement. Ils ont chacun un connecteur dédié, sur lequel ils sont branchés directement, sans passer par l'intermédiaire d'un câble, mais sans être soudés non plus. Il s'agit du processeur et de la mémoire RAM, deux composants centraux des PC modernes.

[[File:Pentium III SL4CB.jpg|thumb|Processeur Pentium III.]]

Le '''processeur''' traite les données, les modifie, les manipule. Pour faire simple, il s’agit d’une grosse calculatrice hyper-puissante. Il comprend à la fois un circuit qui fait des calculs, et un circuit de contrôle qui s'occupe de séquencer les calculs dans l'ordre demandé. Il est souvent caché sous un radiateur, lui-même surmonté par un ventilateur. En effet, un processeur chauffe beaucoup, ce qui demande d'évacuer cette chaleur. Un chapitre entier expliquera pourquoi les processeurs chauffent, ainsi que les techniques utilisées pour limiter leur production de chaleur et leur consommation électrique.

La '''mémoire vive''' conserve des informations/données temporairement, tant que le processeur en a besoin. Elle prend la forme de barrettes de RAM, comme montré ci-dessous.

[[File:2 gb ddr2 667.jpg|centre|vignette|upright=2|Barrette de RAM.]]

Outre ces composants dits principaux, un ordinateur peut comprendre plusieurs composants moins importants, surtout présents sur les ordinateurs personnels. Ils sont techniquement facultatifs, mais sont très présents dans les ordinateurs personnels. Cependant, certains ordinateurs spécialisés s'en passent. Il s'agit des diverses '''cartes d'extension''' sont branchées sur la carte mère. Elles permettent d’accélérer certains calculs ou certaines applications, afin de décharger le processeur. Par exemple, la carte graphique s'occupe des calculs graphiques, qu'il s'agisse de graphismes 3D de jeux vidéos ou de l'affichage en 2D du bureau. Dans un autre registre, la carte son prend en charge le microphone et les haut-parleurs.

[[Fichier:Personal computer, exploded 4.svg|thumb|upright=1.0|Éclaté d'un ordinateur de type PC :&lt;br /&gt;
1 : Écran ;&lt;br /&gt;
2 : Carte mère ;&lt;br /&gt;
3 : Processeur ;&lt;br /&gt;
4 : Câble Parallel ATA ;&lt;br /&gt;
5 : Mémoire vive (RAM) ;&lt;br /&gt;
6 : Carte d'extension ;&lt;br /&gt;
7 : Alimentation électrique ;&lt;br /&gt;
8 : Lecteur de disque optique ;&lt;br /&gt;
9 : Disque dur ;&lt;br /&gt;
10 : Clavier ;&lt;br /&gt;
11 : Souris.]]

Si on regarde une carte mère de face, on voit un grand nombre de connecteurs, mais aussi des circuits électroniques soudés à la carte mère.

[[File:Architecture matérielle d'une carte mère.png|centre|vignette|upright=2.0|Architecture matérielle d'une carte mère]]

Les '''connecteurs''' sont là où on branche les périphériques, la carte graphique, le processeur, la mémoire, etc. Dans l'ensemble, toute carte mère contient les connecteurs suivants :
* Le processeur vient s’enchâsser dans la carte mère sur un connecteur particulier : le '''socket'''. Celui-ci varie suivant la carte mère et le processeur, ce qui est source d'incompatibilités.
* Les barrettes de mémoire RAM s’enchâssent dans un autre type de connecteurs: les '''slots mémoire'''.
* Les mémoires de masse disposent de leurs propres connecteurs : connecteurs P-ATA pour les anciens disques durs, et S-ATA pour les récents.
* Les périphériques (clavier, souris, USB, Firewire, ...) sont connectés sur un ensemble de connecteurs dédiés, localisés à l'arrière du boitier de l'unité centrale. 
* Les autres périphériques sont placés dans l'unité centrale et sont connectés via des connecteurs spécialisés. Ces périphériques sont des cartes imprimées, d'où leur nom de '''cartes filles'''. On peut notamment citer les cartes réseau, les cartes son, ou les cartes vidéo.

===Les ordinateurs portables===

[[File:Samsung QX-511 (2).JPG|vignette|Ordinateur portable Samsung QX-511 (2), pour illustration.]]

Un ordinateur portable est identique à un ordinateur de type PC. Si vous ouvrez votre ordinateur portable (attention à la garantie), vous retrouverez les mêmes composants qu'un PC à l'intérieur. Un point important est la présence d'une batterie à l'intérieur du PC portable, absente des PC fixes.

[[File:LG gram 14Z90Q mainboard with battery.jpg|centre|vignette|upright=2|LG gram 14Z90Q avec sa batterie.]]

Une fois la batterie et les circuits associés retiré, la seule différence notable est que tous les composants sont soudés sur la carte mère, au lieu d'être branchés sur des connecteurs, à part éventuellement la RAM et le disque dur.

[[File:LG gram 14Z90Q mainboard without battery.jpg|centre|vignette|upright=2|LG gram 14Z90Q sans sa batterie.]]

La RAM est parfois soudée sur la carte mère, d'autres fois sous la forme de barrettes de mémoire vive semblables à celles des PC. Dans le dernier cas, elle est connectée à des connecteurs spécifiques, ce qui permet de les changer/upgrader. Les PC portables sont parfois construits de manière à pouvoir changer la RAM facilement, en ouvrant un cache spécial, concu pour.

[[File:Lenovo G555 состав - Донор.JPG|centre|vignette|upright=2|Lenovo G555.]]

La conception d'un ordinateur portable est légèrement différente de celle d'un PC, pour des raisons thermiques. Un PC fixe a plus de place pour évacuer sa chaleur. Les ventilateurs peuvent plus facilement déplacer l'air dans le boitier, même si le flux d'air dans le boitier est éventuellement gêné par la carte graphique. Mais l'évacuation de la chaleur est assez efficace. Sur les PC portables, leur finesse fait que le trajet de l'air est beaucoup plus contraint. Évacuer la chaleur produite par l'ordinateur est plus complexe, ce qui demande d'utiliser des systèmes de refroidissement et de ventilation spécifiques.

Là où les PC fixes se débrouillent avec des radiateurs et des ventilateurs posés sur le processeur, les PC portables font autrement. Ils ne peuvent pas forcément mettre le ventilateur sur le processeur. A la place, ils mettent le ventilateur à côté, mais le processeur est surmonté par un mécanisme de transmission de la chaleur, qui transfère la chaleur du processeur vers le ventilateur.

[[File:Diagram - How a laptop cooling system works.png|centre|vignette|upright=2|Comment fonctionne le système de ventilation d'un ordinateur portable, en anglais.]]

Les difficultés pour dissiper la chaleur font que les ordinateurs portables utilisent souvent des composants peu performants, mais qui chauffent peu. En effet, nous verrons que plus un composant est puissant, plus il chauffe. La relation n'est pas parfaite, mais les processeurs haute performance chauffent plus que les modèles d'entrée ou milieu de gamme moins puissants. En conséquence, les PC portables sont souvent moins puissants que les PC fixes, même pour les modèles dit ''gaming''.

===Les serveurs et ''mainframes''===

Les grandes entreprises utilisent des ordinateurs de grande taille, très puissants, appelés des ''mainframes''. Ils sont souvent confondus avec les serveurs par le grand public, il y a une différence entre les deux. Un serveur est une fonction logicielle/réseau, pas un type d'ordinateur. Mais laissons cette différence de côté, ce qui est dit pour les ''mainframes'' sert pour les gros serveurs haute performance.

[[File:IBM Z15 mainframe.jpg|vignette|Exemple de ''mainframe''' de type IBM Z15.]]

Les anciens ''mainframes'' des années 50-80 avaient une taille pouvant être impressionnante, au point de prendre une pièce complète d'un bâtiment. Mais de nos jours, les ''mainframes'' tiennent dans une grosse armoire un peu haute. Les ''mainframes'' doivent rester allumé en permanence et ne doivent pas être éteint, sauf éventuellement quelques jours par an pour des opérations de maintenance. Ils utilisent pour cela des techniques spécifiques, avec beaucoup de redondance interne.

[[File:ACONIT hall grandes machines.jpg|centre|vignette|upright=2|''Mainframe'' ACONIT.]]

Les ''mainframes'' sont aussi conçus pour mutualiser au maximum leur utilisation, ils peuvent être utilisés par plusieurs utilisateurs à la suite, voire en même temps. Pour cela, les anciens ''mainframes'' étaient capables de faire tourner plusieurs applications distinctes l'une à la suite de l'autre, avec des commutations fréquentes entre logiciels. De nos jours, ils sont capables d'exécuter un grand nombre de tâches en même temps, grâce à la présence de plusieurs processeurs. Les ''mainframes'' modernes sont même capables de faire tourner plusieurs systèmes d'exploitation en même temps si besoin.

Les anciens ''mainframes'' étaient des ordinateurs assez simples, avec un processeur, de la mémoire RAM, un ou plusieurs disques durs, pas plus. Le ''mainframe'' était tellement énorme et cher que les entreprises n'en avaient qu'un seul pour toute l'entreprise. Les employés avaient sur leur bureau des terminaux, qui permettaient d'accéder à l'ordinateur central, mais n'étaient pas des ordinateurs. Les terminaux étaient des composants électroniques simples, avec un écran, un clavier et une souris, mais sans processeur. Ils envoyaient des données au ''mainframe'', ils en recevaient de sa part, mais tout traitement était réalisé sur le ''mainframe''. L'arrivée sur le marché des ordinateurs personnels, de type PC fixe/portable, a entrainé l'abandon de ce genre de pratique, tous les employés ont maintenant un ordinateur rien que pour eux.

{|
|-
! colspan=&quot;2&quot; | Exemples de terminaux
|-
|[[File:Terminal-in2-sm9400.jpg|centre|vignette|upright=1.5|Exemple de terminal. Notez la présence d'un écran et d'un clavier, mais l'asbence d'une unité centrale.]]
|[[File:Chromatics CT4100.jpg|vignette|upright=1.5|Autre exemple de terminal. Le clavier est couplé à un stylo CRT, qui remplacait la souris et agissait sur l'écran comme s'il était tactile.]]
|-
! colspan=&quot;2&quot; | Intérieur d'un terminal
|-
|[[File:CT1024 Monitor.jpg|vignette|upright=1.5|Terminal CT1024, sans le boitier extérieur.]]
|[[File:CT1024 Terminal System.jpg|vignette|upright=1.5|Terminal CT1024, description des composants interne.]]
|}

De nos jours, les ''mainframes'' contiennent en réalité plusieurs ordinateurs simples interconnectés via un réseau local. Un ''mainframe'' qui tient dans une armoire contient facilement une dizaine ou centaine de processeurs, plein de RAM, des disques durs séparés dans une armoire distincte, etc. Vu qu'ils communiquent uniquement via le réseau, ils n'ont pas d'interface, pas d'écran, 'entrée via clavier/souris. Le tout est commandé avec une console de commande, typiquement un ordinateur portable ou un terminal assez simple séparé de l'armoire, qui permet à un administrateur de faire des opérations de surveillance, configuration et maintenance. Il peut y avoir une console de commande pour plusieurs armoires séparées, la console peut même être dans un autre bâtiment et accéder au ''mainframe'' par le réseau.

[[File:IBM System Z9 (type 2094 inside).jpg|centre|vignette|upright=2|''Mainframe'' de type IBM System Z9. L'ordinateur portable sert de console pour qu'un administrateur fasse des opérations de surveillance, configuration et maintenance.]]

Les processeurs et la RAM sont typiquement installés sur des cartes amovibles, qui sont connectées au fond de l'armoire lors de l'installation. Il est même possible de retirer ou d'ajouter des cartes en fonctionnement, afin d'ajouter/retirer des processeurs, des disques durs, etc. Ce qui est très utile si un composant est en panne et qu'il faut le remplacer. 

[[File:IBM TotalStorage Exp400.jpg|centre|vignette|upright=2|IBM TotalStorage Exp400]]

==Un peu d'abstraction : qu'est-ce qu'un ordinateur ?==

Un ordinateur comprend donc un processeur, plusieurs mémoires, des cartes d'extension et une carte mère pour connecter le tout. Mais il s'agit là d'une description assez terre-à-terre de ce qu'est un ordinateur. Une autre description, plus abstraite, se base sur le fait qu'un ordinateur est une énorme calculatrice programmable. Elle permet d'expliquer pourquoi il y a une distinction entre processeur et mémoire, entre unité centrale et périphériques. Tout ce qui va suivre pourra vous paraitre assez abstrait, mais rassurez-vous : les prochains chapitres rendront tout cela plus concrets.

===La séparation entre entrées-sorties et traitement===

L'unité centrale peut être vue comme une énorme calculatrice ultra-puissante, qui exécute des commandes/opérations. Mais à elle seule, elle ne servirait à rien, il faut interagir avec par l'intermédiaire de plusieurs périphériques. Il existe deux types de périphériques, qui sont conceptuellement différents. Les périphériques comme le clavier ou la souris permettent d'envoyer des informations à l'ordinateur, d'agir sur celui-ci. A l'inverse, les écrans transmettent des informations dans le sens inverse : de l'ordinateur vers l'utilisateur. Les premiers sont appelés des '''entrées''', les seconds des '''sorties'''.

Dans un ordinateur, les informations sont représentées sous la forme de nombres. Toute donnée dans un ordinateur est codée avec un ou plusieurs nombres regroupés dans une donnée, un fichier, ou autre. Et la transmissions avec les entrées et sorties se fait là-encore avec des nombres. Par exemple, quand vous appuyez sur votre clavier, le clavier envoie un numéro de touche à l'unité centrale, qui indique quelle touche a été appuyée. L'image à afficher à l'écran est codée sous la forme d'une suite de nombres (un par pixel). L'image est envoyée à l'écran, qui traduit la suite de nombre en image à afficher. Les entrées traduisent des actions utilisateurs en nombres, on dit que les entrées encodent les actions utilisateur. Les sorties font la traduction inverse, elles transforment des suites de nombres en une action physique. On dit qu'elles décodent des informations.

Pour résumer, toute appareil électronique est composé par :
* Des '''entrées''' sur lesquelles l'utilisateur agit sur l'ordinateur. Les entrées transforment les actions de l'utilisateur en nombres, qui sont interprétés par l'ordinateur.
* Une '''unité de traitement''', qui manipule des nombres et fait des calculs/opérations dessus. Les nombres proviennent des entrées, du disque dur, ou d'autres sources, peu importe.
* Des '''sorties''', qui va récupèrent le résultat calculé par l'unité de traitement pour en faire quelque chose : écrire sur une imprimante ou sur un moniteur, émettre du son,...

[[File:Ordinateur théorique Simple 1.png|centre|vignette|upright=2|Ordinateur théorique Simple 1]]

L'unité de traitement proprement dite, celle qui fait les calculs, est couplée à une mémoire qui mémorise les opérandes et résultats des calculs. La séparation entre processeur et mémoire est nécessaire pour qu'un appareil électronique soit qualifié d'ordinateur. De nombreux appareils n'ont pas de séparation entre unité de traitement et mémoire, comme certaines vielles radios AM/FM.

[[File:Schéma de principe d'un ordinateur.png|centre|vignette|upright=2|Schéma de principe d'un ordinateur]]

===Un ordinateur est un appareil programmable===

Les appareils simples sont non-programmables, ce qui veut dire qu’ils sont conçus pour une utilisation particulière et qu’ils ne peuvent pas faire autre chose. Par exemple, les circuits électroniques d’un lecteur de DVD ne peuvent pas être transformé en lecteur audio ou en console de jeux... Les circuits non-programmables sont câblés une bonne fois pour toute, et on ne peut pas les modifier. On peut parfois reconfigurer le circuit, pour faire varier certains paramètres, via des interrupteurs ou des boutons, mais cela s’arrête là. Et cela pose un problème : à chaque problème qu'on veut résoudre en utilisant un automate, on doit recréer un nouveau circuit.

À l'inverse, un ordinateur n’est pas conçu pour une utilisation particulière, contrairement aux autres objets techniques. Il est possible de modifier leur fonction du jour au lendemain, on peut lui faire faire ce qu’on veut. On dit qu'ils sont '''programmables'''. Pour cela, il suffit d’utiliser un logiciel, une application, un programme (ces termes sont synonymes), qui fait ce que l'on souhaite. La totalité des logiciels présents sur un ordinateur sont des programmes comme les autres, même le système d'exploitation (Windows, Linux, ...) ne fait pas exception.

Un programme est une suite de d'instructions, chaque instruction effectuant une action dans l'ordinateur. Sur les ordinateurs modernes, la majorité de ces instructions effectuent une opération arithmétique, comme une addition, une multiplication, une soustraction, etc. Les ordinateurs modernes sont donc de grosses calculettes très puissantes, capables d'effectuer des millions d'opérations par secondes. Et qui dit opération dit nombres : un ordinateur gère nativement des nombres, qui sont codés en binaire sur la quasi-totalité des ordinateurs modernes.

Une instruction est représentée dans un ordinateur par une série de nombres : un nombre qui indique quelle opération/commande effectuer et des autres nombres pour coder les données (ou de quoi les retrouver dans l'ordinateur). L'ordinateur récupére les commandes une par une, les traduit en opération à effectuer, exécuter l'opération, et enregistre le résultat. Puis il recommence avec la commande suivante.

[[File:Ordinateur Théorique Complexe 1.png|centre|vignette|upright=3|Ordinateur Théorique Complexe. En jaune, le programme informatique, la liste de commande. Le rectangle gris est l'ordinateur proprement dit.]]

De nombreux appareils sont programmables, mais tous ne sont pas des ordinateurs. Par exemple, certains circuits programmables nommés FPGA n'en sont pas. Pour être qualifié d'ordinateur, un appareil programmable doit avoir un processeur séparé de la mémoire. De plus, il doit utiliser un '''codage numérique''', chose que nous allons aborder dans le chapitre suivant.

===Les ordinateurs à programme mémorisé ou programme externe===

Au tout début de l'informatique, on utilisait des cartes perforées en plastique, sur lesquelles on inscrivait le programme à exécuter, les données à traiter, bref : tout ce qu'on donnait à manger à l'ordinateur. Par la suite, les premiers ordinateurs grand public, comme les Amstrad ou les Commodore, utilisaient des cassettes audio magnétiques pour stocker les programmes. Dans le même style, les consoles de jeu utilisaient autrefois des cartouches de jeu, qui contenaient le programme du jeu à exécuter. Pour résumer, les anciens ordinateurs mémorisaient les programmes sur un support externe, lu par un périphérique. De tels ordinateurs sont dits à '''programme externe'''.

: D’anciens ordinateurs personnels, comme l’Amstrad ou le Commodore, permettaient de taper les programmes à exécuter à la main, au clavier, avant d’appuyer une touche pour les exécuter. Nul besoin de vous dire que les cassettes audio étaient plus pratiques.

Mais de nos jours, les programmes sont enregistrés sur le disque dur de l'ordinateur ou dans une mémoire intégrée à l'ordinateur. On dit qu'ils sont installés, ce qui est un mot bien compliqué pour dire que le programme est enregistré sur le disque dur de l’ordinateur. A défaut de disque dur, le programme/logiciel est enregistré dans une mémoire spécialisée pour le stockage. Par exemple, sur les cartes électroniques grand public de marque Arduino, les programmes sont envoyés à la carte via le port USB, mais les programmes sont enregistrés dans la carte Arduino, dans une mémoire FLASH dédiée. Disque dur ou non, le programme est mémorisé dans la mémoire de l'ordinateur. Il est possible d'installer ou de désinstaller les programmes en modifiant le contenu de la mémoire. Le terme utilisé est alors celui de '''programme stocké en mémoire'''.

Les programmes à installer sont disponibles soit sur un périphérique, comme un DVD ou une clé USB, soit sont téléchargés depuis internet. Les premiers PC fournissaient les logiciels sur des disquettes, qui contenaient un programme d'installation pour enregistrer le programme sur le disque dur de l'ordinateur. Par la suite, le support des logiciels a migré vers les CD et DVD, les logiciels devenant de plus en plus gros. De nos jours, la majorité des applications sont téléchargées depuis le net, l'usage de périphériques est devenu obsolète, même les consoles de jeu abandonnent cette méthode de distribution.

==Les générations d'ordinateurs : un historique rapide==

L'informatique a beaucoup évolué dans le temps. Et une bonne partie de cette évolution tient à l'évolution de l’électronique sous-jacente. Les ordinateurs actuels sont fabriqués avec des transistors, des petits composants électroniques qui servent d'interrupteurs programmables, qu'on détaillera dans ce qui suit. Mais ça n'a pas toujours été le cas. Et cela permet de distinguer plusieurs '''générations d'ordinateurs'''.

===Les ordinateurs électro-mécaniques : les premiers ordinateurs===

Le tout premier ordinateur est le '''Z1''', un modèle unique inventé par Konrad Suze entre 1936 et 1938. Son processeur gérait non pas des nombres entiers, mais des nombres à virgule (des nombres dits flottants, pour être précis), encodés sur 22 bits. Le processeur du Z1 était capable de faire des additions et des soustractions, car il intégrait un circuit additionneur-soustracteur basique. Des circuits annexes permettaient de faire des multiplications et des divisions en enchainant des additions/soustractions successives. Il fonctionnait à une fréquence de 1 Hz, ce qui fait qu'il pouvait faire une addition/soustraction par seconde maximum.

[[File:Blue-punch-card-front.png|vignette|upright=0.5|Carte Perforée.]]

Niveau mémoire, la RAM de l'ordinateur était très limitée : seulement 16 nombres de 22 bits chacun. S'il s'agissait d'une mémoire électronique, les programmes étaient mémorisés sur une mémoire mécanique. Les programmes étaient enregistrés sur des cartes perforées, à savoir des cartes en papier dans lesquelles un 1 est codé par un trou dans le papier et un 0 par une absence de trou. Les programmes étaient exécutés par l'ordinateur quand on insérait la carte perforée dans le lecteur et qu'on appuyait sur un bouton.

[[File:German Museum of Technology, Berlin 2017 024.jpg|centre|vignette|upright=2|Réplique du Z1 au ''German Museum of Technology'' de Berlin, 2017.]]

Après sa destruction dans un bombardement, le Z1 a été reconstruit et amélioré, ce qui donné les deux ordinateurs Z2 et Z3. Quelques années plus tard, de nombreux ordinateurs ont été construits dans des laboratoires de recherche. Des grands noms de l'histoire de l'informatique datent de cette époque : le Harvard Mark I et le Colossus Mark 1 (UK) ont tous deux été mis en service en 1944, par exemple. Ils ont servi pour les cryptanalystes pour casser les codes utilisés par les Allemands pour leurs transmissions, pendant la seconde guerre mondiale.

Les ordinateurs cités dans le précédent paragraphe étaient tous des ordinateurs dit '''électro-mécaniques''', car ils mélangeaient des composants électroniques et des composants mécaniques (tout ce qui a trait aux cartes perforées, notamment). Les composants électroniques étaient soit des relais, soit des tubes à vides, les deux étant des interrupteurs commandables électriquement plus ou moins équivalents aux transistors. Les ordinateurs d'avant l'année 1944, étaient tous de ce type. Quelques ordinateurs des années 50 étaient de ce type, mais leur nombre n'a pas dépassé 30. Il faut dire qu'ils ont rapidement laissé la place à des ordinateurs purement électroniques, que nous allons voir dans ce qui suit.

===La première génération : les tubes à vide===

Les ordinateurs qui ont suivi les ordinateurs électromécaniques sont regroupés dans la '''première génération d'ordinateur'''. Ils étaient conçus avec des tubes à vide, ce qui les place entre les premiers ordinateurs électro-mécaniques et les ordinateurs utilisant des transistors. Les tubes à vide étaient assez encombrants, ils consommaient beaucoup de courant, ils chauffaient et étaient assez peu fiables. Ils tombaient en panne assez souvent. Et ils étaient assez simples à fabriquer, mais restaient malgré tout chers.

[[File:Elektronenroehren-auswahl.jpg|centre|vignette|upright=2|Tubes à vides.]]

Au vu de la taille des tubes à vide, les ordinateurs de l'époque étaient composés de plusieurs milliers de ces tubes, guère plus. Et malgré cela, un ordinateur prenait facilement un étage de bâtiment entier, ou au moins plusieurs pièces. La conséquence est que les ordinateurs de première génération étaient très simples, rudimentaires quand on les compare aux ordinateurs modernes. Ils ne géraient que quelques opérations simples : l'addition, la soustraction, pas grand-chose de plus. À quelques exceptions près, ils ne géraient pas la multiplication et encore moins la division, cela aurait demandé trop de tubes à vides.

Une des toutes premières machines construite avec des tubes à vide était l'Atanasoff–Berry. Ce n'était pas un ordinateur, car elle ne pouvait pas exécuter de programme sans intervention humaine pour séquencer des opérations, mais c'était la première machine de calcul purement électronique, sans aucune pièce mécanique. Elle utilisait une mémoire RAM construite avec des condensateurs, ceux-ci étant placés sur des cylindres tournants. Les circuits de calcul étaient construits avec des tubes à vide et faisaient leur travail un bit à la fois. Elle fonctionnait à une fréquence de 60 Hz et pouvait faire 30 additions/soustractions par seconde. Les nombres étaient encodés sur 50 bits. 

[[File:Atanasoff Berry Computer.gif|centre|vignette|upright=2.5|Atanasoff–Berry.]]

L'arrivée de l'ENIAC en 1945 a changé la donne. Cet ordinateur a introduit plusieurs innovations majeures. La première est assez technique, il s'agit de la turing-complétude, elle a trait aux programmes qui peuvent être écrit pour un ordinateur, nous ne la détaillerons pas ici.

[[File:BabyArchitecture.png|vignette|Architecture de la Manchester Baby.]]

En 1948, le ''Manchester Baby'' a introduit une innovation extrêmement importante : le programme n'était plus mémorisé sur des cartes perforées, mais dans une mémoire électronique à l’intérieur de l'ordinateur lui-même. En clair, le ''Manchester Baby'' était le premier '''ordinateur à programme stocké en mémoire''' en français. Au-delà de ça, le Manchester Baby restait quand même très simple, c'était limite un prototype.

Niveau interface, l'ordinateur avait une console avec 32 boutons, des interrupteurs et un écran de sortie sur lequel afficher les résultats. A l'intérieur, il y avait un processeur et une RAM de 32 nombres de 32 bits, fabriquées avec des tubes Williams (abordés dans une annexe à la fin du cours). Une instruction prenant autant de place qu'un nombre en RAM, ce qui limitait les programmes à 32 instructions maximum. Le processeur gérait 8 instructions en tout, mais la seule instruction de calcul qu'il gérait était la soustraction. L'addition n'était pas supportée. Il pouvait cependant émuler l'addition à partir d'une soustraction et inversant l'opérande soustrait.

Le Manchester Mark 1 était une amélioration du Manchester Baby. Il utilisait 4500 tubes à vide. L'ordinateur gérait des nombres de 40 bits, mais les instructions étaient codées sur 20 bits. La RAM avait la même taille, à savoir 32 nombres, leur taille était simplement augmentée. Par contre, la RAM était complémentée par l’ancêtre du disque dur magnétique, à savoir un tambour magnétique, l’ancêtre du disque dur magnétique. Il contenait 40 pages, chacune ayant la même taille que la RAM. Contrairement à la Manchester Baby, son processeur gérait l'addition et quelques opérations logiques (ET et OU), en plus de la soustraction et de la comparaison.

Par la suite, les ordinateurs commerciaux ont vu le jour. Les ordinateurs précédents provenaient de projets de recherches, souvent publics. Mais les entreprises privées se sont mises à fabriquer des ordinateurs elle-mêmes, pour les vendre à d'autres entreprises. On peut notamment citer les ordinateurs comme le UNIVAC I, le Bull Gamma 3 ou les premiers ordinateurs IBM. La performance de ces ordinateurs était nettement plus importante que leurs prédécesseurs, avec des fréquences de l'ordre de la centaine de kilo-hertz. Par exemple, le Bull Gamma 3 allait à 281 kHz, l'IBM 650 allait à 50 Khz.

===La seconde génération : le remplacement des tubes à vides par des transistors===

[[File:IBM 7070.jpg|vignette|Cartes imprimées de l'IBM 704, avec des transistors et résistances dessus.]]

La '''seconde génération''' est celle des ordinateurs fabriqués avec des '''transistors''' isolés, reliés entre avec des fils électriques. Les transistors en question possèdent trois broches, des pattes métalliques sur lesquelles on connecte des fils électriques. Le transistor s'utilise le plus souvent comme un interrupteur commandé par sa troisième broche. Le courant qui traverse les deux premières broches passe ou ne passe pas selon ce qu'on met sur la troisième.

[[File:Transistor basic flow.svg|centre|vignette|Un transistor est un morceau de conducteur, dont la conductivité est contrôlée par sa troisième broche/borne.]]

Les ordinateurs de seconde génération avaient entre 1000 et 500 000 transistors. Les capacités des ordinateurs étaient donc nettement supérieures à celles des ordinateurs de première génération. Une part non négligeable des ordinateurs de seconde génération supportait l'opération de multiplication, absente sur les ordinateurs de première génération. Néanmoins, cela variait beaucoup selon les ordinateurs.

Un exemple assez hors du commun est celui du premier modèle de l'IBM 1620. Le tout premier modèle n'avait aucun circuit de calcul, il n'était même pas capable de faire une addition ou une multiplication. A la place, il utilisait une table d'addition et une table de multiplication en mémoire RAM. Les deux tables devaient être initialisées par le logiciel lors du démarrage de la machine. La table d'addition faisait une centaine de chiffres, la table de multiplication faisait le double. Le processeur de l'ordinateur gérait des instructions pour faire des additions ou des multiplications, mais ces opérations lisaient le résultat dans la table d'addition. Les calculs étaient faits chiffre par chiffre, avec un encodage partiellement décimal, partiellement binaire (des chiffres décimaux étaient encodés en binaire, nous en reparlerons quand nous parlerons du BCD) !

[[File:KL CoreMemory.jpg|vignette|Mémoire à tore de ferrite.]]

Les transistors n'étaient utilisés que pour le processeur et les circuits annexes. La mémoire n'était pas faite en transistors, pas à cette époque. La mémoire était une mémoire aujourd'hui abandonnée, appelée une '''mémoire à tores de ferrite'''. Elle sera détaillée dans un chapitre ultérieur. Mais sachez pour le moment qu'il s'agit d'une mémoire au support magnétique, les données étant stockées sur un support magnétique.

Transistors comme tubes à vide prenaient beaucoup de place, ce qui fait que les ordinateurs étaient assez gros. Concrètement, ils prenaient une pièce de bâtiment entière dans le meilleur des cas. C'était l'époque des gros ''mainframes'', reliés à des terminaux, peu puissants comparé aux standards actuels. Seules les grandes entreprises et les grands instituts de recherche pouvaient se payer les services de ce genre d'ordinateurs. Seuls les professionnels avaient accès à ce genre d'équipement.

===La troisième génération : le circuit intégré===

[[File:D8259AC-2.jpg|vignette|Exemple de circuit intégré.]]

La troisième génération est toujours fabriquée avec des transistors, mais dont la taille a été réduite. Avec l'évolution de la technologie, les transistors ont diminué en taille, de plus en plus. Ils sont devenus tellement petits qu'ils ont fini par être regroupés dans des '''circuits intégrés''', des circuits regroupent plusieurs transistors sur la même puce de silicium. Les circuits intégrés se présentent le plus souvent sous la forme de boitiers rectangulaires, comme illustré ci-contre. D'autres ont des boitiers de forme carrées, comme ceux que l'on peut trouver sur les barrettes de mémoire RAM, ou à l'intérieur des clés USB/ disques SSD.

Lors de cette génération, les processeurs étaient fournis en pièces détachées qu'il fallait relier entre elles. Le processeur était composé de plusieurs circuits intégrés séparés, impossible de mettre un processeur dans un seul boitier. Un exemple de processeur conçu en kit est la série des Intel 3000. Elle regroupe plusieurs circuits séparés aux noms à coucher dehors, mais dont vous comprendrez ce qu'ils veulent dire dans les chapitres adéquats : l'Intel 3001 est un séquenceur, l'Intel 3002 regroupe unité de calcul et registres, le 3003 est un circuit d'anticipation de retenue complémentaire du 3002, le 3212 est une mémoire tampon, le 3214 est une unité de gestion des interruptions, les 3216/3226 sont des interfaces de bus mémoire. On pourrait aussi citer la famille de circuits intégrés AMD Am2900.

Même si le processeur était en pièces détachées, utiliser une dizaine de circuits intégrés était nettement mieux que d'utiliser plusieurs milliers de transistors individuels. En conséquence, les ordinateurs ont vu leur taille grandement réduite, passant de pièces entières à une simple armoire, voire à quelques cartes intégrées superposées. De plus, le prix des circuits intégré était abordable, du moins comparé aux ordinateurs d'avant. Le prix des ordinateurs a alors grandement décru, permettant à des entreprises et administrations de taille modeste de s'équiper d'ordinateurs.

===La quatrième génération : le microprocesseur===

[[File:MOS6502.svg|vignette|Microprocesseur, ici un processeur MOS6502, de la quatrième génération.]]

Lors de la troisième génération, les circuits intégrés regroupaient plusieurs dizaines ou centaines de transistors, mais sont rapidement montés en gamme. De centaines de transistors, ils sont passés au millier de transistors, puis au million et maintenant au-delà du milliard. Les transistors étaient devenus tellement petits, tellement miniaturisés, qu'il était devenu possible de mettre un processeur entier dans un circuit intégré. C'est ainsi qu'est né le microprocesseur, à savoir un processeur qui tient tout entier dans un seul circuit imprimé. La quatrième génération d’ordinateur est celle des ordinateurs basés autour d'un microprocesseur.

Les tout premiers microprocesseurs étaient des processeurs à application militaire, comme le processeur du F-14 CADC ou celui de l'Air data computer. Le tout premier microprocesseur commercialisé au grand public est le 4004 d'Intel, sorti en 1971. L'intel 4004 comprenait environ 2300 transistors, avait une fréquence de 740 MHz, pouvait faire 46 opérations différentes, et manipulait des entiers de 4 bits. Il était au départ un processeur de commande, prévu pour être intégré dans la calculatrice Busicom calculator 141-P, mais il fut utilisé pour d'autres applications quelque temps plus tard. Immédiatement après le 4004, les premiers microprocesseurs 8 bits furent commercialisés. Le 4004 fut suivi par le 8008 et quelques autres processeurs 8 bits extrêmement connus, comme le 8080 d'Intel, le 68000 de Motorola, le 6502 ou le Z80.

Les microprocesseurs permirent encore uen fois de réduire la taille des ordinateurs, qui pouvaient tenir dans un boitier de PC, ou un boitier de console de jeu. Le prix des ordinateurs a aussi chuté en même temps que les transistors étaient miniaturisés. C'est cette invention qui permis l'invention des consoles de jeux et des mini-ordinateurs, à savoir les ordinateurs personnels. Sans miniaturisation, on n'aurait pas d'ordinateur personnel, pas de PC fixe ou portable.

==L'organisation du cours : les différents niveaux d'explication==

Le fonctionnement d'un ordinateur est assez complexe à expliquer car les explications peuvent se faire sur plusieurs niveaux. Par plusieurs niveaux, on veut dire qu'un ordinateur est composé de composants très simples, qui sont assemblés pour donner des composants eux-même plus complexes, qui sont eux-même regrouper, etc. Étudier tout cela demande de voir plusieurs niveaux, allant de transistors très petits à des processeurs multicœurs. Les niveaux les plus bas sont de l'électronique pur et dure, alors que ceux plus haut sont à mi-chemin entre électronique et informatique.

===Les niveaux d'abstraction en architecture des ordinateurs===

Les trois premiers niveaux sont de l'électronique pur et dure. Ils correspondent aux premiers chapitres du cours, qui porteront sur les circuits électroniques en général.
* Le premier niveau est celui des '''transistors''', des circuits intégrés, des ''wafer'' et autres circuits de très petite taille.
* Le second niveau est celui des '''portes logiques''', des circuits très basiques, très simples, à la base de tous les autres.
* Le troisième niveau est celui dit de la '''''Register Transfer Level''''', où un circuit électronique est construit à partir de circuits basiques, dont des registres et autres circuits dits combinatoires.
Les deux niveaux suivants sont de l'informatique proprement dit. C'est dans ces deux niveaux qu'on étudie les ordinateurs proprement dit, les circuits qu'il y a dedans et non l'électronique en général.
* Le quatrième niveau est celui de la '''microarchitecture''', qui étudie ce qu'il y a à l'intérieur d'un processeur, d'une mémoire, des périphériques et autres.
* Le cinquième niveau est celui de l''''architecture externe''', qui décrit l'interface du processeur, de la mémoire, d'un périphérique ou autre. Par décrire l'interface, on veut dire : comment un programmeur voit le processeur et la mémoire, comment il peut les manipuler. Une architecture externe unique peut avoir plusieurs microarchitecture, ce qui fait qu'on sépare les deux. Tout cela sera plus clair quand on passera aux chapitres sur le processeur et les mémoires.

Nous n'allons pas voir les 5 niveaux dans l'ordre, des transistors vers l'architecture externe. En réalité, nous allons procéder autrement. La première partie du cours portera sur les trois premiers niveaux, le reste sur les deux autres. Les 5 niveaux seront vus dans des chapitres séparés, du moins le plus possible. Au niveau pédagogique, tout est plus simple si on scinde les 5 niveaux. Bien sûr, il y a quelques explications qui demandent de voir plusieurs niveaux à la fois. Par exemple, dans le chapitre sur les mémoires caches, nous auront des explications portant sur la RTL, la microarchitecture du cache et son architecture externe. Mais le gros du cours tentera de séparer le plus possible les 5 niveaux.

===Les trois parties principales du cours===

Nous allons commencer par parler du binaire, avant de voir les portes logiques. Avec ces portes logiques, nous allons voir comment fabriquer des circuits basiques qui reviendront très souvent dans la suite du cours. Nous verrons les registres, les décodeurs, les additionneurs et plein d'autres circuits. Puis, nous reviendrons au niveau des transistors pour finir la première partie. La raison est que c'est plus simple de faire comme cela. Tout ce qui a trait aux transistors sert à expliquer comment fabriquer des portes logiques, et il faut expliquer les portes logiques pour voir le niveau de la RTL.

Une fois la première partie finie, nous allons voir les différents composants d'un ordinateur. Une première partie expliquera ce qu'il y a dans un ordinateur, quels sont ses composants. Nous y parlerons de l'architecture de base, de la hiérarchie mémoire, des tendances technologiques, et d'autres généralités qui serviront de base pour la suite. Puis, nous verrons dans l'ordre les bus électroniques, les mémoires RAM/ROM, le processeur, les périphériques, les mémoires de stockage (SSD et disques durs) et les mémoires caches. Pour chaque composant, nous allons voir leur architecture externe, avant de voir leur microarchitecture. La raison est que la microarchitecture ne peut se comprendre que quand on sait quelle architecture externe elle implémente.

Enfin, dans une troisième partie, nous allons voir les optimisations majeures présentes dans tous les ordinateurs modernes, avec une partie sur le pipeline et le parallélisme d'instruction, et une autre sur les architectures parallèles. Pour finir, les annexes de fin parlerons de sujets un peu à part.

&lt;noinclude&gt;
{{NavChapitre | book=Fonctionnement d'un ordinateur
           | next=L'encodage des données
           | nextText=L'encodage des données
}}
&lt;/noinclude&gt;</text>
      <sha1>krr1qhs0tc9ch5ex5gx2owdu5kxt08l</sha1>
    </revision>
    <revision>
      <id>744145</id>
      <parentid>744142</parentid>
      <timestamp>2025-06-05T11:49:16Z</timestamp>
      <contributor>
        <username>Mewtow</username>
        <id>31375</id>
      </contributor>
      <minor />
      <comment>/* Un ordinateur est un appareil programmable */</comment>
      <origin>744145</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="45960" sha1="8a8wurewyp5on2dahmakp4ur93esu2d" xml:space="preserve">Pour commencer, nous allons voir qu'il existe de nombreux types d'ordinateurs. Le plus connu est certainement le PC, l'ordinateur personnel, que vous avez sans doute dans votre salon. Les ordinateurs portables sont un deuxième type d'ordinateur assez intuitif, que vous avez peut-être. Mais il y a aussi d'autres types d'ordinateurs auxquels vous n'avez jamais été confrontés.

==Les différents types d'ordinateurs==

Dans cette section, nous allons décrire rapidement les ordinateurs les plus courant, mais surtout voir ce qu'il y a à l'intérieur d'un ordinateur.

===L'ordinateur de type PC fixe===

De l'extérieur, l'ordinateur est composé d'une unité centrale sur laquelle on branche des périphériques.

[[File:Typical computer architecture systems.jpg|vignette|upright=1.5|Exemples de périphériques, connectés à une unité centrale (ici appelée à tort ''operating system'').]]

Les '''périphériques''' regroupent l'écran, la souris, le clavier, l'imprimante, et bien d'autres choses. Ils permettent à l'utilisateur d'interagir avec l'ordinateur : un clavier permet de saisir du texte sous dans un fichier, une souris enregistre des déplacements de la main en déplacement du curseur, un écran affiche des données d’images/vidéos, un haut-parleur émet du son, etc. Tout ce qui est branché sur un ordinateur est, formellement un périphérique.

L''''unité centrale''' est là où se trouvent tous les composants importants d'un ordinateur, ceux qui font des calculs, qui exécutent des logiciels, qui mémorisent vos données, etc. Voici ce à quoi ressemble l'intérieur de l'unité centrale. Trois sections sont visibles : l'alimentation électrique en haut à gauche, la carte mère en bas à gauche et en jaune/orange, les disques et lecteurs à droite des câbles. Et on voit aussi beaucoup de câbles.

[[File:Asus P5K-SEIntel E6320.jpg|centre|vignette|upright=2|Exemple d'unité centrale.]]

Tout en haut à gauche, se trouve l''''alimentation électrique''', qui convertit le courant de la prise électrique en un courant plus faible, utilisable par les autres composants. Elle émet de nombreux câbles assez gros, qui sont reliés au reste. Les PC actuels utilisent des alimentations électriques standardisées, qui fournissent trois tensions au reste de l'ordinateur : une tension de 12 Volts, une de 5 Volts, une de 3,3 Volts.

À droite, caché par la partie &quot;métallique&quot; du boitier, se trouvent les lecteurs de CD/DVD, et les disques durs. Les lecteurs CD-ROM ou DVD-ROM permettaient de lire des CD ou des DVD. Je parle au passé, car ils ont aujourd'hui disparu des ordinateurs modernes. Les '''disques durs''' sont des mémoires de stockage, qui mémorisent vos données de manière permanente. De nos jours, ils sont remplacés par des SSD, qui sont des disques durs électroniques, là où les disques durs proprement dit sont des mémoires magnétiques. Nous verrons la différence dans deux chapitres dédiés, un sur les disques durs, l'autre sur les SSD.

En bas à droite, se trouve la '''carte mère''' un support plat, en plastique ou en céramique, sur laquelle sont soudés/connectés les autres composants. Sur celle-ci, de nombreux composants sont soudés, d'autres sont branchés dessus avec des câbles, d'autres sont connectés dessus avec des connecteurs. Ils sont reliés entre eux par des fils conducteurs, le plus souvent du cuivre ou de l’aluminium, ce qui leur permet de s’échanger des données. Sur les cartes simples, ces fils sont intégrés dans la carte électronique, dans des creux du plastique. Ils portent le nom de pistes.

Avant, les disques durs, SSD et lecteurs de CD/DVD sont branchés dessus via des connecteurs dédiés, appelés des connecteurs S-ATA. De nos jours, ils sont branchés sur un autre connecteur, grâce à l'interface NVME. Toujours est-il qu'ils sont reliés à la carte mère par des câbles, ce qui montre que ce sont des sortes de périphériques interne. Ils sont placés dans le boitier, mais on aurait tout aussi bien pu les mettre à l'extérieur, vu qu'ils communiquent avec l'ordinateur par l'intermédiaire d'un câble ou d'un connecteur dédié.

Mais deux autres composants très importants sont eux placés sur la carte mère, directement. Ils ont chacun un connecteur dédié, sur lequel ils sont branchés directement, sans passer par l'intermédiaire d'un câble, mais sans être soudés non plus. Il s'agit du processeur et de la mémoire RAM, deux composants centraux des PC modernes.

[[File:Pentium III SL4CB.jpg|thumb|Processeur Pentium III.]]

Le '''processeur''' traite les données, les modifie, les manipule. Pour faire simple, il s’agit d’une grosse calculatrice hyper-puissante. Il comprend à la fois un circuit qui fait des calculs, et un circuit de contrôle qui s'occupe de séquencer les calculs dans l'ordre demandé. Il est souvent caché sous un radiateur, lui-même surmonté par un ventilateur. En effet, un processeur chauffe beaucoup, ce qui demande d'évacuer cette chaleur. Un chapitre entier expliquera pourquoi les processeurs chauffent, ainsi que les techniques utilisées pour limiter leur production de chaleur et leur consommation électrique.

La '''mémoire vive''' conserve des informations/données temporairement, tant que le processeur en a besoin. Elle prend la forme de barrettes de RAM, comme montré ci-dessous.

[[File:2 gb ddr2 667.jpg|centre|vignette|upright=2|Barrette de RAM.]]

Outre ces composants dits principaux, un ordinateur peut comprendre plusieurs composants moins importants, surtout présents sur les ordinateurs personnels. Ils sont techniquement facultatifs, mais sont très présents dans les ordinateurs personnels. Cependant, certains ordinateurs spécialisés s'en passent. Il s'agit des diverses '''cartes d'extension''' sont branchées sur la carte mère. Elles permettent d’accélérer certains calculs ou certaines applications, afin de décharger le processeur. Par exemple, la carte graphique s'occupe des calculs graphiques, qu'il s'agisse de graphismes 3D de jeux vidéos ou de l'affichage en 2D du bureau. Dans un autre registre, la carte son prend en charge le microphone et les haut-parleurs.

[[Fichier:Personal computer, exploded 4.svg|thumb|upright=1.0|Éclaté d'un ordinateur de type PC :&lt;br /&gt;
1 : Écran ;&lt;br /&gt;
2 : Carte mère ;&lt;br /&gt;
3 : Processeur ;&lt;br /&gt;
4 : Câble Parallel ATA ;&lt;br /&gt;
5 : Mémoire vive (RAM) ;&lt;br /&gt;
6 : Carte d'extension ;&lt;br /&gt;
7 : Alimentation électrique ;&lt;br /&gt;
8 : Lecteur de disque optique ;&lt;br /&gt;
9 : Disque dur ;&lt;br /&gt;
10 : Clavier ;&lt;br /&gt;
11 : Souris.]]

Si on regarde une carte mère de face, on voit un grand nombre de connecteurs, mais aussi des circuits électroniques soudés à la carte mère.

[[File:Architecture matérielle d'une carte mère.png|centre|vignette|upright=2.0|Architecture matérielle d'une carte mère]]

Les '''connecteurs''' sont là où on branche les périphériques, la carte graphique, le processeur, la mémoire, etc. Dans l'ensemble, toute carte mère contient les connecteurs suivants :
* Le processeur vient s’enchâsser dans la carte mère sur un connecteur particulier : le '''socket'''. Celui-ci varie suivant la carte mère et le processeur, ce qui est source d'incompatibilités.
* Les barrettes de mémoire RAM s’enchâssent dans un autre type de connecteurs: les '''slots mémoire'''.
* Les mémoires de masse disposent de leurs propres connecteurs : connecteurs P-ATA pour les anciens disques durs, et S-ATA pour les récents.
* Les périphériques (clavier, souris, USB, Firewire, ...) sont connectés sur un ensemble de connecteurs dédiés, localisés à l'arrière du boitier de l'unité centrale. 
* Les autres périphériques sont placés dans l'unité centrale et sont connectés via des connecteurs spécialisés. Ces périphériques sont des cartes imprimées, d'où leur nom de '''cartes filles'''. On peut notamment citer les cartes réseau, les cartes son, ou les cartes vidéo.

===Les ordinateurs portables===

[[File:Samsung QX-511 (2).JPG|vignette|Ordinateur portable Samsung QX-511 (2), pour illustration.]]

Un ordinateur portable est identique à un ordinateur de type PC. Si vous ouvrez votre ordinateur portable (attention à la garantie), vous retrouverez les mêmes composants qu'un PC à l'intérieur. Un point important est la présence d'une batterie à l'intérieur du PC portable, absente des PC fixes.

[[File:LG gram 14Z90Q mainboard with battery.jpg|centre|vignette|upright=2|LG gram 14Z90Q avec sa batterie.]]

Une fois la batterie et les circuits associés retiré, la seule différence notable est que tous les composants sont soudés sur la carte mère, au lieu d'être branchés sur des connecteurs, à part éventuellement la RAM et le disque dur.

[[File:LG gram 14Z90Q mainboard without battery.jpg|centre|vignette|upright=2|LG gram 14Z90Q sans sa batterie.]]

La RAM est parfois soudée sur la carte mère, d'autres fois sous la forme de barrettes de mémoire vive semblables à celles des PC. Dans le dernier cas, elle est connectée à des connecteurs spécifiques, ce qui permet de les changer/upgrader. Les PC portables sont parfois construits de manière à pouvoir changer la RAM facilement, en ouvrant un cache spécial, concu pour.

[[File:Lenovo G555 состав - Донор.JPG|centre|vignette|upright=2|Lenovo G555.]]

La conception d'un ordinateur portable est légèrement différente de celle d'un PC, pour des raisons thermiques. Un PC fixe a plus de place pour évacuer sa chaleur. Les ventilateurs peuvent plus facilement déplacer l'air dans le boitier, même si le flux d'air dans le boitier est éventuellement gêné par la carte graphique. Mais l'évacuation de la chaleur est assez efficace. Sur les PC portables, leur finesse fait que le trajet de l'air est beaucoup plus contraint. Évacuer la chaleur produite par l'ordinateur est plus complexe, ce qui demande d'utiliser des systèmes de refroidissement et de ventilation spécifiques.

Là où les PC fixes se débrouillent avec des radiateurs et des ventilateurs posés sur le processeur, les PC portables font autrement. Ils ne peuvent pas forcément mettre le ventilateur sur le processeur. A la place, ils mettent le ventilateur à côté, mais le processeur est surmonté par un mécanisme de transmission de la chaleur, qui transfère la chaleur du processeur vers le ventilateur.

[[File:Diagram - How a laptop cooling system works.png|centre|vignette|upright=2|Comment fonctionne le système de ventilation d'un ordinateur portable, en anglais.]]

Les difficultés pour dissiper la chaleur font que les ordinateurs portables utilisent souvent des composants peu performants, mais qui chauffent peu. En effet, nous verrons que plus un composant est puissant, plus il chauffe. La relation n'est pas parfaite, mais les processeurs haute performance chauffent plus que les modèles d'entrée ou milieu de gamme moins puissants. En conséquence, les PC portables sont souvent moins puissants que les PC fixes, même pour les modèles dit ''gaming''.

===Les serveurs et ''mainframes''===

Les grandes entreprises utilisent des ordinateurs de grande taille, très puissants, appelés des ''mainframes''. Ils sont souvent confondus avec les serveurs par le grand public, il y a une différence entre les deux. Un serveur est une fonction logicielle/réseau, pas un type d'ordinateur. Mais laissons cette différence de côté, ce qui est dit pour les ''mainframes'' sert pour les gros serveurs haute performance.

[[File:IBM Z15 mainframe.jpg|vignette|Exemple de ''mainframe''' de type IBM Z15.]]

Les anciens ''mainframes'' des années 50-80 avaient une taille pouvant être impressionnante, au point de prendre une pièce complète d'un bâtiment. Mais de nos jours, les ''mainframes'' tiennent dans une grosse armoire un peu haute. Les ''mainframes'' doivent rester allumé en permanence et ne doivent pas être éteint, sauf éventuellement quelques jours par an pour des opérations de maintenance. Ils utilisent pour cela des techniques spécifiques, avec beaucoup de redondance interne.

[[File:ACONIT hall grandes machines.jpg|centre|vignette|upright=2|''Mainframe'' ACONIT.]]

Les ''mainframes'' sont aussi conçus pour mutualiser au maximum leur utilisation, ils peuvent être utilisés par plusieurs utilisateurs à la suite, voire en même temps. Pour cela, les anciens ''mainframes'' étaient capables de faire tourner plusieurs applications distinctes l'une à la suite de l'autre, avec des commutations fréquentes entre logiciels. De nos jours, ils sont capables d'exécuter un grand nombre de tâches en même temps, grâce à la présence de plusieurs processeurs. Les ''mainframes'' modernes sont même capables de faire tourner plusieurs systèmes d'exploitation en même temps si besoin.

Les anciens ''mainframes'' étaient des ordinateurs assez simples, avec un processeur, de la mémoire RAM, un ou plusieurs disques durs, pas plus. Le ''mainframe'' était tellement énorme et cher que les entreprises n'en avaient qu'un seul pour toute l'entreprise. Les employés avaient sur leur bureau des terminaux, qui permettaient d'accéder à l'ordinateur central, mais n'étaient pas des ordinateurs. Les terminaux étaient des composants électroniques simples, avec un écran, un clavier et une souris, mais sans processeur. Ils envoyaient des données au ''mainframe'', ils en recevaient de sa part, mais tout traitement était réalisé sur le ''mainframe''. L'arrivée sur le marché des ordinateurs personnels, de type PC fixe/portable, a entrainé l'abandon de ce genre de pratique, tous les employés ont maintenant un ordinateur rien que pour eux.

{|
|-
! colspan=&quot;2&quot; | Exemples de terminaux
|-
|[[File:Terminal-in2-sm9400.jpg|centre|vignette|upright=1.5|Exemple de terminal. Notez la présence d'un écran et d'un clavier, mais l'asbence d'une unité centrale.]]
|[[File:Chromatics CT4100.jpg|vignette|upright=1.5|Autre exemple de terminal. Le clavier est couplé à un stylo CRT, qui remplacait la souris et agissait sur l'écran comme s'il était tactile.]]
|-
! colspan=&quot;2&quot; | Intérieur d'un terminal
|-
|[[File:CT1024 Monitor.jpg|vignette|upright=1.5|Terminal CT1024, sans le boitier extérieur.]]
|[[File:CT1024 Terminal System.jpg|vignette|upright=1.5|Terminal CT1024, description des composants interne.]]
|}

De nos jours, les ''mainframes'' contiennent en réalité plusieurs ordinateurs simples interconnectés via un réseau local. Un ''mainframe'' qui tient dans une armoire contient facilement une dizaine ou centaine de processeurs, plein de RAM, des disques durs séparés dans une armoire distincte, etc. Vu qu'ils communiquent uniquement via le réseau, ils n'ont pas d'interface, pas d'écran, 'entrée via clavier/souris. Le tout est commandé avec une console de commande, typiquement un ordinateur portable ou un terminal assez simple séparé de l'armoire, qui permet à un administrateur de faire des opérations de surveillance, configuration et maintenance. Il peut y avoir une console de commande pour plusieurs armoires séparées, la console peut même être dans un autre bâtiment et accéder au ''mainframe'' par le réseau.

[[File:IBM System Z9 (type 2094 inside).jpg|centre|vignette|upright=2|''Mainframe'' de type IBM System Z9. L'ordinateur portable sert de console pour qu'un administrateur fasse des opérations de surveillance, configuration et maintenance.]]

Les processeurs et la RAM sont typiquement installés sur des cartes amovibles, qui sont connectées au fond de l'armoire lors de l'installation. Il est même possible de retirer ou d'ajouter des cartes en fonctionnement, afin d'ajouter/retirer des processeurs, des disques durs, etc. Ce qui est très utile si un composant est en panne et qu'il faut le remplacer. 

[[File:IBM TotalStorage Exp400.jpg|centre|vignette|upright=2|IBM TotalStorage Exp400]]

==Un peu d'abstraction : qu'est-ce qu'un ordinateur ?==

Un ordinateur comprend donc un processeur, plusieurs mémoires, des cartes d'extension et une carte mère pour connecter le tout. Mais il s'agit là d'une description assez terre-à-terre de ce qu'est un ordinateur. Une autre description, plus abstraite, se base sur le fait qu'un ordinateur est une énorme calculatrice programmable. Elle permet d'expliquer pourquoi il y a une distinction entre processeur et mémoire, entre unité centrale et périphériques. Tout ce qui va suivre pourra vous paraitre assez abstrait, mais rassurez-vous : les prochains chapitres rendront tout cela plus concrets.

===La séparation entre entrées-sorties et traitement===

L'unité centrale peut être vue comme une énorme calculatrice ultra-puissante, qui exécute des commandes/opérations. Mais à elle seule, elle ne servirait à rien, il faut interagir avec par l'intermédiaire de plusieurs périphériques. Il existe deux types de périphériques, qui sont conceptuellement différents. Les périphériques comme le clavier ou la souris permettent d'envoyer des informations à l'ordinateur, d'agir sur celui-ci. A l'inverse, les écrans transmettent des informations dans le sens inverse : de l'ordinateur vers l'utilisateur. Les premiers sont appelés des '''entrées''', les seconds des '''sorties'''.

Dans un ordinateur, les informations sont représentées sous la forme de nombres. Toute donnée dans un ordinateur est codée avec un ou plusieurs nombres regroupés dans une donnée, un fichier, ou autre. Et la transmissions avec les entrées et sorties se fait là-encore avec des nombres. Par exemple, quand vous appuyez sur votre clavier, le clavier envoie un numéro de touche à l'unité centrale, qui indique quelle touche a été appuyée. L'image à afficher à l'écran est codée sous la forme d'une suite de nombres (un par pixel). L'image est envoyée à l'écran, qui traduit la suite de nombre en image à afficher. Les entrées traduisent des actions utilisateurs en nombres, on dit que les entrées encodent les actions utilisateur. Les sorties font la traduction inverse, elles transforment des suites de nombres en une action physique. On dit qu'elles décodent des informations.

Pour résumer, toute appareil électronique est composé par :
* Des '''entrées''' sur lesquelles l'utilisateur agit sur l'ordinateur. Les entrées transforment les actions de l'utilisateur en nombres, qui sont interprétés par l'ordinateur.
* Une '''unité de traitement''', qui manipule des nombres et fait des calculs/opérations dessus. Les nombres proviennent des entrées, du disque dur, ou d'autres sources, peu importe.
* Des '''sorties''', qui va récupèrent le résultat calculé par l'unité de traitement pour en faire quelque chose : écrire sur une imprimante ou sur un moniteur, émettre du son,...

[[File:Ordinateur théorique Simple 1.png|centre|vignette|upright=2|Ordinateur théorique Simple 1]]

L'unité de traitement proprement dite, celle qui fait les calculs, est couplée à une mémoire qui mémorise les opérandes et résultats des calculs. La séparation entre processeur et mémoire est nécessaire pour qu'un appareil électronique soit qualifié d'ordinateur. De nombreux appareils n'ont pas de séparation entre unité de traitement et mémoire, comme certaines vielles radios AM/FM.

[[File:Schéma de principe d'un ordinateur.png|centre|vignette|upright=2|Schéma de principe d'un ordinateur]]

===Un ordinateur est un appareil programmable===

Les appareils simples sont non-programmables, ce qui veut dire qu’ils sont conçus pour une utilisation particulière et qu’ils ne peuvent pas faire autre chose. Par exemple, les circuits électroniques d’un lecteur de DVD ne peuvent pas être transformé en lecteur audio ou en console de jeux... Les circuits non-programmables sont câblés une bonne fois pour toute, et on ne peut pas les modifier. On peut parfois reconfigurer le circuit, pour faire varier certains paramètres, via des interrupteurs ou des boutons, mais cela s’arrête là. Et cela pose un problème : à chaque problème qu'on veut résoudre en utilisant un automate, on doit recréer un nouveau circuit.

À l'inverse, un ordinateur n’est pas conçu pour une utilisation particulière, contrairement aux autres objets techniques. Il est possible de modifier leur fonction du jour au lendemain, on peut lui faire faire ce qu’on veut. On dit qu'ils sont '''programmables'''. Pour cela, il suffit d’utiliser un logiciel, une application, un programme (ces termes sont synonymes), qui fait ce que l'on souhaite. La totalité des logiciels présents sur un ordinateur sont des programmes comme les autres, même le système d'exploitation (Windows, Linux, ...) ne fait pas exception.

Un programme est une suite de d''''instructions machines''', chaque instruction effectuant une action dans l'ordinateur. Sur les ordinateurs modernes, les instructions les plus communes effectuent une opération arithmétique : une addition, une multiplication, une soustraction, etc. Les ordinateurs modernes sont donc de grosses calculettes très puissantes, capables d'effectuer des millions d'opérations par secondes.

Et qui dit opération dit nombres : un ordinateur gère nativement des nombres, qui sont codés en binaire sur la quasi-totalité des ordinateurs modernes. Les ordinateurs modernes sont capables de faire des calculs sur des nombres entiers, mais aussi des nombres à virgule. Il existe plusieurs manières de représenter des nombres en binaire, certaines représentant des nombres entiers dits naturels (0 et plus), d'autres des nombres signés (positifs ou négatifs), d'autres des nombres à virgule. Un chapitre entier détaillera comment sont encodés ces nombres.

Une instruction est représentée dans un ordinateur par une série de nombres entiers : un nombre qui indique quelle opération/commande effectuer et des autres nombres pour coder les données (ou de quoi les retrouver dans l'ordinateur). L'ordinateur récupére les commandes une par une, les traduit en opération à effectuer, exécuter l'opération, et enregistre le résultat. Puis il recommence avec la commande suivante.

[[File:Ordinateur Théorique Complexe 1.png|centre|vignette|upright=3|Ordinateur Théorique Complexe. En jaune, le programme informatique, la liste de commande. Le rectangle gris est l'ordinateur proprement dit.]]

De nombreux appareils sont programmables, mais tous ne sont pas des ordinateurs. Par exemple, certains circuits programmables nommés FPGA n'en sont pas. Pour être qualifié d'ordinateur, un appareil programmable doit avoir un processeur séparé de la mémoire. De plus, il doit utiliser un '''codage numérique''', chose que nous allons aborder dans le chapitre suivant.

===Les ordinateurs à programme mémorisé ou programme externe===

Au tout début de l'informatique, on utilisait des cartes perforées en plastique, sur lesquelles on inscrivait le programme à exécuter, les données à traiter, bref : tout ce qu'on donnait à manger à l'ordinateur. Par la suite, les premiers ordinateurs grand public, comme les Amstrad ou les Commodore, utilisaient des cassettes audio magnétiques pour stocker les programmes. Dans le même style, les consoles de jeu utilisaient autrefois des cartouches de jeu, qui contenaient le programme du jeu à exécuter. Pour résumer, les anciens ordinateurs mémorisaient les programmes sur un support externe, lu par un périphérique. De tels ordinateurs sont dits à '''programme externe'''.

: D’anciens ordinateurs personnels, comme l’Amstrad ou le Commodore, permettaient de taper les programmes à exécuter à la main, au clavier, avant d’appuyer une touche pour les exécuter. Nul besoin de vous dire que les cassettes audio étaient plus pratiques.

Mais de nos jours, les programmes sont enregistrés sur le disque dur de l'ordinateur ou dans une mémoire intégrée à l'ordinateur. On dit qu'ils sont installés, ce qui est un mot bien compliqué pour dire que le programme est enregistré sur le disque dur de l’ordinateur. A défaut de disque dur, le programme/logiciel est enregistré dans une mémoire spécialisée pour le stockage. Par exemple, sur les cartes électroniques grand public de marque Arduino, les programmes sont envoyés à la carte via le port USB, mais les programmes sont enregistrés dans la carte Arduino, dans une mémoire FLASH dédiée. Disque dur ou non, le programme est mémorisé dans la mémoire de l'ordinateur. Il est possible d'installer ou de désinstaller les programmes en modifiant le contenu de la mémoire. Le terme utilisé est alors celui de '''programme stocké en mémoire'''.

Les programmes à installer sont disponibles soit sur un périphérique, comme un DVD ou une clé USB, soit sont téléchargés depuis internet. Les premiers PC fournissaient les logiciels sur des disquettes, qui contenaient un programme d'installation pour enregistrer le programme sur le disque dur de l'ordinateur. Par la suite, le support des logiciels a migré vers les CD et DVD, les logiciels devenant de plus en plus gros. De nos jours, la majorité des applications sont téléchargées depuis le net, l'usage de périphériques est devenu obsolète, même les consoles de jeu abandonnent cette méthode de distribution.

==Les générations d'ordinateurs : un historique rapide==

L'informatique a beaucoup évolué dans le temps. Et une bonne partie de cette évolution tient à l'évolution de l’électronique sous-jacente. Les ordinateurs actuels sont fabriqués avec des transistors, des petits composants électroniques qui servent d'interrupteurs programmables, qu'on détaillera dans ce qui suit. Mais ça n'a pas toujours été le cas. Et cela permet de distinguer plusieurs '''générations d'ordinateurs'''.

===Les ordinateurs électro-mécaniques : les premiers ordinateurs===

Le tout premier ordinateur est le '''Z1''', un modèle unique inventé par Konrad Suze entre 1936 et 1938. Son processeur gérait non pas des nombres entiers, mais des nombres à virgule (des nombres dits flottants, pour être précis), encodés sur 22 bits. Le processeur du Z1 était capable de faire des additions et des soustractions, car il intégrait un circuit additionneur-soustracteur basique. Des circuits annexes permettaient de faire des multiplications et des divisions en enchainant des additions/soustractions successives. Il fonctionnait à une fréquence de 1 Hz, ce qui fait qu'il pouvait faire une addition/soustraction par seconde maximum.

[[File:Blue-punch-card-front.png|vignette|upright=0.5|Carte Perforée.]]

Niveau mémoire, la RAM de l'ordinateur était très limitée : seulement 16 nombres de 22 bits chacun. S'il s'agissait d'une mémoire électronique, les programmes étaient mémorisés sur une mémoire mécanique. Les programmes étaient enregistrés sur des cartes perforées, à savoir des cartes en papier dans lesquelles un 1 est codé par un trou dans le papier et un 0 par une absence de trou. Les programmes étaient exécutés par l'ordinateur quand on insérait la carte perforée dans le lecteur et qu'on appuyait sur un bouton.

[[File:German Museum of Technology, Berlin 2017 024.jpg|centre|vignette|upright=2|Réplique du Z1 au ''German Museum of Technology'' de Berlin, 2017.]]

Après sa destruction dans un bombardement, le Z1 a été reconstruit et amélioré, ce qui donné les deux ordinateurs Z2 et Z3. Quelques années plus tard, de nombreux ordinateurs ont été construits dans des laboratoires de recherche. Des grands noms de l'histoire de l'informatique datent de cette époque : le Harvard Mark I et le Colossus Mark 1 (UK) ont tous deux été mis en service en 1944, par exemple. Ils ont servi pour les cryptanalystes pour casser les codes utilisés par les Allemands pour leurs transmissions, pendant la seconde guerre mondiale.

Les ordinateurs cités dans le précédent paragraphe étaient tous des ordinateurs dit '''électro-mécaniques''', car ils mélangeaient des composants électroniques et des composants mécaniques (tout ce qui a trait aux cartes perforées, notamment). Les composants électroniques étaient soit des relais, soit des tubes à vides, les deux étant des interrupteurs commandables électriquement plus ou moins équivalents aux transistors. Les ordinateurs d'avant l'année 1944, étaient tous de ce type. Quelques ordinateurs des années 50 étaient de ce type, mais leur nombre n'a pas dépassé 30. Il faut dire qu'ils ont rapidement laissé la place à des ordinateurs purement électroniques, que nous allons voir dans ce qui suit.

===La première génération : les tubes à vide===

Les ordinateurs qui ont suivi les ordinateurs électromécaniques sont regroupés dans la '''première génération d'ordinateur'''. Ils étaient conçus avec des tubes à vide, ce qui les place entre les premiers ordinateurs électro-mécaniques et les ordinateurs utilisant des transistors. Les tubes à vide étaient assez encombrants, ils consommaient beaucoup de courant, ils chauffaient et étaient assez peu fiables. Ils tombaient en panne assez souvent. Et ils étaient assez simples à fabriquer, mais restaient malgré tout chers.

[[File:Elektronenroehren-auswahl.jpg|centre|vignette|upright=2|Tubes à vides.]]

Au vu de la taille des tubes à vide, les ordinateurs de l'époque étaient composés de plusieurs milliers de ces tubes, guère plus. Et malgré cela, un ordinateur prenait facilement un étage de bâtiment entier, ou au moins plusieurs pièces. La conséquence est que les ordinateurs de première génération étaient très simples, rudimentaires quand on les compare aux ordinateurs modernes. Ils ne géraient que quelques opérations simples : l'addition, la soustraction, pas grand-chose de plus. À quelques exceptions près, ils ne géraient pas la multiplication et encore moins la division, cela aurait demandé trop de tubes à vides.

Une des toutes premières machines construite avec des tubes à vide était l'Atanasoff–Berry. Ce n'était pas un ordinateur, car elle ne pouvait pas exécuter de programme sans intervention humaine pour séquencer des opérations, mais c'était la première machine de calcul purement électronique, sans aucune pièce mécanique. Elle utilisait une mémoire RAM construite avec des condensateurs, ceux-ci étant placés sur des cylindres tournants. Les circuits de calcul étaient construits avec des tubes à vide et faisaient leur travail un bit à la fois. Elle fonctionnait à une fréquence de 60 Hz et pouvait faire 30 additions/soustractions par seconde. Les nombres étaient encodés sur 50 bits. 

[[File:Atanasoff Berry Computer.gif|centre|vignette|upright=2.5|Atanasoff–Berry.]]

L'arrivée de l'ENIAC en 1945 a changé la donne. Cet ordinateur a introduit plusieurs innovations majeures. La première est assez technique, il s'agit de la turing-complétude, elle a trait aux programmes qui peuvent être écrit pour un ordinateur, nous ne la détaillerons pas ici.

[[File:BabyArchitecture.png|vignette|Architecture de la Manchester Baby.]]

En 1948, le ''Manchester Baby'' a introduit une innovation extrêmement importante : le programme n'était plus mémorisé sur des cartes perforées, mais dans une mémoire électronique à l’intérieur de l'ordinateur lui-même. En clair, le ''Manchester Baby'' était le premier '''ordinateur à programme stocké en mémoire''' en français. Au-delà de ça, le Manchester Baby restait quand même très simple, c'était limite un prototype.

Niveau interface, l'ordinateur avait une console avec 32 boutons, des interrupteurs et un écran de sortie sur lequel afficher les résultats. A l'intérieur, il y avait un processeur et une RAM de 32 nombres de 32 bits, fabriquées avec des tubes Williams (abordés dans une annexe à la fin du cours). Une instruction prenant autant de place qu'un nombre en RAM, ce qui limitait les programmes à 32 instructions maximum. Le processeur gérait 8 instructions en tout, mais la seule instruction de calcul qu'il gérait était la soustraction. L'addition n'était pas supportée. Il pouvait cependant émuler l'addition à partir d'une soustraction et inversant l'opérande soustrait.

Le Manchester Mark 1 était une amélioration du Manchester Baby. Il utilisait 4500 tubes à vide. L'ordinateur gérait des nombres de 40 bits, mais les instructions étaient codées sur 20 bits. La RAM avait la même taille, à savoir 32 nombres, leur taille était simplement augmentée. Par contre, la RAM était complémentée par l’ancêtre du disque dur magnétique, à savoir un tambour magnétique, l’ancêtre du disque dur magnétique. Il contenait 40 pages, chacune ayant la même taille que la RAM. Contrairement à la Manchester Baby, son processeur gérait l'addition et quelques opérations logiques (ET et OU), en plus de la soustraction et de la comparaison.

Par la suite, les ordinateurs commerciaux ont vu le jour. Les ordinateurs précédents provenaient de projets de recherches, souvent publics. Mais les entreprises privées se sont mises à fabriquer des ordinateurs elle-mêmes, pour les vendre à d'autres entreprises. On peut notamment citer les ordinateurs comme le UNIVAC I, le Bull Gamma 3 ou les premiers ordinateurs IBM. La performance de ces ordinateurs était nettement plus importante que leurs prédécesseurs, avec des fréquences de l'ordre de la centaine de kilo-hertz. Par exemple, le Bull Gamma 3 allait à 281 kHz, l'IBM 650 allait à 50 Khz.

===La seconde génération : le remplacement des tubes à vides par des transistors===

[[File:IBM 7070.jpg|vignette|Cartes imprimées de l'IBM 704, avec des transistors et résistances dessus.]]

La '''seconde génération''' est celle des ordinateurs fabriqués avec des '''transistors''' isolés, reliés entre avec des fils électriques. Les transistors en question possèdent trois broches, des pattes métalliques sur lesquelles on connecte des fils électriques. Le transistor s'utilise le plus souvent comme un interrupteur commandé par sa troisième broche. Le courant qui traverse les deux premières broches passe ou ne passe pas selon ce qu'on met sur la troisième.

[[File:Transistor basic flow.svg|centre|vignette|Un transistor est un morceau de conducteur, dont la conductivité est contrôlée par sa troisième broche/borne.]]

Les ordinateurs de seconde génération avaient entre 1000 et 500 000 transistors. Les capacités des ordinateurs étaient donc nettement supérieures à celles des ordinateurs de première génération. Une part non négligeable des ordinateurs de seconde génération supportait l'opération de multiplication, absente sur les ordinateurs de première génération. Néanmoins, cela variait beaucoup selon les ordinateurs.

Un exemple assez hors du commun est celui du premier modèle de l'IBM 1620. Le tout premier modèle n'avait aucun circuit de calcul, il n'était même pas capable de faire une addition ou une multiplication. A la place, il utilisait une table d'addition et une table de multiplication en mémoire RAM. Les deux tables devaient être initialisées par le logiciel lors du démarrage de la machine. La table d'addition faisait une centaine de chiffres, la table de multiplication faisait le double. Le processeur de l'ordinateur gérait des instructions pour faire des additions ou des multiplications, mais ces opérations lisaient le résultat dans la table d'addition. Les calculs étaient faits chiffre par chiffre, avec un encodage partiellement décimal, partiellement binaire (des chiffres décimaux étaient encodés en binaire, nous en reparlerons quand nous parlerons du BCD) !

[[File:KL CoreMemory.jpg|vignette|Mémoire à tore de ferrite.]]

Les transistors n'étaient utilisés que pour le processeur et les circuits annexes. La mémoire n'était pas faite en transistors, pas à cette époque. La mémoire était une mémoire aujourd'hui abandonnée, appelée une '''mémoire à tores de ferrite'''. Elle sera détaillée dans un chapitre ultérieur. Mais sachez pour le moment qu'il s'agit d'une mémoire au support magnétique, les données étant stockées sur un support magnétique.

Transistors comme tubes à vide prenaient beaucoup de place, ce qui fait que les ordinateurs étaient assez gros. Concrètement, ils prenaient une pièce de bâtiment entière dans le meilleur des cas. C'était l'époque des gros ''mainframes'', reliés à des terminaux, peu puissants comparé aux standards actuels. Seules les grandes entreprises et les grands instituts de recherche pouvaient se payer les services de ce genre d'ordinateurs. Seuls les professionnels avaient accès à ce genre d'équipement.

===La troisième génération : le circuit intégré===

[[File:D8259AC-2.jpg|vignette|Exemple de circuit intégré.]]

La troisième génération est toujours fabriquée avec des transistors, mais dont la taille a été réduite. Avec l'évolution de la technologie, les transistors ont diminué en taille, de plus en plus. Ils sont devenus tellement petits qu'ils ont fini par être regroupés dans des '''circuits intégrés''', des circuits regroupent plusieurs transistors sur la même puce de silicium. Les circuits intégrés se présentent le plus souvent sous la forme de boitiers rectangulaires, comme illustré ci-contre. D'autres ont des boitiers de forme carrées, comme ceux que l'on peut trouver sur les barrettes de mémoire RAM, ou à l'intérieur des clés USB/ disques SSD.

Lors de cette génération, les processeurs étaient fournis en pièces détachées qu'il fallait relier entre elles. Le processeur était composé de plusieurs circuits intégrés séparés, impossible de mettre un processeur dans un seul boitier. Un exemple de processeur conçu en kit est la série des Intel 3000. Elle regroupe plusieurs circuits séparés aux noms à coucher dehors, mais dont vous comprendrez ce qu'ils veulent dire dans les chapitres adéquats : l'Intel 3001 est un séquenceur, l'Intel 3002 regroupe unité de calcul et registres, le 3003 est un circuit d'anticipation de retenue complémentaire du 3002, le 3212 est une mémoire tampon, le 3214 est une unité de gestion des interruptions, les 3216/3226 sont des interfaces de bus mémoire. On pourrait aussi citer la famille de circuits intégrés AMD Am2900.

Même si le processeur était en pièces détachées, utiliser une dizaine de circuits intégrés était nettement mieux que d'utiliser plusieurs milliers de transistors individuels. En conséquence, les ordinateurs ont vu leur taille grandement réduite, passant de pièces entières à une simple armoire, voire à quelques cartes intégrées superposées. De plus, le prix des circuits intégré était abordable, du moins comparé aux ordinateurs d'avant. Le prix des ordinateurs a alors grandement décru, permettant à des entreprises et administrations de taille modeste de s'équiper d'ordinateurs.

===La quatrième génération : le microprocesseur===

[[File:MOS6502.svg|vignette|Microprocesseur, ici un processeur MOS6502, de la quatrième génération.]]

Lors de la troisième génération, les circuits intégrés regroupaient plusieurs dizaines ou centaines de transistors, mais sont rapidement montés en gamme. De centaines de transistors, ils sont passés au millier de transistors, puis au million et maintenant au-delà du milliard. Les transistors étaient devenus tellement petits, tellement miniaturisés, qu'il était devenu possible de mettre un processeur entier dans un circuit intégré. C'est ainsi qu'est né le microprocesseur, à savoir un processeur qui tient tout entier dans un seul circuit imprimé. La quatrième génération d’ordinateur est celle des ordinateurs basés autour d'un microprocesseur.

Les tout premiers microprocesseurs étaient des processeurs à application militaire, comme le processeur du F-14 CADC ou celui de l'Air data computer. Le tout premier microprocesseur commercialisé au grand public est le 4004 d'Intel, sorti en 1971. L'intel 4004 comprenait environ 2300 transistors, avait une fréquence de 740 MHz, pouvait faire 46 opérations différentes, et manipulait des entiers de 4 bits. Il était au départ un processeur de commande, prévu pour être intégré dans la calculatrice Busicom calculator 141-P, mais il fut utilisé pour d'autres applications quelque temps plus tard. Immédiatement après le 4004, les premiers microprocesseurs 8 bits furent commercialisés. Le 4004 fut suivi par le 8008 et quelques autres processeurs 8 bits extrêmement connus, comme le 8080 d'Intel, le 68000 de Motorola, le 6502 ou le Z80.

Les microprocesseurs permirent encore uen fois de réduire la taille des ordinateurs, qui pouvaient tenir dans un boitier de PC, ou un boitier de console de jeu. Le prix des ordinateurs a aussi chuté en même temps que les transistors étaient miniaturisés. C'est cette invention qui permis l'invention des consoles de jeux et des mini-ordinateurs, à savoir les ordinateurs personnels. Sans miniaturisation, on n'aurait pas d'ordinateur personnel, pas de PC fixe ou portable.

==L'organisation du cours : les différents niveaux d'explication==

Le fonctionnement d'un ordinateur est assez complexe à expliquer car les explications peuvent se faire sur plusieurs niveaux. Par plusieurs niveaux, on veut dire qu'un ordinateur est composé de composants très simples, qui sont assemblés pour donner des composants eux-même plus complexes, qui sont eux-même regrouper, etc. Étudier tout cela demande de voir plusieurs niveaux, allant de transistors très petits à des processeurs multicœurs. Les niveaux les plus bas sont de l'électronique pur et dure, alors que ceux plus haut sont à mi-chemin entre électronique et informatique.

===Les niveaux d'abstraction en architecture des ordinateurs===

Les trois premiers niveaux sont de l'électronique pur et dure. Ils correspondent aux premiers chapitres du cours, qui porteront sur les circuits électroniques en général.
* Le premier niveau est celui des '''transistors''', des circuits intégrés, des ''wafer'' et autres circuits de très petite taille.
* Le second niveau est celui des '''portes logiques''', des circuits très basiques, très simples, à la base de tous les autres.
* Le troisième niveau est celui dit de la '''''Register Transfer Level''''', où un circuit électronique est construit à partir de circuits basiques, dont des registres et autres circuits dits combinatoires.
Les deux niveaux suivants sont de l'informatique proprement dit. C'est dans ces deux niveaux qu'on étudie les ordinateurs proprement dit, les circuits qu'il y a dedans et non l'électronique en général.
* Le quatrième niveau est celui de la '''microarchitecture''', qui étudie ce qu'il y a à l'intérieur d'un processeur, d'une mémoire, des périphériques et autres.
* Le cinquième niveau est celui de l''''architecture externe''', qui décrit l'interface du processeur, de la mémoire, d'un périphérique ou autre. Par décrire l'interface, on veut dire : comment un programmeur voit le processeur et la mémoire, comment il peut les manipuler. Une architecture externe unique peut avoir plusieurs microarchitecture, ce qui fait qu'on sépare les deux. Tout cela sera plus clair quand on passera aux chapitres sur le processeur et les mémoires.

Nous n'allons pas voir les 5 niveaux dans l'ordre, des transistors vers l'architecture externe. En réalité, nous allons procéder autrement. La première partie du cours portera sur les trois premiers niveaux, le reste sur les deux autres. Les 5 niveaux seront vus dans des chapitres séparés, du moins le plus possible. Au niveau pédagogique, tout est plus simple si on scinde les 5 niveaux. Bien sûr, il y a quelques explications qui demandent de voir plusieurs niveaux à la fois. Par exemple, dans le chapitre sur les mémoires caches, nous auront des explications portant sur la RTL, la microarchitecture du cache et son architecture externe. Mais le gros du cours tentera de séparer le plus possible les 5 niveaux.

===Les trois parties principales du cours===

Nous allons commencer par parler du binaire, avant de voir les portes logiques. Avec ces portes logiques, nous allons voir comment fabriquer des circuits basiques qui reviendront très souvent dans la suite du cours. Nous verrons les registres, les décodeurs, les additionneurs et plein d'autres circuits. Puis, nous reviendrons au niveau des transistors pour finir la première partie. La raison est que c'est plus simple de faire comme cela. Tout ce qui a trait aux transistors sert à expliquer comment fabriquer des portes logiques, et il faut expliquer les portes logiques pour voir le niveau de la RTL.

Une fois la première partie finie, nous allons voir les différents composants d'un ordinateur. Une première partie expliquera ce qu'il y a dans un ordinateur, quels sont ses composants. Nous y parlerons de l'architecture de base, de la hiérarchie mémoire, des tendances technologiques, et d'autres généralités qui serviront de base pour la suite. Puis, nous verrons dans l'ordre les bus électroniques, les mémoires RAM/ROM, le processeur, les périphériques, les mémoires de stockage (SSD et disques durs) et les mémoires caches. Pour chaque composant, nous allons voir leur architecture externe, avant de voir leur microarchitecture. La raison est que la microarchitecture ne peut se comprendre que quand on sait quelle architecture externe elle implémente.

Enfin, dans une troisième partie, nous allons voir les optimisations majeures présentes dans tous les ordinateurs modernes, avec une partie sur le pipeline et le parallélisme d'instruction, et une autre sur les architectures parallèles. Pour finir, les annexes de fin parlerons de sujets un peu à part.

&lt;noinclude&gt;
{{NavChapitre | book=Fonctionnement d'un ordinateur
           | next=L'encodage des données
           | nextText=L'encodage des données
}}
&lt;/noinclude&gt;</text>
      <sha1>8a8wurewyp5on2dahmakp4ur93esu2d</sha1>
    </revision>
    <revision>
      <id>744146</id>
      <parentid>744145</parentid>
      <timestamp>2025-06-05T11:49:53Z</timestamp>
      <contributor>
        <username>Mewtow</username>
        <id>31375</id>
      </contributor>
      <minor />
      <comment>/* Les ordinateurs électro-mécaniques : les premiers ordinateurs */</comment>
      <origin>744146</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="45970" sha1="lfnf2mtk6b0x714wzo55y6l8l9i35sb" xml:space="preserve">Pour commencer, nous allons voir qu'il existe de nombreux types d'ordinateurs. Le plus connu est certainement le PC, l'ordinateur personnel, que vous avez sans doute dans votre salon. Les ordinateurs portables sont un deuxième type d'ordinateur assez intuitif, que vous avez peut-être. Mais il y a aussi d'autres types d'ordinateurs auxquels vous n'avez jamais été confrontés.

==Les différents types d'ordinateurs==

Dans cette section, nous allons décrire rapidement les ordinateurs les plus courant, mais surtout voir ce qu'il y a à l'intérieur d'un ordinateur.

===L'ordinateur de type PC fixe===

De l'extérieur, l'ordinateur est composé d'une unité centrale sur laquelle on branche des périphériques.

[[File:Typical computer architecture systems.jpg|vignette|upright=1.5|Exemples de périphériques, connectés à une unité centrale (ici appelée à tort ''operating system'').]]

Les '''périphériques''' regroupent l'écran, la souris, le clavier, l'imprimante, et bien d'autres choses. Ils permettent à l'utilisateur d'interagir avec l'ordinateur : un clavier permet de saisir du texte sous dans un fichier, une souris enregistre des déplacements de la main en déplacement du curseur, un écran affiche des données d’images/vidéos, un haut-parleur émet du son, etc. Tout ce qui est branché sur un ordinateur est, formellement un périphérique.

L''''unité centrale''' est là où se trouvent tous les composants importants d'un ordinateur, ceux qui font des calculs, qui exécutent des logiciels, qui mémorisent vos données, etc. Voici ce à quoi ressemble l'intérieur de l'unité centrale. Trois sections sont visibles : l'alimentation électrique en haut à gauche, la carte mère en bas à gauche et en jaune/orange, les disques et lecteurs à droite des câbles. Et on voit aussi beaucoup de câbles.

[[File:Asus P5K-SEIntel E6320.jpg|centre|vignette|upright=2|Exemple d'unité centrale.]]

Tout en haut à gauche, se trouve l''''alimentation électrique''', qui convertit le courant de la prise électrique en un courant plus faible, utilisable par les autres composants. Elle émet de nombreux câbles assez gros, qui sont reliés au reste. Les PC actuels utilisent des alimentations électriques standardisées, qui fournissent trois tensions au reste de l'ordinateur : une tension de 12 Volts, une de 5 Volts, une de 3,3 Volts.

À droite, caché par la partie &quot;métallique&quot; du boitier, se trouvent les lecteurs de CD/DVD, et les disques durs. Les lecteurs CD-ROM ou DVD-ROM permettaient de lire des CD ou des DVD. Je parle au passé, car ils ont aujourd'hui disparu des ordinateurs modernes. Les '''disques durs''' sont des mémoires de stockage, qui mémorisent vos données de manière permanente. De nos jours, ils sont remplacés par des SSD, qui sont des disques durs électroniques, là où les disques durs proprement dit sont des mémoires magnétiques. Nous verrons la différence dans deux chapitres dédiés, un sur les disques durs, l'autre sur les SSD.

En bas à droite, se trouve la '''carte mère''' un support plat, en plastique ou en céramique, sur laquelle sont soudés/connectés les autres composants. Sur celle-ci, de nombreux composants sont soudés, d'autres sont branchés dessus avec des câbles, d'autres sont connectés dessus avec des connecteurs. Ils sont reliés entre eux par des fils conducteurs, le plus souvent du cuivre ou de l’aluminium, ce qui leur permet de s’échanger des données. Sur les cartes simples, ces fils sont intégrés dans la carte électronique, dans des creux du plastique. Ils portent le nom de pistes.

Avant, les disques durs, SSD et lecteurs de CD/DVD sont branchés dessus via des connecteurs dédiés, appelés des connecteurs S-ATA. De nos jours, ils sont branchés sur un autre connecteur, grâce à l'interface NVME. Toujours est-il qu'ils sont reliés à la carte mère par des câbles, ce qui montre que ce sont des sortes de périphériques interne. Ils sont placés dans le boitier, mais on aurait tout aussi bien pu les mettre à l'extérieur, vu qu'ils communiquent avec l'ordinateur par l'intermédiaire d'un câble ou d'un connecteur dédié.

Mais deux autres composants très importants sont eux placés sur la carte mère, directement. Ils ont chacun un connecteur dédié, sur lequel ils sont branchés directement, sans passer par l'intermédiaire d'un câble, mais sans être soudés non plus. Il s'agit du processeur et de la mémoire RAM, deux composants centraux des PC modernes.

[[File:Pentium III SL4CB.jpg|thumb|Processeur Pentium III.]]

Le '''processeur''' traite les données, les modifie, les manipule. Pour faire simple, il s’agit d’une grosse calculatrice hyper-puissante. Il comprend à la fois un circuit qui fait des calculs, et un circuit de contrôle qui s'occupe de séquencer les calculs dans l'ordre demandé. Il est souvent caché sous un radiateur, lui-même surmonté par un ventilateur. En effet, un processeur chauffe beaucoup, ce qui demande d'évacuer cette chaleur. Un chapitre entier expliquera pourquoi les processeurs chauffent, ainsi que les techniques utilisées pour limiter leur production de chaleur et leur consommation électrique.

La '''mémoire vive''' conserve des informations/données temporairement, tant que le processeur en a besoin. Elle prend la forme de barrettes de RAM, comme montré ci-dessous.

[[File:2 gb ddr2 667.jpg|centre|vignette|upright=2|Barrette de RAM.]]

Outre ces composants dits principaux, un ordinateur peut comprendre plusieurs composants moins importants, surtout présents sur les ordinateurs personnels. Ils sont techniquement facultatifs, mais sont très présents dans les ordinateurs personnels. Cependant, certains ordinateurs spécialisés s'en passent. Il s'agit des diverses '''cartes d'extension''' sont branchées sur la carte mère. Elles permettent d’accélérer certains calculs ou certaines applications, afin de décharger le processeur. Par exemple, la carte graphique s'occupe des calculs graphiques, qu'il s'agisse de graphismes 3D de jeux vidéos ou de l'affichage en 2D du bureau. Dans un autre registre, la carte son prend en charge le microphone et les haut-parleurs.

[[Fichier:Personal computer, exploded 4.svg|thumb|upright=1.0|Éclaté d'un ordinateur de type PC :&lt;br /&gt;
1 : Écran ;&lt;br /&gt;
2 : Carte mère ;&lt;br /&gt;
3 : Processeur ;&lt;br /&gt;
4 : Câble Parallel ATA ;&lt;br /&gt;
5 : Mémoire vive (RAM) ;&lt;br /&gt;
6 : Carte d'extension ;&lt;br /&gt;
7 : Alimentation électrique ;&lt;br /&gt;
8 : Lecteur de disque optique ;&lt;br /&gt;
9 : Disque dur ;&lt;br /&gt;
10 : Clavier ;&lt;br /&gt;
11 : Souris.]]

Si on regarde une carte mère de face, on voit un grand nombre de connecteurs, mais aussi des circuits électroniques soudés à la carte mère.

[[File:Architecture matérielle d'une carte mère.png|centre|vignette|upright=2.0|Architecture matérielle d'une carte mère]]

Les '''connecteurs''' sont là où on branche les périphériques, la carte graphique, le processeur, la mémoire, etc. Dans l'ensemble, toute carte mère contient les connecteurs suivants :
* Le processeur vient s’enchâsser dans la carte mère sur un connecteur particulier : le '''socket'''. Celui-ci varie suivant la carte mère et le processeur, ce qui est source d'incompatibilités.
* Les barrettes de mémoire RAM s’enchâssent dans un autre type de connecteurs: les '''slots mémoire'''.
* Les mémoires de masse disposent de leurs propres connecteurs : connecteurs P-ATA pour les anciens disques durs, et S-ATA pour les récents.
* Les périphériques (clavier, souris, USB, Firewire, ...) sont connectés sur un ensemble de connecteurs dédiés, localisés à l'arrière du boitier de l'unité centrale. 
* Les autres périphériques sont placés dans l'unité centrale et sont connectés via des connecteurs spécialisés. Ces périphériques sont des cartes imprimées, d'où leur nom de '''cartes filles'''. On peut notamment citer les cartes réseau, les cartes son, ou les cartes vidéo.

===Les ordinateurs portables===

[[File:Samsung QX-511 (2).JPG|vignette|Ordinateur portable Samsung QX-511 (2), pour illustration.]]

Un ordinateur portable est identique à un ordinateur de type PC. Si vous ouvrez votre ordinateur portable (attention à la garantie), vous retrouverez les mêmes composants qu'un PC à l'intérieur. Un point important est la présence d'une batterie à l'intérieur du PC portable, absente des PC fixes.

[[File:LG gram 14Z90Q mainboard with battery.jpg|centre|vignette|upright=2|LG gram 14Z90Q avec sa batterie.]]

Une fois la batterie et les circuits associés retiré, la seule différence notable est que tous les composants sont soudés sur la carte mère, au lieu d'être branchés sur des connecteurs, à part éventuellement la RAM et le disque dur.

[[File:LG gram 14Z90Q mainboard without battery.jpg|centre|vignette|upright=2|LG gram 14Z90Q sans sa batterie.]]

La RAM est parfois soudée sur la carte mère, d'autres fois sous la forme de barrettes de mémoire vive semblables à celles des PC. Dans le dernier cas, elle est connectée à des connecteurs spécifiques, ce qui permet de les changer/upgrader. Les PC portables sont parfois construits de manière à pouvoir changer la RAM facilement, en ouvrant un cache spécial, concu pour.

[[File:Lenovo G555 состав - Донор.JPG|centre|vignette|upright=2|Lenovo G555.]]

La conception d'un ordinateur portable est légèrement différente de celle d'un PC, pour des raisons thermiques. Un PC fixe a plus de place pour évacuer sa chaleur. Les ventilateurs peuvent plus facilement déplacer l'air dans le boitier, même si le flux d'air dans le boitier est éventuellement gêné par la carte graphique. Mais l'évacuation de la chaleur est assez efficace. Sur les PC portables, leur finesse fait que le trajet de l'air est beaucoup plus contraint. Évacuer la chaleur produite par l'ordinateur est plus complexe, ce qui demande d'utiliser des systèmes de refroidissement et de ventilation spécifiques.

Là où les PC fixes se débrouillent avec des radiateurs et des ventilateurs posés sur le processeur, les PC portables font autrement. Ils ne peuvent pas forcément mettre le ventilateur sur le processeur. A la place, ils mettent le ventilateur à côté, mais le processeur est surmonté par un mécanisme de transmission de la chaleur, qui transfère la chaleur du processeur vers le ventilateur.

[[File:Diagram - How a laptop cooling system works.png|centre|vignette|upright=2|Comment fonctionne le système de ventilation d'un ordinateur portable, en anglais.]]

Les difficultés pour dissiper la chaleur font que les ordinateurs portables utilisent souvent des composants peu performants, mais qui chauffent peu. En effet, nous verrons que plus un composant est puissant, plus il chauffe. La relation n'est pas parfaite, mais les processeurs haute performance chauffent plus que les modèles d'entrée ou milieu de gamme moins puissants. En conséquence, les PC portables sont souvent moins puissants que les PC fixes, même pour les modèles dit ''gaming''.

===Les serveurs et ''mainframes''===

Les grandes entreprises utilisent des ordinateurs de grande taille, très puissants, appelés des ''mainframes''. Ils sont souvent confondus avec les serveurs par le grand public, il y a une différence entre les deux. Un serveur est une fonction logicielle/réseau, pas un type d'ordinateur. Mais laissons cette différence de côté, ce qui est dit pour les ''mainframes'' sert pour les gros serveurs haute performance.

[[File:IBM Z15 mainframe.jpg|vignette|Exemple de ''mainframe''' de type IBM Z15.]]

Les anciens ''mainframes'' des années 50-80 avaient une taille pouvant être impressionnante, au point de prendre une pièce complète d'un bâtiment. Mais de nos jours, les ''mainframes'' tiennent dans une grosse armoire un peu haute. Les ''mainframes'' doivent rester allumé en permanence et ne doivent pas être éteint, sauf éventuellement quelques jours par an pour des opérations de maintenance. Ils utilisent pour cela des techniques spécifiques, avec beaucoup de redondance interne.

[[File:ACONIT hall grandes machines.jpg|centre|vignette|upright=2|''Mainframe'' ACONIT.]]

Les ''mainframes'' sont aussi conçus pour mutualiser au maximum leur utilisation, ils peuvent être utilisés par plusieurs utilisateurs à la suite, voire en même temps. Pour cela, les anciens ''mainframes'' étaient capables de faire tourner plusieurs applications distinctes l'une à la suite de l'autre, avec des commutations fréquentes entre logiciels. De nos jours, ils sont capables d'exécuter un grand nombre de tâches en même temps, grâce à la présence de plusieurs processeurs. Les ''mainframes'' modernes sont même capables de faire tourner plusieurs systèmes d'exploitation en même temps si besoin.

Les anciens ''mainframes'' étaient des ordinateurs assez simples, avec un processeur, de la mémoire RAM, un ou plusieurs disques durs, pas plus. Le ''mainframe'' était tellement énorme et cher que les entreprises n'en avaient qu'un seul pour toute l'entreprise. Les employés avaient sur leur bureau des terminaux, qui permettaient d'accéder à l'ordinateur central, mais n'étaient pas des ordinateurs. Les terminaux étaient des composants électroniques simples, avec un écran, un clavier et une souris, mais sans processeur. Ils envoyaient des données au ''mainframe'', ils en recevaient de sa part, mais tout traitement était réalisé sur le ''mainframe''. L'arrivée sur le marché des ordinateurs personnels, de type PC fixe/portable, a entrainé l'abandon de ce genre de pratique, tous les employés ont maintenant un ordinateur rien que pour eux.

{|
|-
! colspan=&quot;2&quot; | Exemples de terminaux
|-
|[[File:Terminal-in2-sm9400.jpg|centre|vignette|upright=1.5|Exemple de terminal. Notez la présence d'un écran et d'un clavier, mais l'asbence d'une unité centrale.]]
|[[File:Chromatics CT4100.jpg|vignette|upright=1.5|Autre exemple de terminal. Le clavier est couplé à un stylo CRT, qui remplacait la souris et agissait sur l'écran comme s'il était tactile.]]
|-
! colspan=&quot;2&quot; | Intérieur d'un terminal
|-
|[[File:CT1024 Monitor.jpg|vignette|upright=1.5|Terminal CT1024, sans le boitier extérieur.]]
|[[File:CT1024 Terminal System.jpg|vignette|upright=1.5|Terminal CT1024, description des composants interne.]]
|}

De nos jours, les ''mainframes'' contiennent en réalité plusieurs ordinateurs simples interconnectés via un réseau local. Un ''mainframe'' qui tient dans une armoire contient facilement une dizaine ou centaine de processeurs, plein de RAM, des disques durs séparés dans une armoire distincte, etc. Vu qu'ils communiquent uniquement via le réseau, ils n'ont pas d'interface, pas d'écran, 'entrée via clavier/souris. Le tout est commandé avec une console de commande, typiquement un ordinateur portable ou un terminal assez simple séparé de l'armoire, qui permet à un administrateur de faire des opérations de surveillance, configuration et maintenance. Il peut y avoir une console de commande pour plusieurs armoires séparées, la console peut même être dans un autre bâtiment et accéder au ''mainframe'' par le réseau.

[[File:IBM System Z9 (type 2094 inside).jpg|centre|vignette|upright=2|''Mainframe'' de type IBM System Z9. L'ordinateur portable sert de console pour qu'un administrateur fasse des opérations de surveillance, configuration et maintenance.]]

Les processeurs et la RAM sont typiquement installés sur des cartes amovibles, qui sont connectées au fond de l'armoire lors de l'installation. Il est même possible de retirer ou d'ajouter des cartes en fonctionnement, afin d'ajouter/retirer des processeurs, des disques durs, etc. Ce qui est très utile si un composant est en panne et qu'il faut le remplacer. 

[[File:IBM TotalStorage Exp400.jpg|centre|vignette|upright=2|IBM TotalStorage Exp400]]

==Un peu d'abstraction : qu'est-ce qu'un ordinateur ?==

Un ordinateur comprend donc un processeur, plusieurs mémoires, des cartes d'extension et une carte mère pour connecter le tout. Mais il s'agit là d'une description assez terre-à-terre de ce qu'est un ordinateur. Une autre description, plus abstraite, se base sur le fait qu'un ordinateur est une énorme calculatrice programmable. Elle permet d'expliquer pourquoi il y a une distinction entre processeur et mémoire, entre unité centrale et périphériques. Tout ce qui va suivre pourra vous paraitre assez abstrait, mais rassurez-vous : les prochains chapitres rendront tout cela plus concrets.

===La séparation entre entrées-sorties et traitement===

L'unité centrale peut être vue comme une énorme calculatrice ultra-puissante, qui exécute des commandes/opérations. Mais à elle seule, elle ne servirait à rien, il faut interagir avec par l'intermédiaire de plusieurs périphériques. Il existe deux types de périphériques, qui sont conceptuellement différents. Les périphériques comme le clavier ou la souris permettent d'envoyer des informations à l'ordinateur, d'agir sur celui-ci. A l'inverse, les écrans transmettent des informations dans le sens inverse : de l'ordinateur vers l'utilisateur. Les premiers sont appelés des '''entrées''', les seconds des '''sorties'''.

Dans un ordinateur, les informations sont représentées sous la forme de nombres. Toute donnée dans un ordinateur est codée avec un ou plusieurs nombres regroupés dans une donnée, un fichier, ou autre. Et la transmissions avec les entrées et sorties se fait là-encore avec des nombres. Par exemple, quand vous appuyez sur votre clavier, le clavier envoie un numéro de touche à l'unité centrale, qui indique quelle touche a été appuyée. L'image à afficher à l'écran est codée sous la forme d'une suite de nombres (un par pixel). L'image est envoyée à l'écran, qui traduit la suite de nombre en image à afficher. Les entrées traduisent des actions utilisateurs en nombres, on dit que les entrées encodent les actions utilisateur. Les sorties font la traduction inverse, elles transforment des suites de nombres en une action physique. On dit qu'elles décodent des informations.

Pour résumer, toute appareil électronique est composé par :
* Des '''entrées''' sur lesquelles l'utilisateur agit sur l'ordinateur. Les entrées transforment les actions de l'utilisateur en nombres, qui sont interprétés par l'ordinateur.
* Une '''unité de traitement''', qui manipule des nombres et fait des calculs/opérations dessus. Les nombres proviennent des entrées, du disque dur, ou d'autres sources, peu importe.
* Des '''sorties''', qui va récupèrent le résultat calculé par l'unité de traitement pour en faire quelque chose : écrire sur une imprimante ou sur un moniteur, émettre du son,...

[[File:Ordinateur théorique Simple 1.png|centre|vignette|upright=2|Ordinateur théorique Simple 1]]

L'unité de traitement proprement dite, celle qui fait les calculs, est couplée à une mémoire qui mémorise les opérandes et résultats des calculs. La séparation entre processeur et mémoire est nécessaire pour qu'un appareil électronique soit qualifié d'ordinateur. De nombreux appareils n'ont pas de séparation entre unité de traitement et mémoire, comme certaines vielles radios AM/FM.

[[File:Schéma de principe d'un ordinateur.png|centre|vignette|upright=2|Schéma de principe d'un ordinateur]]

===Un ordinateur est un appareil programmable===

Les appareils simples sont non-programmables, ce qui veut dire qu’ils sont conçus pour une utilisation particulière et qu’ils ne peuvent pas faire autre chose. Par exemple, les circuits électroniques d’un lecteur de DVD ne peuvent pas être transformé en lecteur audio ou en console de jeux... Les circuits non-programmables sont câblés une bonne fois pour toute, et on ne peut pas les modifier. On peut parfois reconfigurer le circuit, pour faire varier certains paramètres, via des interrupteurs ou des boutons, mais cela s’arrête là. Et cela pose un problème : à chaque problème qu'on veut résoudre en utilisant un automate, on doit recréer un nouveau circuit.

À l'inverse, un ordinateur n’est pas conçu pour une utilisation particulière, contrairement aux autres objets techniques. Il est possible de modifier leur fonction du jour au lendemain, on peut lui faire faire ce qu’on veut. On dit qu'ils sont '''programmables'''. Pour cela, il suffit d’utiliser un logiciel, une application, un programme (ces termes sont synonymes), qui fait ce que l'on souhaite. La totalité des logiciels présents sur un ordinateur sont des programmes comme les autres, même le système d'exploitation (Windows, Linux, ...) ne fait pas exception.

Un programme est une suite de d''''instructions machines''', chaque instruction effectuant une action dans l'ordinateur. Sur les ordinateurs modernes, les instructions les plus communes effectuent une opération arithmétique : une addition, une multiplication, une soustraction, etc. Les ordinateurs modernes sont donc de grosses calculettes très puissantes, capables d'effectuer des millions d'opérations par secondes.

Et qui dit opération dit nombres : un ordinateur gère nativement des nombres, qui sont codés en binaire sur la quasi-totalité des ordinateurs modernes. Les ordinateurs modernes sont capables de faire des calculs sur des nombres entiers, mais aussi des nombres à virgule. Il existe plusieurs manières de représenter des nombres en binaire, certaines représentant des nombres entiers dits naturels (0 et plus), d'autres des nombres signés (positifs ou négatifs), d'autres des nombres à virgule. Un chapitre entier détaillera comment sont encodés ces nombres.

Une instruction est représentée dans un ordinateur par une série de nombres entiers : un nombre qui indique quelle opération/commande effectuer et des autres nombres pour coder les données (ou de quoi les retrouver dans l'ordinateur). L'ordinateur récupére les commandes une par une, les traduit en opération à effectuer, exécuter l'opération, et enregistre le résultat. Puis il recommence avec la commande suivante.

[[File:Ordinateur Théorique Complexe 1.png|centre|vignette|upright=3|Ordinateur Théorique Complexe. En jaune, le programme informatique, la liste de commande. Le rectangle gris est l'ordinateur proprement dit.]]

De nombreux appareils sont programmables, mais tous ne sont pas des ordinateurs. Par exemple, certains circuits programmables nommés FPGA n'en sont pas. Pour être qualifié d'ordinateur, un appareil programmable doit avoir un processeur séparé de la mémoire. De plus, il doit utiliser un '''codage numérique''', chose que nous allons aborder dans le chapitre suivant.

===Les ordinateurs à programme mémorisé ou programme externe===

Au tout début de l'informatique, on utilisait des cartes perforées en plastique, sur lesquelles on inscrivait le programme à exécuter, les données à traiter, bref : tout ce qu'on donnait à manger à l'ordinateur. Par la suite, les premiers ordinateurs grand public, comme les Amstrad ou les Commodore, utilisaient des cassettes audio magnétiques pour stocker les programmes. Dans le même style, les consoles de jeu utilisaient autrefois des cartouches de jeu, qui contenaient le programme du jeu à exécuter. Pour résumer, les anciens ordinateurs mémorisaient les programmes sur un support externe, lu par un périphérique. De tels ordinateurs sont dits à '''programme externe'''.

: D’anciens ordinateurs personnels, comme l’Amstrad ou le Commodore, permettaient de taper les programmes à exécuter à la main, au clavier, avant d’appuyer une touche pour les exécuter. Nul besoin de vous dire que les cassettes audio étaient plus pratiques.

Mais de nos jours, les programmes sont enregistrés sur le disque dur de l'ordinateur ou dans une mémoire intégrée à l'ordinateur. On dit qu'ils sont installés, ce qui est un mot bien compliqué pour dire que le programme est enregistré sur le disque dur de l’ordinateur. A défaut de disque dur, le programme/logiciel est enregistré dans une mémoire spécialisée pour le stockage. Par exemple, sur les cartes électroniques grand public de marque Arduino, les programmes sont envoyés à la carte via le port USB, mais les programmes sont enregistrés dans la carte Arduino, dans une mémoire FLASH dédiée. Disque dur ou non, le programme est mémorisé dans la mémoire de l'ordinateur. Il est possible d'installer ou de désinstaller les programmes en modifiant le contenu de la mémoire. Le terme utilisé est alors celui de '''programme stocké en mémoire'''.

Les programmes à installer sont disponibles soit sur un périphérique, comme un DVD ou une clé USB, soit sont téléchargés depuis internet. Les premiers PC fournissaient les logiciels sur des disquettes, qui contenaient un programme d'installation pour enregistrer le programme sur le disque dur de l'ordinateur. Par la suite, le support des logiciels a migré vers les CD et DVD, les logiciels devenant de plus en plus gros. De nos jours, la majorité des applications sont téléchargées depuis le net, l'usage de périphériques est devenu obsolète, même les consoles de jeu abandonnent cette méthode de distribution.

==Les générations d'ordinateurs : un historique rapide==

L'informatique a beaucoup évolué dans le temps. Et une bonne partie de cette évolution tient à l'évolution de l’électronique sous-jacente. Les ordinateurs actuels sont fabriqués avec des transistors, des petits composants électroniques qui servent d'interrupteurs programmables, qu'on détaillera dans ce qui suit. Mais ça n'a pas toujours été le cas. Et cela permet de distinguer plusieurs '''générations d'ordinateurs'''.

===Les ordinateurs électro-mécaniques : les premiers ordinateurs===

Le tout premier ordinateur est le '''Z1''', un modèle unique inventé par Konrad Suze entre 1936 et 1938. Son processeur gérait non pas des nombres entiers, mais des nombres à virgule (des nombres dits flottants, pour être précis), encodés sur 22 bits. Le processeur du Z1 était capable de faire des additions et des soustractions, car il intégrait un circuit additionneur-soustracteur basique. Des circuits annexes permettaient de faire des multiplications et des divisions en enchainant des additions/soustractions successives. Il fonctionnait à une fréquence de 1 Hz, ce qui fait qu'il pouvait faire une addition/soustraction par seconde maximum.

[[File:Blue-punch-card-front.png|vignette|upright=0.5|Carte Perforée.]]

Niveau mémoire, la RAM de l'ordinateur était très limitée : seulement 16 nombres de 22 bits chacun. S'il s'agissait d'une mémoire électronique, les programmes étaient mémorisés sur une mémoire mécanique. Les programmes étaient enregistrés sur des cartes perforées, à savoir des cartes en papier/plastique dans lesquelles un 1 est codé par un trou dans le papier et un 0 par une absence de trou. Les programmes étaient exécutés par l'ordinateur quand on insérait la carte perforée dans le lecteur et qu'on appuyait sur un bouton.

[[File:German Museum of Technology, Berlin 2017 024.jpg|centre|vignette|upright=2|Réplique du Z1 au ''German Museum of Technology'' de Berlin, 2017.]]

Après sa destruction dans un bombardement, le Z1 a été reconstruit et amélioré, ce qui donné les deux ordinateurs Z2 et Z3. Quelques années plus tard, de nombreux ordinateurs ont été construits dans des laboratoires de recherche. Des grands noms de l'histoire de l'informatique datent de cette époque : le Harvard Mark I et le Colossus Mark 1 (UK) ont tous deux été mis en service en 1944, par exemple. Ils ont servi pour les cryptanalystes pour casser les codes utilisés par les Allemands pour leurs transmissions, pendant la seconde guerre mondiale.

Les ordinateurs cités dans le précédent paragraphe étaient tous des ordinateurs dit '''électro-mécaniques''', car ils mélangeaient des composants électroniques et des composants mécaniques (tout ce qui a trait aux cartes perforées, notamment). Les composants électroniques étaient soit des relais, soit des tubes à vides, les deux étant des interrupteurs commandables électriquement plus ou moins équivalents aux transistors. Les ordinateurs d'avant l'année 1944, étaient tous de ce type. Quelques ordinateurs des années 50 étaient de ce type, mais leur nombre n'a pas dépassé 30. Il faut dire qu'ils ont rapidement laissé la place à des ordinateurs purement électroniques, que nous allons voir dans ce qui suit.

===La première génération : les tubes à vide===

Les ordinateurs qui ont suivi les ordinateurs électromécaniques sont regroupés dans la '''première génération d'ordinateur'''. Ils étaient conçus avec des tubes à vide, ce qui les place entre les premiers ordinateurs électro-mécaniques et les ordinateurs utilisant des transistors. Les tubes à vide étaient assez encombrants, ils consommaient beaucoup de courant, ils chauffaient et étaient assez peu fiables. Ils tombaient en panne assez souvent. Et ils étaient assez simples à fabriquer, mais restaient malgré tout chers.

[[File:Elektronenroehren-auswahl.jpg|centre|vignette|upright=2|Tubes à vides.]]

Au vu de la taille des tubes à vide, les ordinateurs de l'époque étaient composés de plusieurs milliers de ces tubes, guère plus. Et malgré cela, un ordinateur prenait facilement un étage de bâtiment entier, ou au moins plusieurs pièces. La conséquence est que les ordinateurs de première génération étaient très simples, rudimentaires quand on les compare aux ordinateurs modernes. Ils ne géraient que quelques opérations simples : l'addition, la soustraction, pas grand-chose de plus. À quelques exceptions près, ils ne géraient pas la multiplication et encore moins la division, cela aurait demandé trop de tubes à vides.

Une des toutes premières machines construite avec des tubes à vide était l'Atanasoff–Berry. Ce n'était pas un ordinateur, car elle ne pouvait pas exécuter de programme sans intervention humaine pour séquencer des opérations, mais c'était la première machine de calcul purement électronique, sans aucune pièce mécanique. Elle utilisait une mémoire RAM construite avec des condensateurs, ceux-ci étant placés sur des cylindres tournants. Les circuits de calcul étaient construits avec des tubes à vide et faisaient leur travail un bit à la fois. Elle fonctionnait à une fréquence de 60 Hz et pouvait faire 30 additions/soustractions par seconde. Les nombres étaient encodés sur 50 bits. 

[[File:Atanasoff Berry Computer.gif|centre|vignette|upright=2.5|Atanasoff–Berry.]]

L'arrivée de l'ENIAC en 1945 a changé la donne. Cet ordinateur a introduit plusieurs innovations majeures. La première est assez technique, il s'agit de la turing-complétude, elle a trait aux programmes qui peuvent être écrit pour un ordinateur, nous ne la détaillerons pas ici.

[[File:BabyArchitecture.png|vignette|Architecture de la Manchester Baby.]]

En 1948, le ''Manchester Baby'' a introduit une innovation extrêmement importante : le programme n'était plus mémorisé sur des cartes perforées, mais dans une mémoire électronique à l’intérieur de l'ordinateur lui-même. En clair, le ''Manchester Baby'' était le premier '''ordinateur à programme stocké en mémoire''' en français. Au-delà de ça, le Manchester Baby restait quand même très simple, c'était limite un prototype.

Niveau interface, l'ordinateur avait une console avec 32 boutons, des interrupteurs et un écran de sortie sur lequel afficher les résultats. A l'intérieur, il y avait un processeur et une RAM de 32 nombres de 32 bits, fabriquées avec des tubes Williams (abordés dans une annexe à la fin du cours). Une instruction prenant autant de place qu'un nombre en RAM, ce qui limitait les programmes à 32 instructions maximum. Le processeur gérait 8 instructions en tout, mais la seule instruction de calcul qu'il gérait était la soustraction. L'addition n'était pas supportée. Il pouvait cependant émuler l'addition à partir d'une soustraction et inversant l'opérande soustrait.

Le Manchester Mark 1 était une amélioration du Manchester Baby. Il utilisait 4500 tubes à vide. L'ordinateur gérait des nombres de 40 bits, mais les instructions étaient codées sur 20 bits. La RAM avait la même taille, à savoir 32 nombres, leur taille était simplement augmentée. Par contre, la RAM était complémentée par l’ancêtre du disque dur magnétique, à savoir un tambour magnétique, l’ancêtre du disque dur magnétique. Il contenait 40 pages, chacune ayant la même taille que la RAM. Contrairement à la Manchester Baby, son processeur gérait l'addition et quelques opérations logiques (ET et OU), en plus de la soustraction et de la comparaison.

Par la suite, les ordinateurs commerciaux ont vu le jour. Les ordinateurs précédents provenaient de projets de recherches, souvent publics. Mais les entreprises privées se sont mises à fabriquer des ordinateurs elle-mêmes, pour les vendre à d'autres entreprises. On peut notamment citer les ordinateurs comme le UNIVAC I, le Bull Gamma 3 ou les premiers ordinateurs IBM. La performance de ces ordinateurs était nettement plus importante que leurs prédécesseurs, avec des fréquences de l'ordre de la centaine de kilo-hertz. Par exemple, le Bull Gamma 3 allait à 281 kHz, l'IBM 650 allait à 50 Khz.

===La seconde génération : le remplacement des tubes à vides par des transistors===

[[File:IBM 7070.jpg|vignette|Cartes imprimées de l'IBM 704, avec des transistors et résistances dessus.]]

La '''seconde génération''' est celle des ordinateurs fabriqués avec des '''transistors''' isolés, reliés entre avec des fils électriques. Les transistors en question possèdent trois broches, des pattes métalliques sur lesquelles on connecte des fils électriques. Le transistor s'utilise le plus souvent comme un interrupteur commandé par sa troisième broche. Le courant qui traverse les deux premières broches passe ou ne passe pas selon ce qu'on met sur la troisième.

[[File:Transistor basic flow.svg|centre|vignette|Un transistor est un morceau de conducteur, dont la conductivité est contrôlée par sa troisième broche/borne.]]

Les ordinateurs de seconde génération avaient entre 1000 et 500 000 transistors. Les capacités des ordinateurs étaient donc nettement supérieures à celles des ordinateurs de première génération. Une part non négligeable des ordinateurs de seconde génération supportait l'opération de multiplication, absente sur les ordinateurs de première génération. Néanmoins, cela variait beaucoup selon les ordinateurs.

Un exemple assez hors du commun est celui du premier modèle de l'IBM 1620. Le tout premier modèle n'avait aucun circuit de calcul, il n'était même pas capable de faire une addition ou une multiplication. A la place, il utilisait une table d'addition et une table de multiplication en mémoire RAM. Les deux tables devaient être initialisées par le logiciel lors du démarrage de la machine. La table d'addition faisait une centaine de chiffres, la table de multiplication faisait le double. Le processeur de l'ordinateur gérait des instructions pour faire des additions ou des multiplications, mais ces opérations lisaient le résultat dans la table d'addition. Les calculs étaient faits chiffre par chiffre, avec un encodage partiellement décimal, partiellement binaire (des chiffres décimaux étaient encodés en binaire, nous en reparlerons quand nous parlerons du BCD) !

[[File:KL CoreMemory.jpg|vignette|Mémoire à tore de ferrite.]]

Les transistors n'étaient utilisés que pour le processeur et les circuits annexes. La mémoire n'était pas faite en transistors, pas à cette époque. La mémoire était une mémoire aujourd'hui abandonnée, appelée une '''mémoire à tores de ferrite'''. Elle sera détaillée dans un chapitre ultérieur. Mais sachez pour le moment qu'il s'agit d'une mémoire au support magnétique, les données étant stockées sur un support magnétique.

Transistors comme tubes à vide prenaient beaucoup de place, ce qui fait que les ordinateurs étaient assez gros. Concrètement, ils prenaient une pièce de bâtiment entière dans le meilleur des cas. C'était l'époque des gros ''mainframes'', reliés à des terminaux, peu puissants comparé aux standards actuels. Seules les grandes entreprises et les grands instituts de recherche pouvaient se payer les services de ce genre d'ordinateurs. Seuls les professionnels avaient accès à ce genre d'équipement.

===La troisième génération : le circuit intégré===

[[File:D8259AC-2.jpg|vignette|Exemple de circuit intégré.]]

La troisième génération est toujours fabriquée avec des transistors, mais dont la taille a été réduite. Avec l'évolution de la technologie, les transistors ont diminué en taille, de plus en plus. Ils sont devenus tellement petits qu'ils ont fini par être regroupés dans des '''circuits intégrés''', des circuits regroupent plusieurs transistors sur la même puce de silicium. Les circuits intégrés se présentent le plus souvent sous la forme de boitiers rectangulaires, comme illustré ci-contre. D'autres ont des boitiers de forme carrées, comme ceux que l'on peut trouver sur les barrettes de mémoire RAM, ou à l'intérieur des clés USB/ disques SSD.

Lors de cette génération, les processeurs étaient fournis en pièces détachées qu'il fallait relier entre elles. Le processeur était composé de plusieurs circuits intégrés séparés, impossible de mettre un processeur dans un seul boitier. Un exemple de processeur conçu en kit est la série des Intel 3000. Elle regroupe plusieurs circuits séparés aux noms à coucher dehors, mais dont vous comprendrez ce qu'ils veulent dire dans les chapitres adéquats : l'Intel 3001 est un séquenceur, l'Intel 3002 regroupe unité de calcul et registres, le 3003 est un circuit d'anticipation de retenue complémentaire du 3002, le 3212 est une mémoire tampon, le 3214 est une unité de gestion des interruptions, les 3216/3226 sont des interfaces de bus mémoire. On pourrait aussi citer la famille de circuits intégrés AMD Am2900.

Même si le processeur était en pièces détachées, utiliser une dizaine de circuits intégrés était nettement mieux que d'utiliser plusieurs milliers de transistors individuels. En conséquence, les ordinateurs ont vu leur taille grandement réduite, passant de pièces entières à une simple armoire, voire à quelques cartes intégrées superposées. De plus, le prix des circuits intégré était abordable, du moins comparé aux ordinateurs d'avant. Le prix des ordinateurs a alors grandement décru, permettant à des entreprises et administrations de taille modeste de s'équiper d'ordinateurs.

===La quatrième génération : le microprocesseur===

[[File:MOS6502.svg|vignette|Microprocesseur, ici un processeur MOS6502, de la quatrième génération.]]

Lors de la troisième génération, les circuits intégrés regroupaient plusieurs dizaines ou centaines de transistors, mais sont rapidement montés en gamme. De centaines de transistors, ils sont passés au millier de transistors, puis au million et maintenant au-delà du milliard. Les transistors étaient devenus tellement petits, tellement miniaturisés, qu'il était devenu possible de mettre un processeur entier dans un circuit intégré. C'est ainsi qu'est né le microprocesseur, à savoir un processeur qui tient tout entier dans un seul circuit imprimé. La quatrième génération d’ordinateur est celle des ordinateurs basés autour d'un microprocesseur.

Les tout premiers microprocesseurs étaient des processeurs à application militaire, comme le processeur du F-14 CADC ou celui de l'Air data computer. Le tout premier microprocesseur commercialisé au grand public est le 4004 d'Intel, sorti en 1971. L'intel 4004 comprenait environ 2300 transistors, avait une fréquence de 740 MHz, pouvait faire 46 opérations différentes, et manipulait des entiers de 4 bits. Il était au départ un processeur de commande, prévu pour être intégré dans la calculatrice Busicom calculator 141-P, mais il fut utilisé pour d'autres applications quelque temps plus tard. Immédiatement après le 4004, les premiers microprocesseurs 8 bits furent commercialisés. Le 4004 fut suivi par le 8008 et quelques autres processeurs 8 bits extrêmement connus, comme le 8080 d'Intel, le 68000 de Motorola, le 6502 ou le Z80.

Les microprocesseurs permirent encore uen fois de réduire la taille des ordinateurs, qui pouvaient tenir dans un boitier de PC, ou un boitier de console de jeu. Le prix des ordinateurs a aussi chuté en même temps que les transistors étaient miniaturisés. C'est cette invention qui permis l'invention des consoles de jeux et des mini-ordinateurs, à savoir les ordinateurs personnels. Sans miniaturisation, on n'aurait pas d'ordinateur personnel, pas de PC fixe ou portable.

==L'organisation du cours : les différents niveaux d'explication==

Le fonctionnement d'un ordinateur est assez complexe à expliquer car les explications peuvent se faire sur plusieurs niveaux. Par plusieurs niveaux, on veut dire qu'un ordinateur est composé de composants très simples, qui sont assemblés pour donner des composants eux-même plus complexes, qui sont eux-même regrouper, etc. Étudier tout cela demande de voir plusieurs niveaux, allant de transistors très petits à des processeurs multicœurs. Les niveaux les plus bas sont de l'électronique pur et dure, alors que ceux plus haut sont à mi-chemin entre électronique et informatique.

===Les niveaux d'abstraction en architecture des ordinateurs===

Les trois premiers niveaux sont de l'électronique pur et dure. Ils correspondent aux premiers chapitres du cours, qui porteront sur les circuits électroniques en général.
* Le premier niveau est celui des '''transistors''', des circuits intégrés, des ''wafer'' et autres circuits de très petite taille.
* Le second niveau est celui des '''portes logiques''', des circuits très basiques, très simples, à la base de tous les autres.
* Le troisième niveau est celui dit de la '''''Register Transfer Level''''', où un circuit électronique est construit à partir de circuits basiques, dont des registres et autres circuits dits combinatoires.
Les deux niveaux suivants sont de l'informatique proprement dit. C'est dans ces deux niveaux qu'on étudie les ordinateurs proprement dit, les circuits qu'il y a dedans et non l'électronique en général.
* Le quatrième niveau est celui de la '''microarchitecture''', qui étudie ce qu'il y a à l'intérieur d'un processeur, d'une mémoire, des périphériques et autres.
* Le cinquième niveau est celui de l''''architecture externe''', qui décrit l'interface du processeur, de la mémoire, d'un périphérique ou autre. Par décrire l'interface, on veut dire : comment un programmeur voit le processeur et la mémoire, comment il peut les manipuler. Une architecture externe unique peut avoir plusieurs microarchitecture, ce qui fait qu'on sépare les deux. Tout cela sera plus clair quand on passera aux chapitres sur le processeur et les mémoires.

Nous n'allons pas voir les 5 niveaux dans l'ordre, des transistors vers l'architecture externe. En réalité, nous allons procéder autrement. La première partie du cours portera sur les trois premiers niveaux, le reste sur les deux autres. Les 5 niveaux seront vus dans des chapitres séparés, du moins le plus possible. Au niveau pédagogique, tout est plus simple si on scinde les 5 niveaux. Bien sûr, il y a quelques explications qui demandent de voir plusieurs niveaux à la fois. Par exemple, dans le chapitre sur les mémoires caches, nous auront des explications portant sur la RTL, la microarchitecture du cache et son architecture externe. Mais le gros du cours tentera de séparer le plus possible les 5 niveaux.

===Les trois parties principales du cours===

Nous allons commencer par parler du binaire, avant de voir les portes logiques. Avec ces portes logiques, nous allons voir comment fabriquer des circuits basiques qui reviendront très souvent dans la suite du cours. Nous verrons les registres, les décodeurs, les additionneurs et plein d'autres circuits. Puis, nous reviendrons au niveau des transistors pour finir la première partie. La raison est que c'est plus simple de faire comme cela. Tout ce qui a trait aux transistors sert à expliquer comment fabriquer des portes logiques, et il faut expliquer les portes logiques pour voir le niveau de la RTL.

Une fois la première partie finie, nous allons voir les différents composants d'un ordinateur. Une première partie expliquera ce qu'il y a dans un ordinateur, quels sont ses composants. Nous y parlerons de l'architecture de base, de la hiérarchie mémoire, des tendances technologiques, et d'autres généralités qui serviront de base pour la suite. Puis, nous verrons dans l'ordre les bus électroniques, les mémoires RAM/ROM, le processeur, les périphériques, les mémoires de stockage (SSD et disques durs) et les mémoires caches. Pour chaque composant, nous allons voir leur architecture externe, avant de voir leur microarchitecture. La raison est que la microarchitecture ne peut se comprendre que quand on sait quelle architecture externe elle implémente.

Enfin, dans une troisième partie, nous allons voir les optimisations majeures présentes dans tous les ordinateurs modernes, avec une partie sur le pipeline et le parallélisme d'instruction, et une autre sur les architectures parallèles. Pour finir, les annexes de fin parlerons de sujets un peu à part.

&lt;noinclude&gt;
{{NavChapitre | book=Fonctionnement d'un ordinateur
           | next=L'encodage des données
           | nextText=L'encodage des données
}}
&lt;/noinclude&gt;</text>
      <sha1>lfnf2mtk6b0x714wzo55y6l8l9i35sb</sha1>
    </revision>
    <revision>
      <id>744147</id>
      <parentid>744146</parentid>
      <timestamp>2025-06-05T11:57:06Z</timestamp>
      <contributor>
        <username>Mewtow</username>
        <id>31375</id>
      </contributor>
      <minor />
      <comment>/* Les ordinateurs à programme mémorisé ou programme externe */</comment>
      <origin>744147</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="46280" sha1="fc3v3eqcz40by0dzalp53zh99llu1h3" xml:space="preserve">Pour commencer, nous allons voir qu'il existe de nombreux types d'ordinateurs. Le plus connu est certainement le PC, l'ordinateur personnel, que vous avez sans doute dans votre salon. Les ordinateurs portables sont un deuxième type d'ordinateur assez intuitif, que vous avez peut-être. Mais il y a aussi d'autres types d'ordinateurs auxquels vous n'avez jamais été confrontés.

==Les différents types d'ordinateurs==

Dans cette section, nous allons décrire rapidement les ordinateurs les plus courant, mais surtout voir ce qu'il y a à l'intérieur d'un ordinateur.

===L'ordinateur de type PC fixe===

De l'extérieur, l'ordinateur est composé d'une unité centrale sur laquelle on branche des périphériques.

[[File:Typical computer architecture systems.jpg|vignette|upright=1.5|Exemples de périphériques, connectés à une unité centrale (ici appelée à tort ''operating system'').]]

Les '''périphériques''' regroupent l'écran, la souris, le clavier, l'imprimante, et bien d'autres choses. Ils permettent à l'utilisateur d'interagir avec l'ordinateur : un clavier permet de saisir du texte sous dans un fichier, une souris enregistre des déplacements de la main en déplacement du curseur, un écran affiche des données d’images/vidéos, un haut-parleur émet du son, etc. Tout ce qui est branché sur un ordinateur est, formellement un périphérique.

L''''unité centrale''' est là où se trouvent tous les composants importants d'un ordinateur, ceux qui font des calculs, qui exécutent des logiciels, qui mémorisent vos données, etc. Voici ce à quoi ressemble l'intérieur de l'unité centrale. Trois sections sont visibles : l'alimentation électrique en haut à gauche, la carte mère en bas à gauche et en jaune/orange, les disques et lecteurs à droite des câbles. Et on voit aussi beaucoup de câbles.

[[File:Asus P5K-SEIntel E6320.jpg|centre|vignette|upright=2|Exemple d'unité centrale.]]

Tout en haut à gauche, se trouve l''''alimentation électrique''', qui convertit le courant de la prise électrique en un courant plus faible, utilisable par les autres composants. Elle émet de nombreux câbles assez gros, qui sont reliés au reste. Les PC actuels utilisent des alimentations électriques standardisées, qui fournissent trois tensions au reste de l'ordinateur : une tension de 12 Volts, une de 5 Volts, une de 3,3 Volts.

À droite, caché par la partie &quot;métallique&quot; du boitier, se trouvent les lecteurs de CD/DVD, et les disques durs. Les lecteurs CD-ROM ou DVD-ROM permettaient de lire des CD ou des DVD. Je parle au passé, car ils ont aujourd'hui disparu des ordinateurs modernes. Les '''disques durs''' sont des mémoires de stockage, qui mémorisent vos données de manière permanente. De nos jours, ils sont remplacés par des SSD, qui sont des disques durs électroniques, là où les disques durs proprement dit sont des mémoires magnétiques. Nous verrons la différence dans deux chapitres dédiés, un sur les disques durs, l'autre sur les SSD.

En bas à droite, se trouve la '''carte mère''' un support plat, en plastique ou en céramique, sur laquelle sont soudés/connectés les autres composants. Sur celle-ci, de nombreux composants sont soudés, d'autres sont branchés dessus avec des câbles, d'autres sont connectés dessus avec des connecteurs. Ils sont reliés entre eux par des fils conducteurs, le plus souvent du cuivre ou de l’aluminium, ce qui leur permet de s’échanger des données. Sur les cartes simples, ces fils sont intégrés dans la carte électronique, dans des creux du plastique. Ils portent le nom de pistes.

Avant, les disques durs, SSD et lecteurs de CD/DVD sont branchés dessus via des connecteurs dédiés, appelés des connecteurs S-ATA. De nos jours, ils sont branchés sur un autre connecteur, grâce à l'interface NVME. Toujours est-il qu'ils sont reliés à la carte mère par des câbles, ce qui montre que ce sont des sortes de périphériques interne. Ils sont placés dans le boitier, mais on aurait tout aussi bien pu les mettre à l'extérieur, vu qu'ils communiquent avec l'ordinateur par l'intermédiaire d'un câble ou d'un connecteur dédié.

Mais deux autres composants très importants sont eux placés sur la carte mère, directement. Ils ont chacun un connecteur dédié, sur lequel ils sont branchés directement, sans passer par l'intermédiaire d'un câble, mais sans être soudés non plus. Il s'agit du processeur et de la mémoire RAM, deux composants centraux des PC modernes.

[[File:Pentium III SL4CB.jpg|thumb|Processeur Pentium III.]]

Le '''processeur''' traite les données, les modifie, les manipule. Pour faire simple, il s’agit d’une grosse calculatrice hyper-puissante. Il comprend à la fois un circuit qui fait des calculs, et un circuit de contrôle qui s'occupe de séquencer les calculs dans l'ordre demandé. Il est souvent caché sous un radiateur, lui-même surmonté par un ventilateur. En effet, un processeur chauffe beaucoup, ce qui demande d'évacuer cette chaleur. Un chapitre entier expliquera pourquoi les processeurs chauffent, ainsi que les techniques utilisées pour limiter leur production de chaleur et leur consommation électrique.

La '''mémoire vive''' conserve des informations/données temporairement, tant que le processeur en a besoin. Elle prend la forme de barrettes de RAM, comme montré ci-dessous.

[[File:2 gb ddr2 667.jpg|centre|vignette|upright=2|Barrette de RAM.]]

Outre ces composants dits principaux, un ordinateur peut comprendre plusieurs composants moins importants, surtout présents sur les ordinateurs personnels. Ils sont techniquement facultatifs, mais sont très présents dans les ordinateurs personnels. Cependant, certains ordinateurs spécialisés s'en passent. Il s'agit des diverses '''cartes d'extension''' sont branchées sur la carte mère. Elles permettent d’accélérer certains calculs ou certaines applications, afin de décharger le processeur. Par exemple, la carte graphique s'occupe des calculs graphiques, qu'il s'agisse de graphismes 3D de jeux vidéos ou de l'affichage en 2D du bureau. Dans un autre registre, la carte son prend en charge le microphone et les haut-parleurs.

[[Fichier:Personal computer, exploded 4.svg|thumb|upright=1.0|Éclaté d'un ordinateur de type PC :&lt;br /&gt;
1 : Écran ;&lt;br /&gt;
2 : Carte mère ;&lt;br /&gt;
3 : Processeur ;&lt;br /&gt;
4 : Câble Parallel ATA ;&lt;br /&gt;
5 : Mémoire vive (RAM) ;&lt;br /&gt;
6 : Carte d'extension ;&lt;br /&gt;
7 : Alimentation électrique ;&lt;br /&gt;
8 : Lecteur de disque optique ;&lt;br /&gt;
9 : Disque dur ;&lt;br /&gt;
10 : Clavier ;&lt;br /&gt;
11 : Souris.]]

Si on regarde une carte mère de face, on voit un grand nombre de connecteurs, mais aussi des circuits électroniques soudés à la carte mère.

[[File:Architecture matérielle d'une carte mère.png|centre|vignette|upright=2.0|Architecture matérielle d'une carte mère]]

Les '''connecteurs''' sont là où on branche les périphériques, la carte graphique, le processeur, la mémoire, etc. Dans l'ensemble, toute carte mère contient les connecteurs suivants :
* Le processeur vient s’enchâsser dans la carte mère sur un connecteur particulier : le '''socket'''. Celui-ci varie suivant la carte mère et le processeur, ce qui est source d'incompatibilités.
* Les barrettes de mémoire RAM s’enchâssent dans un autre type de connecteurs: les '''slots mémoire'''.
* Les mémoires de masse disposent de leurs propres connecteurs : connecteurs P-ATA pour les anciens disques durs, et S-ATA pour les récents.
* Les périphériques (clavier, souris, USB, Firewire, ...) sont connectés sur un ensemble de connecteurs dédiés, localisés à l'arrière du boitier de l'unité centrale. 
* Les autres périphériques sont placés dans l'unité centrale et sont connectés via des connecteurs spécialisés. Ces périphériques sont des cartes imprimées, d'où leur nom de '''cartes filles'''. On peut notamment citer les cartes réseau, les cartes son, ou les cartes vidéo.

===Les ordinateurs portables===

[[File:Samsung QX-511 (2).JPG|vignette|Ordinateur portable Samsung QX-511 (2), pour illustration.]]

Un ordinateur portable est identique à un ordinateur de type PC. Si vous ouvrez votre ordinateur portable (attention à la garantie), vous retrouverez les mêmes composants qu'un PC à l'intérieur. Un point important est la présence d'une batterie à l'intérieur du PC portable, absente des PC fixes.

[[File:LG gram 14Z90Q mainboard with battery.jpg|centre|vignette|upright=2|LG gram 14Z90Q avec sa batterie.]]

Une fois la batterie et les circuits associés retiré, la seule différence notable est que tous les composants sont soudés sur la carte mère, au lieu d'être branchés sur des connecteurs, à part éventuellement la RAM et le disque dur.

[[File:LG gram 14Z90Q mainboard without battery.jpg|centre|vignette|upright=2|LG gram 14Z90Q sans sa batterie.]]

La RAM est parfois soudée sur la carte mère, d'autres fois sous la forme de barrettes de mémoire vive semblables à celles des PC. Dans le dernier cas, elle est connectée à des connecteurs spécifiques, ce qui permet de les changer/upgrader. Les PC portables sont parfois construits de manière à pouvoir changer la RAM facilement, en ouvrant un cache spécial, concu pour.

[[File:Lenovo G555 состав - Донор.JPG|centre|vignette|upright=2|Lenovo G555.]]

La conception d'un ordinateur portable est légèrement différente de celle d'un PC, pour des raisons thermiques. Un PC fixe a plus de place pour évacuer sa chaleur. Les ventilateurs peuvent plus facilement déplacer l'air dans le boitier, même si le flux d'air dans le boitier est éventuellement gêné par la carte graphique. Mais l'évacuation de la chaleur est assez efficace. Sur les PC portables, leur finesse fait que le trajet de l'air est beaucoup plus contraint. Évacuer la chaleur produite par l'ordinateur est plus complexe, ce qui demande d'utiliser des systèmes de refroidissement et de ventilation spécifiques.

Là où les PC fixes se débrouillent avec des radiateurs et des ventilateurs posés sur le processeur, les PC portables font autrement. Ils ne peuvent pas forcément mettre le ventilateur sur le processeur. A la place, ils mettent le ventilateur à côté, mais le processeur est surmonté par un mécanisme de transmission de la chaleur, qui transfère la chaleur du processeur vers le ventilateur.

[[File:Diagram - How a laptop cooling system works.png|centre|vignette|upright=2|Comment fonctionne le système de ventilation d'un ordinateur portable, en anglais.]]

Les difficultés pour dissiper la chaleur font que les ordinateurs portables utilisent souvent des composants peu performants, mais qui chauffent peu. En effet, nous verrons que plus un composant est puissant, plus il chauffe. La relation n'est pas parfaite, mais les processeurs haute performance chauffent plus que les modèles d'entrée ou milieu de gamme moins puissants. En conséquence, les PC portables sont souvent moins puissants que les PC fixes, même pour les modèles dit ''gaming''.

===Les serveurs et ''mainframes''===

Les grandes entreprises utilisent des ordinateurs de grande taille, très puissants, appelés des ''mainframes''. Ils sont souvent confondus avec les serveurs par le grand public, il y a une différence entre les deux. Un serveur est une fonction logicielle/réseau, pas un type d'ordinateur. Mais laissons cette différence de côté, ce qui est dit pour les ''mainframes'' sert pour les gros serveurs haute performance.

[[File:IBM Z15 mainframe.jpg|vignette|Exemple de ''mainframe''' de type IBM Z15.]]

Les anciens ''mainframes'' des années 50-80 avaient une taille pouvant être impressionnante, au point de prendre une pièce complète d'un bâtiment. Mais de nos jours, les ''mainframes'' tiennent dans une grosse armoire un peu haute. Les ''mainframes'' doivent rester allumé en permanence et ne doivent pas être éteint, sauf éventuellement quelques jours par an pour des opérations de maintenance. Ils utilisent pour cela des techniques spécifiques, avec beaucoup de redondance interne.

[[File:ACONIT hall grandes machines.jpg|centre|vignette|upright=2|''Mainframe'' ACONIT.]]

Les ''mainframes'' sont aussi conçus pour mutualiser au maximum leur utilisation, ils peuvent être utilisés par plusieurs utilisateurs à la suite, voire en même temps. Pour cela, les anciens ''mainframes'' étaient capables de faire tourner plusieurs applications distinctes l'une à la suite de l'autre, avec des commutations fréquentes entre logiciels. De nos jours, ils sont capables d'exécuter un grand nombre de tâches en même temps, grâce à la présence de plusieurs processeurs. Les ''mainframes'' modernes sont même capables de faire tourner plusieurs systèmes d'exploitation en même temps si besoin.

Les anciens ''mainframes'' étaient des ordinateurs assez simples, avec un processeur, de la mémoire RAM, un ou plusieurs disques durs, pas plus. Le ''mainframe'' était tellement énorme et cher que les entreprises n'en avaient qu'un seul pour toute l'entreprise. Les employés avaient sur leur bureau des terminaux, qui permettaient d'accéder à l'ordinateur central, mais n'étaient pas des ordinateurs. Les terminaux étaient des composants électroniques simples, avec un écran, un clavier et une souris, mais sans processeur. Ils envoyaient des données au ''mainframe'', ils en recevaient de sa part, mais tout traitement était réalisé sur le ''mainframe''. L'arrivée sur le marché des ordinateurs personnels, de type PC fixe/portable, a entrainé l'abandon de ce genre de pratique, tous les employés ont maintenant un ordinateur rien que pour eux.

{|
|-
! colspan=&quot;2&quot; | Exemples de terminaux
|-
|[[File:Terminal-in2-sm9400.jpg|centre|vignette|upright=1.5|Exemple de terminal. Notez la présence d'un écran et d'un clavier, mais l'asbence d'une unité centrale.]]
|[[File:Chromatics CT4100.jpg|vignette|upright=1.5|Autre exemple de terminal. Le clavier est couplé à un stylo CRT, qui remplacait la souris et agissait sur l'écran comme s'il était tactile.]]
|-
! colspan=&quot;2&quot; | Intérieur d'un terminal
|-
|[[File:CT1024 Monitor.jpg|vignette|upright=1.5|Terminal CT1024, sans le boitier extérieur.]]
|[[File:CT1024 Terminal System.jpg|vignette|upright=1.5|Terminal CT1024, description des composants interne.]]
|}

De nos jours, les ''mainframes'' contiennent en réalité plusieurs ordinateurs simples interconnectés via un réseau local. Un ''mainframe'' qui tient dans une armoire contient facilement une dizaine ou centaine de processeurs, plein de RAM, des disques durs séparés dans une armoire distincte, etc. Vu qu'ils communiquent uniquement via le réseau, ils n'ont pas d'interface, pas d'écran, 'entrée via clavier/souris. Le tout est commandé avec une console de commande, typiquement un ordinateur portable ou un terminal assez simple séparé de l'armoire, qui permet à un administrateur de faire des opérations de surveillance, configuration et maintenance. Il peut y avoir une console de commande pour plusieurs armoires séparées, la console peut même être dans un autre bâtiment et accéder au ''mainframe'' par le réseau.

[[File:IBM System Z9 (type 2094 inside).jpg|centre|vignette|upright=2|''Mainframe'' de type IBM System Z9. L'ordinateur portable sert de console pour qu'un administrateur fasse des opérations de surveillance, configuration et maintenance.]]

Les processeurs et la RAM sont typiquement installés sur des cartes amovibles, qui sont connectées au fond de l'armoire lors de l'installation. Il est même possible de retirer ou d'ajouter des cartes en fonctionnement, afin d'ajouter/retirer des processeurs, des disques durs, etc. Ce qui est très utile si un composant est en panne et qu'il faut le remplacer. 

[[File:IBM TotalStorage Exp400.jpg|centre|vignette|upright=2|IBM TotalStorage Exp400]]

==Un peu d'abstraction : qu'est-ce qu'un ordinateur ?==

Un ordinateur comprend donc un processeur, plusieurs mémoires, des cartes d'extension et une carte mère pour connecter le tout. Mais il s'agit là d'une description assez terre-à-terre de ce qu'est un ordinateur. Une autre description, plus abstraite, se base sur le fait qu'un ordinateur est une énorme calculatrice programmable. Elle permet d'expliquer pourquoi il y a une distinction entre processeur et mémoire, entre unité centrale et périphériques. Tout ce qui va suivre pourra vous paraitre assez abstrait, mais rassurez-vous : les prochains chapitres rendront tout cela plus concrets.

===La séparation entre entrées-sorties et traitement===

L'unité centrale peut être vue comme une énorme calculatrice ultra-puissante, qui exécute des commandes/opérations. Mais à elle seule, elle ne servirait à rien, il faut interagir avec par l'intermédiaire de plusieurs périphériques. Il existe deux types de périphériques, qui sont conceptuellement différents. Les périphériques comme le clavier ou la souris permettent d'envoyer des informations à l'ordinateur, d'agir sur celui-ci. A l'inverse, les écrans transmettent des informations dans le sens inverse : de l'ordinateur vers l'utilisateur. Les premiers sont appelés des '''entrées''', les seconds des '''sorties'''.

Dans un ordinateur, les informations sont représentées sous la forme de nombres. Toute donnée dans un ordinateur est codée avec un ou plusieurs nombres regroupés dans une donnée, un fichier, ou autre. Et la transmissions avec les entrées et sorties se fait là-encore avec des nombres. Par exemple, quand vous appuyez sur votre clavier, le clavier envoie un numéro de touche à l'unité centrale, qui indique quelle touche a été appuyée. L'image à afficher à l'écran est codée sous la forme d'une suite de nombres (un par pixel). L'image est envoyée à l'écran, qui traduit la suite de nombre en image à afficher. Les entrées traduisent des actions utilisateurs en nombres, on dit que les entrées encodent les actions utilisateur. Les sorties font la traduction inverse, elles transforment des suites de nombres en une action physique. On dit qu'elles décodent des informations.

Pour résumer, toute appareil électronique est composé par :
* Des '''entrées''' sur lesquelles l'utilisateur agit sur l'ordinateur. Les entrées transforment les actions de l'utilisateur en nombres, qui sont interprétés par l'ordinateur.
* Une '''unité de traitement''', qui manipule des nombres et fait des calculs/opérations dessus. Les nombres proviennent des entrées, du disque dur, ou d'autres sources, peu importe.
* Des '''sorties''', qui va récupèrent le résultat calculé par l'unité de traitement pour en faire quelque chose : écrire sur une imprimante ou sur un moniteur, émettre du son,...

[[File:Ordinateur théorique Simple 1.png|centre|vignette|upright=2|Ordinateur théorique Simple 1]]

L'unité de traitement proprement dite, celle qui fait les calculs, est couplée à une mémoire qui mémorise les opérandes et résultats des calculs. La séparation entre processeur et mémoire est nécessaire pour qu'un appareil électronique soit qualifié d'ordinateur. De nombreux appareils n'ont pas de séparation entre unité de traitement et mémoire, comme certaines vielles radios AM/FM.

[[File:Schéma de principe d'un ordinateur.png|centre|vignette|upright=2|Schéma de principe d'un ordinateur]]

===Un ordinateur est un appareil programmable===

Les appareils simples sont non-programmables, ce qui veut dire qu’ils sont conçus pour une utilisation particulière et qu’ils ne peuvent pas faire autre chose. Par exemple, les circuits électroniques d’un lecteur de DVD ne peuvent pas être transformé en lecteur audio ou en console de jeux... Les circuits non-programmables sont câblés une bonne fois pour toute, et on ne peut pas les modifier. On peut parfois reconfigurer le circuit, pour faire varier certains paramètres, via des interrupteurs ou des boutons, mais cela s’arrête là. Et cela pose un problème : à chaque problème qu'on veut résoudre en utilisant un automate, on doit recréer un nouveau circuit.

À l'inverse, un ordinateur n’est pas conçu pour une utilisation particulière, contrairement aux autres objets techniques. Il est possible de modifier leur fonction du jour au lendemain, on peut lui faire faire ce qu’on veut. On dit qu'ils sont '''programmables'''. Pour cela, il suffit d’utiliser un logiciel, une application, un programme (ces termes sont synonymes), qui fait ce que l'on souhaite. La totalité des logiciels présents sur un ordinateur sont des programmes comme les autres, même le système d'exploitation (Windows, Linux, ...) ne fait pas exception.

Un programme est une suite de d''''instructions machines''', chaque instruction effectuant une action dans l'ordinateur. Sur les ordinateurs modernes, les instructions les plus communes effectuent une opération arithmétique : une addition, une multiplication, une soustraction, etc. Les ordinateurs modernes sont donc de grosses calculettes très puissantes, capables d'effectuer des millions d'opérations par secondes.

Et qui dit opération dit nombres : un ordinateur gère nativement des nombres, qui sont codés en binaire sur la quasi-totalité des ordinateurs modernes. Les ordinateurs modernes sont capables de faire des calculs sur des nombres entiers, mais aussi des nombres à virgule. Il existe plusieurs manières de représenter des nombres en binaire, certaines représentant des nombres entiers dits naturels (0 et plus), d'autres des nombres signés (positifs ou négatifs), d'autres des nombres à virgule. Un chapitre entier détaillera comment sont encodés ces nombres.

Une instruction est représentée dans un ordinateur par une série de nombres entiers : un nombre qui indique quelle opération/commande effectuer et des autres nombres pour coder les données (ou de quoi les retrouver dans l'ordinateur). L'ordinateur récupére les commandes une par une, les traduit en opération à effectuer, exécuter l'opération, et enregistre le résultat. Puis il recommence avec la commande suivante.

[[File:Ordinateur Théorique Complexe 1.png|centre|vignette|upright=3|Ordinateur Théorique Complexe. En jaune, le programme informatique, la liste de commande. Le rectangle gris est l'ordinateur proprement dit.]]

De nombreux appareils sont programmables, mais tous ne sont pas des ordinateurs. Par exemple, certains circuits programmables nommés FPGA n'en sont pas. Pour être qualifié d'ordinateur, un appareil programmable doit avoir un processeur séparé de la mémoire. De plus, il doit utiliser un '''codage numérique''', chose que nous allons aborder dans le chapitre suivant.

===Les ordinateurs à programme mémorisé ou programme externe===

Au tout début de l'informatique, les programmes étaient enregistrés sur des cartes perforées, à savoir des cartes en papier/plastique percées par endroits. Un 1 est codé par un trou dans le papier et un 0 par une absence de trou. Les programmes étaient exécutés par l'ordinateur quand on insérait la carte perforée dans le lecteur et qu'on appuyait sur un bouton.

[[File:German Museum of Technology, Berlin 2017 024.jpg|centre|vignette|upright=2|Réplique du Z1 au ''German Museum of Technology'' de Berlin, 2017.]]

Par la suite, les premiers ordinateurs grand public, comme les Amstrad ou les Commodore, utilisaient des cassettes audio magnétiques pour stocker les programmes. Dans le même style, les consoles de jeu utilisaient autrefois des cartouches de jeu, qui contenaient le programme du jeu à exécuter. Pour résumer, les anciens ordinateurs mémorisaient les programmes sur un support externe, lu par un périphérique. De tels ordinateurs sont dits à '''programme externe'''.

: D’anciens ordinateurs personnels, comme l’Amstrad ou le Commodore, permettaient de taper les programmes à exécuter à la main, au clavier, avant d’appuyer une touche pour les exécuter. Nul besoin de vous dire que les cassettes audio étaient plus pratiques.

Mais de nos jours, les programmes sont enregistrés sur le disque dur de l'ordinateur ou dans une mémoire intégrée à l'ordinateur. On dit qu'ils sont installés, ce qui est un mot bien compliqué pour dire que le programme est enregistré sur le disque dur de l’ordinateur. A défaut de disque dur, le programme/logiciel est enregistré dans une mémoire spécialisée pour le stockage. Par exemple, sur les cartes électroniques grand public de marque Arduino, les programmes sont envoyés à la carte via le port USB, mais les programmes sont enregistrés dans la carte Arduino, dans une mémoire FLASH dédiée. Disque dur ou non, le programme est mémorisé dans la mémoire de l'ordinateur. Il est possible d'installer ou de désinstaller les programmes en modifiant le contenu de la mémoire. Le terme utilisé est alors celui de '''programme stocké en mémoire'''.

Les programmes à installer sont disponibles soit sur un périphérique, comme un DVD ou une clé USB, soit sont téléchargés depuis internet. Les premiers PC fournissaient les logiciels sur des disquettes, qui contenaient un programme d'installation pour enregistrer le programme sur le disque dur de l'ordinateur. Par la suite, le support des logiciels a migré vers les CD et DVD, les logiciels devenant de plus en plus gros. De nos jours, la majorité des applications sont téléchargées depuis le net, l'usage de périphériques est devenu obsolète, même les consoles de jeu abandonnent cette méthode de distribution.

==Les générations d'ordinateurs : un historique rapide==

L'informatique a beaucoup évolué dans le temps. Et une bonne partie de cette évolution tient à l'évolution de l’électronique sous-jacente. Les ordinateurs actuels sont fabriqués avec des transistors, des petits composants électroniques qui servent d'interrupteurs programmables, qu'on détaillera dans ce qui suit. Mais ça n'a pas toujours été le cas. Et cela permet de distinguer plusieurs '''générations d'ordinateurs'''.

===Les ordinateurs électro-mécaniques : les premiers ordinateurs===

Le tout premier ordinateur est le '''Z1''', un modèle unique inventé par Konrad Suze entre 1936 et 1938. Son processeur gérait non pas des nombres entiers, mais des nombres à virgule (des nombres dits flottants, pour être précis), encodés sur 22 bits. Le processeur du Z1 était capable de faire des additions et des soustractions, car il intégrait un circuit additionneur-soustracteur basique. Des circuits annexes permettaient de faire des multiplications et des divisions en enchainant des additions/soustractions successives. Il fonctionnait à une fréquence de 1 Hz, ce qui fait qu'il pouvait faire une addition/soustraction par seconde maximum.

[[File:Blue-punch-card-front.png|vignette|upright=0.5|Carte Perforée.]]

Niveau mémoire, la RAM de l'ordinateur était très limitée : seulement 16 nombres de 22 bits chacun. S'il s'agissait d'une mémoire électronique, les programmes étaient mémorisés sur une mémoire mécanique. Les programmes étaient enregistrés sur des cartes perforées, à savoir des cartes en papier/plastique dans lesquelles un 1 est codé par un trou dans le papier et un 0 par une absence de trou. Les programmes étaient exécutés par l'ordinateur quand on insérait la carte perforée dans le lecteur et qu'on appuyait sur un bouton.

[[File:German Museum of Technology, Berlin 2017 024.jpg|centre|vignette|upright=2|Réplique du Z1 au ''German Museum of Technology'' de Berlin, 2017.]]

Après sa destruction dans un bombardement, le Z1 a été reconstruit et amélioré, ce qui donné les deux ordinateurs Z2 et Z3. Quelques années plus tard, de nombreux ordinateurs ont été construits dans des laboratoires de recherche. Des grands noms de l'histoire de l'informatique datent de cette époque : le Harvard Mark I et le Colossus Mark 1 (UK) ont tous deux été mis en service en 1944, par exemple. Ils ont servi pour les cryptanalystes pour casser les codes utilisés par les Allemands pour leurs transmissions, pendant la seconde guerre mondiale.

Les ordinateurs cités dans le précédent paragraphe étaient tous des ordinateurs dit '''électro-mécaniques''', car ils mélangeaient des composants électroniques et des composants mécaniques (tout ce qui a trait aux cartes perforées, notamment). Les composants électroniques étaient soit des relais, soit des tubes à vides, les deux étant des interrupteurs commandables électriquement plus ou moins équivalents aux transistors. Les ordinateurs d'avant l'année 1944, étaient tous de ce type. Quelques ordinateurs des années 50 étaient de ce type, mais leur nombre n'a pas dépassé 30. Il faut dire qu'ils ont rapidement laissé la place à des ordinateurs purement électroniques, que nous allons voir dans ce qui suit.

===La première génération : les tubes à vide===

Les ordinateurs qui ont suivi les ordinateurs électromécaniques sont regroupés dans la '''première génération d'ordinateur'''. Ils étaient conçus avec des tubes à vide, ce qui les place entre les premiers ordinateurs électro-mécaniques et les ordinateurs utilisant des transistors. Les tubes à vide étaient assez encombrants, ils consommaient beaucoup de courant, ils chauffaient et étaient assez peu fiables. Ils tombaient en panne assez souvent. Et ils étaient assez simples à fabriquer, mais restaient malgré tout chers.

[[File:Elektronenroehren-auswahl.jpg|centre|vignette|upright=2|Tubes à vides.]]

Au vu de la taille des tubes à vide, les ordinateurs de l'époque étaient composés de plusieurs milliers de ces tubes, guère plus. Et malgré cela, un ordinateur prenait facilement un étage de bâtiment entier, ou au moins plusieurs pièces. La conséquence est que les ordinateurs de première génération étaient très simples, rudimentaires quand on les compare aux ordinateurs modernes. Ils ne géraient que quelques opérations simples : l'addition, la soustraction, pas grand-chose de plus. À quelques exceptions près, ils ne géraient pas la multiplication et encore moins la division, cela aurait demandé trop de tubes à vides.

Une des toutes premières machines construite avec des tubes à vide était l'Atanasoff–Berry. Ce n'était pas un ordinateur, car elle ne pouvait pas exécuter de programme sans intervention humaine pour séquencer des opérations, mais c'était la première machine de calcul purement électronique, sans aucune pièce mécanique. Elle utilisait une mémoire RAM construite avec des condensateurs, ceux-ci étant placés sur des cylindres tournants. Les circuits de calcul étaient construits avec des tubes à vide et faisaient leur travail un bit à la fois. Elle fonctionnait à une fréquence de 60 Hz et pouvait faire 30 additions/soustractions par seconde. Les nombres étaient encodés sur 50 bits. 

[[File:Atanasoff Berry Computer.gif|centre|vignette|upright=2.5|Atanasoff–Berry.]]

L'arrivée de l'ENIAC en 1945 a changé la donne. Cet ordinateur a introduit plusieurs innovations majeures. La première est assez technique, il s'agit de la turing-complétude, elle a trait aux programmes qui peuvent être écrit pour un ordinateur, nous ne la détaillerons pas ici.

[[File:BabyArchitecture.png|vignette|Architecture de la Manchester Baby.]]

En 1948, le ''Manchester Baby'' a introduit une innovation extrêmement importante : le programme n'était plus mémorisé sur des cartes perforées, mais dans une mémoire électronique à l’intérieur de l'ordinateur lui-même. En clair, le ''Manchester Baby'' était le premier '''ordinateur à programme stocké en mémoire''' en français. Au-delà de ça, le Manchester Baby restait quand même très simple, c'était limite un prototype.

Niveau interface, l'ordinateur avait une console avec 32 boutons, des interrupteurs et un écran de sortie sur lequel afficher les résultats. A l'intérieur, il y avait un processeur et une RAM de 32 nombres de 32 bits, fabriquées avec des tubes Williams (abordés dans une annexe à la fin du cours). Une instruction prenant autant de place qu'un nombre en RAM, ce qui limitait les programmes à 32 instructions maximum. Le processeur gérait 8 instructions en tout, mais la seule instruction de calcul qu'il gérait était la soustraction. L'addition n'était pas supportée. Il pouvait cependant émuler l'addition à partir d'une soustraction et inversant l'opérande soustrait.

Le Manchester Mark 1 était une amélioration du Manchester Baby. Il utilisait 4500 tubes à vide. L'ordinateur gérait des nombres de 40 bits, mais les instructions étaient codées sur 20 bits. La RAM avait la même taille, à savoir 32 nombres, leur taille était simplement augmentée. Par contre, la RAM était complémentée par l’ancêtre du disque dur magnétique, à savoir un tambour magnétique, l’ancêtre du disque dur magnétique. Il contenait 40 pages, chacune ayant la même taille que la RAM. Contrairement à la Manchester Baby, son processeur gérait l'addition et quelques opérations logiques (ET et OU), en plus de la soustraction et de la comparaison.

Par la suite, les ordinateurs commerciaux ont vu le jour. Les ordinateurs précédents provenaient de projets de recherches, souvent publics. Mais les entreprises privées se sont mises à fabriquer des ordinateurs elle-mêmes, pour les vendre à d'autres entreprises. On peut notamment citer les ordinateurs comme le UNIVAC I, le Bull Gamma 3 ou les premiers ordinateurs IBM. La performance de ces ordinateurs était nettement plus importante que leurs prédécesseurs, avec des fréquences de l'ordre de la centaine de kilo-hertz. Par exemple, le Bull Gamma 3 allait à 281 kHz, l'IBM 650 allait à 50 Khz.

===La seconde génération : le remplacement des tubes à vides par des transistors===

[[File:IBM 7070.jpg|vignette|Cartes imprimées de l'IBM 704, avec des transistors et résistances dessus.]]

La '''seconde génération''' est celle des ordinateurs fabriqués avec des '''transistors''' isolés, reliés entre avec des fils électriques. Les transistors en question possèdent trois broches, des pattes métalliques sur lesquelles on connecte des fils électriques. Le transistor s'utilise le plus souvent comme un interrupteur commandé par sa troisième broche. Le courant qui traverse les deux premières broches passe ou ne passe pas selon ce qu'on met sur la troisième.

[[File:Transistor basic flow.svg|centre|vignette|Un transistor est un morceau de conducteur, dont la conductivité est contrôlée par sa troisième broche/borne.]]

Les ordinateurs de seconde génération avaient entre 1000 et 500 000 transistors. Les capacités des ordinateurs étaient donc nettement supérieures à celles des ordinateurs de première génération. Une part non négligeable des ordinateurs de seconde génération supportait l'opération de multiplication, absente sur les ordinateurs de première génération. Néanmoins, cela variait beaucoup selon les ordinateurs.

Un exemple assez hors du commun est celui du premier modèle de l'IBM 1620. Le tout premier modèle n'avait aucun circuit de calcul, il n'était même pas capable de faire une addition ou une multiplication. A la place, il utilisait une table d'addition et une table de multiplication en mémoire RAM. Les deux tables devaient être initialisées par le logiciel lors du démarrage de la machine. La table d'addition faisait une centaine de chiffres, la table de multiplication faisait le double. Le processeur de l'ordinateur gérait des instructions pour faire des additions ou des multiplications, mais ces opérations lisaient le résultat dans la table d'addition. Les calculs étaient faits chiffre par chiffre, avec un encodage partiellement décimal, partiellement binaire (des chiffres décimaux étaient encodés en binaire, nous en reparlerons quand nous parlerons du BCD) !

[[File:KL CoreMemory.jpg|vignette|Mémoire à tore de ferrite.]]

Les transistors n'étaient utilisés que pour le processeur et les circuits annexes. La mémoire n'était pas faite en transistors, pas à cette époque. La mémoire était une mémoire aujourd'hui abandonnée, appelée une '''mémoire à tores de ferrite'''. Elle sera détaillée dans un chapitre ultérieur. Mais sachez pour le moment qu'il s'agit d'une mémoire au support magnétique, les données étant stockées sur un support magnétique.

Transistors comme tubes à vide prenaient beaucoup de place, ce qui fait que les ordinateurs étaient assez gros. Concrètement, ils prenaient une pièce de bâtiment entière dans le meilleur des cas. C'était l'époque des gros ''mainframes'', reliés à des terminaux, peu puissants comparé aux standards actuels. Seules les grandes entreprises et les grands instituts de recherche pouvaient se payer les services de ce genre d'ordinateurs. Seuls les professionnels avaient accès à ce genre d'équipement.

===La troisième génération : le circuit intégré===

[[File:D8259AC-2.jpg|vignette|Exemple de circuit intégré.]]

La troisième génération est toujours fabriquée avec des transistors, mais dont la taille a été réduite. Avec l'évolution de la technologie, les transistors ont diminué en taille, de plus en plus. Ils sont devenus tellement petits qu'ils ont fini par être regroupés dans des '''circuits intégrés''', des circuits regroupent plusieurs transistors sur la même puce de silicium. Les circuits intégrés se présentent le plus souvent sous la forme de boitiers rectangulaires, comme illustré ci-contre. D'autres ont des boitiers de forme carrées, comme ceux que l'on peut trouver sur les barrettes de mémoire RAM, ou à l'intérieur des clés USB/ disques SSD.

Lors de cette génération, les processeurs étaient fournis en pièces détachées qu'il fallait relier entre elles. Le processeur était composé de plusieurs circuits intégrés séparés, impossible de mettre un processeur dans un seul boitier. Un exemple de processeur conçu en kit est la série des Intel 3000. Elle regroupe plusieurs circuits séparés aux noms à coucher dehors, mais dont vous comprendrez ce qu'ils veulent dire dans les chapitres adéquats : l'Intel 3001 est un séquenceur, l'Intel 3002 regroupe unité de calcul et registres, le 3003 est un circuit d'anticipation de retenue complémentaire du 3002, le 3212 est une mémoire tampon, le 3214 est une unité de gestion des interruptions, les 3216/3226 sont des interfaces de bus mémoire. On pourrait aussi citer la famille de circuits intégrés AMD Am2900.

Même si le processeur était en pièces détachées, utiliser une dizaine de circuits intégrés était nettement mieux que d'utiliser plusieurs milliers de transistors individuels. En conséquence, les ordinateurs ont vu leur taille grandement réduite, passant de pièces entières à une simple armoire, voire à quelques cartes intégrées superposées. De plus, le prix des circuits intégré était abordable, du moins comparé aux ordinateurs d'avant. Le prix des ordinateurs a alors grandement décru, permettant à des entreprises et administrations de taille modeste de s'équiper d'ordinateurs.

===La quatrième génération : le microprocesseur===

[[File:MOS6502.svg|vignette|Microprocesseur, ici un processeur MOS6502, de la quatrième génération.]]

Lors de la troisième génération, les circuits intégrés regroupaient plusieurs dizaines ou centaines de transistors, mais sont rapidement montés en gamme. De centaines de transistors, ils sont passés au millier de transistors, puis au million et maintenant au-delà du milliard. Les transistors étaient devenus tellement petits, tellement miniaturisés, qu'il était devenu possible de mettre un processeur entier dans un circuit intégré. C'est ainsi qu'est né le microprocesseur, à savoir un processeur qui tient tout entier dans un seul circuit imprimé. La quatrième génération d’ordinateur est celle des ordinateurs basés autour d'un microprocesseur.

Les tout premiers microprocesseurs étaient des processeurs à application militaire, comme le processeur du F-14 CADC ou celui de l'Air data computer. Le tout premier microprocesseur commercialisé au grand public est le 4004 d'Intel, sorti en 1971. L'intel 4004 comprenait environ 2300 transistors, avait une fréquence de 740 MHz, pouvait faire 46 opérations différentes, et manipulait des entiers de 4 bits. Il était au départ un processeur de commande, prévu pour être intégré dans la calculatrice Busicom calculator 141-P, mais il fut utilisé pour d'autres applications quelque temps plus tard. Immédiatement après le 4004, les premiers microprocesseurs 8 bits furent commercialisés. Le 4004 fut suivi par le 8008 et quelques autres processeurs 8 bits extrêmement connus, comme le 8080 d'Intel, le 68000 de Motorola, le 6502 ou le Z80.

Les microprocesseurs permirent encore uen fois de réduire la taille des ordinateurs, qui pouvaient tenir dans un boitier de PC, ou un boitier de console de jeu. Le prix des ordinateurs a aussi chuté en même temps que les transistors étaient miniaturisés. C'est cette invention qui permis l'invention des consoles de jeux et des mini-ordinateurs, à savoir les ordinateurs personnels. Sans miniaturisation, on n'aurait pas d'ordinateur personnel, pas de PC fixe ou portable.

==L'organisation du cours : les différents niveaux d'explication==

Le fonctionnement d'un ordinateur est assez complexe à expliquer car les explications peuvent se faire sur plusieurs niveaux. Par plusieurs niveaux, on veut dire qu'un ordinateur est composé de composants très simples, qui sont assemblés pour donner des composants eux-même plus complexes, qui sont eux-même regrouper, etc. Étudier tout cela demande de voir plusieurs niveaux, allant de transistors très petits à des processeurs multicœurs. Les niveaux les plus bas sont de l'électronique pur et dure, alors que ceux plus haut sont à mi-chemin entre électronique et informatique.

===Les niveaux d'abstraction en architecture des ordinateurs===

Les trois premiers niveaux sont de l'électronique pur et dure. Ils correspondent aux premiers chapitres du cours, qui porteront sur les circuits électroniques en général.
* Le premier niveau est celui des '''transistors''', des circuits intégrés, des ''wafer'' et autres circuits de très petite taille.
* Le second niveau est celui des '''portes logiques''', des circuits très basiques, très simples, à la base de tous les autres.
* Le troisième niveau est celui dit de la '''''Register Transfer Level''''', où un circuit électronique est construit à partir de circuits basiques, dont des registres et autres circuits dits combinatoires.
Les deux niveaux suivants sont de l'informatique proprement dit. C'est dans ces deux niveaux qu'on étudie les ordinateurs proprement dit, les circuits qu'il y a dedans et non l'électronique en général.
* Le quatrième niveau est celui de la '''microarchitecture''', qui étudie ce qu'il y a à l'intérieur d'un processeur, d'une mémoire, des périphériques et autres.
* Le cinquième niveau est celui de l''''architecture externe''', qui décrit l'interface du processeur, de la mémoire, d'un périphérique ou autre. Par décrire l'interface, on veut dire : comment un programmeur voit le processeur et la mémoire, comment il peut les manipuler. Une architecture externe unique peut avoir plusieurs microarchitecture, ce qui fait qu'on sépare les deux. Tout cela sera plus clair quand on passera aux chapitres sur le processeur et les mémoires.

Nous n'allons pas voir les 5 niveaux dans l'ordre, des transistors vers l'architecture externe. En réalité, nous allons procéder autrement. La première partie du cours portera sur les trois premiers niveaux, le reste sur les deux autres. Les 5 niveaux seront vus dans des chapitres séparés, du moins le plus possible. Au niveau pédagogique, tout est plus simple si on scinde les 5 niveaux. Bien sûr, il y a quelques explications qui demandent de voir plusieurs niveaux à la fois. Par exemple, dans le chapitre sur les mémoires caches, nous auront des explications portant sur la RTL, la microarchitecture du cache et son architecture externe. Mais le gros du cours tentera de séparer le plus possible les 5 niveaux.

===Les trois parties principales du cours===

Nous allons commencer par parler du binaire, avant de voir les portes logiques. Avec ces portes logiques, nous allons voir comment fabriquer des circuits basiques qui reviendront très souvent dans la suite du cours. Nous verrons les registres, les décodeurs, les additionneurs et plein d'autres circuits. Puis, nous reviendrons au niveau des transistors pour finir la première partie. La raison est que c'est plus simple de faire comme cela. Tout ce qui a trait aux transistors sert à expliquer comment fabriquer des portes logiques, et il faut expliquer les portes logiques pour voir le niveau de la RTL.

Une fois la première partie finie, nous allons voir les différents composants d'un ordinateur. Une première partie expliquera ce qu'il y a dans un ordinateur, quels sont ses composants. Nous y parlerons de l'architecture de base, de la hiérarchie mémoire, des tendances technologiques, et d'autres généralités qui serviront de base pour la suite. Puis, nous verrons dans l'ordre les bus électroniques, les mémoires RAM/ROM, le processeur, les périphériques, les mémoires de stockage (SSD et disques durs) et les mémoires caches. Pour chaque composant, nous allons voir leur architecture externe, avant de voir leur microarchitecture. La raison est que la microarchitecture ne peut se comprendre que quand on sait quelle architecture externe elle implémente.

Enfin, dans une troisième partie, nous allons voir les optimisations majeures présentes dans tous les ordinateurs modernes, avec une partie sur le pipeline et le parallélisme d'instruction, et une autre sur les architectures parallèles. Pour finir, les annexes de fin parlerons de sujets un peu à part.

&lt;noinclude&gt;
{{NavChapitre | book=Fonctionnement d'un ordinateur
           | next=L'encodage des données
           | nextText=L'encodage des données
}}
&lt;/noinclude&gt;</text>
      <sha1>fc3v3eqcz40by0dzalp53zh99llu1h3</sha1>
    </revision>
    <revision>
      <id>744148</id>
      <parentid>744147</parentid>
      <timestamp>2025-06-05T11:57:17Z</timestamp>
      <contributor>
        <username>Mewtow</username>
        <id>31375</id>
      </contributor>
      <minor />
      <comment>/* Les ordinateurs à programme mémorisé ou programme externe */</comment>
      <origin>744148</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="46127" sha1="169nvf2yv8ux5qngiz6if51t8jl0k68" xml:space="preserve">Pour commencer, nous allons voir qu'il existe de nombreux types d'ordinateurs. Le plus connu est certainement le PC, l'ordinateur personnel, que vous avez sans doute dans votre salon. Les ordinateurs portables sont un deuxième type d'ordinateur assez intuitif, que vous avez peut-être. Mais il y a aussi d'autres types d'ordinateurs auxquels vous n'avez jamais été confrontés.

==Les différents types d'ordinateurs==

Dans cette section, nous allons décrire rapidement les ordinateurs les plus courant, mais surtout voir ce qu'il y a à l'intérieur d'un ordinateur.

===L'ordinateur de type PC fixe===

De l'extérieur, l'ordinateur est composé d'une unité centrale sur laquelle on branche des périphériques.

[[File:Typical computer architecture systems.jpg|vignette|upright=1.5|Exemples de périphériques, connectés à une unité centrale (ici appelée à tort ''operating system'').]]

Les '''périphériques''' regroupent l'écran, la souris, le clavier, l'imprimante, et bien d'autres choses. Ils permettent à l'utilisateur d'interagir avec l'ordinateur : un clavier permet de saisir du texte sous dans un fichier, une souris enregistre des déplacements de la main en déplacement du curseur, un écran affiche des données d’images/vidéos, un haut-parleur émet du son, etc. Tout ce qui est branché sur un ordinateur est, formellement un périphérique.

L''''unité centrale''' est là où se trouvent tous les composants importants d'un ordinateur, ceux qui font des calculs, qui exécutent des logiciels, qui mémorisent vos données, etc. Voici ce à quoi ressemble l'intérieur de l'unité centrale. Trois sections sont visibles : l'alimentation électrique en haut à gauche, la carte mère en bas à gauche et en jaune/orange, les disques et lecteurs à droite des câbles. Et on voit aussi beaucoup de câbles.

[[File:Asus P5K-SEIntel E6320.jpg|centre|vignette|upright=2|Exemple d'unité centrale.]]

Tout en haut à gauche, se trouve l''''alimentation électrique''', qui convertit le courant de la prise électrique en un courant plus faible, utilisable par les autres composants. Elle émet de nombreux câbles assez gros, qui sont reliés au reste. Les PC actuels utilisent des alimentations électriques standardisées, qui fournissent trois tensions au reste de l'ordinateur : une tension de 12 Volts, une de 5 Volts, une de 3,3 Volts.

À droite, caché par la partie &quot;métallique&quot; du boitier, se trouvent les lecteurs de CD/DVD, et les disques durs. Les lecteurs CD-ROM ou DVD-ROM permettaient de lire des CD ou des DVD. Je parle au passé, car ils ont aujourd'hui disparu des ordinateurs modernes. Les '''disques durs''' sont des mémoires de stockage, qui mémorisent vos données de manière permanente. De nos jours, ils sont remplacés par des SSD, qui sont des disques durs électroniques, là où les disques durs proprement dit sont des mémoires magnétiques. Nous verrons la différence dans deux chapitres dédiés, un sur les disques durs, l'autre sur les SSD.

En bas à droite, se trouve la '''carte mère''' un support plat, en plastique ou en céramique, sur laquelle sont soudés/connectés les autres composants. Sur celle-ci, de nombreux composants sont soudés, d'autres sont branchés dessus avec des câbles, d'autres sont connectés dessus avec des connecteurs. Ils sont reliés entre eux par des fils conducteurs, le plus souvent du cuivre ou de l’aluminium, ce qui leur permet de s’échanger des données. Sur les cartes simples, ces fils sont intégrés dans la carte électronique, dans des creux du plastique. Ils portent le nom de pistes.

Avant, les disques durs, SSD et lecteurs de CD/DVD sont branchés dessus via des connecteurs dédiés, appelés des connecteurs S-ATA. De nos jours, ils sont branchés sur un autre connecteur, grâce à l'interface NVME. Toujours est-il qu'ils sont reliés à la carte mère par des câbles, ce qui montre que ce sont des sortes de périphériques interne. Ils sont placés dans le boitier, mais on aurait tout aussi bien pu les mettre à l'extérieur, vu qu'ils communiquent avec l'ordinateur par l'intermédiaire d'un câble ou d'un connecteur dédié.

Mais deux autres composants très importants sont eux placés sur la carte mère, directement. Ils ont chacun un connecteur dédié, sur lequel ils sont branchés directement, sans passer par l'intermédiaire d'un câble, mais sans être soudés non plus. Il s'agit du processeur et de la mémoire RAM, deux composants centraux des PC modernes.

[[File:Pentium III SL4CB.jpg|thumb|Processeur Pentium III.]]

Le '''processeur''' traite les données, les modifie, les manipule. Pour faire simple, il s’agit d’une grosse calculatrice hyper-puissante. Il comprend à la fois un circuit qui fait des calculs, et un circuit de contrôle qui s'occupe de séquencer les calculs dans l'ordre demandé. Il est souvent caché sous un radiateur, lui-même surmonté par un ventilateur. En effet, un processeur chauffe beaucoup, ce qui demande d'évacuer cette chaleur. Un chapitre entier expliquera pourquoi les processeurs chauffent, ainsi que les techniques utilisées pour limiter leur production de chaleur et leur consommation électrique.

La '''mémoire vive''' conserve des informations/données temporairement, tant que le processeur en a besoin. Elle prend la forme de barrettes de RAM, comme montré ci-dessous.

[[File:2 gb ddr2 667.jpg|centre|vignette|upright=2|Barrette de RAM.]]

Outre ces composants dits principaux, un ordinateur peut comprendre plusieurs composants moins importants, surtout présents sur les ordinateurs personnels. Ils sont techniquement facultatifs, mais sont très présents dans les ordinateurs personnels. Cependant, certains ordinateurs spécialisés s'en passent. Il s'agit des diverses '''cartes d'extension''' sont branchées sur la carte mère. Elles permettent d’accélérer certains calculs ou certaines applications, afin de décharger le processeur. Par exemple, la carte graphique s'occupe des calculs graphiques, qu'il s'agisse de graphismes 3D de jeux vidéos ou de l'affichage en 2D du bureau. Dans un autre registre, la carte son prend en charge le microphone et les haut-parleurs.

[[Fichier:Personal computer, exploded 4.svg|thumb|upright=1.0|Éclaté d'un ordinateur de type PC :&lt;br /&gt;
1 : Écran ;&lt;br /&gt;
2 : Carte mère ;&lt;br /&gt;
3 : Processeur ;&lt;br /&gt;
4 : Câble Parallel ATA ;&lt;br /&gt;
5 : Mémoire vive (RAM) ;&lt;br /&gt;
6 : Carte d'extension ;&lt;br /&gt;
7 : Alimentation électrique ;&lt;br /&gt;
8 : Lecteur de disque optique ;&lt;br /&gt;
9 : Disque dur ;&lt;br /&gt;
10 : Clavier ;&lt;br /&gt;
11 : Souris.]]

Si on regarde une carte mère de face, on voit un grand nombre de connecteurs, mais aussi des circuits électroniques soudés à la carte mère.

[[File:Architecture matérielle d'une carte mère.png|centre|vignette|upright=2.0|Architecture matérielle d'une carte mère]]

Les '''connecteurs''' sont là où on branche les périphériques, la carte graphique, le processeur, la mémoire, etc. Dans l'ensemble, toute carte mère contient les connecteurs suivants :
* Le processeur vient s’enchâsser dans la carte mère sur un connecteur particulier : le '''socket'''. Celui-ci varie suivant la carte mère et le processeur, ce qui est source d'incompatibilités.
* Les barrettes de mémoire RAM s’enchâssent dans un autre type de connecteurs: les '''slots mémoire'''.
* Les mémoires de masse disposent de leurs propres connecteurs : connecteurs P-ATA pour les anciens disques durs, et S-ATA pour les récents.
* Les périphériques (clavier, souris, USB, Firewire, ...) sont connectés sur un ensemble de connecteurs dédiés, localisés à l'arrière du boitier de l'unité centrale. 
* Les autres périphériques sont placés dans l'unité centrale et sont connectés via des connecteurs spécialisés. Ces périphériques sont des cartes imprimées, d'où leur nom de '''cartes filles'''. On peut notamment citer les cartes réseau, les cartes son, ou les cartes vidéo.

===Les ordinateurs portables===

[[File:Samsung QX-511 (2).JPG|vignette|Ordinateur portable Samsung QX-511 (2), pour illustration.]]

Un ordinateur portable est identique à un ordinateur de type PC. Si vous ouvrez votre ordinateur portable (attention à la garantie), vous retrouverez les mêmes composants qu'un PC à l'intérieur. Un point important est la présence d'une batterie à l'intérieur du PC portable, absente des PC fixes.

[[File:LG gram 14Z90Q mainboard with battery.jpg|centre|vignette|upright=2|LG gram 14Z90Q avec sa batterie.]]

Une fois la batterie et les circuits associés retiré, la seule différence notable est que tous les composants sont soudés sur la carte mère, au lieu d'être branchés sur des connecteurs, à part éventuellement la RAM et le disque dur.

[[File:LG gram 14Z90Q mainboard without battery.jpg|centre|vignette|upright=2|LG gram 14Z90Q sans sa batterie.]]

La RAM est parfois soudée sur la carte mère, d'autres fois sous la forme de barrettes de mémoire vive semblables à celles des PC. Dans le dernier cas, elle est connectée à des connecteurs spécifiques, ce qui permet de les changer/upgrader. Les PC portables sont parfois construits de manière à pouvoir changer la RAM facilement, en ouvrant un cache spécial, concu pour.

[[File:Lenovo G555 состав - Донор.JPG|centre|vignette|upright=2|Lenovo G555.]]

La conception d'un ordinateur portable est légèrement différente de celle d'un PC, pour des raisons thermiques. Un PC fixe a plus de place pour évacuer sa chaleur. Les ventilateurs peuvent plus facilement déplacer l'air dans le boitier, même si le flux d'air dans le boitier est éventuellement gêné par la carte graphique. Mais l'évacuation de la chaleur est assez efficace. Sur les PC portables, leur finesse fait que le trajet de l'air est beaucoup plus contraint. Évacuer la chaleur produite par l'ordinateur est plus complexe, ce qui demande d'utiliser des systèmes de refroidissement et de ventilation spécifiques.

Là où les PC fixes se débrouillent avec des radiateurs et des ventilateurs posés sur le processeur, les PC portables font autrement. Ils ne peuvent pas forcément mettre le ventilateur sur le processeur. A la place, ils mettent le ventilateur à côté, mais le processeur est surmonté par un mécanisme de transmission de la chaleur, qui transfère la chaleur du processeur vers le ventilateur.

[[File:Diagram - How a laptop cooling system works.png|centre|vignette|upright=2|Comment fonctionne le système de ventilation d'un ordinateur portable, en anglais.]]

Les difficultés pour dissiper la chaleur font que les ordinateurs portables utilisent souvent des composants peu performants, mais qui chauffent peu. En effet, nous verrons que plus un composant est puissant, plus il chauffe. La relation n'est pas parfaite, mais les processeurs haute performance chauffent plus que les modèles d'entrée ou milieu de gamme moins puissants. En conséquence, les PC portables sont souvent moins puissants que les PC fixes, même pour les modèles dit ''gaming''.

===Les serveurs et ''mainframes''===

Les grandes entreprises utilisent des ordinateurs de grande taille, très puissants, appelés des ''mainframes''. Ils sont souvent confondus avec les serveurs par le grand public, il y a une différence entre les deux. Un serveur est une fonction logicielle/réseau, pas un type d'ordinateur. Mais laissons cette différence de côté, ce qui est dit pour les ''mainframes'' sert pour les gros serveurs haute performance.

[[File:IBM Z15 mainframe.jpg|vignette|Exemple de ''mainframe''' de type IBM Z15.]]

Les anciens ''mainframes'' des années 50-80 avaient une taille pouvant être impressionnante, au point de prendre une pièce complète d'un bâtiment. Mais de nos jours, les ''mainframes'' tiennent dans une grosse armoire un peu haute. Les ''mainframes'' doivent rester allumé en permanence et ne doivent pas être éteint, sauf éventuellement quelques jours par an pour des opérations de maintenance. Ils utilisent pour cela des techniques spécifiques, avec beaucoup de redondance interne.

[[File:ACONIT hall grandes machines.jpg|centre|vignette|upright=2|''Mainframe'' ACONIT.]]

Les ''mainframes'' sont aussi conçus pour mutualiser au maximum leur utilisation, ils peuvent être utilisés par plusieurs utilisateurs à la suite, voire en même temps. Pour cela, les anciens ''mainframes'' étaient capables de faire tourner plusieurs applications distinctes l'une à la suite de l'autre, avec des commutations fréquentes entre logiciels. De nos jours, ils sont capables d'exécuter un grand nombre de tâches en même temps, grâce à la présence de plusieurs processeurs. Les ''mainframes'' modernes sont même capables de faire tourner plusieurs systèmes d'exploitation en même temps si besoin.

Les anciens ''mainframes'' étaient des ordinateurs assez simples, avec un processeur, de la mémoire RAM, un ou plusieurs disques durs, pas plus. Le ''mainframe'' était tellement énorme et cher que les entreprises n'en avaient qu'un seul pour toute l'entreprise. Les employés avaient sur leur bureau des terminaux, qui permettaient d'accéder à l'ordinateur central, mais n'étaient pas des ordinateurs. Les terminaux étaient des composants électroniques simples, avec un écran, un clavier et une souris, mais sans processeur. Ils envoyaient des données au ''mainframe'', ils en recevaient de sa part, mais tout traitement était réalisé sur le ''mainframe''. L'arrivée sur le marché des ordinateurs personnels, de type PC fixe/portable, a entrainé l'abandon de ce genre de pratique, tous les employés ont maintenant un ordinateur rien que pour eux.

{|
|-
! colspan=&quot;2&quot; | Exemples de terminaux
|-
|[[File:Terminal-in2-sm9400.jpg|centre|vignette|upright=1.5|Exemple de terminal. Notez la présence d'un écran et d'un clavier, mais l'asbence d'une unité centrale.]]
|[[File:Chromatics CT4100.jpg|vignette|upright=1.5|Autre exemple de terminal. Le clavier est couplé à un stylo CRT, qui remplacait la souris et agissait sur l'écran comme s'il était tactile.]]
|-
! colspan=&quot;2&quot; | Intérieur d'un terminal
|-
|[[File:CT1024 Monitor.jpg|vignette|upright=1.5|Terminal CT1024, sans le boitier extérieur.]]
|[[File:CT1024 Terminal System.jpg|vignette|upright=1.5|Terminal CT1024, description des composants interne.]]
|}

De nos jours, les ''mainframes'' contiennent en réalité plusieurs ordinateurs simples interconnectés via un réseau local. Un ''mainframe'' qui tient dans une armoire contient facilement une dizaine ou centaine de processeurs, plein de RAM, des disques durs séparés dans une armoire distincte, etc. Vu qu'ils communiquent uniquement via le réseau, ils n'ont pas d'interface, pas d'écran, 'entrée via clavier/souris. Le tout est commandé avec une console de commande, typiquement un ordinateur portable ou un terminal assez simple séparé de l'armoire, qui permet à un administrateur de faire des opérations de surveillance, configuration et maintenance. Il peut y avoir une console de commande pour plusieurs armoires séparées, la console peut même être dans un autre bâtiment et accéder au ''mainframe'' par le réseau.

[[File:IBM System Z9 (type 2094 inside).jpg|centre|vignette|upright=2|''Mainframe'' de type IBM System Z9. L'ordinateur portable sert de console pour qu'un administrateur fasse des opérations de surveillance, configuration et maintenance.]]

Les processeurs et la RAM sont typiquement installés sur des cartes amovibles, qui sont connectées au fond de l'armoire lors de l'installation. Il est même possible de retirer ou d'ajouter des cartes en fonctionnement, afin d'ajouter/retirer des processeurs, des disques durs, etc. Ce qui est très utile si un composant est en panne et qu'il faut le remplacer. 

[[File:IBM TotalStorage Exp400.jpg|centre|vignette|upright=2|IBM TotalStorage Exp400]]

==Un peu d'abstraction : qu'est-ce qu'un ordinateur ?==

Un ordinateur comprend donc un processeur, plusieurs mémoires, des cartes d'extension et une carte mère pour connecter le tout. Mais il s'agit là d'une description assez terre-à-terre de ce qu'est un ordinateur. Une autre description, plus abstraite, se base sur le fait qu'un ordinateur est une énorme calculatrice programmable. Elle permet d'expliquer pourquoi il y a une distinction entre processeur et mémoire, entre unité centrale et périphériques. Tout ce qui va suivre pourra vous paraitre assez abstrait, mais rassurez-vous : les prochains chapitres rendront tout cela plus concrets.

===La séparation entre entrées-sorties et traitement===

L'unité centrale peut être vue comme une énorme calculatrice ultra-puissante, qui exécute des commandes/opérations. Mais à elle seule, elle ne servirait à rien, il faut interagir avec par l'intermédiaire de plusieurs périphériques. Il existe deux types de périphériques, qui sont conceptuellement différents. Les périphériques comme le clavier ou la souris permettent d'envoyer des informations à l'ordinateur, d'agir sur celui-ci. A l'inverse, les écrans transmettent des informations dans le sens inverse : de l'ordinateur vers l'utilisateur. Les premiers sont appelés des '''entrées''', les seconds des '''sorties'''.

Dans un ordinateur, les informations sont représentées sous la forme de nombres. Toute donnée dans un ordinateur est codée avec un ou plusieurs nombres regroupés dans une donnée, un fichier, ou autre. Et la transmissions avec les entrées et sorties se fait là-encore avec des nombres. Par exemple, quand vous appuyez sur votre clavier, le clavier envoie un numéro de touche à l'unité centrale, qui indique quelle touche a été appuyée. L'image à afficher à l'écran est codée sous la forme d'une suite de nombres (un par pixel). L'image est envoyée à l'écran, qui traduit la suite de nombre en image à afficher. Les entrées traduisent des actions utilisateurs en nombres, on dit que les entrées encodent les actions utilisateur. Les sorties font la traduction inverse, elles transforment des suites de nombres en une action physique. On dit qu'elles décodent des informations.

Pour résumer, toute appareil électronique est composé par :
* Des '''entrées''' sur lesquelles l'utilisateur agit sur l'ordinateur. Les entrées transforment les actions de l'utilisateur en nombres, qui sont interprétés par l'ordinateur.
* Une '''unité de traitement''', qui manipule des nombres et fait des calculs/opérations dessus. Les nombres proviennent des entrées, du disque dur, ou d'autres sources, peu importe.
* Des '''sorties''', qui va récupèrent le résultat calculé par l'unité de traitement pour en faire quelque chose : écrire sur une imprimante ou sur un moniteur, émettre du son,...

[[File:Ordinateur théorique Simple 1.png|centre|vignette|upright=2|Ordinateur théorique Simple 1]]

L'unité de traitement proprement dite, celle qui fait les calculs, est couplée à une mémoire qui mémorise les opérandes et résultats des calculs. La séparation entre processeur et mémoire est nécessaire pour qu'un appareil électronique soit qualifié d'ordinateur. De nombreux appareils n'ont pas de séparation entre unité de traitement et mémoire, comme certaines vielles radios AM/FM.

[[File:Schéma de principe d'un ordinateur.png|centre|vignette|upright=2|Schéma de principe d'un ordinateur]]

===Un ordinateur est un appareil programmable===

Les appareils simples sont non-programmables, ce qui veut dire qu’ils sont conçus pour une utilisation particulière et qu’ils ne peuvent pas faire autre chose. Par exemple, les circuits électroniques d’un lecteur de DVD ne peuvent pas être transformé en lecteur audio ou en console de jeux... Les circuits non-programmables sont câblés une bonne fois pour toute, et on ne peut pas les modifier. On peut parfois reconfigurer le circuit, pour faire varier certains paramètres, via des interrupteurs ou des boutons, mais cela s’arrête là. Et cela pose un problème : à chaque problème qu'on veut résoudre en utilisant un automate, on doit recréer un nouveau circuit.

À l'inverse, un ordinateur n’est pas conçu pour une utilisation particulière, contrairement aux autres objets techniques. Il est possible de modifier leur fonction du jour au lendemain, on peut lui faire faire ce qu’on veut. On dit qu'ils sont '''programmables'''. Pour cela, il suffit d’utiliser un logiciel, une application, un programme (ces termes sont synonymes), qui fait ce que l'on souhaite. La totalité des logiciels présents sur un ordinateur sont des programmes comme les autres, même le système d'exploitation (Windows, Linux, ...) ne fait pas exception.

Un programme est une suite de d''''instructions machines''', chaque instruction effectuant une action dans l'ordinateur. Sur les ordinateurs modernes, les instructions les plus communes effectuent une opération arithmétique : une addition, une multiplication, une soustraction, etc. Les ordinateurs modernes sont donc de grosses calculettes très puissantes, capables d'effectuer des millions d'opérations par secondes.

Et qui dit opération dit nombres : un ordinateur gère nativement des nombres, qui sont codés en binaire sur la quasi-totalité des ordinateurs modernes. Les ordinateurs modernes sont capables de faire des calculs sur des nombres entiers, mais aussi des nombres à virgule. Il existe plusieurs manières de représenter des nombres en binaire, certaines représentant des nombres entiers dits naturels (0 et plus), d'autres des nombres signés (positifs ou négatifs), d'autres des nombres à virgule. Un chapitre entier détaillera comment sont encodés ces nombres.

Une instruction est représentée dans un ordinateur par une série de nombres entiers : un nombre qui indique quelle opération/commande effectuer et des autres nombres pour coder les données (ou de quoi les retrouver dans l'ordinateur). L'ordinateur récupére les commandes une par une, les traduit en opération à effectuer, exécuter l'opération, et enregistre le résultat. Puis il recommence avec la commande suivante.

[[File:Ordinateur Théorique Complexe 1.png|centre|vignette|upright=3|Ordinateur Théorique Complexe. En jaune, le programme informatique, la liste de commande. Le rectangle gris est l'ordinateur proprement dit.]]

De nombreux appareils sont programmables, mais tous ne sont pas des ordinateurs. Par exemple, certains circuits programmables nommés FPGA n'en sont pas. Pour être qualifié d'ordinateur, un appareil programmable doit avoir un processeur séparé de la mémoire. De plus, il doit utiliser un '''codage numérique''', chose que nous allons aborder dans le chapitre suivant.

===Les ordinateurs à programme mémorisé ou programme externe===

Au tout début de l'informatique, les programmes étaient enregistrés sur des cartes perforées, à savoir des cartes en papier/plastique percées par endroits. Un 1 est codé par un trou dans le papier et un 0 par une absence de trou. Les programmes étaient exécutés par l'ordinateur quand on insérait la carte perforée dans le lecteur et qu'on appuyait sur un bouton.

Par la suite, les premiers ordinateurs grand public, comme les Amstrad ou les Commodore, utilisaient des cassettes audio magnétiques pour stocker les programmes. Dans le même style, les consoles de jeu utilisaient autrefois des cartouches de jeu, qui contenaient le programme du jeu à exécuter. Pour résumer, les anciens ordinateurs mémorisaient les programmes sur un support externe, lu par un périphérique. De tels ordinateurs sont dits à '''programme externe'''.

: D’anciens ordinateurs personnels, comme l’Amstrad ou le Commodore, permettaient de taper les programmes à exécuter à la main, au clavier, avant d’appuyer une touche pour les exécuter. Nul besoin de vous dire que les cassettes audio étaient plus pratiques.

Mais de nos jours, les programmes sont enregistrés sur le disque dur de l'ordinateur ou dans une mémoire intégrée à l'ordinateur. On dit qu'ils sont installés, ce qui est un mot bien compliqué pour dire que le programme est enregistré sur le disque dur de l’ordinateur. A défaut de disque dur, le programme/logiciel est enregistré dans une mémoire spécialisée pour le stockage. Par exemple, sur les cartes électroniques grand public de marque Arduino, les programmes sont envoyés à la carte via le port USB, mais les programmes sont enregistrés dans la carte Arduino, dans une mémoire FLASH dédiée. Disque dur ou non, le programme est mémorisé dans la mémoire de l'ordinateur. Il est possible d'installer ou de désinstaller les programmes en modifiant le contenu de la mémoire. Le terme utilisé est alors celui de '''programme stocké en mémoire'''.

Les programmes à installer sont disponibles soit sur un périphérique, comme un DVD ou une clé USB, soit sont téléchargés depuis internet. Les premiers PC fournissaient les logiciels sur des disquettes, qui contenaient un programme d'installation pour enregistrer le programme sur le disque dur de l'ordinateur. Par la suite, le support des logiciels a migré vers les CD et DVD, les logiciels devenant de plus en plus gros. De nos jours, la majorité des applications sont téléchargées depuis le net, l'usage de périphériques est devenu obsolète, même les consoles de jeu abandonnent cette méthode de distribution.

==Les générations d'ordinateurs : un historique rapide==

L'informatique a beaucoup évolué dans le temps. Et une bonne partie de cette évolution tient à l'évolution de l’électronique sous-jacente. Les ordinateurs actuels sont fabriqués avec des transistors, des petits composants électroniques qui servent d'interrupteurs programmables, qu'on détaillera dans ce qui suit. Mais ça n'a pas toujours été le cas. Et cela permet de distinguer plusieurs '''générations d'ordinateurs'''.

===Les ordinateurs électro-mécaniques : les premiers ordinateurs===

Le tout premier ordinateur est le '''Z1''', un modèle unique inventé par Konrad Suze entre 1936 et 1938. Son processeur gérait non pas des nombres entiers, mais des nombres à virgule (des nombres dits flottants, pour être précis), encodés sur 22 bits. Le processeur du Z1 était capable de faire des additions et des soustractions, car il intégrait un circuit additionneur-soustracteur basique. Des circuits annexes permettaient de faire des multiplications et des divisions en enchainant des additions/soustractions successives. Il fonctionnait à une fréquence de 1 Hz, ce qui fait qu'il pouvait faire une addition/soustraction par seconde maximum.

[[File:Blue-punch-card-front.png|vignette|upright=0.5|Carte Perforée.]]

Niveau mémoire, la RAM de l'ordinateur était très limitée : seulement 16 nombres de 22 bits chacun. S'il s'agissait d'une mémoire électronique, les programmes étaient mémorisés sur une mémoire mécanique. Les programmes étaient enregistrés sur des cartes perforées, à savoir des cartes en papier/plastique dans lesquelles un 1 est codé par un trou dans le papier et un 0 par une absence de trou. Les programmes étaient exécutés par l'ordinateur quand on insérait la carte perforée dans le lecteur et qu'on appuyait sur un bouton.

[[File:German Museum of Technology, Berlin 2017 024.jpg|centre|vignette|upright=2|Réplique du Z1 au ''German Museum of Technology'' de Berlin, 2017.]]

Après sa destruction dans un bombardement, le Z1 a été reconstruit et amélioré, ce qui donné les deux ordinateurs Z2 et Z3. Quelques années plus tard, de nombreux ordinateurs ont été construits dans des laboratoires de recherche. Des grands noms de l'histoire de l'informatique datent de cette époque : le Harvard Mark I et le Colossus Mark 1 (UK) ont tous deux été mis en service en 1944, par exemple. Ils ont servi pour les cryptanalystes pour casser les codes utilisés par les Allemands pour leurs transmissions, pendant la seconde guerre mondiale.

Les ordinateurs cités dans le précédent paragraphe étaient tous des ordinateurs dit '''électro-mécaniques''', car ils mélangeaient des composants électroniques et des composants mécaniques (tout ce qui a trait aux cartes perforées, notamment). Les composants électroniques étaient soit des relais, soit des tubes à vides, les deux étant des interrupteurs commandables électriquement plus ou moins équivalents aux transistors. Les ordinateurs d'avant l'année 1944, étaient tous de ce type. Quelques ordinateurs des années 50 étaient de ce type, mais leur nombre n'a pas dépassé 30. Il faut dire qu'ils ont rapidement laissé la place à des ordinateurs purement électroniques, que nous allons voir dans ce qui suit.

===La première génération : les tubes à vide===

Les ordinateurs qui ont suivi les ordinateurs électromécaniques sont regroupés dans la '''première génération d'ordinateur'''. Ils étaient conçus avec des tubes à vide, ce qui les place entre les premiers ordinateurs électro-mécaniques et les ordinateurs utilisant des transistors. Les tubes à vide étaient assez encombrants, ils consommaient beaucoup de courant, ils chauffaient et étaient assez peu fiables. Ils tombaient en panne assez souvent. Et ils étaient assez simples à fabriquer, mais restaient malgré tout chers.

[[File:Elektronenroehren-auswahl.jpg|centre|vignette|upright=2|Tubes à vides.]]

Au vu de la taille des tubes à vide, les ordinateurs de l'époque étaient composés de plusieurs milliers de ces tubes, guère plus. Et malgré cela, un ordinateur prenait facilement un étage de bâtiment entier, ou au moins plusieurs pièces. La conséquence est que les ordinateurs de première génération étaient très simples, rudimentaires quand on les compare aux ordinateurs modernes. Ils ne géraient que quelques opérations simples : l'addition, la soustraction, pas grand-chose de plus. À quelques exceptions près, ils ne géraient pas la multiplication et encore moins la division, cela aurait demandé trop de tubes à vides.

Une des toutes premières machines construite avec des tubes à vide était l'Atanasoff–Berry. Ce n'était pas un ordinateur, car elle ne pouvait pas exécuter de programme sans intervention humaine pour séquencer des opérations, mais c'était la première machine de calcul purement électronique, sans aucune pièce mécanique. Elle utilisait une mémoire RAM construite avec des condensateurs, ceux-ci étant placés sur des cylindres tournants. Les circuits de calcul étaient construits avec des tubes à vide et faisaient leur travail un bit à la fois. Elle fonctionnait à une fréquence de 60 Hz et pouvait faire 30 additions/soustractions par seconde. Les nombres étaient encodés sur 50 bits. 

[[File:Atanasoff Berry Computer.gif|centre|vignette|upright=2.5|Atanasoff–Berry.]]

L'arrivée de l'ENIAC en 1945 a changé la donne. Cet ordinateur a introduit plusieurs innovations majeures. La première est assez technique, il s'agit de la turing-complétude, elle a trait aux programmes qui peuvent être écrit pour un ordinateur, nous ne la détaillerons pas ici.

[[File:BabyArchitecture.png|vignette|Architecture de la Manchester Baby.]]

En 1948, le ''Manchester Baby'' a introduit une innovation extrêmement importante : le programme n'était plus mémorisé sur des cartes perforées, mais dans une mémoire électronique à l’intérieur de l'ordinateur lui-même. En clair, le ''Manchester Baby'' était le premier '''ordinateur à programme stocké en mémoire''' en français. Au-delà de ça, le Manchester Baby restait quand même très simple, c'était limite un prototype.

Niveau interface, l'ordinateur avait une console avec 32 boutons, des interrupteurs et un écran de sortie sur lequel afficher les résultats. A l'intérieur, il y avait un processeur et une RAM de 32 nombres de 32 bits, fabriquées avec des tubes Williams (abordés dans une annexe à la fin du cours). Une instruction prenant autant de place qu'un nombre en RAM, ce qui limitait les programmes à 32 instructions maximum. Le processeur gérait 8 instructions en tout, mais la seule instruction de calcul qu'il gérait était la soustraction. L'addition n'était pas supportée. Il pouvait cependant émuler l'addition à partir d'une soustraction et inversant l'opérande soustrait.

Le Manchester Mark 1 était une amélioration du Manchester Baby. Il utilisait 4500 tubes à vide. L'ordinateur gérait des nombres de 40 bits, mais les instructions étaient codées sur 20 bits. La RAM avait la même taille, à savoir 32 nombres, leur taille était simplement augmentée. Par contre, la RAM était complémentée par l’ancêtre du disque dur magnétique, à savoir un tambour magnétique, l’ancêtre du disque dur magnétique. Il contenait 40 pages, chacune ayant la même taille que la RAM. Contrairement à la Manchester Baby, son processeur gérait l'addition et quelques opérations logiques (ET et OU), en plus de la soustraction et de la comparaison.

Par la suite, les ordinateurs commerciaux ont vu le jour. Les ordinateurs précédents provenaient de projets de recherches, souvent publics. Mais les entreprises privées se sont mises à fabriquer des ordinateurs elle-mêmes, pour les vendre à d'autres entreprises. On peut notamment citer les ordinateurs comme le UNIVAC I, le Bull Gamma 3 ou les premiers ordinateurs IBM. La performance de ces ordinateurs était nettement plus importante que leurs prédécesseurs, avec des fréquences de l'ordre de la centaine de kilo-hertz. Par exemple, le Bull Gamma 3 allait à 281 kHz, l'IBM 650 allait à 50 Khz.

===La seconde génération : le remplacement des tubes à vides par des transistors===

[[File:IBM 7070.jpg|vignette|Cartes imprimées de l'IBM 704, avec des transistors et résistances dessus.]]

La '''seconde génération''' est celle des ordinateurs fabriqués avec des '''transistors''' isolés, reliés entre avec des fils électriques. Les transistors en question possèdent trois broches, des pattes métalliques sur lesquelles on connecte des fils électriques. Le transistor s'utilise le plus souvent comme un interrupteur commandé par sa troisième broche. Le courant qui traverse les deux premières broches passe ou ne passe pas selon ce qu'on met sur la troisième.

[[File:Transistor basic flow.svg|centre|vignette|Un transistor est un morceau de conducteur, dont la conductivité est contrôlée par sa troisième broche/borne.]]

Les ordinateurs de seconde génération avaient entre 1000 et 500 000 transistors. Les capacités des ordinateurs étaient donc nettement supérieures à celles des ordinateurs de première génération. Une part non négligeable des ordinateurs de seconde génération supportait l'opération de multiplication, absente sur les ordinateurs de première génération. Néanmoins, cela variait beaucoup selon les ordinateurs.

Un exemple assez hors du commun est celui du premier modèle de l'IBM 1620. Le tout premier modèle n'avait aucun circuit de calcul, il n'était même pas capable de faire une addition ou une multiplication. A la place, il utilisait une table d'addition et une table de multiplication en mémoire RAM. Les deux tables devaient être initialisées par le logiciel lors du démarrage de la machine. La table d'addition faisait une centaine de chiffres, la table de multiplication faisait le double. Le processeur de l'ordinateur gérait des instructions pour faire des additions ou des multiplications, mais ces opérations lisaient le résultat dans la table d'addition. Les calculs étaient faits chiffre par chiffre, avec un encodage partiellement décimal, partiellement binaire (des chiffres décimaux étaient encodés en binaire, nous en reparlerons quand nous parlerons du BCD) !

[[File:KL CoreMemory.jpg|vignette|Mémoire à tore de ferrite.]]

Les transistors n'étaient utilisés que pour le processeur et les circuits annexes. La mémoire n'était pas faite en transistors, pas à cette époque. La mémoire était une mémoire aujourd'hui abandonnée, appelée une '''mémoire à tores de ferrite'''. Elle sera détaillée dans un chapitre ultérieur. Mais sachez pour le moment qu'il s'agit d'une mémoire au support magnétique, les données étant stockées sur un support magnétique.

Transistors comme tubes à vide prenaient beaucoup de place, ce qui fait que les ordinateurs étaient assez gros. Concrètement, ils prenaient une pièce de bâtiment entière dans le meilleur des cas. C'était l'époque des gros ''mainframes'', reliés à des terminaux, peu puissants comparé aux standards actuels. Seules les grandes entreprises et les grands instituts de recherche pouvaient se payer les services de ce genre d'ordinateurs. Seuls les professionnels avaient accès à ce genre d'équipement.

===La troisième génération : le circuit intégré===

[[File:D8259AC-2.jpg|vignette|Exemple de circuit intégré.]]

La troisième génération est toujours fabriquée avec des transistors, mais dont la taille a été réduite. Avec l'évolution de la technologie, les transistors ont diminué en taille, de plus en plus. Ils sont devenus tellement petits qu'ils ont fini par être regroupés dans des '''circuits intégrés''', des circuits regroupent plusieurs transistors sur la même puce de silicium. Les circuits intégrés se présentent le plus souvent sous la forme de boitiers rectangulaires, comme illustré ci-contre. D'autres ont des boitiers de forme carrées, comme ceux que l'on peut trouver sur les barrettes de mémoire RAM, ou à l'intérieur des clés USB/ disques SSD.

Lors de cette génération, les processeurs étaient fournis en pièces détachées qu'il fallait relier entre elles. Le processeur était composé de plusieurs circuits intégrés séparés, impossible de mettre un processeur dans un seul boitier. Un exemple de processeur conçu en kit est la série des Intel 3000. Elle regroupe plusieurs circuits séparés aux noms à coucher dehors, mais dont vous comprendrez ce qu'ils veulent dire dans les chapitres adéquats : l'Intel 3001 est un séquenceur, l'Intel 3002 regroupe unité de calcul et registres, le 3003 est un circuit d'anticipation de retenue complémentaire du 3002, le 3212 est une mémoire tampon, le 3214 est une unité de gestion des interruptions, les 3216/3226 sont des interfaces de bus mémoire. On pourrait aussi citer la famille de circuits intégrés AMD Am2900.

Même si le processeur était en pièces détachées, utiliser une dizaine de circuits intégrés était nettement mieux que d'utiliser plusieurs milliers de transistors individuels. En conséquence, les ordinateurs ont vu leur taille grandement réduite, passant de pièces entières à une simple armoire, voire à quelques cartes intégrées superposées. De plus, le prix des circuits intégré était abordable, du moins comparé aux ordinateurs d'avant. Le prix des ordinateurs a alors grandement décru, permettant à des entreprises et administrations de taille modeste de s'équiper d'ordinateurs.

===La quatrième génération : le microprocesseur===

[[File:MOS6502.svg|vignette|Microprocesseur, ici un processeur MOS6502, de la quatrième génération.]]

Lors de la troisième génération, les circuits intégrés regroupaient plusieurs dizaines ou centaines de transistors, mais sont rapidement montés en gamme. De centaines de transistors, ils sont passés au millier de transistors, puis au million et maintenant au-delà du milliard. Les transistors étaient devenus tellement petits, tellement miniaturisés, qu'il était devenu possible de mettre un processeur entier dans un circuit intégré. C'est ainsi qu'est né le microprocesseur, à savoir un processeur qui tient tout entier dans un seul circuit imprimé. La quatrième génération d’ordinateur est celle des ordinateurs basés autour d'un microprocesseur.

Les tout premiers microprocesseurs étaient des processeurs à application militaire, comme le processeur du F-14 CADC ou celui de l'Air data computer. Le tout premier microprocesseur commercialisé au grand public est le 4004 d'Intel, sorti en 1971. L'intel 4004 comprenait environ 2300 transistors, avait une fréquence de 740 MHz, pouvait faire 46 opérations différentes, et manipulait des entiers de 4 bits. Il était au départ un processeur de commande, prévu pour être intégré dans la calculatrice Busicom calculator 141-P, mais il fut utilisé pour d'autres applications quelque temps plus tard. Immédiatement après le 4004, les premiers microprocesseurs 8 bits furent commercialisés. Le 4004 fut suivi par le 8008 et quelques autres processeurs 8 bits extrêmement connus, comme le 8080 d'Intel, le 68000 de Motorola, le 6502 ou le Z80.

Les microprocesseurs permirent encore uen fois de réduire la taille des ordinateurs, qui pouvaient tenir dans un boitier de PC, ou un boitier de console de jeu. Le prix des ordinateurs a aussi chuté en même temps que les transistors étaient miniaturisés. C'est cette invention qui permis l'invention des consoles de jeux et des mini-ordinateurs, à savoir les ordinateurs personnels. Sans miniaturisation, on n'aurait pas d'ordinateur personnel, pas de PC fixe ou portable.

==L'organisation du cours : les différents niveaux d'explication==

Le fonctionnement d'un ordinateur est assez complexe à expliquer car les explications peuvent se faire sur plusieurs niveaux. Par plusieurs niveaux, on veut dire qu'un ordinateur est composé de composants très simples, qui sont assemblés pour donner des composants eux-même plus complexes, qui sont eux-même regrouper, etc. Étudier tout cela demande de voir plusieurs niveaux, allant de transistors très petits à des processeurs multicœurs. Les niveaux les plus bas sont de l'électronique pur et dure, alors que ceux plus haut sont à mi-chemin entre électronique et informatique.

===Les niveaux d'abstraction en architecture des ordinateurs===

Les trois premiers niveaux sont de l'électronique pur et dure. Ils correspondent aux premiers chapitres du cours, qui porteront sur les circuits électroniques en général.
* Le premier niveau est celui des '''transistors''', des circuits intégrés, des ''wafer'' et autres circuits de très petite taille.
* Le second niveau est celui des '''portes logiques''', des circuits très basiques, très simples, à la base de tous les autres.
* Le troisième niveau est celui dit de la '''''Register Transfer Level''''', où un circuit électronique est construit à partir de circuits basiques, dont des registres et autres circuits dits combinatoires.
Les deux niveaux suivants sont de l'informatique proprement dit. C'est dans ces deux niveaux qu'on étudie les ordinateurs proprement dit, les circuits qu'il y a dedans et non l'électronique en général.
* Le quatrième niveau est celui de la '''microarchitecture''', qui étudie ce qu'il y a à l'intérieur d'un processeur, d'une mémoire, des périphériques et autres.
* Le cinquième niveau est celui de l''''architecture externe''', qui décrit l'interface du processeur, de la mémoire, d'un périphérique ou autre. Par décrire l'interface, on veut dire : comment un programmeur voit le processeur et la mémoire, comment il peut les manipuler. Une architecture externe unique peut avoir plusieurs microarchitecture, ce qui fait qu'on sépare les deux. Tout cela sera plus clair quand on passera aux chapitres sur le processeur et les mémoires.

Nous n'allons pas voir les 5 niveaux dans l'ordre, des transistors vers l'architecture externe. En réalité, nous allons procéder autrement. La première partie du cours portera sur les trois premiers niveaux, le reste sur les deux autres. Les 5 niveaux seront vus dans des chapitres séparés, du moins le plus possible. Au niveau pédagogique, tout est plus simple si on scinde les 5 niveaux. Bien sûr, il y a quelques explications qui demandent de voir plusieurs niveaux à la fois. Par exemple, dans le chapitre sur les mémoires caches, nous auront des explications portant sur la RTL, la microarchitecture du cache et son architecture externe. Mais le gros du cours tentera de séparer le plus possible les 5 niveaux.

===Les trois parties principales du cours===

Nous allons commencer par parler du binaire, avant de voir les portes logiques. Avec ces portes logiques, nous allons voir comment fabriquer des circuits basiques qui reviendront très souvent dans la suite du cours. Nous verrons les registres, les décodeurs, les additionneurs et plein d'autres circuits. Puis, nous reviendrons au niveau des transistors pour finir la première partie. La raison est que c'est plus simple de faire comme cela. Tout ce qui a trait aux transistors sert à expliquer comment fabriquer des portes logiques, et il faut expliquer les portes logiques pour voir le niveau de la RTL.

Une fois la première partie finie, nous allons voir les différents composants d'un ordinateur. Une première partie expliquera ce qu'il y a dans un ordinateur, quels sont ses composants. Nous y parlerons de l'architecture de base, de la hiérarchie mémoire, des tendances technologiques, et d'autres généralités qui serviront de base pour la suite. Puis, nous verrons dans l'ordre les bus électroniques, les mémoires RAM/ROM, le processeur, les périphériques, les mémoires de stockage (SSD et disques durs) et les mémoires caches. Pour chaque composant, nous allons voir leur architecture externe, avant de voir leur microarchitecture. La raison est que la microarchitecture ne peut se comprendre que quand on sait quelle architecture externe elle implémente.

Enfin, dans une troisième partie, nous allons voir les optimisations majeures présentes dans tous les ordinateurs modernes, avec une partie sur le pipeline et le parallélisme d'instruction, et une autre sur les architectures parallèles. Pour finir, les annexes de fin parlerons de sujets un peu à part.

&lt;noinclude&gt;
{{NavChapitre | book=Fonctionnement d'un ordinateur
           | next=L'encodage des données
           | nextText=L'encodage des données
}}
&lt;/noinclude&gt;</text>
      <sha1>169nvf2yv8ux5qngiz6if51t8jl0k68</sha1>
    </revision>
    <revision>
      <id>744149</id>
      <parentid>744148</parentid>
      <timestamp>2025-06-05T11:57:38Z</timestamp>
      <contributor>
        <username>Mewtow</username>
        <id>31375</id>
      </contributor>
      <minor />
      <comment>/* Les ordinateurs électro-mécaniques : les premiers ordinateurs */</comment>
      <origin>744149</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="46033" sha1="3u0r267jmf3ogp3q1jscn42c92m1udt" xml:space="preserve">Pour commencer, nous allons voir qu'il existe de nombreux types d'ordinateurs. Le plus connu est certainement le PC, l'ordinateur personnel, que vous avez sans doute dans votre salon. Les ordinateurs portables sont un deuxième type d'ordinateur assez intuitif, que vous avez peut-être. Mais il y a aussi d'autres types d'ordinateurs auxquels vous n'avez jamais été confrontés.

==Les différents types d'ordinateurs==

Dans cette section, nous allons décrire rapidement les ordinateurs les plus courant, mais surtout voir ce qu'il y a à l'intérieur d'un ordinateur.

===L'ordinateur de type PC fixe===

De l'extérieur, l'ordinateur est composé d'une unité centrale sur laquelle on branche des périphériques.

[[File:Typical computer architecture systems.jpg|vignette|upright=1.5|Exemples de périphériques, connectés à une unité centrale (ici appelée à tort ''operating system'').]]

Les '''périphériques''' regroupent l'écran, la souris, le clavier, l'imprimante, et bien d'autres choses. Ils permettent à l'utilisateur d'interagir avec l'ordinateur : un clavier permet de saisir du texte sous dans un fichier, une souris enregistre des déplacements de la main en déplacement du curseur, un écran affiche des données d’images/vidéos, un haut-parleur émet du son, etc. Tout ce qui est branché sur un ordinateur est, formellement un périphérique.

L''''unité centrale''' est là où se trouvent tous les composants importants d'un ordinateur, ceux qui font des calculs, qui exécutent des logiciels, qui mémorisent vos données, etc. Voici ce à quoi ressemble l'intérieur de l'unité centrale. Trois sections sont visibles : l'alimentation électrique en haut à gauche, la carte mère en bas à gauche et en jaune/orange, les disques et lecteurs à droite des câbles. Et on voit aussi beaucoup de câbles.

[[File:Asus P5K-SEIntel E6320.jpg|centre|vignette|upright=2|Exemple d'unité centrale.]]

Tout en haut à gauche, se trouve l''''alimentation électrique''', qui convertit le courant de la prise électrique en un courant plus faible, utilisable par les autres composants. Elle émet de nombreux câbles assez gros, qui sont reliés au reste. Les PC actuels utilisent des alimentations électriques standardisées, qui fournissent trois tensions au reste de l'ordinateur : une tension de 12 Volts, une de 5 Volts, une de 3,3 Volts.

À droite, caché par la partie &quot;métallique&quot; du boitier, se trouvent les lecteurs de CD/DVD, et les disques durs. Les lecteurs CD-ROM ou DVD-ROM permettaient de lire des CD ou des DVD. Je parle au passé, car ils ont aujourd'hui disparu des ordinateurs modernes. Les '''disques durs''' sont des mémoires de stockage, qui mémorisent vos données de manière permanente. De nos jours, ils sont remplacés par des SSD, qui sont des disques durs électroniques, là où les disques durs proprement dit sont des mémoires magnétiques. Nous verrons la différence dans deux chapitres dédiés, un sur les disques durs, l'autre sur les SSD.

En bas à droite, se trouve la '''carte mère''' un support plat, en plastique ou en céramique, sur laquelle sont soudés/connectés les autres composants. Sur celle-ci, de nombreux composants sont soudés, d'autres sont branchés dessus avec des câbles, d'autres sont connectés dessus avec des connecteurs. Ils sont reliés entre eux par des fils conducteurs, le plus souvent du cuivre ou de l’aluminium, ce qui leur permet de s’échanger des données. Sur les cartes simples, ces fils sont intégrés dans la carte électronique, dans des creux du plastique. Ils portent le nom de pistes.

Avant, les disques durs, SSD et lecteurs de CD/DVD sont branchés dessus via des connecteurs dédiés, appelés des connecteurs S-ATA. De nos jours, ils sont branchés sur un autre connecteur, grâce à l'interface NVME. Toujours est-il qu'ils sont reliés à la carte mère par des câbles, ce qui montre que ce sont des sortes de périphériques interne. Ils sont placés dans le boitier, mais on aurait tout aussi bien pu les mettre à l'extérieur, vu qu'ils communiquent avec l'ordinateur par l'intermédiaire d'un câble ou d'un connecteur dédié.

Mais deux autres composants très importants sont eux placés sur la carte mère, directement. Ils ont chacun un connecteur dédié, sur lequel ils sont branchés directement, sans passer par l'intermédiaire d'un câble, mais sans être soudés non plus. Il s'agit du processeur et de la mémoire RAM, deux composants centraux des PC modernes.

[[File:Pentium III SL4CB.jpg|thumb|Processeur Pentium III.]]

Le '''processeur''' traite les données, les modifie, les manipule. Pour faire simple, il s’agit d’une grosse calculatrice hyper-puissante. Il comprend à la fois un circuit qui fait des calculs, et un circuit de contrôle qui s'occupe de séquencer les calculs dans l'ordre demandé. Il est souvent caché sous un radiateur, lui-même surmonté par un ventilateur. En effet, un processeur chauffe beaucoup, ce qui demande d'évacuer cette chaleur. Un chapitre entier expliquera pourquoi les processeurs chauffent, ainsi que les techniques utilisées pour limiter leur production de chaleur et leur consommation électrique.

La '''mémoire vive''' conserve des informations/données temporairement, tant que le processeur en a besoin. Elle prend la forme de barrettes de RAM, comme montré ci-dessous.

[[File:2 gb ddr2 667.jpg|centre|vignette|upright=2|Barrette de RAM.]]

Outre ces composants dits principaux, un ordinateur peut comprendre plusieurs composants moins importants, surtout présents sur les ordinateurs personnels. Ils sont techniquement facultatifs, mais sont très présents dans les ordinateurs personnels. Cependant, certains ordinateurs spécialisés s'en passent. Il s'agit des diverses '''cartes d'extension''' sont branchées sur la carte mère. Elles permettent d’accélérer certains calculs ou certaines applications, afin de décharger le processeur. Par exemple, la carte graphique s'occupe des calculs graphiques, qu'il s'agisse de graphismes 3D de jeux vidéos ou de l'affichage en 2D du bureau. Dans un autre registre, la carte son prend en charge le microphone et les haut-parleurs.

[[Fichier:Personal computer, exploded 4.svg|thumb|upright=1.0|Éclaté d'un ordinateur de type PC :&lt;br /&gt;
1 : Écran ;&lt;br /&gt;
2 : Carte mère ;&lt;br /&gt;
3 : Processeur ;&lt;br /&gt;
4 : Câble Parallel ATA ;&lt;br /&gt;
5 : Mémoire vive (RAM) ;&lt;br /&gt;
6 : Carte d'extension ;&lt;br /&gt;
7 : Alimentation électrique ;&lt;br /&gt;
8 : Lecteur de disque optique ;&lt;br /&gt;
9 : Disque dur ;&lt;br /&gt;
10 : Clavier ;&lt;br /&gt;
11 : Souris.]]

Si on regarde une carte mère de face, on voit un grand nombre de connecteurs, mais aussi des circuits électroniques soudés à la carte mère.

[[File:Architecture matérielle d'une carte mère.png|centre|vignette|upright=2.0|Architecture matérielle d'une carte mère]]

Les '''connecteurs''' sont là où on branche les périphériques, la carte graphique, le processeur, la mémoire, etc. Dans l'ensemble, toute carte mère contient les connecteurs suivants :
* Le processeur vient s’enchâsser dans la carte mère sur un connecteur particulier : le '''socket'''. Celui-ci varie suivant la carte mère et le processeur, ce qui est source d'incompatibilités.
* Les barrettes de mémoire RAM s’enchâssent dans un autre type de connecteurs: les '''slots mémoire'''.
* Les mémoires de masse disposent de leurs propres connecteurs : connecteurs P-ATA pour les anciens disques durs, et S-ATA pour les récents.
* Les périphériques (clavier, souris, USB, Firewire, ...) sont connectés sur un ensemble de connecteurs dédiés, localisés à l'arrière du boitier de l'unité centrale. 
* Les autres périphériques sont placés dans l'unité centrale et sont connectés via des connecteurs spécialisés. Ces périphériques sont des cartes imprimées, d'où leur nom de '''cartes filles'''. On peut notamment citer les cartes réseau, les cartes son, ou les cartes vidéo.

===Les ordinateurs portables===

[[File:Samsung QX-511 (2).JPG|vignette|Ordinateur portable Samsung QX-511 (2), pour illustration.]]

Un ordinateur portable est identique à un ordinateur de type PC. Si vous ouvrez votre ordinateur portable (attention à la garantie), vous retrouverez les mêmes composants qu'un PC à l'intérieur. Un point important est la présence d'une batterie à l'intérieur du PC portable, absente des PC fixes.

[[File:LG gram 14Z90Q mainboard with battery.jpg|centre|vignette|upright=2|LG gram 14Z90Q avec sa batterie.]]

Une fois la batterie et les circuits associés retiré, la seule différence notable est que tous les composants sont soudés sur la carte mère, au lieu d'être branchés sur des connecteurs, à part éventuellement la RAM et le disque dur.

[[File:LG gram 14Z90Q mainboard without battery.jpg|centre|vignette|upright=2|LG gram 14Z90Q sans sa batterie.]]

La RAM est parfois soudée sur la carte mère, d'autres fois sous la forme de barrettes de mémoire vive semblables à celles des PC. Dans le dernier cas, elle est connectée à des connecteurs spécifiques, ce qui permet de les changer/upgrader. Les PC portables sont parfois construits de manière à pouvoir changer la RAM facilement, en ouvrant un cache spécial, concu pour.

[[File:Lenovo G555 состав - Донор.JPG|centre|vignette|upright=2|Lenovo G555.]]

La conception d'un ordinateur portable est légèrement différente de celle d'un PC, pour des raisons thermiques. Un PC fixe a plus de place pour évacuer sa chaleur. Les ventilateurs peuvent plus facilement déplacer l'air dans le boitier, même si le flux d'air dans le boitier est éventuellement gêné par la carte graphique. Mais l'évacuation de la chaleur est assez efficace. Sur les PC portables, leur finesse fait que le trajet de l'air est beaucoup plus contraint. Évacuer la chaleur produite par l'ordinateur est plus complexe, ce qui demande d'utiliser des systèmes de refroidissement et de ventilation spécifiques.

Là où les PC fixes se débrouillent avec des radiateurs et des ventilateurs posés sur le processeur, les PC portables font autrement. Ils ne peuvent pas forcément mettre le ventilateur sur le processeur. A la place, ils mettent le ventilateur à côté, mais le processeur est surmonté par un mécanisme de transmission de la chaleur, qui transfère la chaleur du processeur vers le ventilateur.

[[File:Diagram - How a laptop cooling system works.png|centre|vignette|upright=2|Comment fonctionne le système de ventilation d'un ordinateur portable, en anglais.]]

Les difficultés pour dissiper la chaleur font que les ordinateurs portables utilisent souvent des composants peu performants, mais qui chauffent peu. En effet, nous verrons que plus un composant est puissant, plus il chauffe. La relation n'est pas parfaite, mais les processeurs haute performance chauffent plus que les modèles d'entrée ou milieu de gamme moins puissants. En conséquence, les PC portables sont souvent moins puissants que les PC fixes, même pour les modèles dit ''gaming''.

===Les serveurs et ''mainframes''===

Les grandes entreprises utilisent des ordinateurs de grande taille, très puissants, appelés des ''mainframes''. Ils sont souvent confondus avec les serveurs par le grand public, il y a une différence entre les deux. Un serveur est une fonction logicielle/réseau, pas un type d'ordinateur. Mais laissons cette différence de côté, ce qui est dit pour les ''mainframes'' sert pour les gros serveurs haute performance.

[[File:IBM Z15 mainframe.jpg|vignette|Exemple de ''mainframe''' de type IBM Z15.]]

Les anciens ''mainframes'' des années 50-80 avaient une taille pouvant être impressionnante, au point de prendre une pièce complète d'un bâtiment. Mais de nos jours, les ''mainframes'' tiennent dans une grosse armoire un peu haute. Les ''mainframes'' doivent rester allumé en permanence et ne doivent pas être éteint, sauf éventuellement quelques jours par an pour des opérations de maintenance. Ils utilisent pour cela des techniques spécifiques, avec beaucoup de redondance interne.

[[File:ACONIT hall grandes machines.jpg|centre|vignette|upright=2|''Mainframe'' ACONIT.]]

Les ''mainframes'' sont aussi conçus pour mutualiser au maximum leur utilisation, ils peuvent être utilisés par plusieurs utilisateurs à la suite, voire en même temps. Pour cela, les anciens ''mainframes'' étaient capables de faire tourner plusieurs applications distinctes l'une à la suite de l'autre, avec des commutations fréquentes entre logiciels. De nos jours, ils sont capables d'exécuter un grand nombre de tâches en même temps, grâce à la présence de plusieurs processeurs. Les ''mainframes'' modernes sont même capables de faire tourner plusieurs systèmes d'exploitation en même temps si besoin.

Les anciens ''mainframes'' étaient des ordinateurs assez simples, avec un processeur, de la mémoire RAM, un ou plusieurs disques durs, pas plus. Le ''mainframe'' était tellement énorme et cher que les entreprises n'en avaient qu'un seul pour toute l'entreprise. Les employés avaient sur leur bureau des terminaux, qui permettaient d'accéder à l'ordinateur central, mais n'étaient pas des ordinateurs. Les terminaux étaient des composants électroniques simples, avec un écran, un clavier et une souris, mais sans processeur. Ils envoyaient des données au ''mainframe'', ils en recevaient de sa part, mais tout traitement était réalisé sur le ''mainframe''. L'arrivée sur le marché des ordinateurs personnels, de type PC fixe/portable, a entrainé l'abandon de ce genre de pratique, tous les employés ont maintenant un ordinateur rien que pour eux.

{|
|-
! colspan=&quot;2&quot; | Exemples de terminaux
|-
|[[File:Terminal-in2-sm9400.jpg|centre|vignette|upright=1.5|Exemple de terminal. Notez la présence d'un écran et d'un clavier, mais l'asbence d'une unité centrale.]]
|[[File:Chromatics CT4100.jpg|vignette|upright=1.5|Autre exemple de terminal. Le clavier est couplé à un stylo CRT, qui remplacait la souris et agissait sur l'écran comme s'il était tactile.]]
|-
! colspan=&quot;2&quot; | Intérieur d'un terminal
|-
|[[File:CT1024 Monitor.jpg|vignette|upright=1.5|Terminal CT1024, sans le boitier extérieur.]]
|[[File:CT1024 Terminal System.jpg|vignette|upright=1.5|Terminal CT1024, description des composants interne.]]
|}

De nos jours, les ''mainframes'' contiennent en réalité plusieurs ordinateurs simples interconnectés via un réseau local. Un ''mainframe'' qui tient dans une armoire contient facilement une dizaine ou centaine de processeurs, plein de RAM, des disques durs séparés dans une armoire distincte, etc. Vu qu'ils communiquent uniquement via le réseau, ils n'ont pas d'interface, pas d'écran, 'entrée via clavier/souris. Le tout est commandé avec une console de commande, typiquement un ordinateur portable ou un terminal assez simple séparé de l'armoire, qui permet à un administrateur de faire des opérations de surveillance, configuration et maintenance. Il peut y avoir une console de commande pour plusieurs armoires séparées, la console peut même être dans un autre bâtiment et accéder au ''mainframe'' par le réseau.

[[File:IBM System Z9 (type 2094 inside).jpg|centre|vignette|upright=2|''Mainframe'' de type IBM System Z9. L'ordinateur portable sert de console pour qu'un administrateur fasse des opérations de surveillance, configuration et maintenance.]]

Les processeurs et la RAM sont typiquement installés sur des cartes amovibles, qui sont connectées au fond de l'armoire lors de l'installation. Il est même possible de retirer ou d'ajouter des cartes en fonctionnement, afin d'ajouter/retirer des processeurs, des disques durs, etc. Ce qui est très utile si un composant est en panne et qu'il faut le remplacer. 

[[File:IBM TotalStorage Exp400.jpg|centre|vignette|upright=2|IBM TotalStorage Exp400]]

==Un peu d'abstraction : qu'est-ce qu'un ordinateur ?==

Un ordinateur comprend donc un processeur, plusieurs mémoires, des cartes d'extension et une carte mère pour connecter le tout. Mais il s'agit là d'une description assez terre-à-terre de ce qu'est un ordinateur. Une autre description, plus abstraite, se base sur le fait qu'un ordinateur est une énorme calculatrice programmable. Elle permet d'expliquer pourquoi il y a une distinction entre processeur et mémoire, entre unité centrale et périphériques. Tout ce qui va suivre pourra vous paraitre assez abstrait, mais rassurez-vous : les prochains chapitres rendront tout cela plus concrets.

===La séparation entre entrées-sorties et traitement===

L'unité centrale peut être vue comme une énorme calculatrice ultra-puissante, qui exécute des commandes/opérations. Mais à elle seule, elle ne servirait à rien, il faut interagir avec par l'intermédiaire de plusieurs périphériques. Il existe deux types de périphériques, qui sont conceptuellement différents. Les périphériques comme le clavier ou la souris permettent d'envoyer des informations à l'ordinateur, d'agir sur celui-ci. A l'inverse, les écrans transmettent des informations dans le sens inverse : de l'ordinateur vers l'utilisateur. Les premiers sont appelés des '''entrées''', les seconds des '''sorties'''.

Dans un ordinateur, les informations sont représentées sous la forme de nombres. Toute donnée dans un ordinateur est codée avec un ou plusieurs nombres regroupés dans une donnée, un fichier, ou autre. Et la transmissions avec les entrées et sorties se fait là-encore avec des nombres. Par exemple, quand vous appuyez sur votre clavier, le clavier envoie un numéro de touche à l'unité centrale, qui indique quelle touche a été appuyée. L'image à afficher à l'écran est codée sous la forme d'une suite de nombres (un par pixel). L'image est envoyée à l'écran, qui traduit la suite de nombre en image à afficher. Les entrées traduisent des actions utilisateurs en nombres, on dit que les entrées encodent les actions utilisateur. Les sorties font la traduction inverse, elles transforment des suites de nombres en une action physique. On dit qu'elles décodent des informations.

Pour résumer, toute appareil électronique est composé par :
* Des '''entrées''' sur lesquelles l'utilisateur agit sur l'ordinateur. Les entrées transforment les actions de l'utilisateur en nombres, qui sont interprétés par l'ordinateur.
* Une '''unité de traitement''', qui manipule des nombres et fait des calculs/opérations dessus. Les nombres proviennent des entrées, du disque dur, ou d'autres sources, peu importe.
* Des '''sorties''', qui va récupèrent le résultat calculé par l'unité de traitement pour en faire quelque chose : écrire sur une imprimante ou sur un moniteur, émettre du son,...

[[File:Ordinateur théorique Simple 1.png|centre|vignette|upright=2|Ordinateur théorique Simple 1]]

L'unité de traitement proprement dite, celle qui fait les calculs, est couplée à une mémoire qui mémorise les opérandes et résultats des calculs. La séparation entre processeur et mémoire est nécessaire pour qu'un appareil électronique soit qualifié d'ordinateur. De nombreux appareils n'ont pas de séparation entre unité de traitement et mémoire, comme certaines vielles radios AM/FM.

[[File:Schéma de principe d'un ordinateur.png|centre|vignette|upright=2|Schéma de principe d'un ordinateur]]

===Un ordinateur est un appareil programmable===

Les appareils simples sont non-programmables, ce qui veut dire qu’ils sont conçus pour une utilisation particulière et qu’ils ne peuvent pas faire autre chose. Par exemple, les circuits électroniques d’un lecteur de DVD ne peuvent pas être transformé en lecteur audio ou en console de jeux... Les circuits non-programmables sont câblés une bonne fois pour toute, et on ne peut pas les modifier. On peut parfois reconfigurer le circuit, pour faire varier certains paramètres, via des interrupteurs ou des boutons, mais cela s’arrête là. Et cela pose un problème : à chaque problème qu'on veut résoudre en utilisant un automate, on doit recréer un nouveau circuit.

À l'inverse, un ordinateur n’est pas conçu pour une utilisation particulière, contrairement aux autres objets techniques. Il est possible de modifier leur fonction du jour au lendemain, on peut lui faire faire ce qu’on veut. On dit qu'ils sont '''programmables'''. Pour cela, il suffit d’utiliser un logiciel, une application, un programme (ces termes sont synonymes), qui fait ce que l'on souhaite. La totalité des logiciels présents sur un ordinateur sont des programmes comme les autres, même le système d'exploitation (Windows, Linux, ...) ne fait pas exception.

Un programme est une suite de d''''instructions machines''', chaque instruction effectuant une action dans l'ordinateur. Sur les ordinateurs modernes, les instructions les plus communes effectuent une opération arithmétique : une addition, une multiplication, une soustraction, etc. Les ordinateurs modernes sont donc de grosses calculettes très puissantes, capables d'effectuer des millions d'opérations par secondes.

Et qui dit opération dit nombres : un ordinateur gère nativement des nombres, qui sont codés en binaire sur la quasi-totalité des ordinateurs modernes. Les ordinateurs modernes sont capables de faire des calculs sur des nombres entiers, mais aussi des nombres à virgule. Il existe plusieurs manières de représenter des nombres en binaire, certaines représentant des nombres entiers dits naturels (0 et plus), d'autres des nombres signés (positifs ou négatifs), d'autres des nombres à virgule. Un chapitre entier détaillera comment sont encodés ces nombres.

Une instruction est représentée dans un ordinateur par une série de nombres entiers : un nombre qui indique quelle opération/commande effectuer et des autres nombres pour coder les données (ou de quoi les retrouver dans l'ordinateur). L'ordinateur récupére les commandes une par une, les traduit en opération à effectuer, exécuter l'opération, et enregistre le résultat. Puis il recommence avec la commande suivante.

[[File:Ordinateur Théorique Complexe 1.png|centre|vignette|upright=3|Ordinateur Théorique Complexe. En jaune, le programme informatique, la liste de commande. Le rectangle gris est l'ordinateur proprement dit.]]

De nombreux appareils sont programmables, mais tous ne sont pas des ordinateurs. Par exemple, certains circuits programmables nommés FPGA n'en sont pas. Pour être qualifié d'ordinateur, un appareil programmable doit avoir un processeur séparé de la mémoire. De plus, il doit utiliser un '''codage numérique''', chose que nous allons aborder dans le chapitre suivant.

===Les ordinateurs à programme mémorisé ou programme externe===

Au tout début de l'informatique, les programmes étaient enregistrés sur des cartes perforées, à savoir des cartes en papier/plastique percées par endroits. Un 1 est codé par un trou dans le papier et un 0 par une absence de trou. Les programmes étaient exécutés par l'ordinateur quand on insérait la carte perforée dans le lecteur et qu'on appuyait sur un bouton.

Par la suite, les premiers ordinateurs grand public, comme les Amstrad ou les Commodore, utilisaient des cassettes audio magnétiques pour stocker les programmes. Dans le même style, les consoles de jeu utilisaient autrefois des cartouches de jeu, qui contenaient le programme du jeu à exécuter. Pour résumer, les anciens ordinateurs mémorisaient les programmes sur un support externe, lu par un périphérique. De tels ordinateurs sont dits à '''programme externe'''.

: D’anciens ordinateurs personnels, comme l’Amstrad ou le Commodore, permettaient de taper les programmes à exécuter à la main, au clavier, avant d’appuyer une touche pour les exécuter. Nul besoin de vous dire que les cassettes audio étaient plus pratiques.

Mais de nos jours, les programmes sont enregistrés sur le disque dur de l'ordinateur ou dans une mémoire intégrée à l'ordinateur. On dit qu'ils sont installés, ce qui est un mot bien compliqué pour dire que le programme est enregistré sur le disque dur de l’ordinateur. A défaut de disque dur, le programme/logiciel est enregistré dans une mémoire spécialisée pour le stockage. Par exemple, sur les cartes électroniques grand public de marque Arduino, les programmes sont envoyés à la carte via le port USB, mais les programmes sont enregistrés dans la carte Arduino, dans une mémoire FLASH dédiée. Disque dur ou non, le programme est mémorisé dans la mémoire de l'ordinateur. Il est possible d'installer ou de désinstaller les programmes en modifiant le contenu de la mémoire. Le terme utilisé est alors celui de '''programme stocké en mémoire'''.

Les programmes à installer sont disponibles soit sur un périphérique, comme un DVD ou une clé USB, soit sont téléchargés depuis internet. Les premiers PC fournissaient les logiciels sur des disquettes, qui contenaient un programme d'installation pour enregistrer le programme sur le disque dur de l'ordinateur. Par la suite, le support des logiciels a migré vers les CD et DVD, les logiciels devenant de plus en plus gros. De nos jours, la majorité des applications sont téléchargées depuis le net, l'usage de périphériques est devenu obsolète, même les consoles de jeu abandonnent cette méthode de distribution.

==Les générations d'ordinateurs : un historique rapide==

L'informatique a beaucoup évolué dans le temps. Et une bonne partie de cette évolution tient à l'évolution de l’électronique sous-jacente. Les ordinateurs actuels sont fabriqués avec des transistors, des petits composants électroniques qui servent d'interrupteurs programmables, qu'on détaillera dans ce qui suit. Mais ça n'a pas toujours été le cas. Et cela permet de distinguer plusieurs '''générations d'ordinateurs'''.

===Les ordinateurs électro-mécaniques : les premiers ordinateurs===

Le tout premier ordinateur est le '''Z1''', un modèle unique inventé par Konrad Suze entre 1936 et 1938. Son processeur gérait non pas des nombres entiers, mais des nombres à virgule (des nombres dits flottants, pour être précis), encodés sur 22 bits. Le processeur du Z1 était capable de faire des additions et des soustractions, car il intégrait un circuit additionneur-soustracteur basique. Des circuits annexes permettaient de faire des multiplications et des divisions en enchainant des additions/soustractions successives. Il fonctionnait à une fréquence de 1 Hz, ce qui fait qu'il pouvait faire une addition/soustraction par seconde maximum.

Niveau mémoire, la RAM de l'ordinateur était très limitée : seulement 16 nombres de 22 bits chacun. S'il s'agissait d'une mémoire électronique, les programmes étaient mémorisés sur une mémoire mécanique et précisémment sur des cartes perforées, à savoir des cartes en papier/plastique dans lesquelles un 1 est codé par un trou dans le papier et un 0 par une absence de trou. Les programmes étaient exécutés par l'ordinateur quand on insérait la carte perforée dans le lecteur et qu'on appuyait sur un bouton.

[[File:German Museum of Technology, Berlin 2017 024.jpg|centre|vignette|upright=2|Réplique du Z1 au ''German Museum of Technology'' de Berlin, 2017.]]

Après sa destruction dans un bombardement, le Z1 a été reconstruit et amélioré, ce qui donné les deux ordinateurs Z2 et Z3. Quelques années plus tard, de nombreux ordinateurs ont été construits dans des laboratoires de recherche. Des grands noms de l'histoire de l'informatique datent de cette époque : le Harvard Mark I et le Colossus Mark 1 (UK) ont tous deux été mis en service en 1944, par exemple. Ils ont servi pour les cryptanalystes pour casser les codes utilisés par les Allemands pour leurs transmissions, pendant la seconde guerre mondiale.

Les ordinateurs cités dans le précédent paragraphe étaient tous des ordinateurs dit '''électro-mécaniques''', car ils mélangeaient des composants électroniques et des composants mécaniques (tout ce qui a trait aux cartes perforées, notamment). Les composants électroniques étaient soit des relais, soit des tubes à vides, les deux étant des interrupteurs commandables électriquement plus ou moins équivalents aux transistors. Les ordinateurs d'avant l'année 1944, étaient tous de ce type. Quelques ordinateurs des années 50 étaient de ce type, mais leur nombre n'a pas dépassé 30. Il faut dire qu'ils ont rapidement laissé la place à des ordinateurs purement électroniques, que nous allons voir dans ce qui suit.

===La première génération : les tubes à vide===

Les ordinateurs qui ont suivi les ordinateurs électromécaniques sont regroupés dans la '''première génération d'ordinateur'''. Ils étaient conçus avec des tubes à vide, ce qui les place entre les premiers ordinateurs électro-mécaniques et les ordinateurs utilisant des transistors. Les tubes à vide étaient assez encombrants, ils consommaient beaucoup de courant, ils chauffaient et étaient assez peu fiables. Ils tombaient en panne assez souvent. Et ils étaient assez simples à fabriquer, mais restaient malgré tout chers.

[[File:Elektronenroehren-auswahl.jpg|centre|vignette|upright=2|Tubes à vides.]]

Au vu de la taille des tubes à vide, les ordinateurs de l'époque étaient composés de plusieurs milliers de ces tubes, guère plus. Et malgré cela, un ordinateur prenait facilement un étage de bâtiment entier, ou au moins plusieurs pièces. La conséquence est que les ordinateurs de première génération étaient très simples, rudimentaires quand on les compare aux ordinateurs modernes. Ils ne géraient que quelques opérations simples : l'addition, la soustraction, pas grand-chose de plus. À quelques exceptions près, ils ne géraient pas la multiplication et encore moins la division, cela aurait demandé trop de tubes à vides.

Une des toutes premières machines construite avec des tubes à vide était l'Atanasoff–Berry. Ce n'était pas un ordinateur, car elle ne pouvait pas exécuter de programme sans intervention humaine pour séquencer des opérations, mais c'était la première machine de calcul purement électronique, sans aucune pièce mécanique. Elle utilisait une mémoire RAM construite avec des condensateurs, ceux-ci étant placés sur des cylindres tournants. Les circuits de calcul étaient construits avec des tubes à vide et faisaient leur travail un bit à la fois. Elle fonctionnait à une fréquence de 60 Hz et pouvait faire 30 additions/soustractions par seconde. Les nombres étaient encodés sur 50 bits. 

[[File:Atanasoff Berry Computer.gif|centre|vignette|upright=2.5|Atanasoff–Berry.]]

L'arrivée de l'ENIAC en 1945 a changé la donne. Cet ordinateur a introduit plusieurs innovations majeures. La première est assez technique, il s'agit de la turing-complétude, elle a trait aux programmes qui peuvent être écrit pour un ordinateur, nous ne la détaillerons pas ici.

[[File:BabyArchitecture.png|vignette|Architecture de la Manchester Baby.]]

En 1948, le ''Manchester Baby'' a introduit une innovation extrêmement importante : le programme n'était plus mémorisé sur des cartes perforées, mais dans une mémoire électronique à l’intérieur de l'ordinateur lui-même. En clair, le ''Manchester Baby'' était le premier '''ordinateur à programme stocké en mémoire''' en français. Au-delà de ça, le Manchester Baby restait quand même très simple, c'était limite un prototype.

Niveau interface, l'ordinateur avait une console avec 32 boutons, des interrupteurs et un écran de sortie sur lequel afficher les résultats. A l'intérieur, il y avait un processeur et une RAM de 32 nombres de 32 bits, fabriquées avec des tubes Williams (abordés dans une annexe à la fin du cours). Une instruction prenant autant de place qu'un nombre en RAM, ce qui limitait les programmes à 32 instructions maximum. Le processeur gérait 8 instructions en tout, mais la seule instruction de calcul qu'il gérait était la soustraction. L'addition n'était pas supportée. Il pouvait cependant émuler l'addition à partir d'une soustraction et inversant l'opérande soustrait.

Le Manchester Mark 1 était une amélioration du Manchester Baby. Il utilisait 4500 tubes à vide. L'ordinateur gérait des nombres de 40 bits, mais les instructions étaient codées sur 20 bits. La RAM avait la même taille, à savoir 32 nombres, leur taille était simplement augmentée. Par contre, la RAM était complémentée par l’ancêtre du disque dur magnétique, à savoir un tambour magnétique, l’ancêtre du disque dur magnétique. Il contenait 40 pages, chacune ayant la même taille que la RAM. Contrairement à la Manchester Baby, son processeur gérait l'addition et quelques opérations logiques (ET et OU), en plus de la soustraction et de la comparaison.

Par la suite, les ordinateurs commerciaux ont vu le jour. Les ordinateurs précédents provenaient de projets de recherches, souvent publics. Mais les entreprises privées se sont mises à fabriquer des ordinateurs elle-mêmes, pour les vendre à d'autres entreprises. On peut notamment citer les ordinateurs comme le UNIVAC I, le Bull Gamma 3 ou les premiers ordinateurs IBM. La performance de ces ordinateurs était nettement plus importante que leurs prédécesseurs, avec des fréquences de l'ordre de la centaine de kilo-hertz. Par exemple, le Bull Gamma 3 allait à 281 kHz, l'IBM 650 allait à 50 Khz.

===La seconde génération : le remplacement des tubes à vides par des transistors===

[[File:IBM 7070.jpg|vignette|Cartes imprimées de l'IBM 704, avec des transistors et résistances dessus.]]

La '''seconde génération''' est celle des ordinateurs fabriqués avec des '''transistors''' isolés, reliés entre avec des fils électriques. Les transistors en question possèdent trois broches, des pattes métalliques sur lesquelles on connecte des fils électriques. Le transistor s'utilise le plus souvent comme un interrupteur commandé par sa troisième broche. Le courant qui traverse les deux premières broches passe ou ne passe pas selon ce qu'on met sur la troisième.

[[File:Transistor basic flow.svg|centre|vignette|Un transistor est un morceau de conducteur, dont la conductivité est contrôlée par sa troisième broche/borne.]]

Les ordinateurs de seconde génération avaient entre 1000 et 500 000 transistors. Les capacités des ordinateurs étaient donc nettement supérieures à celles des ordinateurs de première génération. Une part non négligeable des ordinateurs de seconde génération supportait l'opération de multiplication, absente sur les ordinateurs de première génération. Néanmoins, cela variait beaucoup selon les ordinateurs.

Un exemple assez hors du commun est celui du premier modèle de l'IBM 1620. Le tout premier modèle n'avait aucun circuit de calcul, il n'était même pas capable de faire une addition ou une multiplication. A la place, il utilisait une table d'addition et une table de multiplication en mémoire RAM. Les deux tables devaient être initialisées par le logiciel lors du démarrage de la machine. La table d'addition faisait une centaine de chiffres, la table de multiplication faisait le double. Le processeur de l'ordinateur gérait des instructions pour faire des additions ou des multiplications, mais ces opérations lisaient le résultat dans la table d'addition. Les calculs étaient faits chiffre par chiffre, avec un encodage partiellement décimal, partiellement binaire (des chiffres décimaux étaient encodés en binaire, nous en reparlerons quand nous parlerons du BCD) !

[[File:KL CoreMemory.jpg|vignette|Mémoire à tore de ferrite.]]

Les transistors n'étaient utilisés que pour le processeur et les circuits annexes. La mémoire n'était pas faite en transistors, pas à cette époque. La mémoire était une mémoire aujourd'hui abandonnée, appelée une '''mémoire à tores de ferrite'''. Elle sera détaillée dans un chapitre ultérieur. Mais sachez pour le moment qu'il s'agit d'une mémoire au support magnétique, les données étant stockées sur un support magnétique.

Transistors comme tubes à vide prenaient beaucoup de place, ce qui fait que les ordinateurs étaient assez gros. Concrètement, ils prenaient une pièce de bâtiment entière dans le meilleur des cas. C'était l'époque des gros ''mainframes'', reliés à des terminaux, peu puissants comparé aux standards actuels. Seules les grandes entreprises et les grands instituts de recherche pouvaient se payer les services de ce genre d'ordinateurs. Seuls les professionnels avaient accès à ce genre d'équipement.

===La troisième génération : le circuit intégré===

[[File:D8259AC-2.jpg|vignette|Exemple de circuit intégré.]]

La troisième génération est toujours fabriquée avec des transistors, mais dont la taille a été réduite. Avec l'évolution de la technologie, les transistors ont diminué en taille, de plus en plus. Ils sont devenus tellement petits qu'ils ont fini par être regroupés dans des '''circuits intégrés''', des circuits regroupent plusieurs transistors sur la même puce de silicium. Les circuits intégrés se présentent le plus souvent sous la forme de boitiers rectangulaires, comme illustré ci-contre. D'autres ont des boitiers de forme carrées, comme ceux que l'on peut trouver sur les barrettes de mémoire RAM, ou à l'intérieur des clés USB/ disques SSD.

Lors de cette génération, les processeurs étaient fournis en pièces détachées qu'il fallait relier entre elles. Le processeur était composé de plusieurs circuits intégrés séparés, impossible de mettre un processeur dans un seul boitier. Un exemple de processeur conçu en kit est la série des Intel 3000. Elle regroupe plusieurs circuits séparés aux noms à coucher dehors, mais dont vous comprendrez ce qu'ils veulent dire dans les chapitres adéquats : l'Intel 3001 est un séquenceur, l'Intel 3002 regroupe unité de calcul et registres, le 3003 est un circuit d'anticipation de retenue complémentaire du 3002, le 3212 est une mémoire tampon, le 3214 est une unité de gestion des interruptions, les 3216/3226 sont des interfaces de bus mémoire. On pourrait aussi citer la famille de circuits intégrés AMD Am2900.

Même si le processeur était en pièces détachées, utiliser une dizaine de circuits intégrés était nettement mieux que d'utiliser plusieurs milliers de transistors individuels. En conséquence, les ordinateurs ont vu leur taille grandement réduite, passant de pièces entières à une simple armoire, voire à quelques cartes intégrées superposées. De plus, le prix des circuits intégré était abordable, du moins comparé aux ordinateurs d'avant. Le prix des ordinateurs a alors grandement décru, permettant à des entreprises et administrations de taille modeste de s'équiper d'ordinateurs.

===La quatrième génération : le microprocesseur===

[[File:MOS6502.svg|vignette|Microprocesseur, ici un processeur MOS6502, de la quatrième génération.]]

Lors de la troisième génération, les circuits intégrés regroupaient plusieurs dizaines ou centaines de transistors, mais sont rapidement montés en gamme. De centaines de transistors, ils sont passés au millier de transistors, puis au million et maintenant au-delà du milliard. Les transistors étaient devenus tellement petits, tellement miniaturisés, qu'il était devenu possible de mettre un processeur entier dans un circuit intégré. C'est ainsi qu'est né le microprocesseur, à savoir un processeur qui tient tout entier dans un seul circuit imprimé. La quatrième génération d’ordinateur est celle des ordinateurs basés autour d'un microprocesseur.

Les tout premiers microprocesseurs étaient des processeurs à application militaire, comme le processeur du F-14 CADC ou celui de l'Air data computer. Le tout premier microprocesseur commercialisé au grand public est le 4004 d'Intel, sorti en 1971. L'intel 4004 comprenait environ 2300 transistors, avait une fréquence de 740 MHz, pouvait faire 46 opérations différentes, et manipulait des entiers de 4 bits. Il était au départ un processeur de commande, prévu pour être intégré dans la calculatrice Busicom calculator 141-P, mais il fut utilisé pour d'autres applications quelque temps plus tard. Immédiatement après le 4004, les premiers microprocesseurs 8 bits furent commercialisés. Le 4004 fut suivi par le 8008 et quelques autres processeurs 8 bits extrêmement connus, comme le 8080 d'Intel, le 68000 de Motorola, le 6502 ou le Z80.

Les microprocesseurs permirent encore uen fois de réduire la taille des ordinateurs, qui pouvaient tenir dans un boitier de PC, ou un boitier de console de jeu. Le prix des ordinateurs a aussi chuté en même temps que les transistors étaient miniaturisés. C'est cette invention qui permis l'invention des consoles de jeux et des mini-ordinateurs, à savoir les ordinateurs personnels. Sans miniaturisation, on n'aurait pas d'ordinateur personnel, pas de PC fixe ou portable.

==L'organisation du cours : les différents niveaux d'explication==

Le fonctionnement d'un ordinateur est assez complexe à expliquer car les explications peuvent se faire sur plusieurs niveaux. Par plusieurs niveaux, on veut dire qu'un ordinateur est composé de composants très simples, qui sont assemblés pour donner des composants eux-même plus complexes, qui sont eux-même regrouper, etc. Étudier tout cela demande de voir plusieurs niveaux, allant de transistors très petits à des processeurs multicœurs. Les niveaux les plus bas sont de l'électronique pur et dure, alors que ceux plus haut sont à mi-chemin entre électronique et informatique.

===Les niveaux d'abstraction en architecture des ordinateurs===

Les trois premiers niveaux sont de l'électronique pur et dure. Ils correspondent aux premiers chapitres du cours, qui porteront sur les circuits électroniques en général.
* Le premier niveau est celui des '''transistors''', des circuits intégrés, des ''wafer'' et autres circuits de très petite taille.
* Le second niveau est celui des '''portes logiques''', des circuits très basiques, très simples, à la base de tous les autres.
* Le troisième niveau est celui dit de la '''''Register Transfer Level''''', où un circuit électronique est construit à partir de circuits basiques, dont des registres et autres circuits dits combinatoires.
Les deux niveaux suivants sont de l'informatique proprement dit. C'est dans ces deux niveaux qu'on étudie les ordinateurs proprement dit, les circuits qu'il y a dedans et non l'électronique en général.
* Le quatrième niveau est celui de la '''microarchitecture''', qui étudie ce qu'il y a à l'intérieur d'un processeur, d'une mémoire, des périphériques et autres.
* Le cinquième niveau est celui de l''''architecture externe''', qui décrit l'interface du processeur, de la mémoire, d'un périphérique ou autre. Par décrire l'interface, on veut dire : comment un programmeur voit le processeur et la mémoire, comment il peut les manipuler. Une architecture externe unique peut avoir plusieurs microarchitecture, ce qui fait qu'on sépare les deux. Tout cela sera plus clair quand on passera aux chapitres sur le processeur et les mémoires.

Nous n'allons pas voir les 5 niveaux dans l'ordre, des transistors vers l'architecture externe. En réalité, nous allons procéder autrement. La première partie du cours portera sur les trois premiers niveaux, le reste sur les deux autres. Les 5 niveaux seront vus dans des chapitres séparés, du moins le plus possible. Au niveau pédagogique, tout est plus simple si on scinde les 5 niveaux. Bien sûr, il y a quelques explications qui demandent de voir plusieurs niveaux à la fois. Par exemple, dans le chapitre sur les mémoires caches, nous auront des explications portant sur la RTL, la microarchitecture du cache et son architecture externe. Mais le gros du cours tentera de séparer le plus possible les 5 niveaux.

===Les trois parties principales du cours===

Nous allons commencer par parler du binaire, avant de voir les portes logiques. Avec ces portes logiques, nous allons voir comment fabriquer des circuits basiques qui reviendront très souvent dans la suite du cours. Nous verrons les registres, les décodeurs, les additionneurs et plein d'autres circuits. Puis, nous reviendrons au niveau des transistors pour finir la première partie. La raison est que c'est plus simple de faire comme cela. Tout ce qui a trait aux transistors sert à expliquer comment fabriquer des portes logiques, et il faut expliquer les portes logiques pour voir le niveau de la RTL.

Une fois la première partie finie, nous allons voir les différents composants d'un ordinateur. Une première partie expliquera ce qu'il y a dans un ordinateur, quels sont ses composants. Nous y parlerons de l'architecture de base, de la hiérarchie mémoire, des tendances technologiques, et d'autres généralités qui serviront de base pour la suite. Puis, nous verrons dans l'ordre les bus électroniques, les mémoires RAM/ROM, le processeur, les périphériques, les mémoires de stockage (SSD et disques durs) et les mémoires caches. Pour chaque composant, nous allons voir leur architecture externe, avant de voir leur microarchitecture. La raison est que la microarchitecture ne peut se comprendre que quand on sait quelle architecture externe elle implémente.

Enfin, dans une troisième partie, nous allons voir les optimisations majeures présentes dans tous les ordinateurs modernes, avec une partie sur le pipeline et le parallélisme d'instruction, et une autre sur les architectures parallèles. Pour finir, les annexes de fin parlerons de sujets un peu à part.

&lt;noinclude&gt;
{{NavChapitre | book=Fonctionnement d'un ordinateur
           | next=L'encodage des données
           | nextText=L'encodage des données
}}
&lt;/noinclude&gt;</text>
      <sha1>3u0r267jmf3ogp3q1jscn42c92m1udt</sha1>
    </revision>
    <revision>
      <id>744150</id>
      <parentid>744149</parentid>
      <timestamp>2025-06-05T11:57:47Z</timestamp>
      <contributor>
        <username>Mewtow</username>
        <id>31375</id>
      </contributor>
      <minor />
      <comment>/* Les ordinateurs à programme mémorisé ou programme externe */</comment>
      <origin>744150</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="46107" sha1="5pwnqmhwsgavm5eimca5toyjntvf5ru" xml:space="preserve">Pour commencer, nous allons voir qu'il existe de nombreux types d'ordinateurs. Le plus connu est certainement le PC, l'ordinateur personnel, que vous avez sans doute dans votre salon. Les ordinateurs portables sont un deuxième type d'ordinateur assez intuitif, que vous avez peut-être. Mais il y a aussi d'autres types d'ordinateurs auxquels vous n'avez jamais été confrontés.

==Les différents types d'ordinateurs==

Dans cette section, nous allons décrire rapidement les ordinateurs les plus courant, mais surtout voir ce qu'il y a à l'intérieur d'un ordinateur.

===L'ordinateur de type PC fixe===

De l'extérieur, l'ordinateur est composé d'une unité centrale sur laquelle on branche des périphériques.

[[File:Typical computer architecture systems.jpg|vignette|upright=1.5|Exemples de périphériques, connectés à une unité centrale (ici appelée à tort ''operating system'').]]

Les '''périphériques''' regroupent l'écran, la souris, le clavier, l'imprimante, et bien d'autres choses. Ils permettent à l'utilisateur d'interagir avec l'ordinateur : un clavier permet de saisir du texte sous dans un fichier, une souris enregistre des déplacements de la main en déplacement du curseur, un écran affiche des données d’images/vidéos, un haut-parleur émet du son, etc. Tout ce qui est branché sur un ordinateur est, formellement un périphérique.

L''''unité centrale''' est là où se trouvent tous les composants importants d'un ordinateur, ceux qui font des calculs, qui exécutent des logiciels, qui mémorisent vos données, etc. Voici ce à quoi ressemble l'intérieur de l'unité centrale. Trois sections sont visibles : l'alimentation électrique en haut à gauche, la carte mère en bas à gauche et en jaune/orange, les disques et lecteurs à droite des câbles. Et on voit aussi beaucoup de câbles.

[[File:Asus P5K-SEIntel E6320.jpg|centre|vignette|upright=2|Exemple d'unité centrale.]]

Tout en haut à gauche, se trouve l''''alimentation électrique''', qui convertit le courant de la prise électrique en un courant plus faible, utilisable par les autres composants. Elle émet de nombreux câbles assez gros, qui sont reliés au reste. Les PC actuels utilisent des alimentations électriques standardisées, qui fournissent trois tensions au reste de l'ordinateur : une tension de 12 Volts, une de 5 Volts, une de 3,3 Volts.

À droite, caché par la partie &quot;métallique&quot; du boitier, se trouvent les lecteurs de CD/DVD, et les disques durs. Les lecteurs CD-ROM ou DVD-ROM permettaient de lire des CD ou des DVD. Je parle au passé, car ils ont aujourd'hui disparu des ordinateurs modernes. Les '''disques durs''' sont des mémoires de stockage, qui mémorisent vos données de manière permanente. De nos jours, ils sont remplacés par des SSD, qui sont des disques durs électroniques, là où les disques durs proprement dit sont des mémoires magnétiques. Nous verrons la différence dans deux chapitres dédiés, un sur les disques durs, l'autre sur les SSD.

En bas à droite, se trouve la '''carte mère''' un support plat, en plastique ou en céramique, sur laquelle sont soudés/connectés les autres composants. Sur celle-ci, de nombreux composants sont soudés, d'autres sont branchés dessus avec des câbles, d'autres sont connectés dessus avec des connecteurs. Ils sont reliés entre eux par des fils conducteurs, le plus souvent du cuivre ou de l’aluminium, ce qui leur permet de s’échanger des données. Sur les cartes simples, ces fils sont intégrés dans la carte électronique, dans des creux du plastique. Ils portent le nom de pistes.

Avant, les disques durs, SSD et lecteurs de CD/DVD sont branchés dessus via des connecteurs dédiés, appelés des connecteurs S-ATA. De nos jours, ils sont branchés sur un autre connecteur, grâce à l'interface NVME. Toujours est-il qu'ils sont reliés à la carte mère par des câbles, ce qui montre que ce sont des sortes de périphériques interne. Ils sont placés dans le boitier, mais on aurait tout aussi bien pu les mettre à l'extérieur, vu qu'ils communiquent avec l'ordinateur par l'intermédiaire d'un câble ou d'un connecteur dédié.

Mais deux autres composants très importants sont eux placés sur la carte mère, directement. Ils ont chacun un connecteur dédié, sur lequel ils sont branchés directement, sans passer par l'intermédiaire d'un câble, mais sans être soudés non plus. Il s'agit du processeur et de la mémoire RAM, deux composants centraux des PC modernes.

[[File:Pentium III SL4CB.jpg|thumb|Processeur Pentium III.]]

Le '''processeur''' traite les données, les modifie, les manipule. Pour faire simple, il s’agit d’une grosse calculatrice hyper-puissante. Il comprend à la fois un circuit qui fait des calculs, et un circuit de contrôle qui s'occupe de séquencer les calculs dans l'ordre demandé. Il est souvent caché sous un radiateur, lui-même surmonté par un ventilateur. En effet, un processeur chauffe beaucoup, ce qui demande d'évacuer cette chaleur. Un chapitre entier expliquera pourquoi les processeurs chauffent, ainsi que les techniques utilisées pour limiter leur production de chaleur et leur consommation électrique.

La '''mémoire vive''' conserve des informations/données temporairement, tant que le processeur en a besoin. Elle prend la forme de barrettes de RAM, comme montré ci-dessous.

[[File:2 gb ddr2 667.jpg|centre|vignette|upright=2|Barrette de RAM.]]

Outre ces composants dits principaux, un ordinateur peut comprendre plusieurs composants moins importants, surtout présents sur les ordinateurs personnels. Ils sont techniquement facultatifs, mais sont très présents dans les ordinateurs personnels. Cependant, certains ordinateurs spécialisés s'en passent. Il s'agit des diverses '''cartes d'extension''' sont branchées sur la carte mère. Elles permettent d’accélérer certains calculs ou certaines applications, afin de décharger le processeur. Par exemple, la carte graphique s'occupe des calculs graphiques, qu'il s'agisse de graphismes 3D de jeux vidéos ou de l'affichage en 2D du bureau. Dans un autre registre, la carte son prend en charge le microphone et les haut-parleurs.

[[Fichier:Personal computer, exploded 4.svg|thumb|upright=1.0|Éclaté d'un ordinateur de type PC :&lt;br /&gt;
1 : Écran ;&lt;br /&gt;
2 : Carte mère ;&lt;br /&gt;
3 : Processeur ;&lt;br /&gt;
4 : Câble Parallel ATA ;&lt;br /&gt;
5 : Mémoire vive (RAM) ;&lt;br /&gt;
6 : Carte d'extension ;&lt;br /&gt;
7 : Alimentation électrique ;&lt;br /&gt;
8 : Lecteur de disque optique ;&lt;br /&gt;
9 : Disque dur ;&lt;br /&gt;
10 : Clavier ;&lt;br /&gt;
11 : Souris.]]

Si on regarde une carte mère de face, on voit un grand nombre de connecteurs, mais aussi des circuits électroniques soudés à la carte mère.

[[File:Architecture matérielle d'une carte mère.png|centre|vignette|upright=2.0|Architecture matérielle d'une carte mère]]

Les '''connecteurs''' sont là où on branche les périphériques, la carte graphique, le processeur, la mémoire, etc. Dans l'ensemble, toute carte mère contient les connecteurs suivants :
* Le processeur vient s’enchâsser dans la carte mère sur un connecteur particulier : le '''socket'''. Celui-ci varie suivant la carte mère et le processeur, ce qui est source d'incompatibilités.
* Les barrettes de mémoire RAM s’enchâssent dans un autre type de connecteurs: les '''slots mémoire'''.
* Les mémoires de masse disposent de leurs propres connecteurs : connecteurs P-ATA pour les anciens disques durs, et S-ATA pour les récents.
* Les périphériques (clavier, souris, USB, Firewire, ...) sont connectés sur un ensemble de connecteurs dédiés, localisés à l'arrière du boitier de l'unité centrale. 
* Les autres périphériques sont placés dans l'unité centrale et sont connectés via des connecteurs spécialisés. Ces périphériques sont des cartes imprimées, d'où leur nom de '''cartes filles'''. On peut notamment citer les cartes réseau, les cartes son, ou les cartes vidéo.

===Les ordinateurs portables===

[[File:Samsung QX-511 (2).JPG|vignette|Ordinateur portable Samsung QX-511 (2), pour illustration.]]

Un ordinateur portable est identique à un ordinateur de type PC. Si vous ouvrez votre ordinateur portable (attention à la garantie), vous retrouverez les mêmes composants qu'un PC à l'intérieur. Un point important est la présence d'une batterie à l'intérieur du PC portable, absente des PC fixes.

[[File:LG gram 14Z90Q mainboard with battery.jpg|centre|vignette|upright=2|LG gram 14Z90Q avec sa batterie.]]

Une fois la batterie et les circuits associés retiré, la seule différence notable est que tous les composants sont soudés sur la carte mère, au lieu d'être branchés sur des connecteurs, à part éventuellement la RAM et le disque dur.

[[File:LG gram 14Z90Q mainboard without battery.jpg|centre|vignette|upright=2|LG gram 14Z90Q sans sa batterie.]]

La RAM est parfois soudée sur la carte mère, d'autres fois sous la forme de barrettes de mémoire vive semblables à celles des PC. Dans le dernier cas, elle est connectée à des connecteurs spécifiques, ce qui permet de les changer/upgrader. Les PC portables sont parfois construits de manière à pouvoir changer la RAM facilement, en ouvrant un cache spécial, concu pour.

[[File:Lenovo G555 состав - Донор.JPG|centre|vignette|upright=2|Lenovo G555.]]

La conception d'un ordinateur portable est légèrement différente de celle d'un PC, pour des raisons thermiques. Un PC fixe a plus de place pour évacuer sa chaleur. Les ventilateurs peuvent plus facilement déplacer l'air dans le boitier, même si le flux d'air dans le boitier est éventuellement gêné par la carte graphique. Mais l'évacuation de la chaleur est assez efficace. Sur les PC portables, leur finesse fait que le trajet de l'air est beaucoup plus contraint. Évacuer la chaleur produite par l'ordinateur est plus complexe, ce qui demande d'utiliser des systèmes de refroidissement et de ventilation spécifiques.

Là où les PC fixes se débrouillent avec des radiateurs et des ventilateurs posés sur le processeur, les PC portables font autrement. Ils ne peuvent pas forcément mettre le ventilateur sur le processeur. A la place, ils mettent le ventilateur à côté, mais le processeur est surmonté par un mécanisme de transmission de la chaleur, qui transfère la chaleur du processeur vers le ventilateur.

[[File:Diagram - How a laptop cooling system works.png|centre|vignette|upright=2|Comment fonctionne le système de ventilation d'un ordinateur portable, en anglais.]]

Les difficultés pour dissiper la chaleur font que les ordinateurs portables utilisent souvent des composants peu performants, mais qui chauffent peu. En effet, nous verrons que plus un composant est puissant, plus il chauffe. La relation n'est pas parfaite, mais les processeurs haute performance chauffent plus que les modèles d'entrée ou milieu de gamme moins puissants. En conséquence, les PC portables sont souvent moins puissants que les PC fixes, même pour les modèles dit ''gaming''.

===Les serveurs et ''mainframes''===

Les grandes entreprises utilisent des ordinateurs de grande taille, très puissants, appelés des ''mainframes''. Ils sont souvent confondus avec les serveurs par le grand public, il y a une différence entre les deux. Un serveur est une fonction logicielle/réseau, pas un type d'ordinateur. Mais laissons cette différence de côté, ce qui est dit pour les ''mainframes'' sert pour les gros serveurs haute performance.

[[File:IBM Z15 mainframe.jpg|vignette|Exemple de ''mainframe''' de type IBM Z15.]]

Les anciens ''mainframes'' des années 50-80 avaient une taille pouvant être impressionnante, au point de prendre une pièce complète d'un bâtiment. Mais de nos jours, les ''mainframes'' tiennent dans une grosse armoire un peu haute. Les ''mainframes'' doivent rester allumé en permanence et ne doivent pas être éteint, sauf éventuellement quelques jours par an pour des opérations de maintenance. Ils utilisent pour cela des techniques spécifiques, avec beaucoup de redondance interne.

[[File:ACONIT hall grandes machines.jpg|centre|vignette|upright=2|''Mainframe'' ACONIT.]]

Les ''mainframes'' sont aussi conçus pour mutualiser au maximum leur utilisation, ils peuvent être utilisés par plusieurs utilisateurs à la suite, voire en même temps. Pour cela, les anciens ''mainframes'' étaient capables de faire tourner plusieurs applications distinctes l'une à la suite de l'autre, avec des commutations fréquentes entre logiciels. De nos jours, ils sont capables d'exécuter un grand nombre de tâches en même temps, grâce à la présence de plusieurs processeurs. Les ''mainframes'' modernes sont même capables de faire tourner plusieurs systèmes d'exploitation en même temps si besoin.

Les anciens ''mainframes'' étaient des ordinateurs assez simples, avec un processeur, de la mémoire RAM, un ou plusieurs disques durs, pas plus. Le ''mainframe'' était tellement énorme et cher que les entreprises n'en avaient qu'un seul pour toute l'entreprise. Les employés avaient sur leur bureau des terminaux, qui permettaient d'accéder à l'ordinateur central, mais n'étaient pas des ordinateurs. Les terminaux étaient des composants électroniques simples, avec un écran, un clavier et une souris, mais sans processeur. Ils envoyaient des données au ''mainframe'', ils en recevaient de sa part, mais tout traitement était réalisé sur le ''mainframe''. L'arrivée sur le marché des ordinateurs personnels, de type PC fixe/portable, a entrainé l'abandon de ce genre de pratique, tous les employés ont maintenant un ordinateur rien que pour eux.

{|
|-
! colspan=&quot;2&quot; | Exemples de terminaux
|-
|[[File:Terminal-in2-sm9400.jpg|centre|vignette|upright=1.5|Exemple de terminal. Notez la présence d'un écran et d'un clavier, mais l'asbence d'une unité centrale.]]
|[[File:Chromatics CT4100.jpg|vignette|upright=1.5|Autre exemple de terminal. Le clavier est couplé à un stylo CRT, qui remplacait la souris et agissait sur l'écran comme s'il était tactile.]]
|-
! colspan=&quot;2&quot; | Intérieur d'un terminal
|-
|[[File:CT1024 Monitor.jpg|vignette|upright=1.5|Terminal CT1024, sans le boitier extérieur.]]
|[[File:CT1024 Terminal System.jpg|vignette|upright=1.5|Terminal CT1024, description des composants interne.]]
|}

De nos jours, les ''mainframes'' contiennent en réalité plusieurs ordinateurs simples interconnectés via un réseau local. Un ''mainframe'' qui tient dans une armoire contient facilement une dizaine ou centaine de processeurs, plein de RAM, des disques durs séparés dans une armoire distincte, etc. Vu qu'ils communiquent uniquement via le réseau, ils n'ont pas d'interface, pas d'écran, 'entrée via clavier/souris. Le tout est commandé avec une console de commande, typiquement un ordinateur portable ou un terminal assez simple séparé de l'armoire, qui permet à un administrateur de faire des opérations de surveillance, configuration et maintenance. Il peut y avoir une console de commande pour plusieurs armoires séparées, la console peut même être dans un autre bâtiment et accéder au ''mainframe'' par le réseau.

[[File:IBM System Z9 (type 2094 inside).jpg|centre|vignette|upright=2|''Mainframe'' de type IBM System Z9. L'ordinateur portable sert de console pour qu'un administrateur fasse des opérations de surveillance, configuration et maintenance.]]

Les processeurs et la RAM sont typiquement installés sur des cartes amovibles, qui sont connectées au fond de l'armoire lors de l'installation. Il est même possible de retirer ou d'ajouter des cartes en fonctionnement, afin d'ajouter/retirer des processeurs, des disques durs, etc. Ce qui est très utile si un composant est en panne et qu'il faut le remplacer. 

[[File:IBM TotalStorage Exp400.jpg|centre|vignette|upright=2|IBM TotalStorage Exp400]]

==Un peu d'abstraction : qu'est-ce qu'un ordinateur ?==

Un ordinateur comprend donc un processeur, plusieurs mémoires, des cartes d'extension et une carte mère pour connecter le tout. Mais il s'agit là d'une description assez terre-à-terre de ce qu'est un ordinateur. Une autre description, plus abstraite, se base sur le fait qu'un ordinateur est une énorme calculatrice programmable. Elle permet d'expliquer pourquoi il y a une distinction entre processeur et mémoire, entre unité centrale et périphériques. Tout ce qui va suivre pourra vous paraitre assez abstrait, mais rassurez-vous : les prochains chapitres rendront tout cela plus concrets.

===La séparation entre entrées-sorties et traitement===

L'unité centrale peut être vue comme une énorme calculatrice ultra-puissante, qui exécute des commandes/opérations. Mais à elle seule, elle ne servirait à rien, il faut interagir avec par l'intermédiaire de plusieurs périphériques. Il existe deux types de périphériques, qui sont conceptuellement différents. Les périphériques comme le clavier ou la souris permettent d'envoyer des informations à l'ordinateur, d'agir sur celui-ci. A l'inverse, les écrans transmettent des informations dans le sens inverse : de l'ordinateur vers l'utilisateur. Les premiers sont appelés des '''entrées''', les seconds des '''sorties'''.

Dans un ordinateur, les informations sont représentées sous la forme de nombres. Toute donnée dans un ordinateur est codée avec un ou plusieurs nombres regroupés dans une donnée, un fichier, ou autre. Et la transmissions avec les entrées et sorties se fait là-encore avec des nombres. Par exemple, quand vous appuyez sur votre clavier, le clavier envoie un numéro de touche à l'unité centrale, qui indique quelle touche a été appuyée. L'image à afficher à l'écran est codée sous la forme d'une suite de nombres (un par pixel). L'image est envoyée à l'écran, qui traduit la suite de nombre en image à afficher. Les entrées traduisent des actions utilisateurs en nombres, on dit que les entrées encodent les actions utilisateur. Les sorties font la traduction inverse, elles transforment des suites de nombres en une action physique. On dit qu'elles décodent des informations.

Pour résumer, toute appareil électronique est composé par :
* Des '''entrées''' sur lesquelles l'utilisateur agit sur l'ordinateur. Les entrées transforment les actions de l'utilisateur en nombres, qui sont interprétés par l'ordinateur.
* Une '''unité de traitement''', qui manipule des nombres et fait des calculs/opérations dessus. Les nombres proviennent des entrées, du disque dur, ou d'autres sources, peu importe.
* Des '''sorties''', qui va récupèrent le résultat calculé par l'unité de traitement pour en faire quelque chose : écrire sur une imprimante ou sur un moniteur, émettre du son,...

[[File:Ordinateur théorique Simple 1.png|centre|vignette|upright=2|Ordinateur théorique Simple 1]]

L'unité de traitement proprement dite, celle qui fait les calculs, est couplée à une mémoire qui mémorise les opérandes et résultats des calculs. La séparation entre processeur et mémoire est nécessaire pour qu'un appareil électronique soit qualifié d'ordinateur. De nombreux appareils n'ont pas de séparation entre unité de traitement et mémoire, comme certaines vielles radios AM/FM.

[[File:Schéma de principe d'un ordinateur.png|centre|vignette|upright=2|Schéma de principe d'un ordinateur]]

===Un ordinateur est un appareil programmable===

Les appareils simples sont non-programmables, ce qui veut dire qu’ils sont conçus pour une utilisation particulière et qu’ils ne peuvent pas faire autre chose. Par exemple, les circuits électroniques d’un lecteur de DVD ne peuvent pas être transformé en lecteur audio ou en console de jeux... Les circuits non-programmables sont câblés une bonne fois pour toute, et on ne peut pas les modifier. On peut parfois reconfigurer le circuit, pour faire varier certains paramètres, via des interrupteurs ou des boutons, mais cela s’arrête là. Et cela pose un problème : à chaque problème qu'on veut résoudre en utilisant un automate, on doit recréer un nouveau circuit.

À l'inverse, un ordinateur n’est pas conçu pour une utilisation particulière, contrairement aux autres objets techniques. Il est possible de modifier leur fonction du jour au lendemain, on peut lui faire faire ce qu’on veut. On dit qu'ils sont '''programmables'''. Pour cela, il suffit d’utiliser un logiciel, une application, un programme (ces termes sont synonymes), qui fait ce que l'on souhaite. La totalité des logiciels présents sur un ordinateur sont des programmes comme les autres, même le système d'exploitation (Windows, Linux, ...) ne fait pas exception.

Un programme est une suite de d''''instructions machines''', chaque instruction effectuant une action dans l'ordinateur. Sur les ordinateurs modernes, les instructions les plus communes effectuent une opération arithmétique : une addition, une multiplication, une soustraction, etc. Les ordinateurs modernes sont donc de grosses calculettes très puissantes, capables d'effectuer des millions d'opérations par secondes.

Et qui dit opération dit nombres : un ordinateur gère nativement des nombres, qui sont codés en binaire sur la quasi-totalité des ordinateurs modernes. Les ordinateurs modernes sont capables de faire des calculs sur des nombres entiers, mais aussi des nombres à virgule. Il existe plusieurs manières de représenter des nombres en binaire, certaines représentant des nombres entiers dits naturels (0 et plus), d'autres des nombres signés (positifs ou négatifs), d'autres des nombres à virgule. Un chapitre entier détaillera comment sont encodés ces nombres.

Une instruction est représentée dans un ordinateur par une série de nombres entiers : un nombre qui indique quelle opération/commande effectuer et des autres nombres pour coder les données (ou de quoi les retrouver dans l'ordinateur). L'ordinateur récupére les commandes une par une, les traduit en opération à effectuer, exécuter l'opération, et enregistre le résultat. Puis il recommence avec la commande suivante.

[[File:Ordinateur Théorique Complexe 1.png|centre|vignette|upright=3|Ordinateur Théorique Complexe. En jaune, le programme informatique, la liste de commande. Le rectangle gris est l'ordinateur proprement dit.]]

De nombreux appareils sont programmables, mais tous ne sont pas des ordinateurs. Par exemple, certains circuits programmables nommés FPGA n'en sont pas. Pour être qualifié d'ordinateur, un appareil programmable doit avoir un processeur séparé de la mémoire. De plus, il doit utiliser un '''codage numérique''', chose que nous allons aborder dans le chapitre suivant.

===Les ordinateurs à programme mémorisé ou programme externe===

[[File:Blue-punch-card-front.png|vignette|upright=0.5|Carte Perforée.]]

Au tout début de l'informatique, les programmes étaient enregistrés sur des cartes perforées, à savoir des cartes en papier/plastique percées par endroits. Un 1 est codé par un trou dans le papier et un 0 par une absence de trou. Les programmes étaient exécutés par l'ordinateur quand on insérait la carte perforée dans le lecteur et qu'on appuyait sur un bouton.

Par la suite, les premiers ordinateurs grand public, comme les Amstrad ou les Commodore, utilisaient des cassettes audio magnétiques pour stocker les programmes. Dans le même style, les consoles de jeu utilisaient autrefois des cartouches de jeu, qui contenaient le programme du jeu à exécuter. Pour résumer, les anciens ordinateurs mémorisaient les programmes sur un support externe, lu par un périphérique. De tels ordinateurs sont dits à '''programme externe'''.

: D’anciens ordinateurs personnels, comme l’Amstrad ou le Commodore, permettaient de taper les programmes à exécuter à la main, au clavier, avant d’appuyer une touche pour les exécuter. Nul besoin de vous dire que les cassettes audio étaient plus pratiques.

Mais de nos jours, les programmes sont enregistrés sur le disque dur de l'ordinateur ou dans une mémoire intégrée à l'ordinateur. On dit qu'ils sont installés, ce qui est un mot bien compliqué pour dire que le programme est enregistré sur le disque dur de l’ordinateur. A défaut de disque dur, le programme/logiciel est enregistré dans une mémoire spécialisée pour le stockage. Par exemple, sur les cartes électroniques grand public de marque Arduino, les programmes sont envoyés à la carte via le port USB, mais les programmes sont enregistrés dans la carte Arduino, dans une mémoire FLASH dédiée. Disque dur ou non, le programme est mémorisé dans la mémoire de l'ordinateur. Il est possible d'installer ou de désinstaller les programmes en modifiant le contenu de la mémoire. Le terme utilisé est alors celui de '''programme stocké en mémoire'''.

Les programmes à installer sont disponibles soit sur un périphérique, comme un DVD ou une clé USB, soit sont téléchargés depuis internet. Les premiers PC fournissaient les logiciels sur des disquettes, qui contenaient un programme d'installation pour enregistrer le programme sur le disque dur de l'ordinateur. Par la suite, le support des logiciels a migré vers les CD et DVD, les logiciels devenant de plus en plus gros. De nos jours, la majorité des applications sont téléchargées depuis le net, l'usage de périphériques est devenu obsolète, même les consoles de jeu abandonnent cette méthode de distribution.

==Les générations d'ordinateurs : un historique rapide==

L'informatique a beaucoup évolué dans le temps. Et une bonne partie de cette évolution tient à l'évolution de l’électronique sous-jacente. Les ordinateurs actuels sont fabriqués avec des transistors, des petits composants électroniques qui servent d'interrupteurs programmables, qu'on détaillera dans ce qui suit. Mais ça n'a pas toujours été le cas. Et cela permet de distinguer plusieurs '''générations d'ordinateurs'''.

===Les ordinateurs électro-mécaniques : les premiers ordinateurs===

Le tout premier ordinateur est le '''Z1''', un modèle unique inventé par Konrad Suze entre 1936 et 1938. Son processeur gérait non pas des nombres entiers, mais des nombres à virgule (des nombres dits flottants, pour être précis), encodés sur 22 bits. Le processeur du Z1 était capable de faire des additions et des soustractions, car il intégrait un circuit additionneur-soustracteur basique. Des circuits annexes permettaient de faire des multiplications et des divisions en enchainant des additions/soustractions successives. Il fonctionnait à une fréquence de 1 Hz, ce qui fait qu'il pouvait faire une addition/soustraction par seconde maximum.

Niveau mémoire, la RAM de l'ordinateur était très limitée : seulement 16 nombres de 22 bits chacun. S'il s'agissait d'une mémoire électronique, les programmes étaient mémorisés sur une mémoire mécanique et précisémment sur des cartes perforées, à savoir des cartes en papier/plastique dans lesquelles un 1 est codé par un trou dans le papier et un 0 par une absence de trou. Les programmes étaient exécutés par l'ordinateur quand on insérait la carte perforée dans le lecteur et qu'on appuyait sur un bouton.

[[File:German Museum of Technology, Berlin 2017 024.jpg|centre|vignette|upright=2|Réplique du Z1 au ''German Museum of Technology'' de Berlin, 2017.]]

Après sa destruction dans un bombardement, le Z1 a été reconstruit et amélioré, ce qui donné les deux ordinateurs Z2 et Z3. Quelques années plus tard, de nombreux ordinateurs ont été construits dans des laboratoires de recherche. Des grands noms de l'histoire de l'informatique datent de cette époque : le Harvard Mark I et le Colossus Mark 1 (UK) ont tous deux été mis en service en 1944, par exemple. Ils ont servi pour les cryptanalystes pour casser les codes utilisés par les Allemands pour leurs transmissions, pendant la seconde guerre mondiale.

Les ordinateurs cités dans le précédent paragraphe étaient tous des ordinateurs dit '''électro-mécaniques''', car ils mélangeaient des composants électroniques et des composants mécaniques (tout ce qui a trait aux cartes perforées, notamment). Les composants électroniques étaient soit des relais, soit des tubes à vides, les deux étant des interrupteurs commandables électriquement plus ou moins équivalents aux transistors. Les ordinateurs d'avant l'année 1944, étaient tous de ce type. Quelques ordinateurs des années 50 étaient de ce type, mais leur nombre n'a pas dépassé 30. Il faut dire qu'ils ont rapidement laissé la place à des ordinateurs purement électroniques, que nous allons voir dans ce qui suit.

===La première génération : les tubes à vide===

Les ordinateurs qui ont suivi les ordinateurs électromécaniques sont regroupés dans la '''première génération d'ordinateur'''. Ils étaient conçus avec des tubes à vide, ce qui les place entre les premiers ordinateurs électro-mécaniques et les ordinateurs utilisant des transistors. Les tubes à vide étaient assez encombrants, ils consommaient beaucoup de courant, ils chauffaient et étaient assez peu fiables. Ils tombaient en panne assez souvent. Et ils étaient assez simples à fabriquer, mais restaient malgré tout chers.

[[File:Elektronenroehren-auswahl.jpg|centre|vignette|upright=2|Tubes à vides.]]

Au vu de la taille des tubes à vide, les ordinateurs de l'époque étaient composés de plusieurs milliers de ces tubes, guère plus. Et malgré cela, un ordinateur prenait facilement un étage de bâtiment entier, ou au moins plusieurs pièces. La conséquence est que les ordinateurs de première génération étaient très simples, rudimentaires quand on les compare aux ordinateurs modernes. Ils ne géraient que quelques opérations simples : l'addition, la soustraction, pas grand-chose de plus. À quelques exceptions près, ils ne géraient pas la multiplication et encore moins la division, cela aurait demandé trop de tubes à vides.

Une des toutes premières machines construite avec des tubes à vide était l'Atanasoff–Berry. Ce n'était pas un ordinateur, car elle ne pouvait pas exécuter de programme sans intervention humaine pour séquencer des opérations, mais c'était la première machine de calcul purement électronique, sans aucune pièce mécanique. Elle utilisait une mémoire RAM construite avec des condensateurs, ceux-ci étant placés sur des cylindres tournants. Les circuits de calcul étaient construits avec des tubes à vide et faisaient leur travail un bit à la fois. Elle fonctionnait à une fréquence de 60 Hz et pouvait faire 30 additions/soustractions par seconde. Les nombres étaient encodés sur 50 bits. 

[[File:Atanasoff Berry Computer.gif|centre|vignette|upright=2.5|Atanasoff–Berry.]]

L'arrivée de l'ENIAC en 1945 a changé la donne. Cet ordinateur a introduit plusieurs innovations majeures. La première est assez technique, il s'agit de la turing-complétude, elle a trait aux programmes qui peuvent être écrit pour un ordinateur, nous ne la détaillerons pas ici.

[[File:BabyArchitecture.png|vignette|Architecture de la Manchester Baby.]]

En 1948, le ''Manchester Baby'' a introduit une innovation extrêmement importante : le programme n'était plus mémorisé sur des cartes perforées, mais dans une mémoire électronique à l’intérieur de l'ordinateur lui-même. En clair, le ''Manchester Baby'' était le premier '''ordinateur à programme stocké en mémoire''' en français. Au-delà de ça, le Manchester Baby restait quand même très simple, c'était limite un prototype.

Niveau interface, l'ordinateur avait une console avec 32 boutons, des interrupteurs et un écran de sortie sur lequel afficher les résultats. A l'intérieur, il y avait un processeur et une RAM de 32 nombres de 32 bits, fabriquées avec des tubes Williams (abordés dans une annexe à la fin du cours). Une instruction prenant autant de place qu'un nombre en RAM, ce qui limitait les programmes à 32 instructions maximum. Le processeur gérait 8 instructions en tout, mais la seule instruction de calcul qu'il gérait était la soustraction. L'addition n'était pas supportée. Il pouvait cependant émuler l'addition à partir d'une soustraction et inversant l'opérande soustrait.

Le Manchester Mark 1 était une amélioration du Manchester Baby. Il utilisait 4500 tubes à vide. L'ordinateur gérait des nombres de 40 bits, mais les instructions étaient codées sur 20 bits. La RAM avait la même taille, à savoir 32 nombres, leur taille était simplement augmentée. Par contre, la RAM était complémentée par l’ancêtre du disque dur magnétique, à savoir un tambour magnétique, l’ancêtre du disque dur magnétique. Il contenait 40 pages, chacune ayant la même taille que la RAM. Contrairement à la Manchester Baby, son processeur gérait l'addition et quelques opérations logiques (ET et OU), en plus de la soustraction et de la comparaison.

Par la suite, les ordinateurs commerciaux ont vu le jour. Les ordinateurs précédents provenaient de projets de recherches, souvent publics. Mais les entreprises privées se sont mises à fabriquer des ordinateurs elle-mêmes, pour les vendre à d'autres entreprises. On peut notamment citer les ordinateurs comme le UNIVAC I, le Bull Gamma 3 ou les premiers ordinateurs IBM. La performance de ces ordinateurs était nettement plus importante que leurs prédécesseurs, avec des fréquences de l'ordre de la centaine de kilo-hertz. Par exemple, le Bull Gamma 3 allait à 281 kHz, l'IBM 650 allait à 50 Khz.

===La seconde génération : le remplacement des tubes à vides par des transistors===

[[File:IBM 7070.jpg|vignette|Cartes imprimées de l'IBM 704, avec des transistors et résistances dessus.]]

La '''seconde génération''' est celle des ordinateurs fabriqués avec des '''transistors''' isolés, reliés entre avec des fils électriques. Les transistors en question possèdent trois broches, des pattes métalliques sur lesquelles on connecte des fils électriques. Le transistor s'utilise le plus souvent comme un interrupteur commandé par sa troisième broche. Le courant qui traverse les deux premières broches passe ou ne passe pas selon ce qu'on met sur la troisième.

[[File:Transistor basic flow.svg|centre|vignette|Un transistor est un morceau de conducteur, dont la conductivité est contrôlée par sa troisième broche/borne.]]

Les ordinateurs de seconde génération avaient entre 1000 et 500 000 transistors. Les capacités des ordinateurs étaient donc nettement supérieures à celles des ordinateurs de première génération. Une part non négligeable des ordinateurs de seconde génération supportait l'opération de multiplication, absente sur les ordinateurs de première génération. Néanmoins, cela variait beaucoup selon les ordinateurs.

Un exemple assez hors du commun est celui du premier modèle de l'IBM 1620. Le tout premier modèle n'avait aucun circuit de calcul, il n'était même pas capable de faire une addition ou une multiplication. A la place, il utilisait une table d'addition et une table de multiplication en mémoire RAM. Les deux tables devaient être initialisées par le logiciel lors du démarrage de la machine. La table d'addition faisait une centaine de chiffres, la table de multiplication faisait le double. Le processeur de l'ordinateur gérait des instructions pour faire des additions ou des multiplications, mais ces opérations lisaient le résultat dans la table d'addition. Les calculs étaient faits chiffre par chiffre, avec un encodage partiellement décimal, partiellement binaire (des chiffres décimaux étaient encodés en binaire, nous en reparlerons quand nous parlerons du BCD) !

[[File:KL CoreMemory.jpg|vignette|Mémoire à tore de ferrite.]]

Les transistors n'étaient utilisés que pour le processeur et les circuits annexes. La mémoire n'était pas faite en transistors, pas à cette époque. La mémoire était une mémoire aujourd'hui abandonnée, appelée une '''mémoire à tores de ferrite'''. Elle sera détaillée dans un chapitre ultérieur. Mais sachez pour le moment qu'il s'agit d'une mémoire au support magnétique, les données étant stockées sur un support magnétique.

Transistors comme tubes à vide prenaient beaucoup de place, ce qui fait que les ordinateurs étaient assez gros. Concrètement, ils prenaient une pièce de bâtiment entière dans le meilleur des cas. C'était l'époque des gros ''mainframes'', reliés à des terminaux, peu puissants comparé aux standards actuels. Seules les grandes entreprises et les grands instituts de recherche pouvaient se payer les services de ce genre d'ordinateurs. Seuls les professionnels avaient accès à ce genre d'équipement.

===La troisième génération : le circuit intégré===

[[File:D8259AC-2.jpg|vignette|Exemple de circuit intégré.]]

La troisième génération est toujours fabriquée avec des transistors, mais dont la taille a été réduite. Avec l'évolution de la technologie, les transistors ont diminué en taille, de plus en plus. Ils sont devenus tellement petits qu'ils ont fini par être regroupés dans des '''circuits intégrés''', des circuits regroupent plusieurs transistors sur la même puce de silicium. Les circuits intégrés se présentent le plus souvent sous la forme de boitiers rectangulaires, comme illustré ci-contre. D'autres ont des boitiers de forme carrées, comme ceux que l'on peut trouver sur les barrettes de mémoire RAM, ou à l'intérieur des clés USB/ disques SSD.

Lors de cette génération, les processeurs étaient fournis en pièces détachées qu'il fallait relier entre elles. Le processeur était composé de plusieurs circuits intégrés séparés, impossible de mettre un processeur dans un seul boitier. Un exemple de processeur conçu en kit est la série des Intel 3000. Elle regroupe plusieurs circuits séparés aux noms à coucher dehors, mais dont vous comprendrez ce qu'ils veulent dire dans les chapitres adéquats : l'Intel 3001 est un séquenceur, l'Intel 3002 regroupe unité de calcul et registres, le 3003 est un circuit d'anticipation de retenue complémentaire du 3002, le 3212 est une mémoire tampon, le 3214 est une unité de gestion des interruptions, les 3216/3226 sont des interfaces de bus mémoire. On pourrait aussi citer la famille de circuits intégrés AMD Am2900.

Même si le processeur était en pièces détachées, utiliser une dizaine de circuits intégrés était nettement mieux que d'utiliser plusieurs milliers de transistors individuels. En conséquence, les ordinateurs ont vu leur taille grandement réduite, passant de pièces entières à une simple armoire, voire à quelques cartes intégrées superposées. De plus, le prix des circuits intégré était abordable, du moins comparé aux ordinateurs d'avant. Le prix des ordinateurs a alors grandement décru, permettant à des entreprises et administrations de taille modeste de s'équiper d'ordinateurs.

===La quatrième génération : le microprocesseur===

[[File:MOS6502.svg|vignette|Microprocesseur, ici un processeur MOS6502, de la quatrième génération.]]

Lors de la troisième génération, les circuits intégrés regroupaient plusieurs dizaines ou centaines de transistors, mais sont rapidement montés en gamme. De centaines de transistors, ils sont passés au millier de transistors, puis au million et maintenant au-delà du milliard. Les transistors étaient devenus tellement petits, tellement miniaturisés, qu'il était devenu possible de mettre un processeur entier dans un circuit intégré. C'est ainsi qu'est né le microprocesseur, à savoir un processeur qui tient tout entier dans un seul circuit imprimé. La quatrième génération d’ordinateur est celle des ordinateurs basés autour d'un microprocesseur.

Les tout premiers microprocesseurs étaient des processeurs à application militaire, comme le processeur du F-14 CADC ou celui de l'Air data computer. Le tout premier microprocesseur commercialisé au grand public est le 4004 d'Intel, sorti en 1971. L'intel 4004 comprenait environ 2300 transistors, avait une fréquence de 740 MHz, pouvait faire 46 opérations différentes, et manipulait des entiers de 4 bits. Il était au départ un processeur de commande, prévu pour être intégré dans la calculatrice Busicom calculator 141-P, mais il fut utilisé pour d'autres applications quelque temps plus tard. Immédiatement après le 4004, les premiers microprocesseurs 8 bits furent commercialisés. Le 4004 fut suivi par le 8008 et quelques autres processeurs 8 bits extrêmement connus, comme le 8080 d'Intel, le 68000 de Motorola, le 6502 ou le Z80.

Les microprocesseurs permirent encore uen fois de réduire la taille des ordinateurs, qui pouvaient tenir dans un boitier de PC, ou un boitier de console de jeu. Le prix des ordinateurs a aussi chuté en même temps que les transistors étaient miniaturisés. C'est cette invention qui permis l'invention des consoles de jeux et des mini-ordinateurs, à savoir les ordinateurs personnels. Sans miniaturisation, on n'aurait pas d'ordinateur personnel, pas de PC fixe ou portable.

==L'organisation du cours : les différents niveaux d'explication==

Le fonctionnement d'un ordinateur est assez complexe à expliquer car les explications peuvent se faire sur plusieurs niveaux. Par plusieurs niveaux, on veut dire qu'un ordinateur est composé de composants très simples, qui sont assemblés pour donner des composants eux-même plus complexes, qui sont eux-même regrouper, etc. Étudier tout cela demande de voir plusieurs niveaux, allant de transistors très petits à des processeurs multicœurs. Les niveaux les plus bas sont de l'électronique pur et dure, alors que ceux plus haut sont à mi-chemin entre électronique et informatique.

===Les niveaux d'abstraction en architecture des ordinateurs===

Les trois premiers niveaux sont de l'électronique pur et dure. Ils correspondent aux premiers chapitres du cours, qui porteront sur les circuits électroniques en général.
* Le premier niveau est celui des '''transistors''', des circuits intégrés, des ''wafer'' et autres circuits de très petite taille.
* Le second niveau est celui des '''portes logiques''', des circuits très basiques, très simples, à la base de tous les autres.
* Le troisième niveau est celui dit de la '''''Register Transfer Level''''', où un circuit électronique est construit à partir de circuits basiques, dont des registres et autres circuits dits combinatoires.
Les deux niveaux suivants sont de l'informatique proprement dit. C'est dans ces deux niveaux qu'on étudie les ordinateurs proprement dit, les circuits qu'il y a dedans et non l'électronique en général.
* Le quatrième niveau est celui de la '''microarchitecture''', qui étudie ce qu'il y a à l'intérieur d'un processeur, d'une mémoire, des périphériques et autres.
* Le cinquième niveau est celui de l''''architecture externe''', qui décrit l'interface du processeur, de la mémoire, d'un périphérique ou autre. Par décrire l'interface, on veut dire : comment un programmeur voit le processeur et la mémoire, comment il peut les manipuler. Une architecture externe unique peut avoir plusieurs microarchitecture, ce qui fait qu'on sépare les deux. Tout cela sera plus clair quand on passera aux chapitres sur le processeur et les mémoires.

Nous n'allons pas voir les 5 niveaux dans l'ordre, des transistors vers l'architecture externe. En réalité, nous allons procéder autrement. La première partie du cours portera sur les trois premiers niveaux, le reste sur les deux autres. Les 5 niveaux seront vus dans des chapitres séparés, du moins le plus possible. Au niveau pédagogique, tout est plus simple si on scinde les 5 niveaux. Bien sûr, il y a quelques explications qui demandent de voir plusieurs niveaux à la fois. Par exemple, dans le chapitre sur les mémoires caches, nous auront des explications portant sur la RTL, la microarchitecture du cache et son architecture externe. Mais le gros du cours tentera de séparer le plus possible les 5 niveaux.

===Les trois parties principales du cours===

Nous allons commencer par parler du binaire, avant de voir les portes logiques. Avec ces portes logiques, nous allons voir comment fabriquer des circuits basiques qui reviendront très souvent dans la suite du cours. Nous verrons les registres, les décodeurs, les additionneurs et plein d'autres circuits. Puis, nous reviendrons au niveau des transistors pour finir la première partie. La raison est que c'est plus simple de faire comme cela. Tout ce qui a trait aux transistors sert à expliquer comment fabriquer des portes logiques, et il faut expliquer les portes logiques pour voir le niveau de la RTL.

Une fois la première partie finie, nous allons voir les différents composants d'un ordinateur. Une première partie expliquera ce qu'il y a dans un ordinateur, quels sont ses composants. Nous y parlerons de l'architecture de base, de la hiérarchie mémoire, des tendances technologiques, et d'autres généralités qui serviront de base pour la suite. Puis, nous verrons dans l'ordre les bus électroniques, les mémoires RAM/ROM, le processeur, les périphériques, les mémoires de stockage (SSD et disques durs) et les mémoires caches. Pour chaque composant, nous allons voir leur architecture externe, avant de voir leur microarchitecture. La raison est que la microarchitecture ne peut se comprendre que quand on sait quelle architecture externe elle implémente.

Enfin, dans une troisième partie, nous allons voir les optimisations majeures présentes dans tous les ordinateurs modernes, avec une partie sur le pipeline et le parallélisme d'instruction, et une autre sur les architectures parallèles. Pour finir, les annexes de fin parlerons de sujets un peu à part.

&lt;noinclude&gt;
{{NavChapitre | book=Fonctionnement d'un ordinateur
           | next=L'encodage des données
           | nextText=L'encodage des données
}}
&lt;/noinclude&gt;</text>
      <sha1>5pwnqmhwsgavm5eimca5toyjntvf5ru</sha1>
    </revision>
    <revision>
      <id>744151</id>
      <parentid>744150</parentid>
      <timestamp>2025-06-05T12:05:33Z</timestamp>
      <contributor>
        <username>Mewtow</username>
        <id>31375</id>
      </contributor>
      <minor />
      <comment>/* Les ordinateurs électro-mécaniques : les premiers ordinateurs */</comment>
      <origin>744151</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="46021" sha1="fi2ktmq7j3xs7pe97gc8upaiql9od3w" xml:space="preserve">Pour commencer, nous allons voir qu'il existe de nombreux types d'ordinateurs. Le plus connu est certainement le PC, l'ordinateur personnel, que vous avez sans doute dans votre salon. Les ordinateurs portables sont un deuxième type d'ordinateur assez intuitif, que vous avez peut-être. Mais il y a aussi d'autres types d'ordinateurs auxquels vous n'avez jamais été confrontés.

==Les différents types d'ordinateurs==

Dans cette section, nous allons décrire rapidement les ordinateurs les plus courant, mais surtout voir ce qu'il y a à l'intérieur d'un ordinateur.

===L'ordinateur de type PC fixe===

De l'extérieur, l'ordinateur est composé d'une unité centrale sur laquelle on branche des périphériques.

[[File:Typical computer architecture systems.jpg|vignette|upright=1.5|Exemples de périphériques, connectés à une unité centrale (ici appelée à tort ''operating system'').]]

Les '''périphériques''' regroupent l'écran, la souris, le clavier, l'imprimante, et bien d'autres choses. Ils permettent à l'utilisateur d'interagir avec l'ordinateur : un clavier permet de saisir du texte sous dans un fichier, une souris enregistre des déplacements de la main en déplacement du curseur, un écran affiche des données d’images/vidéos, un haut-parleur émet du son, etc. Tout ce qui est branché sur un ordinateur est, formellement un périphérique.

L''''unité centrale''' est là où se trouvent tous les composants importants d'un ordinateur, ceux qui font des calculs, qui exécutent des logiciels, qui mémorisent vos données, etc. Voici ce à quoi ressemble l'intérieur de l'unité centrale. Trois sections sont visibles : l'alimentation électrique en haut à gauche, la carte mère en bas à gauche et en jaune/orange, les disques et lecteurs à droite des câbles. Et on voit aussi beaucoup de câbles.

[[File:Asus P5K-SEIntel E6320.jpg|centre|vignette|upright=2|Exemple d'unité centrale.]]

Tout en haut à gauche, se trouve l''''alimentation électrique''', qui convertit le courant de la prise électrique en un courant plus faible, utilisable par les autres composants. Elle émet de nombreux câbles assez gros, qui sont reliés au reste. Les PC actuels utilisent des alimentations électriques standardisées, qui fournissent trois tensions au reste de l'ordinateur : une tension de 12 Volts, une de 5 Volts, une de 3,3 Volts.

À droite, caché par la partie &quot;métallique&quot; du boitier, se trouvent les lecteurs de CD/DVD, et les disques durs. Les lecteurs CD-ROM ou DVD-ROM permettaient de lire des CD ou des DVD. Je parle au passé, car ils ont aujourd'hui disparu des ordinateurs modernes. Les '''disques durs''' sont des mémoires de stockage, qui mémorisent vos données de manière permanente. De nos jours, ils sont remplacés par des SSD, qui sont des disques durs électroniques, là où les disques durs proprement dit sont des mémoires magnétiques. Nous verrons la différence dans deux chapitres dédiés, un sur les disques durs, l'autre sur les SSD.

En bas à droite, se trouve la '''carte mère''' un support plat, en plastique ou en céramique, sur laquelle sont soudés/connectés les autres composants. Sur celle-ci, de nombreux composants sont soudés, d'autres sont branchés dessus avec des câbles, d'autres sont connectés dessus avec des connecteurs. Ils sont reliés entre eux par des fils conducteurs, le plus souvent du cuivre ou de l’aluminium, ce qui leur permet de s’échanger des données. Sur les cartes simples, ces fils sont intégrés dans la carte électronique, dans des creux du plastique. Ils portent le nom de pistes.

Avant, les disques durs, SSD et lecteurs de CD/DVD sont branchés dessus via des connecteurs dédiés, appelés des connecteurs S-ATA. De nos jours, ils sont branchés sur un autre connecteur, grâce à l'interface NVME. Toujours est-il qu'ils sont reliés à la carte mère par des câbles, ce qui montre que ce sont des sortes de périphériques interne. Ils sont placés dans le boitier, mais on aurait tout aussi bien pu les mettre à l'extérieur, vu qu'ils communiquent avec l'ordinateur par l'intermédiaire d'un câble ou d'un connecteur dédié.

Mais deux autres composants très importants sont eux placés sur la carte mère, directement. Ils ont chacun un connecteur dédié, sur lequel ils sont branchés directement, sans passer par l'intermédiaire d'un câble, mais sans être soudés non plus. Il s'agit du processeur et de la mémoire RAM, deux composants centraux des PC modernes.

[[File:Pentium III SL4CB.jpg|thumb|Processeur Pentium III.]]

Le '''processeur''' traite les données, les modifie, les manipule. Pour faire simple, il s’agit d’une grosse calculatrice hyper-puissante. Il comprend à la fois un circuit qui fait des calculs, et un circuit de contrôle qui s'occupe de séquencer les calculs dans l'ordre demandé. Il est souvent caché sous un radiateur, lui-même surmonté par un ventilateur. En effet, un processeur chauffe beaucoup, ce qui demande d'évacuer cette chaleur. Un chapitre entier expliquera pourquoi les processeurs chauffent, ainsi que les techniques utilisées pour limiter leur production de chaleur et leur consommation électrique.

La '''mémoire vive''' conserve des informations/données temporairement, tant que le processeur en a besoin. Elle prend la forme de barrettes de RAM, comme montré ci-dessous.

[[File:2 gb ddr2 667.jpg|centre|vignette|upright=2|Barrette de RAM.]]

Outre ces composants dits principaux, un ordinateur peut comprendre plusieurs composants moins importants, surtout présents sur les ordinateurs personnels. Ils sont techniquement facultatifs, mais sont très présents dans les ordinateurs personnels. Cependant, certains ordinateurs spécialisés s'en passent. Il s'agit des diverses '''cartes d'extension''' sont branchées sur la carte mère. Elles permettent d’accélérer certains calculs ou certaines applications, afin de décharger le processeur. Par exemple, la carte graphique s'occupe des calculs graphiques, qu'il s'agisse de graphismes 3D de jeux vidéos ou de l'affichage en 2D du bureau. Dans un autre registre, la carte son prend en charge le microphone et les haut-parleurs.

[[Fichier:Personal computer, exploded 4.svg|thumb|upright=1.0|Éclaté d'un ordinateur de type PC :&lt;br /&gt;
1 : Écran ;&lt;br /&gt;
2 : Carte mère ;&lt;br /&gt;
3 : Processeur ;&lt;br /&gt;
4 : Câble Parallel ATA ;&lt;br /&gt;
5 : Mémoire vive (RAM) ;&lt;br /&gt;
6 : Carte d'extension ;&lt;br /&gt;
7 : Alimentation électrique ;&lt;br /&gt;
8 : Lecteur de disque optique ;&lt;br /&gt;
9 : Disque dur ;&lt;br /&gt;
10 : Clavier ;&lt;br /&gt;
11 : Souris.]]

Si on regarde une carte mère de face, on voit un grand nombre de connecteurs, mais aussi des circuits électroniques soudés à la carte mère.

[[File:Architecture matérielle d'une carte mère.png|centre|vignette|upright=2.0|Architecture matérielle d'une carte mère]]

Les '''connecteurs''' sont là où on branche les périphériques, la carte graphique, le processeur, la mémoire, etc. Dans l'ensemble, toute carte mère contient les connecteurs suivants :
* Le processeur vient s’enchâsser dans la carte mère sur un connecteur particulier : le '''socket'''. Celui-ci varie suivant la carte mère et le processeur, ce qui est source d'incompatibilités.
* Les barrettes de mémoire RAM s’enchâssent dans un autre type de connecteurs: les '''slots mémoire'''.
* Les mémoires de masse disposent de leurs propres connecteurs : connecteurs P-ATA pour les anciens disques durs, et S-ATA pour les récents.
* Les périphériques (clavier, souris, USB, Firewire, ...) sont connectés sur un ensemble de connecteurs dédiés, localisés à l'arrière du boitier de l'unité centrale. 
* Les autres périphériques sont placés dans l'unité centrale et sont connectés via des connecteurs spécialisés. Ces périphériques sont des cartes imprimées, d'où leur nom de '''cartes filles'''. On peut notamment citer les cartes réseau, les cartes son, ou les cartes vidéo.

===Les ordinateurs portables===

[[File:Samsung QX-511 (2).JPG|vignette|Ordinateur portable Samsung QX-511 (2), pour illustration.]]

Un ordinateur portable est identique à un ordinateur de type PC. Si vous ouvrez votre ordinateur portable (attention à la garantie), vous retrouverez les mêmes composants qu'un PC à l'intérieur. Un point important est la présence d'une batterie à l'intérieur du PC portable, absente des PC fixes.

[[File:LG gram 14Z90Q mainboard with battery.jpg|centre|vignette|upright=2|LG gram 14Z90Q avec sa batterie.]]

Une fois la batterie et les circuits associés retiré, la seule différence notable est que tous les composants sont soudés sur la carte mère, au lieu d'être branchés sur des connecteurs, à part éventuellement la RAM et le disque dur.

[[File:LG gram 14Z90Q mainboard without battery.jpg|centre|vignette|upright=2|LG gram 14Z90Q sans sa batterie.]]

La RAM est parfois soudée sur la carte mère, d'autres fois sous la forme de barrettes de mémoire vive semblables à celles des PC. Dans le dernier cas, elle est connectée à des connecteurs spécifiques, ce qui permet de les changer/upgrader. Les PC portables sont parfois construits de manière à pouvoir changer la RAM facilement, en ouvrant un cache spécial, concu pour.

[[File:Lenovo G555 состав - Донор.JPG|centre|vignette|upright=2|Lenovo G555.]]

La conception d'un ordinateur portable est légèrement différente de celle d'un PC, pour des raisons thermiques. Un PC fixe a plus de place pour évacuer sa chaleur. Les ventilateurs peuvent plus facilement déplacer l'air dans le boitier, même si le flux d'air dans le boitier est éventuellement gêné par la carte graphique. Mais l'évacuation de la chaleur est assez efficace. Sur les PC portables, leur finesse fait que le trajet de l'air est beaucoup plus contraint. Évacuer la chaleur produite par l'ordinateur est plus complexe, ce qui demande d'utiliser des systèmes de refroidissement et de ventilation spécifiques.

Là où les PC fixes se débrouillent avec des radiateurs et des ventilateurs posés sur le processeur, les PC portables font autrement. Ils ne peuvent pas forcément mettre le ventilateur sur le processeur. A la place, ils mettent le ventilateur à côté, mais le processeur est surmonté par un mécanisme de transmission de la chaleur, qui transfère la chaleur du processeur vers le ventilateur.

[[File:Diagram - How a laptop cooling system works.png|centre|vignette|upright=2|Comment fonctionne le système de ventilation d'un ordinateur portable, en anglais.]]

Les difficultés pour dissiper la chaleur font que les ordinateurs portables utilisent souvent des composants peu performants, mais qui chauffent peu. En effet, nous verrons que plus un composant est puissant, plus il chauffe. La relation n'est pas parfaite, mais les processeurs haute performance chauffent plus que les modèles d'entrée ou milieu de gamme moins puissants. En conséquence, les PC portables sont souvent moins puissants que les PC fixes, même pour les modèles dit ''gaming''.

===Les serveurs et ''mainframes''===

Les grandes entreprises utilisent des ordinateurs de grande taille, très puissants, appelés des ''mainframes''. Ils sont souvent confondus avec les serveurs par le grand public, il y a une différence entre les deux. Un serveur est une fonction logicielle/réseau, pas un type d'ordinateur. Mais laissons cette différence de côté, ce qui est dit pour les ''mainframes'' sert pour les gros serveurs haute performance.

[[File:IBM Z15 mainframe.jpg|vignette|Exemple de ''mainframe''' de type IBM Z15.]]

Les anciens ''mainframes'' des années 50-80 avaient une taille pouvant être impressionnante, au point de prendre une pièce complète d'un bâtiment. Mais de nos jours, les ''mainframes'' tiennent dans une grosse armoire un peu haute. Les ''mainframes'' doivent rester allumé en permanence et ne doivent pas être éteint, sauf éventuellement quelques jours par an pour des opérations de maintenance. Ils utilisent pour cela des techniques spécifiques, avec beaucoup de redondance interne.

[[File:ACONIT hall grandes machines.jpg|centre|vignette|upright=2|''Mainframe'' ACONIT.]]

Les ''mainframes'' sont aussi conçus pour mutualiser au maximum leur utilisation, ils peuvent être utilisés par plusieurs utilisateurs à la suite, voire en même temps. Pour cela, les anciens ''mainframes'' étaient capables de faire tourner plusieurs applications distinctes l'une à la suite de l'autre, avec des commutations fréquentes entre logiciels. De nos jours, ils sont capables d'exécuter un grand nombre de tâches en même temps, grâce à la présence de plusieurs processeurs. Les ''mainframes'' modernes sont même capables de faire tourner plusieurs systèmes d'exploitation en même temps si besoin.

Les anciens ''mainframes'' étaient des ordinateurs assez simples, avec un processeur, de la mémoire RAM, un ou plusieurs disques durs, pas plus. Le ''mainframe'' était tellement énorme et cher que les entreprises n'en avaient qu'un seul pour toute l'entreprise. Les employés avaient sur leur bureau des terminaux, qui permettaient d'accéder à l'ordinateur central, mais n'étaient pas des ordinateurs. Les terminaux étaient des composants électroniques simples, avec un écran, un clavier et une souris, mais sans processeur. Ils envoyaient des données au ''mainframe'', ils en recevaient de sa part, mais tout traitement était réalisé sur le ''mainframe''. L'arrivée sur le marché des ordinateurs personnels, de type PC fixe/portable, a entrainé l'abandon de ce genre de pratique, tous les employés ont maintenant un ordinateur rien que pour eux.

{|
|-
! colspan=&quot;2&quot; | Exemples de terminaux
|-
|[[File:Terminal-in2-sm9400.jpg|centre|vignette|upright=1.5|Exemple de terminal. Notez la présence d'un écran et d'un clavier, mais l'asbence d'une unité centrale.]]
|[[File:Chromatics CT4100.jpg|vignette|upright=1.5|Autre exemple de terminal. Le clavier est couplé à un stylo CRT, qui remplacait la souris et agissait sur l'écran comme s'il était tactile.]]
|-
! colspan=&quot;2&quot; | Intérieur d'un terminal
|-
|[[File:CT1024 Monitor.jpg|vignette|upright=1.5|Terminal CT1024, sans le boitier extérieur.]]
|[[File:CT1024 Terminal System.jpg|vignette|upright=1.5|Terminal CT1024, description des composants interne.]]
|}

De nos jours, les ''mainframes'' contiennent en réalité plusieurs ordinateurs simples interconnectés via un réseau local. Un ''mainframe'' qui tient dans une armoire contient facilement une dizaine ou centaine de processeurs, plein de RAM, des disques durs séparés dans une armoire distincte, etc. Vu qu'ils communiquent uniquement via le réseau, ils n'ont pas d'interface, pas d'écran, 'entrée via clavier/souris. Le tout est commandé avec une console de commande, typiquement un ordinateur portable ou un terminal assez simple séparé de l'armoire, qui permet à un administrateur de faire des opérations de surveillance, configuration et maintenance. Il peut y avoir une console de commande pour plusieurs armoires séparées, la console peut même être dans un autre bâtiment et accéder au ''mainframe'' par le réseau.

[[File:IBM System Z9 (type 2094 inside).jpg|centre|vignette|upright=2|''Mainframe'' de type IBM System Z9. L'ordinateur portable sert de console pour qu'un administrateur fasse des opérations de surveillance, configuration et maintenance.]]

Les processeurs et la RAM sont typiquement installés sur des cartes amovibles, qui sont connectées au fond de l'armoire lors de l'installation. Il est même possible de retirer ou d'ajouter des cartes en fonctionnement, afin d'ajouter/retirer des processeurs, des disques durs, etc. Ce qui est très utile si un composant est en panne et qu'il faut le remplacer. 

[[File:IBM TotalStorage Exp400.jpg|centre|vignette|upright=2|IBM TotalStorage Exp400]]

==Un peu d'abstraction : qu'est-ce qu'un ordinateur ?==

Un ordinateur comprend donc un processeur, plusieurs mémoires, des cartes d'extension et une carte mère pour connecter le tout. Mais il s'agit là d'une description assez terre-à-terre de ce qu'est un ordinateur. Une autre description, plus abstraite, se base sur le fait qu'un ordinateur est une énorme calculatrice programmable. Elle permet d'expliquer pourquoi il y a une distinction entre processeur et mémoire, entre unité centrale et périphériques. Tout ce qui va suivre pourra vous paraitre assez abstrait, mais rassurez-vous : les prochains chapitres rendront tout cela plus concrets.

===La séparation entre entrées-sorties et traitement===

L'unité centrale peut être vue comme une énorme calculatrice ultra-puissante, qui exécute des commandes/opérations. Mais à elle seule, elle ne servirait à rien, il faut interagir avec par l'intermédiaire de plusieurs périphériques. Il existe deux types de périphériques, qui sont conceptuellement différents. Les périphériques comme le clavier ou la souris permettent d'envoyer des informations à l'ordinateur, d'agir sur celui-ci. A l'inverse, les écrans transmettent des informations dans le sens inverse : de l'ordinateur vers l'utilisateur. Les premiers sont appelés des '''entrées''', les seconds des '''sorties'''.

Dans un ordinateur, les informations sont représentées sous la forme de nombres. Toute donnée dans un ordinateur est codée avec un ou plusieurs nombres regroupés dans une donnée, un fichier, ou autre. Et la transmissions avec les entrées et sorties se fait là-encore avec des nombres. Par exemple, quand vous appuyez sur votre clavier, le clavier envoie un numéro de touche à l'unité centrale, qui indique quelle touche a été appuyée. L'image à afficher à l'écran est codée sous la forme d'une suite de nombres (un par pixel). L'image est envoyée à l'écran, qui traduit la suite de nombre en image à afficher. Les entrées traduisent des actions utilisateurs en nombres, on dit que les entrées encodent les actions utilisateur. Les sorties font la traduction inverse, elles transforment des suites de nombres en une action physique. On dit qu'elles décodent des informations.

Pour résumer, toute appareil électronique est composé par :
* Des '''entrées''' sur lesquelles l'utilisateur agit sur l'ordinateur. Les entrées transforment les actions de l'utilisateur en nombres, qui sont interprétés par l'ordinateur.
* Une '''unité de traitement''', qui manipule des nombres et fait des calculs/opérations dessus. Les nombres proviennent des entrées, du disque dur, ou d'autres sources, peu importe.
* Des '''sorties''', qui va récupèrent le résultat calculé par l'unité de traitement pour en faire quelque chose : écrire sur une imprimante ou sur un moniteur, émettre du son,...

[[File:Ordinateur théorique Simple 1.png|centre|vignette|upright=2|Ordinateur théorique Simple 1]]

L'unité de traitement proprement dite, celle qui fait les calculs, est couplée à une mémoire qui mémorise les opérandes et résultats des calculs. La séparation entre processeur et mémoire est nécessaire pour qu'un appareil électronique soit qualifié d'ordinateur. De nombreux appareils n'ont pas de séparation entre unité de traitement et mémoire, comme certaines vielles radios AM/FM.

[[File:Schéma de principe d'un ordinateur.png|centre|vignette|upright=2|Schéma de principe d'un ordinateur]]

===Un ordinateur est un appareil programmable===

Les appareils simples sont non-programmables, ce qui veut dire qu’ils sont conçus pour une utilisation particulière et qu’ils ne peuvent pas faire autre chose. Par exemple, les circuits électroniques d’un lecteur de DVD ne peuvent pas être transformé en lecteur audio ou en console de jeux... Les circuits non-programmables sont câblés une bonne fois pour toute, et on ne peut pas les modifier. On peut parfois reconfigurer le circuit, pour faire varier certains paramètres, via des interrupteurs ou des boutons, mais cela s’arrête là. Et cela pose un problème : à chaque problème qu'on veut résoudre en utilisant un automate, on doit recréer un nouveau circuit.

À l'inverse, un ordinateur n’est pas conçu pour une utilisation particulière, contrairement aux autres objets techniques. Il est possible de modifier leur fonction du jour au lendemain, on peut lui faire faire ce qu’on veut. On dit qu'ils sont '''programmables'''. Pour cela, il suffit d’utiliser un logiciel, une application, un programme (ces termes sont synonymes), qui fait ce que l'on souhaite. La totalité des logiciels présents sur un ordinateur sont des programmes comme les autres, même le système d'exploitation (Windows, Linux, ...) ne fait pas exception.

Un programme est une suite de d''''instructions machines''', chaque instruction effectuant une action dans l'ordinateur. Sur les ordinateurs modernes, les instructions les plus communes effectuent une opération arithmétique : une addition, une multiplication, une soustraction, etc. Les ordinateurs modernes sont donc de grosses calculettes très puissantes, capables d'effectuer des millions d'opérations par secondes.

Et qui dit opération dit nombres : un ordinateur gère nativement des nombres, qui sont codés en binaire sur la quasi-totalité des ordinateurs modernes. Les ordinateurs modernes sont capables de faire des calculs sur des nombres entiers, mais aussi des nombres à virgule. Il existe plusieurs manières de représenter des nombres en binaire, certaines représentant des nombres entiers dits naturels (0 et plus), d'autres des nombres signés (positifs ou négatifs), d'autres des nombres à virgule. Un chapitre entier détaillera comment sont encodés ces nombres.

Une instruction est représentée dans un ordinateur par une série de nombres entiers : un nombre qui indique quelle opération/commande effectuer et des autres nombres pour coder les données (ou de quoi les retrouver dans l'ordinateur). L'ordinateur récupére les commandes une par une, les traduit en opération à effectuer, exécuter l'opération, et enregistre le résultat. Puis il recommence avec la commande suivante.

[[File:Ordinateur Théorique Complexe 1.png|centre|vignette|upright=3|Ordinateur Théorique Complexe. En jaune, le programme informatique, la liste de commande. Le rectangle gris est l'ordinateur proprement dit.]]

De nombreux appareils sont programmables, mais tous ne sont pas des ordinateurs. Par exemple, certains circuits programmables nommés FPGA n'en sont pas. Pour être qualifié d'ordinateur, un appareil programmable doit avoir un processeur séparé de la mémoire. De plus, il doit utiliser un '''codage numérique''', chose que nous allons aborder dans le chapitre suivant.

===Les ordinateurs à programme mémorisé ou programme externe===

[[File:Blue-punch-card-front.png|vignette|upright=0.5|Carte Perforée.]]

Au tout début de l'informatique, les programmes étaient enregistrés sur des cartes perforées, à savoir des cartes en papier/plastique percées par endroits. Un 1 est codé par un trou dans le papier et un 0 par une absence de trou. Les programmes étaient exécutés par l'ordinateur quand on insérait la carte perforée dans le lecteur et qu'on appuyait sur un bouton.

Par la suite, les premiers ordinateurs grand public, comme les Amstrad ou les Commodore, utilisaient des cassettes audio magnétiques pour stocker les programmes. Dans le même style, les consoles de jeu utilisaient autrefois des cartouches de jeu, qui contenaient le programme du jeu à exécuter. Pour résumer, les anciens ordinateurs mémorisaient les programmes sur un support externe, lu par un périphérique. De tels ordinateurs sont dits à '''programme externe'''.

: D’anciens ordinateurs personnels, comme l’Amstrad ou le Commodore, permettaient de taper les programmes à exécuter à la main, au clavier, avant d’appuyer une touche pour les exécuter. Nul besoin de vous dire que les cassettes audio étaient plus pratiques.

Mais de nos jours, les programmes sont enregistrés sur le disque dur de l'ordinateur ou dans une mémoire intégrée à l'ordinateur. On dit qu'ils sont installés, ce qui est un mot bien compliqué pour dire que le programme est enregistré sur le disque dur de l’ordinateur. A défaut de disque dur, le programme/logiciel est enregistré dans une mémoire spécialisée pour le stockage. Par exemple, sur les cartes électroniques grand public de marque Arduino, les programmes sont envoyés à la carte via le port USB, mais les programmes sont enregistrés dans la carte Arduino, dans une mémoire FLASH dédiée. Disque dur ou non, le programme est mémorisé dans la mémoire de l'ordinateur. Il est possible d'installer ou de désinstaller les programmes en modifiant le contenu de la mémoire. Le terme utilisé est alors celui de '''programme stocké en mémoire'''.

Les programmes à installer sont disponibles soit sur un périphérique, comme un DVD ou une clé USB, soit sont téléchargés depuis internet. Les premiers PC fournissaient les logiciels sur des disquettes, qui contenaient un programme d'installation pour enregistrer le programme sur le disque dur de l'ordinateur. Par la suite, le support des logiciels a migré vers les CD et DVD, les logiciels devenant de plus en plus gros. De nos jours, la majorité des applications sont téléchargées depuis le net, l'usage de périphériques est devenu obsolète, même les consoles de jeu abandonnent cette méthode de distribution.

==Les générations d'ordinateurs : un historique rapide==

L'informatique a beaucoup évolué dans le temps. Et une bonne partie de cette évolution tient à l'évolution de l’électronique sous-jacente. Les ordinateurs actuels sont fabriqués avec des transistors, des petits composants électroniques qui servent d'interrupteurs programmables, qu'on détaillera dans ce qui suit. Mais ça n'a pas toujours été le cas. Et cela permet de distinguer plusieurs '''générations d'ordinateurs'''.

===Les ordinateurs électro-mécaniques : les premiers ordinateurs===

Le tout premier ordinateur est le '''Z1''', un modèle unique inventé par Konrad Suze entre 1936 et 1938. Son processeur gérait non pas des nombres entiers, mais des nombres à virgule (des nombres dits flottants, pour être précis), encodés sur 22 bits. Le processeur du Z1 était capable de faire des additions et des soustractions, car il intégrait un circuit additionneur-soustracteur basique. Des circuits annexes permettaient de faire des multiplications et des divisions en enchainant des additions/soustractions successives. Il fonctionnait à une fréquence de 1 Hz, ce qui fait qu'il pouvait faire une addition/soustraction par seconde maximum.

Niveau mémoire, la RAM de l'ordinateur était très limitée : seulement 16 nombres de 22 bits chacun. S'il s'agissait d'une mémoire électronique, les programmes étaient mémorisés sur une mémoire mécanique et précisémment sur des cartes perforées, à savoir des cartes en papier/plastique dans lesquelles un 1 est codé par un trou dans le papier et un 0 par une absence de trou. Les programmes étaient exécutés par l'ordinateur quand on insérait la carte perforée dans le lecteur et qu'on appuyait sur un bouton.

[[File:German Museum of Technology, Berlin 2017 024.jpg|centre|vignette|upright=2|Réplique du Z1 au ''German Museum of Technology'' de Berlin, 2017.]]

Après sa destruction dans un bombardement, le Z1 a été reconstruit et amélioré, ce qui donné les deux ordinateurs Z2 et Z3. Quelques années plus tard, quelques laboratoires de recherche ont fabriqués des ordinateurs dans leur coin, comme le Harvard Mark I et le Colossus Mark 1 (UK) qui ont été mis en service en 1944. Ils ont servi pour les cryptanalystes pour casser les codes utilisés par les Allemands pour leurs transmissions, pendant la seconde guerre mondiale.

Les ordinateurs cités dans le précédent paragraphe étaient tous des ordinateurs dit '''électro-mécaniques''', car ils mélangeaient des composants électroniques et des composants mécaniques (tout ce qui a trait aux cartes perforées, notamment). Les composants électroniques étaient soit des relais, soit des tubes à vides, les deux étant des interrupteurs commandables électriquement plus ou moins équivalents aux transistors. Les ordinateurs d'avant l'année 1944, étaient tous de ce type. Quelques ordinateurs des années 50 étaient de ce type, mais leur nombre n'a pas dépassé 30. Il faut dire qu'ils ont rapidement laissé la place à des ordinateurs purement électroniques, que nous allons voir dans ce qui suit.

===La première génération : les tubes à vide===

Les ordinateurs qui ont suivi les ordinateurs électromécaniques sont regroupés dans la '''première génération d'ordinateur'''. Ils étaient conçus avec des tubes à vide, ce qui les place entre les premiers ordinateurs électro-mécaniques et les ordinateurs utilisant des transistors. Les tubes à vide étaient assez encombrants, ils consommaient beaucoup de courant, ils chauffaient et étaient assez peu fiables. Ils tombaient en panne assez souvent. Et ils étaient assez simples à fabriquer, mais restaient malgré tout chers.

[[File:Elektronenroehren-auswahl.jpg|centre|vignette|upright=2|Tubes à vides.]]

Au vu de la taille des tubes à vide, les ordinateurs de l'époque étaient composés de plusieurs milliers de ces tubes, guère plus. Et malgré cela, un ordinateur prenait facilement un étage de bâtiment entier, ou au moins plusieurs pièces. La conséquence est que les ordinateurs de première génération étaient très simples, rudimentaires quand on les compare aux ordinateurs modernes. Ils ne géraient que quelques opérations simples : l'addition, la soustraction, pas grand-chose de plus. À quelques exceptions près, ils ne géraient pas la multiplication et encore moins la division, cela aurait demandé trop de tubes à vides.

Une des toutes premières machines construite avec des tubes à vide était l'Atanasoff–Berry. Ce n'était pas un ordinateur, car elle ne pouvait pas exécuter de programme sans intervention humaine pour séquencer des opérations, mais c'était la première machine de calcul purement électronique, sans aucune pièce mécanique. Elle utilisait une mémoire RAM construite avec des condensateurs, ceux-ci étant placés sur des cylindres tournants. Les circuits de calcul étaient construits avec des tubes à vide et faisaient leur travail un bit à la fois. Elle fonctionnait à une fréquence de 60 Hz et pouvait faire 30 additions/soustractions par seconde. Les nombres étaient encodés sur 50 bits. 

[[File:Atanasoff Berry Computer.gif|centre|vignette|upright=2.5|Atanasoff–Berry.]]

L'arrivée de l'ENIAC en 1945 a changé la donne. Cet ordinateur a introduit plusieurs innovations majeures. La première est assez technique, il s'agit de la turing-complétude, elle a trait aux programmes qui peuvent être écrit pour un ordinateur, nous ne la détaillerons pas ici.

[[File:BabyArchitecture.png|vignette|Architecture de la Manchester Baby.]]

En 1948, le ''Manchester Baby'' a introduit une innovation extrêmement importante : le programme n'était plus mémorisé sur des cartes perforées, mais dans une mémoire électronique à l’intérieur de l'ordinateur lui-même. En clair, le ''Manchester Baby'' était le premier '''ordinateur à programme stocké en mémoire''' en français. Au-delà de ça, le Manchester Baby restait quand même très simple, c'était limite un prototype.

Niveau interface, l'ordinateur avait une console avec 32 boutons, des interrupteurs et un écran de sortie sur lequel afficher les résultats. A l'intérieur, il y avait un processeur et une RAM de 32 nombres de 32 bits, fabriquées avec des tubes Williams (abordés dans une annexe à la fin du cours). Une instruction prenant autant de place qu'un nombre en RAM, ce qui limitait les programmes à 32 instructions maximum. Le processeur gérait 8 instructions en tout, mais la seule instruction de calcul qu'il gérait était la soustraction. L'addition n'était pas supportée. Il pouvait cependant émuler l'addition à partir d'une soustraction et inversant l'opérande soustrait.

Le Manchester Mark 1 était une amélioration du Manchester Baby. Il utilisait 4500 tubes à vide. L'ordinateur gérait des nombres de 40 bits, mais les instructions étaient codées sur 20 bits. La RAM avait la même taille, à savoir 32 nombres, leur taille était simplement augmentée. Par contre, la RAM était complémentée par l’ancêtre du disque dur magnétique, à savoir un tambour magnétique, l’ancêtre du disque dur magnétique. Il contenait 40 pages, chacune ayant la même taille que la RAM. Contrairement à la Manchester Baby, son processeur gérait l'addition et quelques opérations logiques (ET et OU), en plus de la soustraction et de la comparaison.

Par la suite, les ordinateurs commerciaux ont vu le jour. Les ordinateurs précédents provenaient de projets de recherches, souvent publics. Mais les entreprises privées se sont mises à fabriquer des ordinateurs elle-mêmes, pour les vendre à d'autres entreprises. On peut notamment citer les ordinateurs comme le UNIVAC I, le Bull Gamma 3 ou les premiers ordinateurs IBM. La performance de ces ordinateurs était nettement plus importante que leurs prédécesseurs, avec des fréquences de l'ordre de la centaine de kilo-hertz. Par exemple, le Bull Gamma 3 allait à 281 kHz, l'IBM 650 allait à 50 Khz.

===La seconde génération : le remplacement des tubes à vides par des transistors===

[[File:IBM 7070.jpg|vignette|Cartes imprimées de l'IBM 704, avec des transistors et résistances dessus.]]

La '''seconde génération''' est celle des ordinateurs fabriqués avec des '''transistors''' isolés, reliés entre avec des fils électriques. Les transistors en question possèdent trois broches, des pattes métalliques sur lesquelles on connecte des fils électriques. Le transistor s'utilise le plus souvent comme un interrupteur commandé par sa troisième broche. Le courant qui traverse les deux premières broches passe ou ne passe pas selon ce qu'on met sur la troisième.

[[File:Transistor basic flow.svg|centre|vignette|Un transistor est un morceau de conducteur, dont la conductivité est contrôlée par sa troisième broche/borne.]]

Les ordinateurs de seconde génération avaient entre 1000 et 500 000 transistors. Les capacités des ordinateurs étaient donc nettement supérieures à celles des ordinateurs de première génération. Une part non négligeable des ordinateurs de seconde génération supportait l'opération de multiplication, absente sur les ordinateurs de première génération. Néanmoins, cela variait beaucoup selon les ordinateurs.

Un exemple assez hors du commun est celui du premier modèle de l'IBM 1620. Le tout premier modèle n'avait aucun circuit de calcul, il n'était même pas capable de faire une addition ou une multiplication. A la place, il utilisait une table d'addition et une table de multiplication en mémoire RAM. Les deux tables devaient être initialisées par le logiciel lors du démarrage de la machine. La table d'addition faisait une centaine de chiffres, la table de multiplication faisait le double. Le processeur de l'ordinateur gérait des instructions pour faire des additions ou des multiplications, mais ces opérations lisaient le résultat dans la table d'addition. Les calculs étaient faits chiffre par chiffre, avec un encodage partiellement décimal, partiellement binaire (des chiffres décimaux étaient encodés en binaire, nous en reparlerons quand nous parlerons du BCD) !

[[File:KL CoreMemory.jpg|vignette|Mémoire à tore de ferrite.]]

Les transistors n'étaient utilisés que pour le processeur et les circuits annexes. La mémoire n'était pas faite en transistors, pas à cette époque. La mémoire était une mémoire aujourd'hui abandonnée, appelée une '''mémoire à tores de ferrite'''. Elle sera détaillée dans un chapitre ultérieur. Mais sachez pour le moment qu'il s'agit d'une mémoire au support magnétique, les données étant stockées sur un support magnétique.

Transistors comme tubes à vide prenaient beaucoup de place, ce qui fait que les ordinateurs étaient assez gros. Concrètement, ils prenaient une pièce de bâtiment entière dans le meilleur des cas. C'était l'époque des gros ''mainframes'', reliés à des terminaux, peu puissants comparé aux standards actuels. Seules les grandes entreprises et les grands instituts de recherche pouvaient se payer les services de ce genre d'ordinateurs. Seuls les professionnels avaient accès à ce genre d'équipement.

===La troisième génération : le circuit intégré===

[[File:D8259AC-2.jpg|vignette|Exemple de circuit intégré.]]

La troisième génération est toujours fabriquée avec des transistors, mais dont la taille a été réduite. Avec l'évolution de la technologie, les transistors ont diminué en taille, de plus en plus. Ils sont devenus tellement petits qu'ils ont fini par être regroupés dans des '''circuits intégrés''', des circuits regroupent plusieurs transistors sur la même puce de silicium. Les circuits intégrés se présentent le plus souvent sous la forme de boitiers rectangulaires, comme illustré ci-contre. D'autres ont des boitiers de forme carrées, comme ceux que l'on peut trouver sur les barrettes de mémoire RAM, ou à l'intérieur des clés USB/ disques SSD.

Lors de cette génération, les processeurs étaient fournis en pièces détachées qu'il fallait relier entre elles. Le processeur était composé de plusieurs circuits intégrés séparés, impossible de mettre un processeur dans un seul boitier. Un exemple de processeur conçu en kit est la série des Intel 3000. Elle regroupe plusieurs circuits séparés aux noms à coucher dehors, mais dont vous comprendrez ce qu'ils veulent dire dans les chapitres adéquats : l'Intel 3001 est un séquenceur, l'Intel 3002 regroupe unité de calcul et registres, le 3003 est un circuit d'anticipation de retenue complémentaire du 3002, le 3212 est une mémoire tampon, le 3214 est une unité de gestion des interruptions, les 3216/3226 sont des interfaces de bus mémoire. On pourrait aussi citer la famille de circuits intégrés AMD Am2900.

Même si le processeur était en pièces détachées, utiliser une dizaine de circuits intégrés était nettement mieux que d'utiliser plusieurs milliers de transistors individuels. En conséquence, les ordinateurs ont vu leur taille grandement réduite, passant de pièces entières à une simple armoire, voire à quelques cartes intégrées superposées. De plus, le prix des circuits intégré était abordable, du moins comparé aux ordinateurs d'avant. Le prix des ordinateurs a alors grandement décru, permettant à des entreprises et administrations de taille modeste de s'équiper d'ordinateurs.

===La quatrième génération : le microprocesseur===

[[File:MOS6502.svg|vignette|Microprocesseur, ici un processeur MOS6502, de la quatrième génération.]]

Lors de la troisième génération, les circuits intégrés regroupaient plusieurs dizaines ou centaines de transistors, mais sont rapidement montés en gamme. De centaines de transistors, ils sont passés au millier de transistors, puis au million et maintenant au-delà du milliard. Les transistors étaient devenus tellement petits, tellement miniaturisés, qu'il était devenu possible de mettre un processeur entier dans un circuit intégré. C'est ainsi qu'est né le microprocesseur, à savoir un processeur qui tient tout entier dans un seul circuit imprimé. La quatrième génération d’ordinateur est celle des ordinateurs basés autour d'un microprocesseur.

Les tout premiers microprocesseurs étaient des processeurs à application militaire, comme le processeur du F-14 CADC ou celui de l'Air data computer. Le tout premier microprocesseur commercialisé au grand public est le 4004 d'Intel, sorti en 1971. L'intel 4004 comprenait environ 2300 transistors, avait une fréquence de 740 MHz, pouvait faire 46 opérations différentes, et manipulait des entiers de 4 bits. Il était au départ un processeur de commande, prévu pour être intégré dans la calculatrice Busicom calculator 141-P, mais il fut utilisé pour d'autres applications quelque temps plus tard. Immédiatement après le 4004, les premiers microprocesseurs 8 bits furent commercialisés. Le 4004 fut suivi par le 8008 et quelques autres processeurs 8 bits extrêmement connus, comme le 8080 d'Intel, le 68000 de Motorola, le 6502 ou le Z80.

Les microprocesseurs permirent encore uen fois de réduire la taille des ordinateurs, qui pouvaient tenir dans un boitier de PC, ou un boitier de console de jeu. Le prix des ordinateurs a aussi chuté en même temps que les transistors étaient miniaturisés. C'est cette invention qui permis l'invention des consoles de jeux et des mini-ordinateurs, à savoir les ordinateurs personnels. Sans miniaturisation, on n'aurait pas d'ordinateur personnel, pas de PC fixe ou portable.

==L'organisation du cours : les différents niveaux d'explication==

Le fonctionnement d'un ordinateur est assez complexe à expliquer car les explications peuvent se faire sur plusieurs niveaux. Par plusieurs niveaux, on veut dire qu'un ordinateur est composé de composants très simples, qui sont assemblés pour donner des composants eux-même plus complexes, qui sont eux-même regrouper, etc. Étudier tout cela demande de voir plusieurs niveaux, allant de transistors très petits à des processeurs multicœurs. Les niveaux les plus bas sont de l'électronique pur et dure, alors que ceux plus haut sont à mi-chemin entre électronique et informatique.

===Les niveaux d'abstraction en architecture des ordinateurs===

Les trois premiers niveaux sont de l'électronique pur et dure. Ils correspondent aux premiers chapitres du cours, qui porteront sur les circuits électroniques en général.
* Le premier niveau est celui des '''transistors''', des circuits intégrés, des ''wafer'' et autres circuits de très petite taille.
* Le second niveau est celui des '''portes logiques''', des circuits très basiques, très simples, à la base de tous les autres.
* Le troisième niveau est celui dit de la '''''Register Transfer Level''''', où un circuit électronique est construit à partir de circuits basiques, dont des registres et autres circuits dits combinatoires.
Les deux niveaux suivants sont de l'informatique proprement dit. C'est dans ces deux niveaux qu'on étudie les ordinateurs proprement dit, les circuits qu'il y a dedans et non l'électronique en général.
* Le quatrième niveau est celui de la '''microarchitecture''', qui étudie ce qu'il y a à l'intérieur d'un processeur, d'une mémoire, des périphériques et autres.
* Le cinquième niveau est celui de l''''architecture externe''', qui décrit l'interface du processeur, de la mémoire, d'un périphérique ou autre. Par décrire l'interface, on veut dire : comment un programmeur voit le processeur et la mémoire, comment il peut les manipuler. Une architecture externe unique peut avoir plusieurs microarchitecture, ce qui fait qu'on sépare les deux. Tout cela sera plus clair quand on passera aux chapitres sur le processeur et les mémoires.

Nous n'allons pas voir les 5 niveaux dans l'ordre, des transistors vers l'architecture externe. En réalité, nous allons procéder autrement. La première partie du cours portera sur les trois premiers niveaux, le reste sur les deux autres. Les 5 niveaux seront vus dans des chapitres séparés, du moins le plus possible. Au niveau pédagogique, tout est plus simple si on scinde les 5 niveaux. Bien sûr, il y a quelques explications qui demandent de voir plusieurs niveaux à la fois. Par exemple, dans le chapitre sur les mémoires caches, nous auront des explications portant sur la RTL, la microarchitecture du cache et son architecture externe. Mais le gros du cours tentera de séparer le plus possible les 5 niveaux.

===Les trois parties principales du cours===

Nous allons commencer par parler du binaire, avant de voir les portes logiques. Avec ces portes logiques, nous allons voir comment fabriquer des circuits basiques qui reviendront très souvent dans la suite du cours. Nous verrons les registres, les décodeurs, les additionneurs et plein d'autres circuits. Puis, nous reviendrons au niveau des transistors pour finir la première partie. La raison est que c'est plus simple de faire comme cela. Tout ce qui a trait aux transistors sert à expliquer comment fabriquer des portes logiques, et il faut expliquer les portes logiques pour voir le niveau de la RTL.

Une fois la première partie finie, nous allons voir les différents composants d'un ordinateur. Une première partie expliquera ce qu'il y a dans un ordinateur, quels sont ses composants. Nous y parlerons de l'architecture de base, de la hiérarchie mémoire, des tendances technologiques, et d'autres généralités qui serviront de base pour la suite. Puis, nous verrons dans l'ordre les bus électroniques, les mémoires RAM/ROM, le processeur, les périphériques, les mémoires de stockage (SSD et disques durs) et les mémoires caches. Pour chaque composant, nous allons voir leur architecture externe, avant de voir leur microarchitecture. La raison est que la microarchitecture ne peut se comprendre que quand on sait quelle architecture externe elle implémente.

Enfin, dans une troisième partie, nous allons voir les optimisations majeures présentes dans tous les ordinateurs modernes, avec une partie sur le pipeline et le parallélisme d'instruction, et une autre sur les architectures parallèles. Pour finir, les annexes de fin parlerons de sujets un peu à part.

&lt;noinclude&gt;
{{NavChapitre | book=Fonctionnement d'un ordinateur
           | next=L'encodage des données
           | nextText=L'encodage des données
}}
&lt;/noinclude&gt;</text>
      <sha1>fi2ktmq7j3xs7pe97gc8upaiql9od3w</sha1>
    </revision>
    <revision>
      <id>744152</id>
      <parentid>744151</parentid>
      <timestamp>2025-06-05T12:07:01Z</timestamp>
      <contributor>
        <username>Mewtow</username>
        <id>31375</id>
      </contributor>
      <minor />
      <comment>/* Les ordinateurs électro-mécaniques : les premiers ordinateurs */</comment>
      <origin>744152</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="45967" sha1="2452c26i1wcfdmpa9b5cvzmckh3ah9g" xml:space="preserve">Pour commencer, nous allons voir qu'il existe de nombreux types d'ordinateurs. Le plus connu est certainement le PC, l'ordinateur personnel, que vous avez sans doute dans votre salon. Les ordinateurs portables sont un deuxième type d'ordinateur assez intuitif, que vous avez peut-être. Mais il y a aussi d'autres types d'ordinateurs auxquels vous n'avez jamais été confrontés.

==Les différents types d'ordinateurs==

Dans cette section, nous allons décrire rapidement les ordinateurs les plus courant, mais surtout voir ce qu'il y a à l'intérieur d'un ordinateur.

===L'ordinateur de type PC fixe===

De l'extérieur, l'ordinateur est composé d'une unité centrale sur laquelle on branche des périphériques.

[[File:Typical computer architecture systems.jpg|vignette|upright=1.5|Exemples de périphériques, connectés à une unité centrale (ici appelée à tort ''operating system'').]]

Les '''périphériques''' regroupent l'écran, la souris, le clavier, l'imprimante, et bien d'autres choses. Ils permettent à l'utilisateur d'interagir avec l'ordinateur : un clavier permet de saisir du texte sous dans un fichier, une souris enregistre des déplacements de la main en déplacement du curseur, un écran affiche des données d’images/vidéos, un haut-parleur émet du son, etc. Tout ce qui est branché sur un ordinateur est, formellement un périphérique.

L''''unité centrale''' est là où se trouvent tous les composants importants d'un ordinateur, ceux qui font des calculs, qui exécutent des logiciels, qui mémorisent vos données, etc. Voici ce à quoi ressemble l'intérieur de l'unité centrale. Trois sections sont visibles : l'alimentation électrique en haut à gauche, la carte mère en bas à gauche et en jaune/orange, les disques et lecteurs à droite des câbles. Et on voit aussi beaucoup de câbles.

[[File:Asus P5K-SEIntel E6320.jpg|centre|vignette|upright=2|Exemple d'unité centrale.]]

Tout en haut à gauche, se trouve l''''alimentation électrique''', qui convertit le courant de la prise électrique en un courant plus faible, utilisable par les autres composants. Elle émet de nombreux câbles assez gros, qui sont reliés au reste. Les PC actuels utilisent des alimentations électriques standardisées, qui fournissent trois tensions au reste de l'ordinateur : une tension de 12 Volts, une de 5 Volts, une de 3,3 Volts.

À droite, caché par la partie &quot;métallique&quot; du boitier, se trouvent les lecteurs de CD/DVD, et les disques durs. Les lecteurs CD-ROM ou DVD-ROM permettaient de lire des CD ou des DVD. Je parle au passé, car ils ont aujourd'hui disparu des ordinateurs modernes. Les '''disques durs''' sont des mémoires de stockage, qui mémorisent vos données de manière permanente. De nos jours, ils sont remplacés par des SSD, qui sont des disques durs électroniques, là où les disques durs proprement dit sont des mémoires magnétiques. Nous verrons la différence dans deux chapitres dédiés, un sur les disques durs, l'autre sur les SSD.

En bas à droite, se trouve la '''carte mère''' un support plat, en plastique ou en céramique, sur laquelle sont soudés/connectés les autres composants. Sur celle-ci, de nombreux composants sont soudés, d'autres sont branchés dessus avec des câbles, d'autres sont connectés dessus avec des connecteurs. Ils sont reliés entre eux par des fils conducteurs, le plus souvent du cuivre ou de l’aluminium, ce qui leur permet de s’échanger des données. Sur les cartes simples, ces fils sont intégrés dans la carte électronique, dans des creux du plastique. Ils portent le nom de pistes.

Avant, les disques durs, SSD et lecteurs de CD/DVD sont branchés dessus via des connecteurs dédiés, appelés des connecteurs S-ATA. De nos jours, ils sont branchés sur un autre connecteur, grâce à l'interface NVME. Toujours est-il qu'ils sont reliés à la carte mère par des câbles, ce qui montre que ce sont des sortes de périphériques interne. Ils sont placés dans le boitier, mais on aurait tout aussi bien pu les mettre à l'extérieur, vu qu'ils communiquent avec l'ordinateur par l'intermédiaire d'un câble ou d'un connecteur dédié.

Mais deux autres composants très importants sont eux placés sur la carte mère, directement. Ils ont chacun un connecteur dédié, sur lequel ils sont branchés directement, sans passer par l'intermédiaire d'un câble, mais sans être soudés non plus. Il s'agit du processeur et de la mémoire RAM, deux composants centraux des PC modernes.

[[File:Pentium III SL4CB.jpg|thumb|Processeur Pentium III.]]

Le '''processeur''' traite les données, les modifie, les manipule. Pour faire simple, il s’agit d’une grosse calculatrice hyper-puissante. Il comprend à la fois un circuit qui fait des calculs, et un circuit de contrôle qui s'occupe de séquencer les calculs dans l'ordre demandé. Il est souvent caché sous un radiateur, lui-même surmonté par un ventilateur. En effet, un processeur chauffe beaucoup, ce qui demande d'évacuer cette chaleur. Un chapitre entier expliquera pourquoi les processeurs chauffent, ainsi que les techniques utilisées pour limiter leur production de chaleur et leur consommation électrique.

La '''mémoire vive''' conserve des informations/données temporairement, tant que le processeur en a besoin. Elle prend la forme de barrettes de RAM, comme montré ci-dessous.

[[File:2 gb ddr2 667.jpg|centre|vignette|upright=2|Barrette de RAM.]]

Outre ces composants dits principaux, un ordinateur peut comprendre plusieurs composants moins importants, surtout présents sur les ordinateurs personnels. Ils sont techniquement facultatifs, mais sont très présents dans les ordinateurs personnels. Cependant, certains ordinateurs spécialisés s'en passent. Il s'agit des diverses '''cartes d'extension''' sont branchées sur la carte mère. Elles permettent d’accélérer certains calculs ou certaines applications, afin de décharger le processeur. Par exemple, la carte graphique s'occupe des calculs graphiques, qu'il s'agisse de graphismes 3D de jeux vidéos ou de l'affichage en 2D du bureau. Dans un autre registre, la carte son prend en charge le microphone et les haut-parleurs.

[[Fichier:Personal computer, exploded 4.svg|thumb|upright=1.0|Éclaté d'un ordinateur de type PC :&lt;br /&gt;
1 : Écran ;&lt;br /&gt;
2 : Carte mère ;&lt;br /&gt;
3 : Processeur ;&lt;br /&gt;
4 : Câble Parallel ATA ;&lt;br /&gt;
5 : Mémoire vive (RAM) ;&lt;br /&gt;
6 : Carte d'extension ;&lt;br /&gt;
7 : Alimentation électrique ;&lt;br /&gt;
8 : Lecteur de disque optique ;&lt;br /&gt;
9 : Disque dur ;&lt;br /&gt;
10 : Clavier ;&lt;br /&gt;
11 : Souris.]]

Si on regarde une carte mère de face, on voit un grand nombre de connecteurs, mais aussi des circuits électroniques soudés à la carte mère.

[[File:Architecture matérielle d'une carte mère.png|centre|vignette|upright=2.0|Architecture matérielle d'une carte mère]]

Les '''connecteurs''' sont là où on branche les périphériques, la carte graphique, le processeur, la mémoire, etc. Dans l'ensemble, toute carte mère contient les connecteurs suivants :
* Le processeur vient s’enchâsser dans la carte mère sur un connecteur particulier : le '''socket'''. Celui-ci varie suivant la carte mère et le processeur, ce qui est source d'incompatibilités.
* Les barrettes de mémoire RAM s’enchâssent dans un autre type de connecteurs: les '''slots mémoire'''.
* Les mémoires de masse disposent de leurs propres connecteurs : connecteurs P-ATA pour les anciens disques durs, et S-ATA pour les récents.
* Les périphériques (clavier, souris, USB, Firewire, ...) sont connectés sur un ensemble de connecteurs dédiés, localisés à l'arrière du boitier de l'unité centrale. 
* Les autres périphériques sont placés dans l'unité centrale et sont connectés via des connecteurs spécialisés. Ces périphériques sont des cartes imprimées, d'où leur nom de '''cartes filles'''. On peut notamment citer les cartes réseau, les cartes son, ou les cartes vidéo.

===Les ordinateurs portables===

[[File:Samsung QX-511 (2).JPG|vignette|Ordinateur portable Samsung QX-511 (2), pour illustration.]]

Un ordinateur portable est identique à un ordinateur de type PC. Si vous ouvrez votre ordinateur portable (attention à la garantie), vous retrouverez les mêmes composants qu'un PC à l'intérieur. Un point important est la présence d'une batterie à l'intérieur du PC portable, absente des PC fixes.

[[File:LG gram 14Z90Q mainboard with battery.jpg|centre|vignette|upright=2|LG gram 14Z90Q avec sa batterie.]]

Une fois la batterie et les circuits associés retiré, la seule différence notable est que tous les composants sont soudés sur la carte mère, au lieu d'être branchés sur des connecteurs, à part éventuellement la RAM et le disque dur.

[[File:LG gram 14Z90Q mainboard without battery.jpg|centre|vignette|upright=2|LG gram 14Z90Q sans sa batterie.]]

La RAM est parfois soudée sur la carte mère, d'autres fois sous la forme de barrettes de mémoire vive semblables à celles des PC. Dans le dernier cas, elle est connectée à des connecteurs spécifiques, ce qui permet de les changer/upgrader. Les PC portables sont parfois construits de manière à pouvoir changer la RAM facilement, en ouvrant un cache spécial, concu pour.

[[File:Lenovo G555 состав - Донор.JPG|centre|vignette|upright=2|Lenovo G555.]]

La conception d'un ordinateur portable est légèrement différente de celle d'un PC, pour des raisons thermiques. Un PC fixe a plus de place pour évacuer sa chaleur. Les ventilateurs peuvent plus facilement déplacer l'air dans le boitier, même si le flux d'air dans le boitier est éventuellement gêné par la carte graphique. Mais l'évacuation de la chaleur est assez efficace. Sur les PC portables, leur finesse fait que le trajet de l'air est beaucoup plus contraint. Évacuer la chaleur produite par l'ordinateur est plus complexe, ce qui demande d'utiliser des systèmes de refroidissement et de ventilation spécifiques.

Là où les PC fixes se débrouillent avec des radiateurs et des ventilateurs posés sur le processeur, les PC portables font autrement. Ils ne peuvent pas forcément mettre le ventilateur sur le processeur. A la place, ils mettent le ventilateur à côté, mais le processeur est surmonté par un mécanisme de transmission de la chaleur, qui transfère la chaleur du processeur vers le ventilateur.

[[File:Diagram - How a laptop cooling system works.png|centre|vignette|upright=2|Comment fonctionne le système de ventilation d'un ordinateur portable, en anglais.]]

Les difficultés pour dissiper la chaleur font que les ordinateurs portables utilisent souvent des composants peu performants, mais qui chauffent peu. En effet, nous verrons que plus un composant est puissant, plus il chauffe. La relation n'est pas parfaite, mais les processeurs haute performance chauffent plus que les modèles d'entrée ou milieu de gamme moins puissants. En conséquence, les PC portables sont souvent moins puissants que les PC fixes, même pour les modèles dit ''gaming''.

===Les serveurs et ''mainframes''===

Les grandes entreprises utilisent des ordinateurs de grande taille, très puissants, appelés des ''mainframes''. Ils sont souvent confondus avec les serveurs par le grand public, il y a une différence entre les deux. Un serveur est une fonction logicielle/réseau, pas un type d'ordinateur. Mais laissons cette différence de côté, ce qui est dit pour les ''mainframes'' sert pour les gros serveurs haute performance.

[[File:IBM Z15 mainframe.jpg|vignette|Exemple de ''mainframe''' de type IBM Z15.]]

Les anciens ''mainframes'' des années 50-80 avaient une taille pouvant être impressionnante, au point de prendre une pièce complète d'un bâtiment. Mais de nos jours, les ''mainframes'' tiennent dans une grosse armoire un peu haute. Les ''mainframes'' doivent rester allumé en permanence et ne doivent pas être éteint, sauf éventuellement quelques jours par an pour des opérations de maintenance. Ils utilisent pour cela des techniques spécifiques, avec beaucoup de redondance interne.

[[File:ACONIT hall grandes machines.jpg|centre|vignette|upright=2|''Mainframe'' ACONIT.]]

Les ''mainframes'' sont aussi conçus pour mutualiser au maximum leur utilisation, ils peuvent être utilisés par plusieurs utilisateurs à la suite, voire en même temps. Pour cela, les anciens ''mainframes'' étaient capables de faire tourner plusieurs applications distinctes l'une à la suite de l'autre, avec des commutations fréquentes entre logiciels. De nos jours, ils sont capables d'exécuter un grand nombre de tâches en même temps, grâce à la présence de plusieurs processeurs. Les ''mainframes'' modernes sont même capables de faire tourner plusieurs systèmes d'exploitation en même temps si besoin.

Les anciens ''mainframes'' étaient des ordinateurs assez simples, avec un processeur, de la mémoire RAM, un ou plusieurs disques durs, pas plus. Le ''mainframe'' était tellement énorme et cher que les entreprises n'en avaient qu'un seul pour toute l'entreprise. Les employés avaient sur leur bureau des terminaux, qui permettaient d'accéder à l'ordinateur central, mais n'étaient pas des ordinateurs. Les terminaux étaient des composants électroniques simples, avec un écran, un clavier et une souris, mais sans processeur. Ils envoyaient des données au ''mainframe'', ils en recevaient de sa part, mais tout traitement était réalisé sur le ''mainframe''. L'arrivée sur le marché des ordinateurs personnels, de type PC fixe/portable, a entrainé l'abandon de ce genre de pratique, tous les employés ont maintenant un ordinateur rien que pour eux.

{|
|-
! colspan=&quot;2&quot; | Exemples de terminaux
|-
|[[File:Terminal-in2-sm9400.jpg|centre|vignette|upright=1.5|Exemple de terminal. Notez la présence d'un écran et d'un clavier, mais l'asbence d'une unité centrale.]]
|[[File:Chromatics CT4100.jpg|vignette|upright=1.5|Autre exemple de terminal. Le clavier est couplé à un stylo CRT, qui remplacait la souris et agissait sur l'écran comme s'il était tactile.]]
|-
! colspan=&quot;2&quot; | Intérieur d'un terminal
|-
|[[File:CT1024 Monitor.jpg|vignette|upright=1.5|Terminal CT1024, sans le boitier extérieur.]]
|[[File:CT1024 Terminal System.jpg|vignette|upright=1.5|Terminal CT1024, description des composants interne.]]
|}

De nos jours, les ''mainframes'' contiennent en réalité plusieurs ordinateurs simples interconnectés via un réseau local. Un ''mainframe'' qui tient dans une armoire contient facilement une dizaine ou centaine de processeurs, plein de RAM, des disques durs séparés dans une armoire distincte, etc. Vu qu'ils communiquent uniquement via le réseau, ils n'ont pas d'interface, pas d'écran, 'entrée via clavier/souris. Le tout est commandé avec une console de commande, typiquement un ordinateur portable ou un terminal assez simple séparé de l'armoire, qui permet à un administrateur de faire des opérations de surveillance, configuration et maintenance. Il peut y avoir une console de commande pour plusieurs armoires séparées, la console peut même être dans un autre bâtiment et accéder au ''mainframe'' par le réseau.

[[File:IBM System Z9 (type 2094 inside).jpg|centre|vignette|upright=2|''Mainframe'' de type IBM System Z9. L'ordinateur portable sert de console pour qu'un administrateur fasse des opérations de surveillance, configuration et maintenance.]]

Les processeurs et la RAM sont typiquement installés sur des cartes amovibles, qui sont connectées au fond de l'armoire lors de l'installation. Il est même possible de retirer ou d'ajouter des cartes en fonctionnement, afin d'ajouter/retirer des processeurs, des disques durs, etc. Ce qui est très utile si un composant est en panne et qu'il faut le remplacer. 

[[File:IBM TotalStorage Exp400.jpg|centre|vignette|upright=2|IBM TotalStorage Exp400]]

==Un peu d'abstraction : qu'est-ce qu'un ordinateur ?==

Un ordinateur comprend donc un processeur, plusieurs mémoires, des cartes d'extension et une carte mère pour connecter le tout. Mais il s'agit là d'une description assez terre-à-terre de ce qu'est un ordinateur. Une autre description, plus abstraite, se base sur le fait qu'un ordinateur est une énorme calculatrice programmable. Elle permet d'expliquer pourquoi il y a une distinction entre processeur et mémoire, entre unité centrale et périphériques. Tout ce qui va suivre pourra vous paraitre assez abstrait, mais rassurez-vous : les prochains chapitres rendront tout cela plus concrets.

===La séparation entre entrées-sorties et traitement===

L'unité centrale peut être vue comme une énorme calculatrice ultra-puissante, qui exécute des commandes/opérations. Mais à elle seule, elle ne servirait à rien, il faut interagir avec par l'intermédiaire de plusieurs périphériques. Il existe deux types de périphériques, qui sont conceptuellement différents. Les périphériques comme le clavier ou la souris permettent d'envoyer des informations à l'ordinateur, d'agir sur celui-ci. A l'inverse, les écrans transmettent des informations dans le sens inverse : de l'ordinateur vers l'utilisateur. Les premiers sont appelés des '''entrées''', les seconds des '''sorties'''.

Dans un ordinateur, les informations sont représentées sous la forme de nombres. Toute donnée dans un ordinateur est codée avec un ou plusieurs nombres regroupés dans une donnée, un fichier, ou autre. Et la transmissions avec les entrées et sorties se fait là-encore avec des nombres. Par exemple, quand vous appuyez sur votre clavier, le clavier envoie un numéro de touche à l'unité centrale, qui indique quelle touche a été appuyée. L'image à afficher à l'écran est codée sous la forme d'une suite de nombres (un par pixel). L'image est envoyée à l'écran, qui traduit la suite de nombre en image à afficher. Les entrées traduisent des actions utilisateurs en nombres, on dit que les entrées encodent les actions utilisateur. Les sorties font la traduction inverse, elles transforment des suites de nombres en une action physique. On dit qu'elles décodent des informations.

Pour résumer, toute appareil électronique est composé par :
* Des '''entrées''' sur lesquelles l'utilisateur agit sur l'ordinateur. Les entrées transforment les actions de l'utilisateur en nombres, qui sont interprétés par l'ordinateur.
* Une '''unité de traitement''', qui manipule des nombres et fait des calculs/opérations dessus. Les nombres proviennent des entrées, du disque dur, ou d'autres sources, peu importe.
* Des '''sorties''', qui va récupèrent le résultat calculé par l'unité de traitement pour en faire quelque chose : écrire sur une imprimante ou sur un moniteur, émettre du son,...

[[File:Ordinateur théorique Simple 1.png|centre|vignette|upright=2|Ordinateur théorique Simple 1]]

L'unité de traitement proprement dite, celle qui fait les calculs, est couplée à une mémoire qui mémorise les opérandes et résultats des calculs. La séparation entre processeur et mémoire est nécessaire pour qu'un appareil électronique soit qualifié d'ordinateur. De nombreux appareils n'ont pas de séparation entre unité de traitement et mémoire, comme certaines vielles radios AM/FM.

[[File:Schéma de principe d'un ordinateur.png|centre|vignette|upright=2|Schéma de principe d'un ordinateur]]

===Un ordinateur est un appareil programmable===

Les appareils simples sont non-programmables, ce qui veut dire qu’ils sont conçus pour une utilisation particulière et qu’ils ne peuvent pas faire autre chose. Par exemple, les circuits électroniques d’un lecteur de DVD ne peuvent pas être transformé en lecteur audio ou en console de jeux... Les circuits non-programmables sont câblés une bonne fois pour toute, et on ne peut pas les modifier. On peut parfois reconfigurer le circuit, pour faire varier certains paramètres, via des interrupteurs ou des boutons, mais cela s’arrête là. Et cela pose un problème : à chaque problème qu'on veut résoudre en utilisant un automate, on doit recréer un nouveau circuit.

À l'inverse, un ordinateur n’est pas conçu pour une utilisation particulière, contrairement aux autres objets techniques. Il est possible de modifier leur fonction du jour au lendemain, on peut lui faire faire ce qu’on veut. On dit qu'ils sont '''programmables'''. Pour cela, il suffit d’utiliser un logiciel, une application, un programme (ces termes sont synonymes), qui fait ce que l'on souhaite. La totalité des logiciels présents sur un ordinateur sont des programmes comme les autres, même le système d'exploitation (Windows, Linux, ...) ne fait pas exception.

Un programme est une suite de d''''instructions machines''', chaque instruction effectuant une action dans l'ordinateur. Sur les ordinateurs modernes, les instructions les plus communes effectuent une opération arithmétique : une addition, une multiplication, une soustraction, etc. Les ordinateurs modernes sont donc de grosses calculettes très puissantes, capables d'effectuer des millions d'opérations par secondes.

Et qui dit opération dit nombres : un ordinateur gère nativement des nombres, qui sont codés en binaire sur la quasi-totalité des ordinateurs modernes. Les ordinateurs modernes sont capables de faire des calculs sur des nombres entiers, mais aussi des nombres à virgule. Il existe plusieurs manières de représenter des nombres en binaire, certaines représentant des nombres entiers dits naturels (0 et plus), d'autres des nombres signés (positifs ou négatifs), d'autres des nombres à virgule. Un chapitre entier détaillera comment sont encodés ces nombres.

Une instruction est représentée dans un ordinateur par une série de nombres entiers : un nombre qui indique quelle opération/commande effectuer et des autres nombres pour coder les données (ou de quoi les retrouver dans l'ordinateur). L'ordinateur récupére les commandes une par une, les traduit en opération à effectuer, exécuter l'opération, et enregistre le résultat. Puis il recommence avec la commande suivante.

[[File:Ordinateur Théorique Complexe 1.png|centre|vignette|upright=3|Ordinateur Théorique Complexe. En jaune, le programme informatique, la liste de commande. Le rectangle gris est l'ordinateur proprement dit.]]

De nombreux appareils sont programmables, mais tous ne sont pas des ordinateurs. Par exemple, certains circuits programmables nommés FPGA n'en sont pas. Pour être qualifié d'ordinateur, un appareil programmable doit avoir un processeur séparé de la mémoire. De plus, il doit utiliser un '''codage numérique''', chose que nous allons aborder dans le chapitre suivant.

===Les ordinateurs à programme mémorisé ou programme externe===

[[File:Blue-punch-card-front.png|vignette|upright=0.5|Carte Perforée.]]

Au tout début de l'informatique, les programmes étaient enregistrés sur des cartes perforées, à savoir des cartes en papier/plastique percées par endroits. Un 1 est codé par un trou dans le papier et un 0 par une absence de trou. Les programmes étaient exécutés par l'ordinateur quand on insérait la carte perforée dans le lecteur et qu'on appuyait sur un bouton.

Par la suite, les premiers ordinateurs grand public, comme les Amstrad ou les Commodore, utilisaient des cassettes audio magnétiques pour stocker les programmes. Dans le même style, les consoles de jeu utilisaient autrefois des cartouches de jeu, qui contenaient le programme du jeu à exécuter. Pour résumer, les anciens ordinateurs mémorisaient les programmes sur un support externe, lu par un périphérique. De tels ordinateurs sont dits à '''programme externe'''.

: D’anciens ordinateurs personnels, comme l’Amstrad ou le Commodore, permettaient de taper les programmes à exécuter à la main, au clavier, avant d’appuyer une touche pour les exécuter. Nul besoin de vous dire que les cassettes audio étaient plus pratiques.

Mais de nos jours, les programmes sont enregistrés sur le disque dur de l'ordinateur ou dans une mémoire intégrée à l'ordinateur. On dit qu'ils sont installés, ce qui est un mot bien compliqué pour dire que le programme est enregistré sur le disque dur de l’ordinateur. A défaut de disque dur, le programme/logiciel est enregistré dans une mémoire spécialisée pour le stockage. Par exemple, sur les cartes électroniques grand public de marque Arduino, les programmes sont envoyés à la carte via le port USB, mais les programmes sont enregistrés dans la carte Arduino, dans une mémoire FLASH dédiée. Disque dur ou non, le programme est mémorisé dans la mémoire de l'ordinateur. Il est possible d'installer ou de désinstaller les programmes en modifiant le contenu de la mémoire. Le terme utilisé est alors celui de '''programme stocké en mémoire'''.

Les programmes à installer sont disponibles soit sur un périphérique, comme un DVD ou une clé USB, soit sont téléchargés depuis internet. Les premiers PC fournissaient les logiciels sur des disquettes, qui contenaient un programme d'installation pour enregistrer le programme sur le disque dur de l'ordinateur. Par la suite, le support des logiciels a migré vers les CD et DVD, les logiciels devenant de plus en plus gros. De nos jours, la majorité des applications sont téléchargées depuis le net, l'usage de périphériques est devenu obsolète, même les consoles de jeu abandonnent cette méthode de distribution.

==Les générations d'ordinateurs : un historique rapide==

L'informatique a beaucoup évolué dans le temps. Et une bonne partie de cette évolution tient à l'évolution de l’électronique sous-jacente. Les ordinateurs actuels sont fabriqués avec des transistors, des petits composants électroniques qui servent d'interrupteurs programmables, qu'on détaillera dans ce qui suit. Mais ça n'a pas toujours été le cas. Et cela permet de distinguer plusieurs '''générations d'ordinateurs'''.

===Les ordinateurs électro-mécaniques : les premiers ordinateurs===

Le tout premier ordinateur est le '''Z1''', un modèle unique inventé par Konrad Suze entre 1936 et 1938. Son processeur gérait non pas des nombres entiers, mais des nombres à virgule (des nombres dits flottants, pour être précis), encodés sur 22 bits. Le processeur du Z1 était capable de faire des additions et des soustractions, car il intégrait un circuit additionneur-soustracteur basique. Des circuits annexes permettaient de faire des multiplications et des divisions en enchainant des additions/soustractions successives. Il fonctionnait à une fréquence de 1 Hz, ce qui fait qu'il pouvait faire une addition/soustraction par seconde maximum.

Niveau mémoire, la RAM de l'ordinateur était très limitée : seulement 16 nombres de 22 bits chacun. S'il s'agissait d'une mémoire électronique, les programmes étaient mémorisés sur une mémoire mécanique et précisémment sur des cartes perforées, à savoir des cartes en papier/plastique dans lesquelles un 1 est codé par un trou dans le papier et un 0 par une absence de trou. Les programmes étaient exécutés par l'ordinateur quand on insérait la carte perforée dans le lecteur et qu'on appuyait sur un bouton.

[[File:German Museum of Technology, Berlin 2017 024.jpg|centre|vignette|upright=2|Réplique du Z1 au ''German Museum of Technology'' de Berlin, 2017.]]

Après sa destruction dans un bombardement, le Z1 a été reconstruit et amélioré, ce qui donné les deux ordinateurs Z2 et Z3. Quelques années plus tard, quelques laboratoires de recherche ont fabriqués des ordinateurs dans leur coin, comme le Harvard Mark I et le Colossus Mark 1 (UK) qui ont été mis en service en 1944. Ils ont servi pour les cryptanalystes pour casser les codes utilisés par les Allemands pour leurs transmissions, pendant la seconde guerre mondiale.

Les ordinateurs cités dans le précédent paragraphe étaient tous des ordinateurs dit '''électro-mécaniques''', car ils mélangeaient des composants électroniques et des composants mécaniques (tout ce qui a trait aux cartes perforées, notamment). Les composants électroniques étaient généralement des relais, à savoir des interrupteurs commandables électriquement, qui sont plus ou moins équivalents aux transistors modernes. La majeure partie des ordinateurs des années 40 étaient de ce type, mais leur nombre n'a pas dépassé 30. Il faut dire qu'ils ont rapidement laissé la place à des ordinateurs purement électroniques, que nous allons voir dans ce qui suit.

===La première génération : les tubes à vide===

Les ordinateurs qui ont suivi les ordinateurs électromécaniques sont regroupés dans la '''première génération d'ordinateur'''. Ils étaient conçus avec des tubes à vide, ce qui les place entre les premiers ordinateurs électro-mécaniques et les ordinateurs utilisant des transistors. Les tubes à vide étaient assez encombrants, ils consommaient beaucoup de courant, ils chauffaient et étaient assez peu fiables. Ils tombaient en panne assez souvent. Et ils étaient assez simples à fabriquer, mais restaient malgré tout chers.

[[File:Elektronenroehren-auswahl.jpg|centre|vignette|upright=2|Tubes à vides.]]

Au vu de la taille des tubes à vide, les ordinateurs de l'époque étaient composés de plusieurs milliers de ces tubes, guère plus. Et malgré cela, un ordinateur prenait facilement un étage de bâtiment entier, ou au moins plusieurs pièces. La conséquence est que les ordinateurs de première génération étaient très simples, rudimentaires quand on les compare aux ordinateurs modernes. Ils ne géraient que quelques opérations simples : l'addition, la soustraction, pas grand-chose de plus. À quelques exceptions près, ils ne géraient pas la multiplication et encore moins la division, cela aurait demandé trop de tubes à vides.

Une des toutes premières machines construite avec des tubes à vide était l'Atanasoff–Berry. Ce n'était pas un ordinateur, car elle ne pouvait pas exécuter de programme sans intervention humaine pour séquencer des opérations, mais c'était la première machine de calcul purement électronique, sans aucune pièce mécanique. Elle utilisait une mémoire RAM construite avec des condensateurs, ceux-ci étant placés sur des cylindres tournants. Les circuits de calcul étaient construits avec des tubes à vide et faisaient leur travail un bit à la fois. Elle fonctionnait à une fréquence de 60 Hz et pouvait faire 30 additions/soustractions par seconde. Les nombres étaient encodés sur 50 bits. 

[[File:Atanasoff Berry Computer.gif|centre|vignette|upright=2.5|Atanasoff–Berry.]]

L'arrivée de l'ENIAC en 1945 a changé la donne. Cet ordinateur a introduit plusieurs innovations majeures. La première est assez technique, il s'agit de la turing-complétude, elle a trait aux programmes qui peuvent être écrit pour un ordinateur, nous ne la détaillerons pas ici.

[[File:BabyArchitecture.png|vignette|Architecture de la Manchester Baby.]]

En 1948, le ''Manchester Baby'' a introduit une innovation extrêmement importante : le programme n'était plus mémorisé sur des cartes perforées, mais dans une mémoire électronique à l’intérieur de l'ordinateur lui-même. En clair, le ''Manchester Baby'' était le premier '''ordinateur à programme stocké en mémoire''' en français. Au-delà de ça, le Manchester Baby restait quand même très simple, c'était limite un prototype.

Niveau interface, l'ordinateur avait une console avec 32 boutons, des interrupteurs et un écran de sortie sur lequel afficher les résultats. A l'intérieur, il y avait un processeur et une RAM de 32 nombres de 32 bits, fabriquées avec des tubes Williams (abordés dans une annexe à la fin du cours). Une instruction prenant autant de place qu'un nombre en RAM, ce qui limitait les programmes à 32 instructions maximum. Le processeur gérait 8 instructions en tout, mais la seule instruction de calcul qu'il gérait était la soustraction. L'addition n'était pas supportée. Il pouvait cependant émuler l'addition à partir d'une soustraction et inversant l'opérande soustrait.

Le Manchester Mark 1 était une amélioration du Manchester Baby. Il utilisait 4500 tubes à vide. L'ordinateur gérait des nombres de 40 bits, mais les instructions étaient codées sur 20 bits. La RAM avait la même taille, à savoir 32 nombres, leur taille était simplement augmentée. Par contre, la RAM était complémentée par l’ancêtre du disque dur magnétique, à savoir un tambour magnétique, l’ancêtre du disque dur magnétique. Il contenait 40 pages, chacune ayant la même taille que la RAM. Contrairement à la Manchester Baby, son processeur gérait l'addition et quelques opérations logiques (ET et OU), en plus de la soustraction et de la comparaison.

Par la suite, les ordinateurs commerciaux ont vu le jour. Les ordinateurs précédents provenaient de projets de recherches, souvent publics. Mais les entreprises privées se sont mises à fabriquer des ordinateurs elle-mêmes, pour les vendre à d'autres entreprises. On peut notamment citer les ordinateurs comme le UNIVAC I, le Bull Gamma 3 ou les premiers ordinateurs IBM. La performance de ces ordinateurs était nettement plus importante que leurs prédécesseurs, avec des fréquences de l'ordre de la centaine de kilo-hertz. Par exemple, le Bull Gamma 3 allait à 281 kHz, l'IBM 650 allait à 50 Khz.

===La seconde génération : le remplacement des tubes à vides par des transistors===

[[File:IBM 7070.jpg|vignette|Cartes imprimées de l'IBM 704, avec des transistors et résistances dessus.]]

La '''seconde génération''' est celle des ordinateurs fabriqués avec des '''transistors''' isolés, reliés entre avec des fils électriques. Les transistors en question possèdent trois broches, des pattes métalliques sur lesquelles on connecte des fils électriques. Le transistor s'utilise le plus souvent comme un interrupteur commandé par sa troisième broche. Le courant qui traverse les deux premières broches passe ou ne passe pas selon ce qu'on met sur la troisième.

[[File:Transistor basic flow.svg|centre|vignette|Un transistor est un morceau de conducteur, dont la conductivité est contrôlée par sa troisième broche/borne.]]

Les ordinateurs de seconde génération avaient entre 1000 et 500 000 transistors. Les capacités des ordinateurs étaient donc nettement supérieures à celles des ordinateurs de première génération. Une part non négligeable des ordinateurs de seconde génération supportait l'opération de multiplication, absente sur les ordinateurs de première génération. Néanmoins, cela variait beaucoup selon les ordinateurs.

Un exemple assez hors du commun est celui du premier modèle de l'IBM 1620. Le tout premier modèle n'avait aucun circuit de calcul, il n'était même pas capable de faire une addition ou une multiplication. A la place, il utilisait une table d'addition et une table de multiplication en mémoire RAM. Les deux tables devaient être initialisées par le logiciel lors du démarrage de la machine. La table d'addition faisait une centaine de chiffres, la table de multiplication faisait le double. Le processeur de l'ordinateur gérait des instructions pour faire des additions ou des multiplications, mais ces opérations lisaient le résultat dans la table d'addition. Les calculs étaient faits chiffre par chiffre, avec un encodage partiellement décimal, partiellement binaire (des chiffres décimaux étaient encodés en binaire, nous en reparlerons quand nous parlerons du BCD) !

[[File:KL CoreMemory.jpg|vignette|Mémoire à tore de ferrite.]]

Les transistors n'étaient utilisés que pour le processeur et les circuits annexes. La mémoire n'était pas faite en transistors, pas à cette époque. La mémoire était une mémoire aujourd'hui abandonnée, appelée une '''mémoire à tores de ferrite'''. Elle sera détaillée dans un chapitre ultérieur. Mais sachez pour le moment qu'il s'agit d'une mémoire au support magnétique, les données étant stockées sur un support magnétique.

Transistors comme tubes à vide prenaient beaucoup de place, ce qui fait que les ordinateurs étaient assez gros. Concrètement, ils prenaient une pièce de bâtiment entière dans le meilleur des cas. C'était l'époque des gros ''mainframes'', reliés à des terminaux, peu puissants comparé aux standards actuels. Seules les grandes entreprises et les grands instituts de recherche pouvaient se payer les services de ce genre d'ordinateurs. Seuls les professionnels avaient accès à ce genre d'équipement.

===La troisième génération : le circuit intégré===

[[File:D8259AC-2.jpg|vignette|Exemple de circuit intégré.]]

La troisième génération est toujours fabriquée avec des transistors, mais dont la taille a été réduite. Avec l'évolution de la technologie, les transistors ont diminué en taille, de plus en plus. Ils sont devenus tellement petits qu'ils ont fini par être regroupés dans des '''circuits intégrés''', des circuits regroupent plusieurs transistors sur la même puce de silicium. Les circuits intégrés se présentent le plus souvent sous la forme de boitiers rectangulaires, comme illustré ci-contre. D'autres ont des boitiers de forme carrées, comme ceux que l'on peut trouver sur les barrettes de mémoire RAM, ou à l'intérieur des clés USB/ disques SSD.

Lors de cette génération, les processeurs étaient fournis en pièces détachées qu'il fallait relier entre elles. Le processeur était composé de plusieurs circuits intégrés séparés, impossible de mettre un processeur dans un seul boitier. Un exemple de processeur conçu en kit est la série des Intel 3000. Elle regroupe plusieurs circuits séparés aux noms à coucher dehors, mais dont vous comprendrez ce qu'ils veulent dire dans les chapitres adéquats : l'Intel 3001 est un séquenceur, l'Intel 3002 regroupe unité de calcul et registres, le 3003 est un circuit d'anticipation de retenue complémentaire du 3002, le 3212 est une mémoire tampon, le 3214 est une unité de gestion des interruptions, les 3216/3226 sont des interfaces de bus mémoire. On pourrait aussi citer la famille de circuits intégrés AMD Am2900.

Même si le processeur était en pièces détachées, utiliser une dizaine de circuits intégrés était nettement mieux que d'utiliser plusieurs milliers de transistors individuels. En conséquence, les ordinateurs ont vu leur taille grandement réduite, passant de pièces entières à une simple armoire, voire à quelques cartes intégrées superposées. De plus, le prix des circuits intégré était abordable, du moins comparé aux ordinateurs d'avant. Le prix des ordinateurs a alors grandement décru, permettant à des entreprises et administrations de taille modeste de s'équiper d'ordinateurs.

===La quatrième génération : le microprocesseur===

[[File:MOS6502.svg|vignette|Microprocesseur, ici un processeur MOS6502, de la quatrième génération.]]

Lors de la troisième génération, les circuits intégrés regroupaient plusieurs dizaines ou centaines de transistors, mais sont rapidement montés en gamme. De centaines de transistors, ils sont passés au millier de transistors, puis au million et maintenant au-delà du milliard. Les transistors étaient devenus tellement petits, tellement miniaturisés, qu'il était devenu possible de mettre un processeur entier dans un circuit intégré. C'est ainsi qu'est né le microprocesseur, à savoir un processeur qui tient tout entier dans un seul circuit imprimé. La quatrième génération d’ordinateur est celle des ordinateurs basés autour d'un microprocesseur.

Les tout premiers microprocesseurs étaient des processeurs à application militaire, comme le processeur du F-14 CADC ou celui de l'Air data computer. Le tout premier microprocesseur commercialisé au grand public est le 4004 d'Intel, sorti en 1971. L'intel 4004 comprenait environ 2300 transistors, avait une fréquence de 740 MHz, pouvait faire 46 opérations différentes, et manipulait des entiers de 4 bits. Il était au départ un processeur de commande, prévu pour être intégré dans la calculatrice Busicom calculator 141-P, mais il fut utilisé pour d'autres applications quelque temps plus tard. Immédiatement après le 4004, les premiers microprocesseurs 8 bits furent commercialisés. Le 4004 fut suivi par le 8008 et quelques autres processeurs 8 bits extrêmement connus, comme le 8080 d'Intel, le 68000 de Motorola, le 6502 ou le Z80.

Les microprocesseurs permirent encore uen fois de réduire la taille des ordinateurs, qui pouvaient tenir dans un boitier de PC, ou un boitier de console de jeu. Le prix des ordinateurs a aussi chuté en même temps que les transistors étaient miniaturisés. C'est cette invention qui permis l'invention des consoles de jeux et des mini-ordinateurs, à savoir les ordinateurs personnels. Sans miniaturisation, on n'aurait pas d'ordinateur personnel, pas de PC fixe ou portable.

==L'organisation du cours : les différents niveaux d'explication==

Le fonctionnement d'un ordinateur est assez complexe à expliquer car les explications peuvent se faire sur plusieurs niveaux. Par plusieurs niveaux, on veut dire qu'un ordinateur est composé de composants très simples, qui sont assemblés pour donner des composants eux-même plus complexes, qui sont eux-même regrouper, etc. Étudier tout cela demande de voir plusieurs niveaux, allant de transistors très petits à des processeurs multicœurs. Les niveaux les plus bas sont de l'électronique pur et dure, alors que ceux plus haut sont à mi-chemin entre électronique et informatique.

===Les niveaux d'abstraction en architecture des ordinateurs===

Les trois premiers niveaux sont de l'électronique pur et dure. Ils correspondent aux premiers chapitres du cours, qui porteront sur les circuits électroniques en général.
* Le premier niveau est celui des '''transistors''', des circuits intégrés, des ''wafer'' et autres circuits de très petite taille.
* Le second niveau est celui des '''portes logiques''', des circuits très basiques, très simples, à la base de tous les autres.
* Le troisième niveau est celui dit de la '''''Register Transfer Level''''', où un circuit électronique est construit à partir de circuits basiques, dont des registres et autres circuits dits combinatoires.
Les deux niveaux suivants sont de l'informatique proprement dit. C'est dans ces deux niveaux qu'on étudie les ordinateurs proprement dit, les circuits qu'il y a dedans et non l'électronique en général.
* Le quatrième niveau est celui de la '''microarchitecture''', qui étudie ce qu'il y a à l'intérieur d'un processeur, d'une mémoire, des périphériques et autres.
* Le cinquième niveau est celui de l''''architecture externe''', qui décrit l'interface du processeur, de la mémoire, d'un périphérique ou autre. Par décrire l'interface, on veut dire : comment un programmeur voit le processeur et la mémoire, comment il peut les manipuler. Une architecture externe unique peut avoir plusieurs microarchitecture, ce qui fait qu'on sépare les deux. Tout cela sera plus clair quand on passera aux chapitres sur le processeur et les mémoires.

Nous n'allons pas voir les 5 niveaux dans l'ordre, des transistors vers l'architecture externe. En réalité, nous allons procéder autrement. La première partie du cours portera sur les trois premiers niveaux, le reste sur les deux autres. Les 5 niveaux seront vus dans des chapitres séparés, du moins le plus possible. Au niveau pédagogique, tout est plus simple si on scinde les 5 niveaux. Bien sûr, il y a quelques explications qui demandent de voir plusieurs niveaux à la fois. Par exemple, dans le chapitre sur les mémoires caches, nous auront des explications portant sur la RTL, la microarchitecture du cache et son architecture externe. Mais le gros du cours tentera de séparer le plus possible les 5 niveaux.

===Les trois parties principales du cours===

Nous allons commencer par parler du binaire, avant de voir les portes logiques. Avec ces portes logiques, nous allons voir comment fabriquer des circuits basiques qui reviendront très souvent dans la suite du cours. Nous verrons les registres, les décodeurs, les additionneurs et plein d'autres circuits. Puis, nous reviendrons au niveau des transistors pour finir la première partie. La raison est que c'est plus simple de faire comme cela. Tout ce qui a trait aux transistors sert à expliquer comment fabriquer des portes logiques, et il faut expliquer les portes logiques pour voir le niveau de la RTL.

Une fois la première partie finie, nous allons voir les différents composants d'un ordinateur. Une première partie expliquera ce qu'il y a dans un ordinateur, quels sont ses composants. Nous y parlerons de l'architecture de base, de la hiérarchie mémoire, des tendances technologiques, et d'autres généralités qui serviront de base pour la suite. Puis, nous verrons dans l'ordre les bus électroniques, les mémoires RAM/ROM, le processeur, les périphériques, les mémoires de stockage (SSD et disques durs) et les mémoires caches. Pour chaque composant, nous allons voir leur architecture externe, avant de voir leur microarchitecture. La raison est que la microarchitecture ne peut se comprendre que quand on sait quelle architecture externe elle implémente.

Enfin, dans une troisième partie, nous allons voir les optimisations majeures présentes dans tous les ordinateurs modernes, avec une partie sur le pipeline et le parallélisme d'instruction, et une autre sur les architectures parallèles. Pour finir, les annexes de fin parlerons de sujets un peu à part.

&lt;noinclude&gt;
{{NavChapitre | book=Fonctionnement d'un ordinateur
           | next=L'encodage des données
           | nextText=L'encodage des données
}}
&lt;/noinclude&gt;</text>
      <sha1>2452c26i1wcfdmpa9b5cvzmckh3ah9g</sha1>
    </revision>
    <revision>
      <id>744153</id>
      <parentid>744152</parentid>
      <timestamp>2025-06-05T12:08:37Z</timestamp>
      <contributor>
        <username>Mewtow</username>
        <id>31375</id>
      </contributor>
      <minor />
      <comment>/* La première génération : les tubes à vide */</comment>
      <origin>744153</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="46068" sha1="k8qicxk26kcfr1js1be759w6p5kphrw" xml:space="preserve">Pour commencer, nous allons voir qu'il existe de nombreux types d'ordinateurs. Le plus connu est certainement le PC, l'ordinateur personnel, que vous avez sans doute dans votre salon. Les ordinateurs portables sont un deuxième type d'ordinateur assez intuitif, que vous avez peut-être. Mais il y a aussi d'autres types d'ordinateurs auxquels vous n'avez jamais été confrontés.

==Les différents types d'ordinateurs==

Dans cette section, nous allons décrire rapidement les ordinateurs les plus courant, mais surtout voir ce qu'il y a à l'intérieur d'un ordinateur.

===L'ordinateur de type PC fixe===

De l'extérieur, l'ordinateur est composé d'une unité centrale sur laquelle on branche des périphériques.

[[File:Typical computer architecture systems.jpg|vignette|upright=1.5|Exemples de périphériques, connectés à une unité centrale (ici appelée à tort ''operating system'').]]

Les '''périphériques''' regroupent l'écran, la souris, le clavier, l'imprimante, et bien d'autres choses. Ils permettent à l'utilisateur d'interagir avec l'ordinateur : un clavier permet de saisir du texte sous dans un fichier, une souris enregistre des déplacements de la main en déplacement du curseur, un écran affiche des données d’images/vidéos, un haut-parleur émet du son, etc. Tout ce qui est branché sur un ordinateur est, formellement un périphérique.

L''''unité centrale''' est là où se trouvent tous les composants importants d'un ordinateur, ceux qui font des calculs, qui exécutent des logiciels, qui mémorisent vos données, etc. Voici ce à quoi ressemble l'intérieur de l'unité centrale. Trois sections sont visibles : l'alimentation électrique en haut à gauche, la carte mère en bas à gauche et en jaune/orange, les disques et lecteurs à droite des câbles. Et on voit aussi beaucoup de câbles.

[[File:Asus P5K-SEIntel E6320.jpg|centre|vignette|upright=2|Exemple d'unité centrale.]]

Tout en haut à gauche, se trouve l''''alimentation électrique''', qui convertit le courant de la prise électrique en un courant plus faible, utilisable par les autres composants. Elle émet de nombreux câbles assez gros, qui sont reliés au reste. Les PC actuels utilisent des alimentations électriques standardisées, qui fournissent trois tensions au reste de l'ordinateur : une tension de 12 Volts, une de 5 Volts, une de 3,3 Volts.

À droite, caché par la partie &quot;métallique&quot; du boitier, se trouvent les lecteurs de CD/DVD, et les disques durs. Les lecteurs CD-ROM ou DVD-ROM permettaient de lire des CD ou des DVD. Je parle au passé, car ils ont aujourd'hui disparu des ordinateurs modernes. Les '''disques durs''' sont des mémoires de stockage, qui mémorisent vos données de manière permanente. De nos jours, ils sont remplacés par des SSD, qui sont des disques durs électroniques, là où les disques durs proprement dit sont des mémoires magnétiques. Nous verrons la différence dans deux chapitres dédiés, un sur les disques durs, l'autre sur les SSD.

En bas à droite, se trouve la '''carte mère''' un support plat, en plastique ou en céramique, sur laquelle sont soudés/connectés les autres composants. Sur celle-ci, de nombreux composants sont soudés, d'autres sont branchés dessus avec des câbles, d'autres sont connectés dessus avec des connecteurs. Ils sont reliés entre eux par des fils conducteurs, le plus souvent du cuivre ou de l’aluminium, ce qui leur permet de s’échanger des données. Sur les cartes simples, ces fils sont intégrés dans la carte électronique, dans des creux du plastique. Ils portent le nom de pistes.

Avant, les disques durs, SSD et lecteurs de CD/DVD sont branchés dessus via des connecteurs dédiés, appelés des connecteurs S-ATA. De nos jours, ils sont branchés sur un autre connecteur, grâce à l'interface NVME. Toujours est-il qu'ils sont reliés à la carte mère par des câbles, ce qui montre que ce sont des sortes de périphériques interne. Ils sont placés dans le boitier, mais on aurait tout aussi bien pu les mettre à l'extérieur, vu qu'ils communiquent avec l'ordinateur par l'intermédiaire d'un câble ou d'un connecteur dédié.

Mais deux autres composants très importants sont eux placés sur la carte mère, directement. Ils ont chacun un connecteur dédié, sur lequel ils sont branchés directement, sans passer par l'intermédiaire d'un câble, mais sans être soudés non plus. Il s'agit du processeur et de la mémoire RAM, deux composants centraux des PC modernes.

[[File:Pentium III SL4CB.jpg|thumb|Processeur Pentium III.]]

Le '''processeur''' traite les données, les modifie, les manipule. Pour faire simple, il s’agit d’une grosse calculatrice hyper-puissante. Il comprend à la fois un circuit qui fait des calculs, et un circuit de contrôle qui s'occupe de séquencer les calculs dans l'ordre demandé. Il est souvent caché sous un radiateur, lui-même surmonté par un ventilateur. En effet, un processeur chauffe beaucoup, ce qui demande d'évacuer cette chaleur. Un chapitre entier expliquera pourquoi les processeurs chauffent, ainsi que les techniques utilisées pour limiter leur production de chaleur et leur consommation électrique.

La '''mémoire vive''' conserve des informations/données temporairement, tant que le processeur en a besoin. Elle prend la forme de barrettes de RAM, comme montré ci-dessous.

[[File:2 gb ddr2 667.jpg|centre|vignette|upright=2|Barrette de RAM.]]

Outre ces composants dits principaux, un ordinateur peut comprendre plusieurs composants moins importants, surtout présents sur les ordinateurs personnels. Ils sont techniquement facultatifs, mais sont très présents dans les ordinateurs personnels. Cependant, certains ordinateurs spécialisés s'en passent. Il s'agit des diverses '''cartes d'extension''' sont branchées sur la carte mère. Elles permettent d’accélérer certains calculs ou certaines applications, afin de décharger le processeur. Par exemple, la carte graphique s'occupe des calculs graphiques, qu'il s'agisse de graphismes 3D de jeux vidéos ou de l'affichage en 2D du bureau. Dans un autre registre, la carte son prend en charge le microphone et les haut-parleurs.

[[Fichier:Personal computer, exploded 4.svg|thumb|upright=1.0|Éclaté d'un ordinateur de type PC :&lt;br /&gt;
1 : Écran ;&lt;br /&gt;
2 : Carte mère ;&lt;br /&gt;
3 : Processeur ;&lt;br /&gt;
4 : Câble Parallel ATA ;&lt;br /&gt;
5 : Mémoire vive (RAM) ;&lt;br /&gt;
6 : Carte d'extension ;&lt;br /&gt;
7 : Alimentation électrique ;&lt;br /&gt;
8 : Lecteur de disque optique ;&lt;br /&gt;
9 : Disque dur ;&lt;br /&gt;
10 : Clavier ;&lt;br /&gt;
11 : Souris.]]

Si on regarde une carte mère de face, on voit un grand nombre de connecteurs, mais aussi des circuits électroniques soudés à la carte mère.

[[File:Architecture matérielle d'une carte mère.png|centre|vignette|upright=2.0|Architecture matérielle d'une carte mère]]

Les '''connecteurs''' sont là où on branche les périphériques, la carte graphique, le processeur, la mémoire, etc. Dans l'ensemble, toute carte mère contient les connecteurs suivants :
* Le processeur vient s’enchâsser dans la carte mère sur un connecteur particulier : le '''socket'''. Celui-ci varie suivant la carte mère et le processeur, ce qui est source d'incompatibilités.
* Les barrettes de mémoire RAM s’enchâssent dans un autre type de connecteurs: les '''slots mémoire'''.
* Les mémoires de masse disposent de leurs propres connecteurs : connecteurs P-ATA pour les anciens disques durs, et S-ATA pour les récents.
* Les périphériques (clavier, souris, USB, Firewire, ...) sont connectés sur un ensemble de connecteurs dédiés, localisés à l'arrière du boitier de l'unité centrale. 
* Les autres périphériques sont placés dans l'unité centrale et sont connectés via des connecteurs spécialisés. Ces périphériques sont des cartes imprimées, d'où leur nom de '''cartes filles'''. On peut notamment citer les cartes réseau, les cartes son, ou les cartes vidéo.

===Les ordinateurs portables===

[[File:Samsung QX-511 (2).JPG|vignette|Ordinateur portable Samsung QX-511 (2), pour illustration.]]

Un ordinateur portable est identique à un ordinateur de type PC. Si vous ouvrez votre ordinateur portable (attention à la garantie), vous retrouverez les mêmes composants qu'un PC à l'intérieur. Un point important est la présence d'une batterie à l'intérieur du PC portable, absente des PC fixes.

[[File:LG gram 14Z90Q mainboard with battery.jpg|centre|vignette|upright=2|LG gram 14Z90Q avec sa batterie.]]

Une fois la batterie et les circuits associés retiré, la seule différence notable est que tous les composants sont soudés sur la carte mère, au lieu d'être branchés sur des connecteurs, à part éventuellement la RAM et le disque dur.

[[File:LG gram 14Z90Q mainboard without battery.jpg|centre|vignette|upright=2|LG gram 14Z90Q sans sa batterie.]]

La RAM est parfois soudée sur la carte mère, d'autres fois sous la forme de barrettes de mémoire vive semblables à celles des PC. Dans le dernier cas, elle est connectée à des connecteurs spécifiques, ce qui permet de les changer/upgrader. Les PC portables sont parfois construits de manière à pouvoir changer la RAM facilement, en ouvrant un cache spécial, concu pour.

[[File:Lenovo G555 состав - Донор.JPG|centre|vignette|upright=2|Lenovo G555.]]

La conception d'un ordinateur portable est légèrement différente de celle d'un PC, pour des raisons thermiques. Un PC fixe a plus de place pour évacuer sa chaleur. Les ventilateurs peuvent plus facilement déplacer l'air dans le boitier, même si le flux d'air dans le boitier est éventuellement gêné par la carte graphique. Mais l'évacuation de la chaleur est assez efficace. Sur les PC portables, leur finesse fait que le trajet de l'air est beaucoup plus contraint. Évacuer la chaleur produite par l'ordinateur est plus complexe, ce qui demande d'utiliser des systèmes de refroidissement et de ventilation spécifiques.

Là où les PC fixes se débrouillent avec des radiateurs et des ventilateurs posés sur le processeur, les PC portables font autrement. Ils ne peuvent pas forcément mettre le ventilateur sur le processeur. A la place, ils mettent le ventilateur à côté, mais le processeur est surmonté par un mécanisme de transmission de la chaleur, qui transfère la chaleur du processeur vers le ventilateur.

[[File:Diagram - How a laptop cooling system works.png|centre|vignette|upright=2|Comment fonctionne le système de ventilation d'un ordinateur portable, en anglais.]]

Les difficultés pour dissiper la chaleur font que les ordinateurs portables utilisent souvent des composants peu performants, mais qui chauffent peu. En effet, nous verrons que plus un composant est puissant, plus il chauffe. La relation n'est pas parfaite, mais les processeurs haute performance chauffent plus que les modèles d'entrée ou milieu de gamme moins puissants. En conséquence, les PC portables sont souvent moins puissants que les PC fixes, même pour les modèles dit ''gaming''.

===Les serveurs et ''mainframes''===

Les grandes entreprises utilisent des ordinateurs de grande taille, très puissants, appelés des ''mainframes''. Ils sont souvent confondus avec les serveurs par le grand public, il y a une différence entre les deux. Un serveur est une fonction logicielle/réseau, pas un type d'ordinateur. Mais laissons cette différence de côté, ce qui est dit pour les ''mainframes'' sert pour les gros serveurs haute performance.

[[File:IBM Z15 mainframe.jpg|vignette|Exemple de ''mainframe''' de type IBM Z15.]]

Les anciens ''mainframes'' des années 50-80 avaient une taille pouvant être impressionnante, au point de prendre une pièce complète d'un bâtiment. Mais de nos jours, les ''mainframes'' tiennent dans une grosse armoire un peu haute. Les ''mainframes'' doivent rester allumé en permanence et ne doivent pas être éteint, sauf éventuellement quelques jours par an pour des opérations de maintenance. Ils utilisent pour cela des techniques spécifiques, avec beaucoup de redondance interne.

[[File:ACONIT hall grandes machines.jpg|centre|vignette|upright=2|''Mainframe'' ACONIT.]]

Les ''mainframes'' sont aussi conçus pour mutualiser au maximum leur utilisation, ils peuvent être utilisés par plusieurs utilisateurs à la suite, voire en même temps. Pour cela, les anciens ''mainframes'' étaient capables de faire tourner plusieurs applications distinctes l'une à la suite de l'autre, avec des commutations fréquentes entre logiciels. De nos jours, ils sont capables d'exécuter un grand nombre de tâches en même temps, grâce à la présence de plusieurs processeurs. Les ''mainframes'' modernes sont même capables de faire tourner plusieurs systèmes d'exploitation en même temps si besoin.

Les anciens ''mainframes'' étaient des ordinateurs assez simples, avec un processeur, de la mémoire RAM, un ou plusieurs disques durs, pas plus. Le ''mainframe'' était tellement énorme et cher que les entreprises n'en avaient qu'un seul pour toute l'entreprise. Les employés avaient sur leur bureau des terminaux, qui permettaient d'accéder à l'ordinateur central, mais n'étaient pas des ordinateurs. Les terminaux étaient des composants électroniques simples, avec un écran, un clavier et une souris, mais sans processeur. Ils envoyaient des données au ''mainframe'', ils en recevaient de sa part, mais tout traitement était réalisé sur le ''mainframe''. L'arrivée sur le marché des ordinateurs personnels, de type PC fixe/portable, a entrainé l'abandon de ce genre de pratique, tous les employés ont maintenant un ordinateur rien que pour eux.

{|
|-
! colspan=&quot;2&quot; | Exemples de terminaux
|-
|[[File:Terminal-in2-sm9400.jpg|centre|vignette|upright=1.5|Exemple de terminal. Notez la présence d'un écran et d'un clavier, mais l'asbence d'une unité centrale.]]
|[[File:Chromatics CT4100.jpg|vignette|upright=1.5|Autre exemple de terminal. Le clavier est couplé à un stylo CRT, qui remplacait la souris et agissait sur l'écran comme s'il était tactile.]]
|-
! colspan=&quot;2&quot; | Intérieur d'un terminal
|-
|[[File:CT1024 Monitor.jpg|vignette|upright=1.5|Terminal CT1024, sans le boitier extérieur.]]
|[[File:CT1024 Terminal System.jpg|vignette|upright=1.5|Terminal CT1024, description des composants interne.]]
|}

De nos jours, les ''mainframes'' contiennent en réalité plusieurs ordinateurs simples interconnectés via un réseau local. Un ''mainframe'' qui tient dans une armoire contient facilement une dizaine ou centaine de processeurs, plein de RAM, des disques durs séparés dans une armoire distincte, etc. Vu qu'ils communiquent uniquement via le réseau, ils n'ont pas d'interface, pas d'écran, 'entrée via clavier/souris. Le tout est commandé avec une console de commande, typiquement un ordinateur portable ou un terminal assez simple séparé de l'armoire, qui permet à un administrateur de faire des opérations de surveillance, configuration et maintenance. Il peut y avoir une console de commande pour plusieurs armoires séparées, la console peut même être dans un autre bâtiment et accéder au ''mainframe'' par le réseau.

[[File:IBM System Z9 (type 2094 inside).jpg|centre|vignette|upright=2|''Mainframe'' de type IBM System Z9. L'ordinateur portable sert de console pour qu'un administrateur fasse des opérations de surveillance, configuration et maintenance.]]

Les processeurs et la RAM sont typiquement installés sur des cartes amovibles, qui sont connectées au fond de l'armoire lors de l'installation. Il est même possible de retirer ou d'ajouter des cartes en fonctionnement, afin d'ajouter/retirer des processeurs, des disques durs, etc. Ce qui est très utile si un composant est en panne et qu'il faut le remplacer. 

[[File:IBM TotalStorage Exp400.jpg|centre|vignette|upright=2|IBM TotalStorage Exp400]]

==Un peu d'abstraction : qu'est-ce qu'un ordinateur ?==

Un ordinateur comprend donc un processeur, plusieurs mémoires, des cartes d'extension et une carte mère pour connecter le tout. Mais il s'agit là d'une description assez terre-à-terre de ce qu'est un ordinateur. Une autre description, plus abstraite, se base sur le fait qu'un ordinateur est une énorme calculatrice programmable. Elle permet d'expliquer pourquoi il y a une distinction entre processeur et mémoire, entre unité centrale et périphériques. Tout ce qui va suivre pourra vous paraitre assez abstrait, mais rassurez-vous : les prochains chapitres rendront tout cela plus concrets.

===La séparation entre entrées-sorties et traitement===

L'unité centrale peut être vue comme une énorme calculatrice ultra-puissante, qui exécute des commandes/opérations. Mais à elle seule, elle ne servirait à rien, il faut interagir avec par l'intermédiaire de plusieurs périphériques. Il existe deux types de périphériques, qui sont conceptuellement différents. Les périphériques comme le clavier ou la souris permettent d'envoyer des informations à l'ordinateur, d'agir sur celui-ci. A l'inverse, les écrans transmettent des informations dans le sens inverse : de l'ordinateur vers l'utilisateur. Les premiers sont appelés des '''entrées''', les seconds des '''sorties'''.

Dans un ordinateur, les informations sont représentées sous la forme de nombres. Toute donnée dans un ordinateur est codée avec un ou plusieurs nombres regroupés dans une donnée, un fichier, ou autre. Et la transmissions avec les entrées et sorties se fait là-encore avec des nombres. Par exemple, quand vous appuyez sur votre clavier, le clavier envoie un numéro de touche à l'unité centrale, qui indique quelle touche a été appuyée. L'image à afficher à l'écran est codée sous la forme d'une suite de nombres (un par pixel). L'image est envoyée à l'écran, qui traduit la suite de nombre en image à afficher. Les entrées traduisent des actions utilisateurs en nombres, on dit que les entrées encodent les actions utilisateur. Les sorties font la traduction inverse, elles transforment des suites de nombres en une action physique. On dit qu'elles décodent des informations.

Pour résumer, toute appareil électronique est composé par :
* Des '''entrées''' sur lesquelles l'utilisateur agit sur l'ordinateur. Les entrées transforment les actions de l'utilisateur en nombres, qui sont interprétés par l'ordinateur.
* Une '''unité de traitement''', qui manipule des nombres et fait des calculs/opérations dessus. Les nombres proviennent des entrées, du disque dur, ou d'autres sources, peu importe.
* Des '''sorties''', qui va récupèrent le résultat calculé par l'unité de traitement pour en faire quelque chose : écrire sur une imprimante ou sur un moniteur, émettre du son,...

[[File:Ordinateur théorique Simple 1.png|centre|vignette|upright=2|Ordinateur théorique Simple 1]]

L'unité de traitement proprement dite, celle qui fait les calculs, est couplée à une mémoire qui mémorise les opérandes et résultats des calculs. La séparation entre processeur et mémoire est nécessaire pour qu'un appareil électronique soit qualifié d'ordinateur. De nombreux appareils n'ont pas de séparation entre unité de traitement et mémoire, comme certaines vielles radios AM/FM.

[[File:Schéma de principe d'un ordinateur.png|centre|vignette|upright=2|Schéma de principe d'un ordinateur]]

===Un ordinateur est un appareil programmable===

Les appareils simples sont non-programmables, ce qui veut dire qu’ils sont conçus pour une utilisation particulière et qu’ils ne peuvent pas faire autre chose. Par exemple, les circuits électroniques d’un lecteur de DVD ne peuvent pas être transformé en lecteur audio ou en console de jeux... Les circuits non-programmables sont câblés une bonne fois pour toute, et on ne peut pas les modifier. On peut parfois reconfigurer le circuit, pour faire varier certains paramètres, via des interrupteurs ou des boutons, mais cela s’arrête là. Et cela pose un problème : à chaque problème qu'on veut résoudre en utilisant un automate, on doit recréer un nouveau circuit.

À l'inverse, un ordinateur n’est pas conçu pour une utilisation particulière, contrairement aux autres objets techniques. Il est possible de modifier leur fonction du jour au lendemain, on peut lui faire faire ce qu’on veut. On dit qu'ils sont '''programmables'''. Pour cela, il suffit d’utiliser un logiciel, une application, un programme (ces termes sont synonymes), qui fait ce que l'on souhaite. La totalité des logiciels présents sur un ordinateur sont des programmes comme les autres, même le système d'exploitation (Windows, Linux, ...) ne fait pas exception.

Un programme est une suite de d''''instructions machines''', chaque instruction effectuant une action dans l'ordinateur. Sur les ordinateurs modernes, les instructions les plus communes effectuent une opération arithmétique : une addition, une multiplication, une soustraction, etc. Les ordinateurs modernes sont donc de grosses calculettes très puissantes, capables d'effectuer des millions d'opérations par secondes.

Et qui dit opération dit nombres : un ordinateur gère nativement des nombres, qui sont codés en binaire sur la quasi-totalité des ordinateurs modernes. Les ordinateurs modernes sont capables de faire des calculs sur des nombres entiers, mais aussi des nombres à virgule. Il existe plusieurs manières de représenter des nombres en binaire, certaines représentant des nombres entiers dits naturels (0 et plus), d'autres des nombres signés (positifs ou négatifs), d'autres des nombres à virgule. Un chapitre entier détaillera comment sont encodés ces nombres.

Une instruction est représentée dans un ordinateur par une série de nombres entiers : un nombre qui indique quelle opération/commande effectuer et des autres nombres pour coder les données (ou de quoi les retrouver dans l'ordinateur). L'ordinateur récupére les commandes une par une, les traduit en opération à effectuer, exécuter l'opération, et enregistre le résultat. Puis il recommence avec la commande suivante.

[[File:Ordinateur Théorique Complexe 1.png|centre|vignette|upright=3|Ordinateur Théorique Complexe. En jaune, le programme informatique, la liste de commande. Le rectangle gris est l'ordinateur proprement dit.]]

De nombreux appareils sont programmables, mais tous ne sont pas des ordinateurs. Par exemple, certains circuits programmables nommés FPGA n'en sont pas. Pour être qualifié d'ordinateur, un appareil programmable doit avoir un processeur séparé de la mémoire. De plus, il doit utiliser un '''codage numérique''', chose que nous allons aborder dans le chapitre suivant.

===Les ordinateurs à programme mémorisé ou programme externe===

[[File:Blue-punch-card-front.png|vignette|upright=0.5|Carte Perforée.]]

Au tout début de l'informatique, les programmes étaient enregistrés sur des cartes perforées, à savoir des cartes en papier/plastique percées par endroits. Un 1 est codé par un trou dans le papier et un 0 par une absence de trou. Les programmes étaient exécutés par l'ordinateur quand on insérait la carte perforée dans le lecteur et qu'on appuyait sur un bouton.

Par la suite, les premiers ordinateurs grand public, comme les Amstrad ou les Commodore, utilisaient des cassettes audio magnétiques pour stocker les programmes. Dans le même style, les consoles de jeu utilisaient autrefois des cartouches de jeu, qui contenaient le programme du jeu à exécuter. Pour résumer, les anciens ordinateurs mémorisaient les programmes sur un support externe, lu par un périphérique. De tels ordinateurs sont dits à '''programme externe'''.

: D’anciens ordinateurs personnels, comme l’Amstrad ou le Commodore, permettaient de taper les programmes à exécuter à la main, au clavier, avant d’appuyer une touche pour les exécuter. Nul besoin de vous dire que les cassettes audio étaient plus pratiques.

Mais de nos jours, les programmes sont enregistrés sur le disque dur de l'ordinateur ou dans une mémoire intégrée à l'ordinateur. On dit qu'ils sont installés, ce qui est un mot bien compliqué pour dire que le programme est enregistré sur le disque dur de l’ordinateur. A défaut de disque dur, le programme/logiciel est enregistré dans une mémoire spécialisée pour le stockage. Par exemple, sur les cartes électroniques grand public de marque Arduino, les programmes sont envoyés à la carte via le port USB, mais les programmes sont enregistrés dans la carte Arduino, dans une mémoire FLASH dédiée. Disque dur ou non, le programme est mémorisé dans la mémoire de l'ordinateur. Il est possible d'installer ou de désinstaller les programmes en modifiant le contenu de la mémoire. Le terme utilisé est alors celui de '''programme stocké en mémoire'''.

Les programmes à installer sont disponibles soit sur un périphérique, comme un DVD ou une clé USB, soit sont téléchargés depuis internet. Les premiers PC fournissaient les logiciels sur des disquettes, qui contenaient un programme d'installation pour enregistrer le programme sur le disque dur de l'ordinateur. Par la suite, le support des logiciels a migré vers les CD et DVD, les logiciels devenant de plus en plus gros. De nos jours, la majorité des applications sont téléchargées depuis le net, l'usage de périphériques est devenu obsolète, même les consoles de jeu abandonnent cette méthode de distribution.

==Les générations d'ordinateurs : un historique rapide==

L'informatique a beaucoup évolué dans le temps. Et une bonne partie de cette évolution tient à l'évolution de l’électronique sous-jacente. Les ordinateurs actuels sont fabriqués avec des transistors, des petits composants électroniques qui servent d'interrupteurs programmables, qu'on détaillera dans ce qui suit. Mais ça n'a pas toujours été le cas. Et cela permet de distinguer plusieurs '''générations d'ordinateurs'''.

===Les ordinateurs électro-mécaniques : les premiers ordinateurs===

Le tout premier ordinateur est le '''Z1''', un modèle unique inventé par Konrad Suze entre 1936 et 1938. Son processeur gérait non pas des nombres entiers, mais des nombres à virgule (des nombres dits flottants, pour être précis), encodés sur 22 bits. Le processeur du Z1 était capable de faire des additions et des soustractions, car il intégrait un circuit additionneur-soustracteur basique. Des circuits annexes permettaient de faire des multiplications et des divisions en enchainant des additions/soustractions successives. Il fonctionnait à une fréquence de 1 Hz, ce qui fait qu'il pouvait faire une addition/soustraction par seconde maximum.

Niveau mémoire, la RAM de l'ordinateur était très limitée : seulement 16 nombres de 22 bits chacun. S'il s'agissait d'une mémoire électronique, les programmes étaient mémorisés sur une mémoire mécanique et précisémment sur des cartes perforées, à savoir des cartes en papier/plastique dans lesquelles un 1 est codé par un trou dans le papier et un 0 par une absence de trou. Les programmes étaient exécutés par l'ordinateur quand on insérait la carte perforée dans le lecteur et qu'on appuyait sur un bouton.

[[File:German Museum of Technology, Berlin 2017 024.jpg|centre|vignette|upright=2|Réplique du Z1 au ''German Museum of Technology'' de Berlin, 2017.]]

Après sa destruction dans un bombardement, le Z1 a été reconstruit et amélioré, ce qui donné les deux ordinateurs Z2 et Z3. Quelques années plus tard, quelques laboratoires de recherche ont fabriqués des ordinateurs dans leur coin, comme le Harvard Mark I et le Colossus Mark 1 (UK) qui ont été mis en service en 1944. Ils ont servi pour les cryptanalystes pour casser les codes utilisés par les Allemands pour leurs transmissions, pendant la seconde guerre mondiale.

Les ordinateurs cités dans le précédent paragraphe étaient tous des ordinateurs dit '''électro-mécaniques''', car ils mélangeaient des composants électroniques et des composants mécaniques (tout ce qui a trait aux cartes perforées, notamment). Les composants électroniques étaient généralement des relais, à savoir des interrupteurs commandables électriquement, qui sont plus ou moins équivalents aux transistors modernes. La majeure partie des ordinateurs des années 40 étaient de ce type, mais leur nombre n'a pas dépassé 30. Il faut dire qu'ils ont rapidement laissé la place à des ordinateurs purement électroniques, que nous allons voir dans ce qui suit.

===La première génération : les tubes à vide===

Les ordinateurs qui ont suivi les ordinateurs électromécaniques sont regroupés dans la '''première génération d'ordinateur'''. Ils étaient conçus avec des tubes à vide, des espèces d'interrupteurs commandables, les ancêtres des transistors modernes. Les tubes à vide étaient assez encombrants, ils consommaient beaucoup de courant, ils chauffaient et étaient assez peu fiables. Ils tombaient en panne assez souvent. Et ils étaient assez simples à fabriquer, mais restaient malgré tout chers.

[[File:Elektronenroehren-auswahl.jpg|centre|vignette|upright=2|Tubes à vides.]]

L'usage de tubes à vide les place entre les premiers ordinateurs électro-mécaniques et les ordinateurs utilisant des transistors. Au vu de la taille des tubes à vide, les ordinateurs de l'époque étaient composés de plusieurs milliers de ces tubes, guère plus. Et malgré cela, un ordinateur prenait facilement un étage de bâtiment entier, ou au moins plusieurs pièces. La conséquence est que les ordinateurs de première génération étaient très simples, rudimentaires quand on les compare aux ordinateurs modernes. Ils ne géraient que quelques opérations simples : l'addition, la soustraction, pas grand-chose de plus. À quelques exceptions près, ils ne géraient pas la multiplication et encore moins la division, cela aurait demandé trop de tubes à vides.

Une des toutes premières machines construite avec des tubes à vide était l'Atanasoff–Berry. Ce n'était pas un ordinateur, car elle ne pouvait pas exécuter de programme sans intervention humaine pour séquencer des opérations, mais c'était la première machine de calcul purement électronique, sans aucune pièce mécanique. Elle utilisait une mémoire RAM construite avec des condensateurs, ceux-ci étant placés sur des cylindres tournants. Les circuits de calcul étaient construits avec des tubes à vide et faisaient leur travail un bit à la fois. Elle fonctionnait à une fréquence de 60 Hz et pouvait faire 30 additions/soustractions par seconde. Les nombres étaient encodés sur 50 bits. 

[[File:Atanasoff Berry Computer.gif|centre|vignette|upright=2.5|Atanasoff–Berry.]]

L'arrivée de l'ENIAC en 1945 a changé la donne. Cet ordinateur a introduit plusieurs innovations majeures. La première est assez technique, il s'agit de la turing-complétude, elle a trait aux programmes qui peuvent être écrit pour un ordinateur, nous ne la détaillerons pas ici.

[[File:BabyArchitecture.png|vignette|Architecture de la Manchester Baby.]]

En 1948, le ''Manchester Baby'' a introduit une innovation extrêmement importante : le programme n'était plus mémorisé sur des cartes perforées, mais dans une mémoire électronique à l’intérieur de l'ordinateur lui-même. En clair, le ''Manchester Baby'' était le premier '''ordinateur à programme stocké en mémoire''' en français. Au-delà de ça, le Manchester Baby restait quand même très simple, c'était limite un prototype.

Niveau interface, l'ordinateur avait une console avec 32 boutons, des interrupteurs et un écran de sortie sur lequel afficher les résultats. A l'intérieur, il y avait un processeur et une RAM de 32 nombres de 32 bits, fabriquées avec des tubes Williams (abordés dans une annexe à la fin du cours). Une instruction prenant autant de place qu'un nombre en RAM, ce qui limitait les programmes à 32 instructions maximum. Le processeur gérait 8 instructions en tout, mais la seule instruction de calcul qu'il gérait était la soustraction. L'addition n'était pas supportée. Il pouvait cependant émuler l'addition à partir d'une soustraction et inversant l'opérande soustrait.

Le Manchester Mark 1 était une amélioration du Manchester Baby. Il utilisait 4500 tubes à vide. L'ordinateur gérait des nombres de 40 bits, mais les instructions étaient codées sur 20 bits. La RAM avait la même taille, à savoir 32 nombres, leur taille était simplement augmentée. Par contre, la RAM était complémentée par l’ancêtre du disque dur magnétique, à savoir un tambour magnétique, l’ancêtre du disque dur magnétique. Il contenait 40 pages, chacune ayant la même taille que la RAM. Contrairement à la Manchester Baby, son processeur gérait l'addition et quelques opérations logiques (ET et OU), en plus de la soustraction et de la comparaison.

Par la suite, les ordinateurs commerciaux ont vu le jour. Les ordinateurs précédents provenaient de projets de recherches, souvent publics. Mais les entreprises privées se sont mises à fabriquer des ordinateurs elle-mêmes, pour les vendre à d'autres entreprises. On peut notamment citer les ordinateurs comme le UNIVAC I, le Bull Gamma 3 ou les premiers ordinateurs IBM. La performance de ces ordinateurs était nettement plus importante que leurs prédécesseurs, avec des fréquences de l'ordre de la centaine de kilo-hertz. Par exemple, le Bull Gamma 3 allait à 281 kHz, l'IBM 650 allait à 50 Khz.

===La seconde génération : le remplacement des tubes à vides par des transistors===

[[File:IBM 7070.jpg|vignette|Cartes imprimées de l'IBM 704, avec des transistors et résistances dessus.]]

La '''seconde génération''' est celle des ordinateurs fabriqués avec des '''transistors''' isolés, reliés entre avec des fils électriques. Les transistors en question possèdent trois broches, des pattes métalliques sur lesquelles on connecte des fils électriques. Le transistor s'utilise le plus souvent comme un interrupteur commandé par sa troisième broche. Le courant qui traverse les deux premières broches passe ou ne passe pas selon ce qu'on met sur la troisième.

[[File:Transistor basic flow.svg|centre|vignette|Un transistor est un morceau de conducteur, dont la conductivité est contrôlée par sa troisième broche/borne.]]

Les ordinateurs de seconde génération avaient entre 1000 et 500 000 transistors. Les capacités des ordinateurs étaient donc nettement supérieures à celles des ordinateurs de première génération. Une part non négligeable des ordinateurs de seconde génération supportait l'opération de multiplication, absente sur les ordinateurs de première génération. Néanmoins, cela variait beaucoup selon les ordinateurs.

Un exemple assez hors du commun est celui du premier modèle de l'IBM 1620. Le tout premier modèle n'avait aucun circuit de calcul, il n'était même pas capable de faire une addition ou une multiplication. A la place, il utilisait une table d'addition et une table de multiplication en mémoire RAM. Les deux tables devaient être initialisées par le logiciel lors du démarrage de la machine. La table d'addition faisait une centaine de chiffres, la table de multiplication faisait le double. Le processeur de l'ordinateur gérait des instructions pour faire des additions ou des multiplications, mais ces opérations lisaient le résultat dans la table d'addition. Les calculs étaient faits chiffre par chiffre, avec un encodage partiellement décimal, partiellement binaire (des chiffres décimaux étaient encodés en binaire, nous en reparlerons quand nous parlerons du BCD) !

[[File:KL CoreMemory.jpg|vignette|Mémoire à tore de ferrite.]]

Les transistors n'étaient utilisés que pour le processeur et les circuits annexes. La mémoire n'était pas faite en transistors, pas à cette époque. La mémoire était une mémoire aujourd'hui abandonnée, appelée une '''mémoire à tores de ferrite'''. Elle sera détaillée dans un chapitre ultérieur. Mais sachez pour le moment qu'il s'agit d'une mémoire au support magnétique, les données étant stockées sur un support magnétique.

Transistors comme tubes à vide prenaient beaucoup de place, ce qui fait que les ordinateurs étaient assez gros. Concrètement, ils prenaient une pièce de bâtiment entière dans le meilleur des cas. C'était l'époque des gros ''mainframes'', reliés à des terminaux, peu puissants comparé aux standards actuels. Seules les grandes entreprises et les grands instituts de recherche pouvaient se payer les services de ce genre d'ordinateurs. Seuls les professionnels avaient accès à ce genre d'équipement.

===La troisième génération : le circuit intégré===

[[File:D8259AC-2.jpg|vignette|Exemple de circuit intégré.]]

La troisième génération est toujours fabriquée avec des transistors, mais dont la taille a été réduite. Avec l'évolution de la technologie, les transistors ont diminué en taille, de plus en plus. Ils sont devenus tellement petits qu'ils ont fini par être regroupés dans des '''circuits intégrés''', des circuits regroupent plusieurs transistors sur la même puce de silicium. Les circuits intégrés se présentent le plus souvent sous la forme de boitiers rectangulaires, comme illustré ci-contre. D'autres ont des boitiers de forme carrées, comme ceux que l'on peut trouver sur les barrettes de mémoire RAM, ou à l'intérieur des clés USB/ disques SSD.

Lors de cette génération, les processeurs étaient fournis en pièces détachées qu'il fallait relier entre elles. Le processeur était composé de plusieurs circuits intégrés séparés, impossible de mettre un processeur dans un seul boitier. Un exemple de processeur conçu en kit est la série des Intel 3000. Elle regroupe plusieurs circuits séparés aux noms à coucher dehors, mais dont vous comprendrez ce qu'ils veulent dire dans les chapitres adéquats : l'Intel 3001 est un séquenceur, l'Intel 3002 regroupe unité de calcul et registres, le 3003 est un circuit d'anticipation de retenue complémentaire du 3002, le 3212 est une mémoire tampon, le 3214 est une unité de gestion des interruptions, les 3216/3226 sont des interfaces de bus mémoire. On pourrait aussi citer la famille de circuits intégrés AMD Am2900.

Même si le processeur était en pièces détachées, utiliser une dizaine de circuits intégrés était nettement mieux que d'utiliser plusieurs milliers de transistors individuels. En conséquence, les ordinateurs ont vu leur taille grandement réduite, passant de pièces entières à une simple armoire, voire à quelques cartes intégrées superposées. De plus, le prix des circuits intégré était abordable, du moins comparé aux ordinateurs d'avant. Le prix des ordinateurs a alors grandement décru, permettant à des entreprises et administrations de taille modeste de s'équiper d'ordinateurs.

===La quatrième génération : le microprocesseur===

[[File:MOS6502.svg|vignette|Microprocesseur, ici un processeur MOS6502, de la quatrième génération.]]

Lors de la troisième génération, les circuits intégrés regroupaient plusieurs dizaines ou centaines de transistors, mais sont rapidement montés en gamme. De centaines de transistors, ils sont passés au millier de transistors, puis au million et maintenant au-delà du milliard. Les transistors étaient devenus tellement petits, tellement miniaturisés, qu'il était devenu possible de mettre un processeur entier dans un circuit intégré. C'est ainsi qu'est né le microprocesseur, à savoir un processeur qui tient tout entier dans un seul circuit imprimé. La quatrième génération d’ordinateur est celle des ordinateurs basés autour d'un microprocesseur.

Les tout premiers microprocesseurs étaient des processeurs à application militaire, comme le processeur du F-14 CADC ou celui de l'Air data computer. Le tout premier microprocesseur commercialisé au grand public est le 4004 d'Intel, sorti en 1971. L'intel 4004 comprenait environ 2300 transistors, avait une fréquence de 740 MHz, pouvait faire 46 opérations différentes, et manipulait des entiers de 4 bits. Il était au départ un processeur de commande, prévu pour être intégré dans la calculatrice Busicom calculator 141-P, mais il fut utilisé pour d'autres applications quelque temps plus tard. Immédiatement après le 4004, les premiers microprocesseurs 8 bits furent commercialisés. Le 4004 fut suivi par le 8008 et quelques autres processeurs 8 bits extrêmement connus, comme le 8080 d'Intel, le 68000 de Motorola, le 6502 ou le Z80.

Les microprocesseurs permirent encore uen fois de réduire la taille des ordinateurs, qui pouvaient tenir dans un boitier de PC, ou un boitier de console de jeu. Le prix des ordinateurs a aussi chuté en même temps que les transistors étaient miniaturisés. C'est cette invention qui permis l'invention des consoles de jeux et des mini-ordinateurs, à savoir les ordinateurs personnels. Sans miniaturisation, on n'aurait pas d'ordinateur personnel, pas de PC fixe ou portable.

==L'organisation du cours : les différents niveaux d'explication==

Le fonctionnement d'un ordinateur est assez complexe à expliquer car les explications peuvent se faire sur plusieurs niveaux. Par plusieurs niveaux, on veut dire qu'un ordinateur est composé de composants très simples, qui sont assemblés pour donner des composants eux-même plus complexes, qui sont eux-même regrouper, etc. Étudier tout cela demande de voir plusieurs niveaux, allant de transistors très petits à des processeurs multicœurs. Les niveaux les plus bas sont de l'électronique pur et dure, alors que ceux plus haut sont à mi-chemin entre électronique et informatique.

===Les niveaux d'abstraction en architecture des ordinateurs===

Les trois premiers niveaux sont de l'électronique pur et dure. Ils correspondent aux premiers chapitres du cours, qui porteront sur les circuits électroniques en général.
* Le premier niveau est celui des '''transistors''', des circuits intégrés, des ''wafer'' et autres circuits de très petite taille.
* Le second niveau est celui des '''portes logiques''', des circuits très basiques, très simples, à la base de tous les autres.
* Le troisième niveau est celui dit de la '''''Register Transfer Level''''', où un circuit électronique est construit à partir de circuits basiques, dont des registres et autres circuits dits combinatoires.
Les deux niveaux suivants sont de l'informatique proprement dit. C'est dans ces deux niveaux qu'on étudie les ordinateurs proprement dit, les circuits qu'il y a dedans et non l'électronique en général.
* Le quatrième niveau est celui de la '''microarchitecture''', qui étudie ce qu'il y a à l'intérieur d'un processeur, d'une mémoire, des périphériques et autres.
* Le cinquième niveau est celui de l''''architecture externe''', qui décrit l'interface du processeur, de la mémoire, d'un périphérique ou autre. Par décrire l'interface, on veut dire : comment un programmeur voit le processeur et la mémoire, comment il peut les manipuler. Une architecture externe unique peut avoir plusieurs microarchitecture, ce qui fait qu'on sépare les deux. Tout cela sera plus clair quand on passera aux chapitres sur le processeur et les mémoires.

Nous n'allons pas voir les 5 niveaux dans l'ordre, des transistors vers l'architecture externe. En réalité, nous allons procéder autrement. La première partie du cours portera sur les trois premiers niveaux, le reste sur les deux autres. Les 5 niveaux seront vus dans des chapitres séparés, du moins le plus possible. Au niveau pédagogique, tout est plus simple si on scinde les 5 niveaux. Bien sûr, il y a quelques explications qui demandent de voir plusieurs niveaux à la fois. Par exemple, dans le chapitre sur les mémoires caches, nous auront des explications portant sur la RTL, la microarchitecture du cache et son architecture externe. Mais le gros du cours tentera de séparer le plus possible les 5 niveaux.

===Les trois parties principales du cours===

Nous allons commencer par parler du binaire, avant de voir les portes logiques. Avec ces portes logiques, nous allons voir comment fabriquer des circuits basiques qui reviendront très souvent dans la suite du cours. Nous verrons les registres, les décodeurs, les additionneurs et plein d'autres circuits. Puis, nous reviendrons au niveau des transistors pour finir la première partie. La raison est que c'est plus simple de faire comme cela. Tout ce qui a trait aux transistors sert à expliquer comment fabriquer des portes logiques, et il faut expliquer les portes logiques pour voir le niveau de la RTL.

Une fois la première partie finie, nous allons voir les différents composants d'un ordinateur. Une première partie expliquera ce qu'il y a dans un ordinateur, quels sont ses composants. Nous y parlerons de l'architecture de base, de la hiérarchie mémoire, des tendances technologiques, et d'autres généralités qui serviront de base pour la suite. Puis, nous verrons dans l'ordre les bus électroniques, les mémoires RAM/ROM, le processeur, les périphériques, les mémoires de stockage (SSD et disques durs) et les mémoires caches. Pour chaque composant, nous allons voir leur architecture externe, avant de voir leur microarchitecture. La raison est que la microarchitecture ne peut se comprendre que quand on sait quelle architecture externe elle implémente.

Enfin, dans une troisième partie, nous allons voir les optimisations majeures présentes dans tous les ordinateurs modernes, avec une partie sur le pipeline et le parallélisme d'instruction, et une autre sur les architectures parallèles. Pour finir, les annexes de fin parlerons de sujets un peu à part.

&lt;noinclude&gt;
{{NavChapitre | book=Fonctionnement d'un ordinateur
           | next=L'encodage des données
           | nextText=L'encodage des données
}}
&lt;/noinclude&gt;</text>
      <sha1>k8qicxk26kcfr1js1be759w6p5kphrw</sha1>
    </revision>
    <revision>
      <id>744161</id>
      <parentid>744153</parentid>
      <timestamp>2025-06-05T14:35:17Z</timestamp>
      <contributor>
        <username>Mewtow</username>
        <id>31375</id>
      </contributor>
      <minor />
      <comment>/* La première génération : les tubes à vide */</comment>
      <origin>744161</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="46137" sha1="2naw81yydt3l8anajqihf7csne6ay87" xml:space="preserve">Pour commencer, nous allons voir qu'il existe de nombreux types d'ordinateurs. Le plus connu est certainement le PC, l'ordinateur personnel, que vous avez sans doute dans votre salon. Les ordinateurs portables sont un deuxième type d'ordinateur assez intuitif, que vous avez peut-être. Mais il y a aussi d'autres types d'ordinateurs auxquels vous n'avez jamais été confrontés.

==Les différents types d'ordinateurs==

Dans cette section, nous allons décrire rapidement les ordinateurs les plus courant, mais surtout voir ce qu'il y a à l'intérieur d'un ordinateur.

===L'ordinateur de type PC fixe===

De l'extérieur, l'ordinateur est composé d'une unité centrale sur laquelle on branche des périphériques.

[[File:Typical computer architecture systems.jpg|vignette|upright=1.5|Exemples de périphériques, connectés à une unité centrale (ici appelée à tort ''operating system'').]]

Les '''périphériques''' regroupent l'écran, la souris, le clavier, l'imprimante, et bien d'autres choses. Ils permettent à l'utilisateur d'interagir avec l'ordinateur : un clavier permet de saisir du texte sous dans un fichier, une souris enregistre des déplacements de la main en déplacement du curseur, un écran affiche des données d’images/vidéos, un haut-parleur émet du son, etc. Tout ce qui est branché sur un ordinateur est, formellement un périphérique.

L''''unité centrale''' est là où se trouvent tous les composants importants d'un ordinateur, ceux qui font des calculs, qui exécutent des logiciels, qui mémorisent vos données, etc. Voici ce à quoi ressemble l'intérieur de l'unité centrale. Trois sections sont visibles : l'alimentation électrique en haut à gauche, la carte mère en bas à gauche et en jaune/orange, les disques et lecteurs à droite des câbles. Et on voit aussi beaucoup de câbles.

[[File:Asus P5K-SEIntel E6320.jpg|centre|vignette|upright=2|Exemple d'unité centrale.]]

Tout en haut à gauche, se trouve l''''alimentation électrique''', qui convertit le courant de la prise électrique en un courant plus faible, utilisable par les autres composants. Elle émet de nombreux câbles assez gros, qui sont reliés au reste. Les PC actuels utilisent des alimentations électriques standardisées, qui fournissent trois tensions au reste de l'ordinateur : une tension de 12 Volts, une de 5 Volts, une de 3,3 Volts.

À droite, caché par la partie &quot;métallique&quot; du boitier, se trouvent les lecteurs de CD/DVD, et les disques durs. Les lecteurs CD-ROM ou DVD-ROM permettaient de lire des CD ou des DVD. Je parle au passé, car ils ont aujourd'hui disparu des ordinateurs modernes. Les '''disques durs''' sont des mémoires de stockage, qui mémorisent vos données de manière permanente. De nos jours, ils sont remplacés par des SSD, qui sont des disques durs électroniques, là où les disques durs proprement dit sont des mémoires magnétiques. Nous verrons la différence dans deux chapitres dédiés, un sur les disques durs, l'autre sur les SSD.

En bas à droite, se trouve la '''carte mère''' un support plat, en plastique ou en céramique, sur laquelle sont soudés/connectés les autres composants. Sur celle-ci, de nombreux composants sont soudés, d'autres sont branchés dessus avec des câbles, d'autres sont connectés dessus avec des connecteurs. Ils sont reliés entre eux par des fils conducteurs, le plus souvent du cuivre ou de l’aluminium, ce qui leur permet de s’échanger des données. Sur les cartes simples, ces fils sont intégrés dans la carte électronique, dans des creux du plastique. Ils portent le nom de pistes.

Avant, les disques durs, SSD et lecteurs de CD/DVD sont branchés dessus via des connecteurs dédiés, appelés des connecteurs S-ATA. De nos jours, ils sont branchés sur un autre connecteur, grâce à l'interface NVME. Toujours est-il qu'ils sont reliés à la carte mère par des câbles, ce qui montre que ce sont des sortes de périphériques interne. Ils sont placés dans le boitier, mais on aurait tout aussi bien pu les mettre à l'extérieur, vu qu'ils communiquent avec l'ordinateur par l'intermédiaire d'un câble ou d'un connecteur dédié.

Mais deux autres composants très importants sont eux placés sur la carte mère, directement. Ils ont chacun un connecteur dédié, sur lequel ils sont branchés directement, sans passer par l'intermédiaire d'un câble, mais sans être soudés non plus. Il s'agit du processeur et de la mémoire RAM, deux composants centraux des PC modernes.

[[File:Pentium III SL4CB.jpg|thumb|Processeur Pentium III.]]

Le '''processeur''' traite les données, les modifie, les manipule. Pour faire simple, il s’agit d’une grosse calculatrice hyper-puissante. Il comprend à la fois un circuit qui fait des calculs, et un circuit de contrôle qui s'occupe de séquencer les calculs dans l'ordre demandé. Il est souvent caché sous un radiateur, lui-même surmonté par un ventilateur. En effet, un processeur chauffe beaucoup, ce qui demande d'évacuer cette chaleur. Un chapitre entier expliquera pourquoi les processeurs chauffent, ainsi que les techniques utilisées pour limiter leur production de chaleur et leur consommation électrique.

La '''mémoire vive''' conserve des informations/données temporairement, tant que le processeur en a besoin. Elle prend la forme de barrettes de RAM, comme montré ci-dessous.

[[File:2 gb ddr2 667.jpg|centre|vignette|upright=2|Barrette de RAM.]]

Outre ces composants dits principaux, un ordinateur peut comprendre plusieurs composants moins importants, surtout présents sur les ordinateurs personnels. Ils sont techniquement facultatifs, mais sont très présents dans les ordinateurs personnels. Cependant, certains ordinateurs spécialisés s'en passent. Il s'agit des diverses '''cartes d'extension''' sont branchées sur la carte mère. Elles permettent d’accélérer certains calculs ou certaines applications, afin de décharger le processeur. Par exemple, la carte graphique s'occupe des calculs graphiques, qu'il s'agisse de graphismes 3D de jeux vidéos ou de l'affichage en 2D du bureau. Dans un autre registre, la carte son prend en charge le microphone et les haut-parleurs.

[[Fichier:Personal computer, exploded 4.svg|thumb|upright=1.0|Éclaté d'un ordinateur de type PC :&lt;br /&gt;
1 : Écran ;&lt;br /&gt;
2 : Carte mère ;&lt;br /&gt;
3 : Processeur ;&lt;br /&gt;
4 : Câble Parallel ATA ;&lt;br /&gt;
5 : Mémoire vive (RAM) ;&lt;br /&gt;
6 : Carte d'extension ;&lt;br /&gt;
7 : Alimentation électrique ;&lt;br /&gt;
8 : Lecteur de disque optique ;&lt;br /&gt;
9 : Disque dur ;&lt;br /&gt;
10 : Clavier ;&lt;br /&gt;
11 : Souris.]]

Si on regarde une carte mère de face, on voit un grand nombre de connecteurs, mais aussi des circuits électroniques soudés à la carte mère.

[[File:Architecture matérielle d'une carte mère.png|centre|vignette|upright=2.0|Architecture matérielle d'une carte mère]]

Les '''connecteurs''' sont là où on branche les périphériques, la carte graphique, le processeur, la mémoire, etc. Dans l'ensemble, toute carte mère contient les connecteurs suivants :
* Le processeur vient s’enchâsser dans la carte mère sur un connecteur particulier : le '''socket'''. Celui-ci varie suivant la carte mère et le processeur, ce qui est source d'incompatibilités.
* Les barrettes de mémoire RAM s’enchâssent dans un autre type de connecteurs: les '''slots mémoire'''.
* Les mémoires de masse disposent de leurs propres connecteurs : connecteurs P-ATA pour les anciens disques durs, et S-ATA pour les récents.
* Les périphériques (clavier, souris, USB, Firewire, ...) sont connectés sur un ensemble de connecteurs dédiés, localisés à l'arrière du boitier de l'unité centrale. 
* Les autres périphériques sont placés dans l'unité centrale et sont connectés via des connecteurs spécialisés. Ces périphériques sont des cartes imprimées, d'où leur nom de '''cartes filles'''. On peut notamment citer les cartes réseau, les cartes son, ou les cartes vidéo.

===Les ordinateurs portables===

[[File:Samsung QX-511 (2).JPG|vignette|Ordinateur portable Samsung QX-511 (2), pour illustration.]]

Un ordinateur portable est identique à un ordinateur de type PC. Si vous ouvrez votre ordinateur portable (attention à la garantie), vous retrouverez les mêmes composants qu'un PC à l'intérieur. Un point important est la présence d'une batterie à l'intérieur du PC portable, absente des PC fixes.

[[File:LG gram 14Z90Q mainboard with battery.jpg|centre|vignette|upright=2|LG gram 14Z90Q avec sa batterie.]]

Une fois la batterie et les circuits associés retiré, la seule différence notable est que tous les composants sont soudés sur la carte mère, au lieu d'être branchés sur des connecteurs, à part éventuellement la RAM et le disque dur.

[[File:LG gram 14Z90Q mainboard without battery.jpg|centre|vignette|upright=2|LG gram 14Z90Q sans sa batterie.]]

La RAM est parfois soudée sur la carte mère, d'autres fois sous la forme de barrettes de mémoire vive semblables à celles des PC. Dans le dernier cas, elle est connectée à des connecteurs spécifiques, ce qui permet de les changer/upgrader. Les PC portables sont parfois construits de manière à pouvoir changer la RAM facilement, en ouvrant un cache spécial, concu pour.

[[File:Lenovo G555 состав - Донор.JPG|centre|vignette|upright=2|Lenovo G555.]]

La conception d'un ordinateur portable est légèrement différente de celle d'un PC, pour des raisons thermiques. Un PC fixe a plus de place pour évacuer sa chaleur. Les ventilateurs peuvent plus facilement déplacer l'air dans le boitier, même si le flux d'air dans le boitier est éventuellement gêné par la carte graphique. Mais l'évacuation de la chaleur est assez efficace. Sur les PC portables, leur finesse fait que le trajet de l'air est beaucoup plus contraint. Évacuer la chaleur produite par l'ordinateur est plus complexe, ce qui demande d'utiliser des systèmes de refroidissement et de ventilation spécifiques.

Là où les PC fixes se débrouillent avec des radiateurs et des ventilateurs posés sur le processeur, les PC portables font autrement. Ils ne peuvent pas forcément mettre le ventilateur sur le processeur. A la place, ils mettent le ventilateur à côté, mais le processeur est surmonté par un mécanisme de transmission de la chaleur, qui transfère la chaleur du processeur vers le ventilateur.

[[File:Diagram - How a laptop cooling system works.png|centre|vignette|upright=2|Comment fonctionne le système de ventilation d'un ordinateur portable, en anglais.]]

Les difficultés pour dissiper la chaleur font que les ordinateurs portables utilisent souvent des composants peu performants, mais qui chauffent peu. En effet, nous verrons que plus un composant est puissant, plus il chauffe. La relation n'est pas parfaite, mais les processeurs haute performance chauffent plus que les modèles d'entrée ou milieu de gamme moins puissants. En conséquence, les PC portables sont souvent moins puissants que les PC fixes, même pour les modèles dit ''gaming''.

===Les serveurs et ''mainframes''===

Les grandes entreprises utilisent des ordinateurs de grande taille, très puissants, appelés des ''mainframes''. Ils sont souvent confondus avec les serveurs par le grand public, il y a une différence entre les deux. Un serveur est une fonction logicielle/réseau, pas un type d'ordinateur. Mais laissons cette différence de côté, ce qui est dit pour les ''mainframes'' sert pour les gros serveurs haute performance.

[[File:IBM Z15 mainframe.jpg|vignette|Exemple de ''mainframe''' de type IBM Z15.]]

Les anciens ''mainframes'' des années 50-80 avaient une taille pouvant être impressionnante, au point de prendre une pièce complète d'un bâtiment. Mais de nos jours, les ''mainframes'' tiennent dans une grosse armoire un peu haute. Les ''mainframes'' doivent rester allumé en permanence et ne doivent pas être éteint, sauf éventuellement quelques jours par an pour des opérations de maintenance. Ils utilisent pour cela des techniques spécifiques, avec beaucoup de redondance interne.

[[File:ACONIT hall grandes machines.jpg|centre|vignette|upright=2|''Mainframe'' ACONIT.]]

Les ''mainframes'' sont aussi conçus pour mutualiser au maximum leur utilisation, ils peuvent être utilisés par plusieurs utilisateurs à la suite, voire en même temps. Pour cela, les anciens ''mainframes'' étaient capables de faire tourner plusieurs applications distinctes l'une à la suite de l'autre, avec des commutations fréquentes entre logiciels. De nos jours, ils sont capables d'exécuter un grand nombre de tâches en même temps, grâce à la présence de plusieurs processeurs. Les ''mainframes'' modernes sont même capables de faire tourner plusieurs systèmes d'exploitation en même temps si besoin.

Les anciens ''mainframes'' étaient des ordinateurs assez simples, avec un processeur, de la mémoire RAM, un ou plusieurs disques durs, pas plus. Le ''mainframe'' était tellement énorme et cher que les entreprises n'en avaient qu'un seul pour toute l'entreprise. Les employés avaient sur leur bureau des terminaux, qui permettaient d'accéder à l'ordinateur central, mais n'étaient pas des ordinateurs. Les terminaux étaient des composants électroniques simples, avec un écran, un clavier et une souris, mais sans processeur. Ils envoyaient des données au ''mainframe'', ils en recevaient de sa part, mais tout traitement était réalisé sur le ''mainframe''. L'arrivée sur le marché des ordinateurs personnels, de type PC fixe/portable, a entrainé l'abandon de ce genre de pratique, tous les employés ont maintenant un ordinateur rien que pour eux.

{|
|-
! colspan=&quot;2&quot; | Exemples de terminaux
|-
|[[File:Terminal-in2-sm9400.jpg|centre|vignette|upright=1.5|Exemple de terminal. Notez la présence d'un écran et d'un clavier, mais l'asbence d'une unité centrale.]]
|[[File:Chromatics CT4100.jpg|vignette|upright=1.5|Autre exemple de terminal. Le clavier est couplé à un stylo CRT, qui remplacait la souris et agissait sur l'écran comme s'il était tactile.]]
|-
! colspan=&quot;2&quot; | Intérieur d'un terminal
|-
|[[File:CT1024 Monitor.jpg|vignette|upright=1.5|Terminal CT1024, sans le boitier extérieur.]]
|[[File:CT1024 Terminal System.jpg|vignette|upright=1.5|Terminal CT1024, description des composants interne.]]
|}

De nos jours, les ''mainframes'' contiennent en réalité plusieurs ordinateurs simples interconnectés via un réseau local. Un ''mainframe'' qui tient dans une armoire contient facilement une dizaine ou centaine de processeurs, plein de RAM, des disques durs séparés dans une armoire distincte, etc. Vu qu'ils communiquent uniquement via le réseau, ils n'ont pas d'interface, pas d'écran, 'entrée via clavier/souris. Le tout est commandé avec une console de commande, typiquement un ordinateur portable ou un terminal assez simple séparé de l'armoire, qui permet à un administrateur de faire des opérations de surveillance, configuration et maintenance. Il peut y avoir une console de commande pour plusieurs armoires séparées, la console peut même être dans un autre bâtiment et accéder au ''mainframe'' par le réseau.

[[File:IBM System Z9 (type 2094 inside).jpg|centre|vignette|upright=2|''Mainframe'' de type IBM System Z9. L'ordinateur portable sert de console pour qu'un administrateur fasse des opérations de surveillance, configuration et maintenance.]]

Les processeurs et la RAM sont typiquement installés sur des cartes amovibles, qui sont connectées au fond de l'armoire lors de l'installation. Il est même possible de retirer ou d'ajouter des cartes en fonctionnement, afin d'ajouter/retirer des processeurs, des disques durs, etc. Ce qui est très utile si un composant est en panne et qu'il faut le remplacer. 

[[File:IBM TotalStorage Exp400.jpg|centre|vignette|upright=2|IBM TotalStorage Exp400]]

==Un peu d'abstraction : qu'est-ce qu'un ordinateur ?==

Un ordinateur comprend donc un processeur, plusieurs mémoires, des cartes d'extension et une carte mère pour connecter le tout. Mais il s'agit là d'une description assez terre-à-terre de ce qu'est un ordinateur. Une autre description, plus abstraite, se base sur le fait qu'un ordinateur est une énorme calculatrice programmable. Elle permet d'expliquer pourquoi il y a une distinction entre processeur et mémoire, entre unité centrale et périphériques. Tout ce qui va suivre pourra vous paraitre assez abstrait, mais rassurez-vous : les prochains chapitres rendront tout cela plus concrets.

===La séparation entre entrées-sorties et traitement===

L'unité centrale peut être vue comme une énorme calculatrice ultra-puissante, qui exécute des commandes/opérations. Mais à elle seule, elle ne servirait à rien, il faut interagir avec par l'intermédiaire de plusieurs périphériques. Il existe deux types de périphériques, qui sont conceptuellement différents. Les périphériques comme le clavier ou la souris permettent d'envoyer des informations à l'ordinateur, d'agir sur celui-ci. A l'inverse, les écrans transmettent des informations dans le sens inverse : de l'ordinateur vers l'utilisateur. Les premiers sont appelés des '''entrées''', les seconds des '''sorties'''.

Dans un ordinateur, les informations sont représentées sous la forme de nombres. Toute donnée dans un ordinateur est codée avec un ou plusieurs nombres regroupés dans une donnée, un fichier, ou autre. Et la transmissions avec les entrées et sorties se fait là-encore avec des nombres. Par exemple, quand vous appuyez sur votre clavier, le clavier envoie un numéro de touche à l'unité centrale, qui indique quelle touche a été appuyée. L'image à afficher à l'écran est codée sous la forme d'une suite de nombres (un par pixel). L'image est envoyée à l'écran, qui traduit la suite de nombre en image à afficher. Les entrées traduisent des actions utilisateurs en nombres, on dit que les entrées encodent les actions utilisateur. Les sorties font la traduction inverse, elles transforment des suites de nombres en une action physique. On dit qu'elles décodent des informations.

Pour résumer, toute appareil électronique est composé par :
* Des '''entrées''' sur lesquelles l'utilisateur agit sur l'ordinateur. Les entrées transforment les actions de l'utilisateur en nombres, qui sont interprétés par l'ordinateur.
* Une '''unité de traitement''', qui manipule des nombres et fait des calculs/opérations dessus. Les nombres proviennent des entrées, du disque dur, ou d'autres sources, peu importe.
* Des '''sorties''', qui va récupèrent le résultat calculé par l'unité de traitement pour en faire quelque chose : écrire sur une imprimante ou sur un moniteur, émettre du son,...

[[File:Ordinateur théorique Simple 1.png|centre|vignette|upright=2|Ordinateur théorique Simple 1]]

L'unité de traitement proprement dite, celle qui fait les calculs, est couplée à une mémoire qui mémorise les opérandes et résultats des calculs. La séparation entre processeur et mémoire est nécessaire pour qu'un appareil électronique soit qualifié d'ordinateur. De nombreux appareils n'ont pas de séparation entre unité de traitement et mémoire, comme certaines vielles radios AM/FM.

[[File:Schéma de principe d'un ordinateur.png|centre|vignette|upright=2|Schéma de principe d'un ordinateur]]

===Un ordinateur est un appareil programmable===

Les appareils simples sont non-programmables, ce qui veut dire qu’ils sont conçus pour une utilisation particulière et qu’ils ne peuvent pas faire autre chose. Par exemple, les circuits électroniques d’un lecteur de DVD ne peuvent pas être transformé en lecteur audio ou en console de jeux... Les circuits non-programmables sont câblés une bonne fois pour toute, et on ne peut pas les modifier. On peut parfois reconfigurer le circuit, pour faire varier certains paramètres, via des interrupteurs ou des boutons, mais cela s’arrête là. Et cela pose un problème : à chaque problème qu'on veut résoudre en utilisant un automate, on doit recréer un nouveau circuit.

À l'inverse, un ordinateur n’est pas conçu pour une utilisation particulière, contrairement aux autres objets techniques. Il est possible de modifier leur fonction du jour au lendemain, on peut lui faire faire ce qu’on veut. On dit qu'ils sont '''programmables'''. Pour cela, il suffit d’utiliser un logiciel, une application, un programme (ces termes sont synonymes), qui fait ce que l'on souhaite. La totalité des logiciels présents sur un ordinateur sont des programmes comme les autres, même le système d'exploitation (Windows, Linux, ...) ne fait pas exception.

Un programme est une suite de d''''instructions machines''', chaque instruction effectuant une action dans l'ordinateur. Sur les ordinateurs modernes, les instructions les plus communes effectuent une opération arithmétique : une addition, une multiplication, une soustraction, etc. Les ordinateurs modernes sont donc de grosses calculettes très puissantes, capables d'effectuer des millions d'opérations par secondes.

Et qui dit opération dit nombres : un ordinateur gère nativement des nombres, qui sont codés en binaire sur la quasi-totalité des ordinateurs modernes. Les ordinateurs modernes sont capables de faire des calculs sur des nombres entiers, mais aussi des nombres à virgule. Il existe plusieurs manières de représenter des nombres en binaire, certaines représentant des nombres entiers dits naturels (0 et plus), d'autres des nombres signés (positifs ou négatifs), d'autres des nombres à virgule. Un chapitre entier détaillera comment sont encodés ces nombres.

Une instruction est représentée dans un ordinateur par une série de nombres entiers : un nombre qui indique quelle opération/commande effectuer et des autres nombres pour coder les données (ou de quoi les retrouver dans l'ordinateur). L'ordinateur récupére les commandes une par une, les traduit en opération à effectuer, exécuter l'opération, et enregistre le résultat. Puis il recommence avec la commande suivante.

[[File:Ordinateur Théorique Complexe 1.png|centre|vignette|upright=3|Ordinateur Théorique Complexe. En jaune, le programme informatique, la liste de commande. Le rectangle gris est l'ordinateur proprement dit.]]

De nombreux appareils sont programmables, mais tous ne sont pas des ordinateurs. Par exemple, certains circuits programmables nommés FPGA n'en sont pas. Pour être qualifié d'ordinateur, un appareil programmable doit avoir un processeur séparé de la mémoire. De plus, il doit utiliser un '''codage numérique''', chose que nous allons aborder dans le chapitre suivant.

===Les ordinateurs à programme mémorisé ou programme externe===

[[File:Blue-punch-card-front.png|vignette|upright=0.5|Carte Perforée.]]

Au tout début de l'informatique, les programmes étaient enregistrés sur des cartes perforées, à savoir des cartes en papier/plastique percées par endroits. Un 1 est codé par un trou dans le papier et un 0 par une absence de trou. Les programmes étaient exécutés par l'ordinateur quand on insérait la carte perforée dans le lecteur et qu'on appuyait sur un bouton.

Par la suite, les premiers ordinateurs grand public, comme les Amstrad ou les Commodore, utilisaient des cassettes audio magnétiques pour stocker les programmes. Dans le même style, les consoles de jeu utilisaient autrefois des cartouches de jeu, qui contenaient le programme du jeu à exécuter. Pour résumer, les anciens ordinateurs mémorisaient les programmes sur un support externe, lu par un périphérique. De tels ordinateurs sont dits à '''programme externe'''.

: D’anciens ordinateurs personnels, comme l’Amstrad ou le Commodore, permettaient de taper les programmes à exécuter à la main, au clavier, avant d’appuyer une touche pour les exécuter. Nul besoin de vous dire que les cassettes audio étaient plus pratiques.

Mais de nos jours, les programmes sont enregistrés sur le disque dur de l'ordinateur ou dans une mémoire intégrée à l'ordinateur. On dit qu'ils sont installés, ce qui est un mot bien compliqué pour dire que le programme est enregistré sur le disque dur de l’ordinateur. A défaut de disque dur, le programme/logiciel est enregistré dans une mémoire spécialisée pour le stockage. Par exemple, sur les cartes électroniques grand public de marque Arduino, les programmes sont envoyés à la carte via le port USB, mais les programmes sont enregistrés dans la carte Arduino, dans une mémoire FLASH dédiée. Disque dur ou non, le programme est mémorisé dans la mémoire de l'ordinateur. Il est possible d'installer ou de désinstaller les programmes en modifiant le contenu de la mémoire. Le terme utilisé est alors celui de '''programme stocké en mémoire'''.

Les programmes à installer sont disponibles soit sur un périphérique, comme un DVD ou une clé USB, soit sont téléchargés depuis internet. Les premiers PC fournissaient les logiciels sur des disquettes, qui contenaient un programme d'installation pour enregistrer le programme sur le disque dur de l'ordinateur. Par la suite, le support des logiciels a migré vers les CD et DVD, les logiciels devenant de plus en plus gros. De nos jours, la majorité des applications sont téléchargées depuis le net, l'usage de périphériques est devenu obsolète, même les consoles de jeu abandonnent cette méthode de distribution.

==Les générations d'ordinateurs : un historique rapide==

L'informatique a beaucoup évolué dans le temps. Et une bonne partie de cette évolution tient à l'évolution de l’électronique sous-jacente. Les ordinateurs actuels sont fabriqués avec des transistors, des petits composants électroniques qui servent d'interrupteurs programmables, qu'on détaillera dans ce qui suit. Mais ça n'a pas toujours été le cas. Et cela permet de distinguer plusieurs '''générations d'ordinateurs'''.

===Les ordinateurs électro-mécaniques : les premiers ordinateurs===

Le tout premier ordinateur est le '''Z1''', un modèle unique inventé par Konrad Suze entre 1936 et 1938. Son processeur gérait non pas des nombres entiers, mais des nombres à virgule (des nombres dits flottants, pour être précis), encodés sur 22 bits. Le processeur du Z1 était capable de faire des additions et des soustractions, car il intégrait un circuit additionneur-soustracteur basique. Des circuits annexes permettaient de faire des multiplications et des divisions en enchainant des additions/soustractions successives. Il fonctionnait à une fréquence de 1 Hz, ce qui fait qu'il pouvait faire une addition/soustraction par seconde maximum.

Niveau mémoire, la RAM de l'ordinateur était très limitée : seulement 16 nombres de 22 bits chacun. S'il s'agissait d'une mémoire électronique, les programmes étaient mémorisés sur une mémoire mécanique et précisémment sur des cartes perforées, à savoir des cartes en papier/plastique dans lesquelles un 1 est codé par un trou dans le papier et un 0 par une absence de trou. Les programmes étaient exécutés par l'ordinateur quand on insérait la carte perforée dans le lecteur et qu'on appuyait sur un bouton.

[[File:German Museum of Technology, Berlin 2017 024.jpg|centre|vignette|upright=2|Réplique du Z1 au ''German Museum of Technology'' de Berlin, 2017.]]

Après sa destruction dans un bombardement, le Z1 a été reconstruit et amélioré, ce qui donné les deux ordinateurs Z2 et Z3. Quelques années plus tard, quelques laboratoires de recherche ont fabriqués des ordinateurs dans leur coin, comme le Harvard Mark I et le Colossus Mark 1 (UK) qui ont été mis en service en 1944. Ils ont servi pour les cryptanalystes pour casser les codes utilisés par les Allemands pour leurs transmissions, pendant la seconde guerre mondiale.

Les ordinateurs cités dans le précédent paragraphe étaient tous des ordinateurs dit '''électro-mécaniques''', car ils mélangeaient des composants électroniques et des composants mécaniques (tout ce qui a trait aux cartes perforées, notamment). Les composants électroniques étaient généralement des relais, à savoir des interrupteurs commandables électriquement, qui sont plus ou moins équivalents aux transistors modernes. La majeure partie des ordinateurs des années 40 étaient de ce type, mais leur nombre n'a pas dépassé 30. Il faut dire qu'ils ont rapidement laissé la place à des ordinateurs purement électroniques, que nous allons voir dans ce qui suit.

===La première génération : les tubes à vide===

Les ordinateurs qui ont suivi les ordinateurs électromécaniques sont regroupés dans la '''première génération d'ordinateur'''. Ils étaient conçus avec des tubes à vide, des espèces d'interrupteurs commandables, les ancêtres des transistors modernes. Les tubes à vide étaient assez encombrants, ils consommaient beaucoup de courant, ils chauffaient et étaient assez peu fiables. Ils tombaient en panne assez souvent. Et ils étaient assez simples à fabriquer, mais restaient malgré tout chers.

[[File:Elektronenroehren-auswahl.jpg|centre|vignette|upright=2|Tubes à vides.]]

L'usage de tubes à vide les place entre les premiers ordinateurs électro-mécaniques et les ordinateurs utilisant des transistors. Au vu de la taille des tubes à vide, les ordinateurs de l'époque étaient composés de plusieurs milliers de ces tubes, guère plus. Et malgré cela, un ordinateur prenait facilement un étage de bâtiment entier, ou au moins plusieurs pièces. La conséquence est que les ordinateurs de première génération étaient très simples, rudimentaires quand on les compare aux ordinateurs modernes. Ils ne géraient que quelques opérations simples : l'addition, la soustraction, pas grand-chose de plus. À quelques exceptions près, ils ne géraient pas la multiplication et encore moins la division, cela aurait demandé trop de tubes à vides.

Une des toutes premières machines construite avec des tubes à vide était l'Atanasoff–Berry. Ce n'était pas un ordinateur, car elle ne pouvait pas exécuter de programme sans intervention humaine pour séquencer des opérations, mais c'était la première machine de calcul purement électronique, sans aucune pièce mécanique. Elle utilisait une mémoire RAM construite avec des condensateurs, ceux-ci étant placés sur des cylindres tournants. Les circuits de calcul étaient construits avec des tubes à vide et faisaient leur travail un bit à la fois. Elle fonctionnait à une fréquence de 60 Hz et pouvait faire 30 additions/soustractions par seconde. Les nombres étaient encodés sur 50 bits. 

[[File:Atanasoff Berry Computer.gif|centre|vignette|upright=2.5|Atanasoff–Berry.]]

L'arrivée de l'ENIAC en 1945 a changé la donne. Cet ordinateur a introduit plusieurs innovations majeures. La première est assez technique, il s'agit de la turing-complétude, elle a trait aux programmes qui peuvent être écrit pour un ordinateur, nous ne la détaillerons pas ici.

[[File:BabyArchitecture.png|vignette|Architecture de la Manchester Baby.]]

En 1948, le ''Manchester Baby'' a introduit une innovation extrêmement importante : le programme n'était plus mémorisé sur des cartes perforées, mais dans une mémoire électronique à l’intérieur de l'ordinateur lui-même. En clair, le ''Manchester Baby'' était le premier '''ordinateur à programme stocké en mémoire''' en français. Au-delà de ça, le Manchester Baby restait quand même très simple, c'était limite un prototype.

Niveau interface, l'ordinateur avait une console avec 32 boutons, des interrupteurs et un écran de sortie sur lequel afficher les résultats. A l'intérieur, il y avait un processeur et une RAM de 32 nombres de 32 bits, fabriquées avec des tubes Williams (abordés dans une annexe à la fin du cours). Une instruction prenant autant de place qu'un nombre en RAM, ce qui limitait les programmes à 32 instructions maximum. Le processeur gérait 8 instructions en tout, mais la seule instruction de calcul qu'il gérait était la soustraction. L'addition n'était pas supportée. Il pouvait cependant émuler l'addition à partir d'une soustraction et inversant l'opérande soustrait.

Le Manchester Mark 1 était une amélioration du Manchester Baby. Il utilisait 4500 tubes à vide. L'ordinateur gérait des nombres de 40 bits, mais les instructions étaient codées sur 20 bits. La RAM avait la même taille, à savoir 32 nombres, leur taille était simplement augmentée. Par contre, la RAM était complémentée par l’ancêtre du disque dur magnétique, à savoir un tambour magnétique, l’ancêtre du disque dur magnétique. Il contenait 40 pages, chacune ayant la même taille que la RAM. Contrairement à la Manchester Baby, son processeur gérait l'addition. Les multiplications étaient réalisées par des additions successives, mais le processeur intégrait des registres pour mémoriser les opérandes à multiplier.

Par la suite, les ordinateurs commerciaux ont vu le jour. Les ordinateurs précédents provenaient de projets de recherches, souvent publics. Mais les entreprises privées se sont mises à fabriquer des ordinateurs elle-mêmes, pour les vendre à d'autres entreprises. On peut notamment citer les ordinateurs comme le UNIVAC I, le Bull Gamma 3 ou les premiers ordinateurs IBM. La performance de ces ordinateurs était nettement plus importante que leurs prédécesseurs, avec des fréquences de l'ordre de la centaine de kilo-hertz. Par exemple, le Bull Gamma 3 allait à 281 kHz, l'IBM 650 allait à 50 Khz.

===La seconde génération : le remplacement des tubes à vides par des transistors===

[[File:IBM 7070.jpg|vignette|Cartes imprimées de l'IBM 704, avec des transistors et résistances dessus.]]

La '''seconde génération''' est celle des ordinateurs fabriqués avec des '''transistors''' isolés, reliés entre avec des fils électriques. Les transistors en question possèdent trois broches, des pattes métalliques sur lesquelles on connecte des fils électriques. Le transistor s'utilise le plus souvent comme un interrupteur commandé par sa troisième broche. Le courant qui traverse les deux premières broches passe ou ne passe pas selon ce qu'on met sur la troisième.

[[File:Transistor basic flow.svg|centre|vignette|Un transistor est un morceau de conducteur, dont la conductivité est contrôlée par sa troisième broche/borne.]]

Les ordinateurs de seconde génération avaient entre 1000 et 500 000 transistors. Les capacités des ordinateurs étaient donc nettement supérieures à celles des ordinateurs de première génération. Une part non négligeable des ordinateurs de seconde génération supportait l'opération de multiplication, absente sur les ordinateurs de première génération. Néanmoins, cela variait beaucoup selon les ordinateurs.

Un exemple assez hors du commun est celui du premier modèle de l'IBM 1620. Le tout premier modèle n'avait aucun circuit de calcul, il n'était même pas capable de faire une addition ou une multiplication. A la place, il utilisait une table d'addition et une table de multiplication en mémoire RAM. Les deux tables devaient être initialisées par le logiciel lors du démarrage de la machine. La table d'addition faisait une centaine de chiffres, la table de multiplication faisait le double. Le processeur de l'ordinateur gérait des instructions pour faire des additions ou des multiplications, mais ces opérations lisaient le résultat dans la table d'addition. Les calculs étaient faits chiffre par chiffre, avec un encodage partiellement décimal, partiellement binaire (des chiffres décimaux étaient encodés en binaire, nous en reparlerons quand nous parlerons du BCD) !

[[File:KL CoreMemory.jpg|vignette|Mémoire à tore de ferrite.]]

Les transistors n'étaient utilisés que pour le processeur et les circuits annexes. La mémoire n'était pas faite en transistors, pas à cette époque. La mémoire était une mémoire aujourd'hui abandonnée, appelée une '''mémoire à tores de ferrite'''. Elle sera détaillée dans un chapitre ultérieur. Mais sachez pour le moment qu'il s'agit d'une mémoire au support magnétique, les données étant stockées sur un support magnétique.

Transistors comme tubes à vide prenaient beaucoup de place, ce qui fait que les ordinateurs étaient assez gros. Concrètement, ils prenaient une pièce de bâtiment entière dans le meilleur des cas. C'était l'époque des gros ''mainframes'', reliés à des terminaux, peu puissants comparé aux standards actuels. Seules les grandes entreprises et les grands instituts de recherche pouvaient se payer les services de ce genre d'ordinateurs. Seuls les professionnels avaient accès à ce genre d'équipement.

===La troisième génération : le circuit intégré===

[[File:D8259AC-2.jpg|vignette|Exemple de circuit intégré.]]

La troisième génération est toujours fabriquée avec des transistors, mais dont la taille a été réduite. Avec l'évolution de la technologie, les transistors ont diminué en taille, de plus en plus. Ils sont devenus tellement petits qu'ils ont fini par être regroupés dans des '''circuits intégrés''', des circuits regroupent plusieurs transistors sur la même puce de silicium. Les circuits intégrés se présentent le plus souvent sous la forme de boitiers rectangulaires, comme illustré ci-contre. D'autres ont des boitiers de forme carrées, comme ceux que l'on peut trouver sur les barrettes de mémoire RAM, ou à l'intérieur des clés USB/ disques SSD.

Lors de cette génération, les processeurs étaient fournis en pièces détachées qu'il fallait relier entre elles. Le processeur était composé de plusieurs circuits intégrés séparés, impossible de mettre un processeur dans un seul boitier. Un exemple de processeur conçu en kit est la série des Intel 3000. Elle regroupe plusieurs circuits séparés aux noms à coucher dehors, mais dont vous comprendrez ce qu'ils veulent dire dans les chapitres adéquats : l'Intel 3001 est un séquenceur, l'Intel 3002 regroupe unité de calcul et registres, le 3003 est un circuit d'anticipation de retenue complémentaire du 3002, le 3212 est une mémoire tampon, le 3214 est une unité de gestion des interruptions, les 3216/3226 sont des interfaces de bus mémoire. On pourrait aussi citer la famille de circuits intégrés AMD Am2900.

Même si le processeur était en pièces détachées, utiliser une dizaine de circuits intégrés était nettement mieux que d'utiliser plusieurs milliers de transistors individuels. En conséquence, les ordinateurs ont vu leur taille grandement réduite, passant de pièces entières à une simple armoire, voire à quelques cartes intégrées superposées. De plus, le prix des circuits intégré était abordable, du moins comparé aux ordinateurs d'avant. Le prix des ordinateurs a alors grandement décru, permettant à des entreprises et administrations de taille modeste de s'équiper d'ordinateurs.

===La quatrième génération : le microprocesseur===

[[File:MOS6502.svg|vignette|Microprocesseur, ici un processeur MOS6502, de la quatrième génération.]]

Lors de la troisième génération, les circuits intégrés regroupaient plusieurs dizaines ou centaines de transistors, mais sont rapidement montés en gamme. De centaines de transistors, ils sont passés au millier de transistors, puis au million et maintenant au-delà du milliard. Les transistors étaient devenus tellement petits, tellement miniaturisés, qu'il était devenu possible de mettre un processeur entier dans un circuit intégré. C'est ainsi qu'est né le microprocesseur, à savoir un processeur qui tient tout entier dans un seul circuit imprimé. La quatrième génération d’ordinateur est celle des ordinateurs basés autour d'un microprocesseur.

Les tout premiers microprocesseurs étaient des processeurs à application militaire, comme le processeur du F-14 CADC ou celui de l'Air data computer. Le tout premier microprocesseur commercialisé au grand public est le 4004 d'Intel, sorti en 1971. L'intel 4004 comprenait environ 2300 transistors, avait une fréquence de 740 MHz, pouvait faire 46 opérations différentes, et manipulait des entiers de 4 bits. Il était au départ un processeur de commande, prévu pour être intégré dans la calculatrice Busicom calculator 141-P, mais il fut utilisé pour d'autres applications quelque temps plus tard. Immédiatement après le 4004, les premiers microprocesseurs 8 bits furent commercialisés. Le 4004 fut suivi par le 8008 et quelques autres processeurs 8 bits extrêmement connus, comme le 8080 d'Intel, le 68000 de Motorola, le 6502 ou le Z80.

Les microprocesseurs permirent encore uen fois de réduire la taille des ordinateurs, qui pouvaient tenir dans un boitier de PC, ou un boitier de console de jeu. Le prix des ordinateurs a aussi chuté en même temps que les transistors étaient miniaturisés. C'est cette invention qui permis l'invention des consoles de jeux et des mini-ordinateurs, à savoir les ordinateurs personnels. Sans miniaturisation, on n'aurait pas d'ordinateur personnel, pas de PC fixe ou portable.

==L'organisation du cours : les différents niveaux d'explication==

Le fonctionnement d'un ordinateur est assez complexe à expliquer car les explications peuvent se faire sur plusieurs niveaux. Par plusieurs niveaux, on veut dire qu'un ordinateur est composé de composants très simples, qui sont assemblés pour donner des composants eux-même plus complexes, qui sont eux-même regrouper, etc. Étudier tout cela demande de voir plusieurs niveaux, allant de transistors très petits à des processeurs multicœurs. Les niveaux les plus bas sont de l'électronique pur et dure, alors que ceux plus haut sont à mi-chemin entre électronique et informatique.

===Les niveaux d'abstraction en architecture des ordinateurs===

Les trois premiers niveaux sont de l'électronique pur et dure. Ils correspondent aux premiers chapitres du cours, qui porteront sur les circuits électroniques en général.
* Le premier niveau est celui des '''transistors''', des circuits intégrés, des ''wafer'' et autres circuits de très petite taille.
* Le second niveau est celui des '''portes logiques''', des circuits très basiques, très simples, à la base de tous les autres.
* Le troisième niveau est celui dit de la '''''Register Transfer Level''''', où un circuit électronique est construit à partir de circuits basiques, dont des registres et autres circuits dits combinatoires.
Les deux niveaux suivants sont de l'informatique proprement dit. C'est dans ces deux niveaux qu'on étudie les ordinateurs proprement dit, les circuits qu'il y a dedans et non l'électronique en général.
* Le quatrième niveau est celui de la '''microarchitecture''', qui étudie ce qu'il y a à l'intérieur d'un processeur, d'une mémoire, des périphériques et autres.
* Le cinquième niveau est celui de l''''architecture externe''', qui décrit l'interface du processeur, de la mémoire, d'un périphérique ou autre. Par décrire l'interface, on veut dire : comment un programmeur voit le processeur et la mémoire, comment il peut les manipuler. Une architecture externe unique peut avoir plusieurs microarchitecture, ce qui fait qu'on sépare les deux. Tout cela sera plus clair quand on passera aux chapitres sur le processeur et les mémoires.

Nous n'allons pas voir les 5 niveaux dans l'ordre, des transistors vers l'architecture externe. En réalité, nous allons procéder autrement. La première partie du cours portera sur les trois premiers niveaux, le reste sur les deux autres. Les 5 niveaux seront vus dans des chapitres séparés, du moins le plus possible. Au niveau pédagogique, tout est plus simple si on scinde les 5 niveaux. Bien sûr, il y a quelques explications qui demandent de voir plusieurs niveaux à la fois. Par exemple, dans le chapitre sur les mémoires caches, nous auront des explications portant sur la RTL, la microarchitecture du cache et son architecture externe. Mais le gros du cours tentera de séparer le plus possible les 5 niveaux.

===Les trois parties principales du cours===

Nous allons commencer par parler du binaire, avant de voir les portes logiques. Avec ces portes logiques, nous allons voir comment fabriquer des circuits basiques qui reviendront très souvent dans la suite du cours. Nous verrons les registres, les décodeurs, les additionneurs et plein d'autres circuits. Puis, nous reviendrons au niveau des transistors pour finir la première partie. La raison est que c'est plus simple de faire comme cela. Tout ce qui a trait aux transistors sert à expliquer comment fabriquer des portes logiques, et il faut expliquer les portes logiques pour voir le niveau de la RTL.

Une fois la première partie finie, nous allons voir les différents composants d'un ordinateur. Une première partie expliquera ce qu'il y a dans un ordinateur, quels sont ses composants. Nous y parlerons de l'architecture de base, de la hiérarchie mémoire, des tendances technologiques, et d'autres généralités qui serviront de base pour la suite. Puis, nous verrons dans l'ordre les bus électroniques, les mémoires RAM/ROM, le processeur, les périphériques, les mémoires de stockage (SSD et disques durs) et les mémoires caches. Pour chaque composant, nous allons voir leur architecture externe, avant de voir leur microarchitecture. La raison est que la microarchitecture ne peut se comprendre que quand on sait quelle architecture externe elle implémente.

Enfin, dans une troisième partie, nous allons voir les optimisations majeures présentes dans tous les ordinateurs modernes, avec une partie sur le pipeline et le parallélisme d'instruction, et une autre sur les architectures parallèles. Pour finir, les annexes de fin parlerons de sujets un peu à part.

&lt;noinclude&gt;
{{NavChapitre | book=Fonctionnement d'un ordinateur
           | next=L'encodage des données
           | nextText=L'encodage des données
}}
&lt;/noinclude&gt;</text>
      <sha1>2naw81yydt3l8anajqihf7csne6ay87</sha1>
    </revision>
    <revision>
      <id>744162</id>
      <parentid>744161</parentid>
      <timestamp>2025-06-05T15:11:49Z</timestamp>
      <contributor>
        <username>Mewtow</username>
        <id>31375</id>
      </contributor>
      <minor />
      <comment>/* La première génération : les tubes à vide */</comment>
      <origin>744162</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="46838" sha1="os0cuco7xo0fudoyuuzvua93r1al2a3" xml:space="preserve">Pour commencer, nous allons voir qu'il existe de nombreux types d'ordinateurs. Le plus connu est certainement le PC, l'ordinateur personnel, que vous avez sans doute dans votre salon. Les ordinateurs portables sont un deuxième type d'ordinateur assez intuitif, que vous avez peut-être. Mais il y a aussi d'autres types d'ordinateurs auxquels vous n'avez jamais été confrontés.

==Les différents types d'ordinateurs==

Dans cette section, nous allons décrire rapidement les ordinateurs les plus courant, mais surtout voir ce qu'il y a à l'intérieur d'un ordinateur.

===L'ordinateur de type PC fixe===

De l'extérieur, l'ordinateur est composé d'une unité centrale sur laquelle on branche des périphériques.

[[File:Typical computer architecture systems.jpg|vignette|upright=1.5|Exemples de périphériques, connectés à une unité centrale (ici appelée à tort ''operating system'').]]

Les '''périphériques''' regroupent l'écran, la souris, le clavier, l'imprimante, et bien d'autres choses. Ils permettent à l'utilisateur d'interagir avec l'ordinateur : un clavier permet de saisir du texte sous dans un fichier, une souris enregistre des déplacements de la main en déplacement du curseur, un écran affiche des données d’images/vidéos, un haut-parleur émet du son, etc. Tout ce qui est branché sur un ordinateur est, formellement un périphérique.

L''''unité centrale''' est là où se trouvent tous les composants importants d'un ordinateur, ceux qui font des calculs, qui exécutent des logiciels, qui mémorisent vos données, etc. Voici ce à quoi ressemble l'intérieur de l'unité centrale. Trois sections sont visibles : l'alimentation électrique en haut à gauche, la carte mère en bas à gauche et en jaune/orange, les disques et lecteurs à droite des câbles. Et on voit aussi beaucoup de câbles.

[[File:Asus P5K-SEIntel E6320.jpg|centre|vignette|upright=2|Exemple d'unité centrale.]]

Tout en haut à gauche, se trouve l''''alimentation électrique''', qui convertit le courant de la prise électrique en un courant plus faible, utilisable par les autres composants. Elle émet de nombreux câbles assez gros, qui sont reliés au reste. Les PC actuels utilisent des alimentations électriques standardisées, qui fournissent trois tensions au reste de l'ordinateur : une tension de 12 Volts, une de 5 Volts, une de 3,3 Volts.

À droite, caché par la partie &quot;métallique&quot; du boitier, se trouvent les lecteurs de CD/DVD, et les disques durs. Les lecteurs CD-ROM ou DVD-ROM permettaient de lire des CD ou des DVD. Je parle au passé, car ils ont aujourd'hui disparu des ordinateurs modernes. Les '''disques durs''' sont des mémoires de stockage, qui mémorisent vos données de manière permanente. De nos jours, ils sont remplacés par des SSD, qui sont des disques durs électroniques, là où les disques durs proprement dit sont des mémoires magnétiques. Nous verrons la différence dans deux chapitres dédiés, un sur les disques durs, l'autre sur les SSD.

En bas à droite, se trouve la '''carte mère''' un support plat, en plastique ou en céramique, sur laquelle sont soudés/connectés les autres composants. Sur celle-ci, de nombreux composants sont soudés, d'autres sont branchés dessus avec des câbles, d'autres sont connectés dessus avec des connecteurs. Ils sont reliés entre eux par des fils conducteurs, le plus souvent du cuivre ou de l’aluminium, ce qui leur permet de s’échanger des données. Sur les cartes simples, ces fils sont intégrés dans la carte électronique, dans des creux du plastique. Ils portent le nom de pistes.

Avant, les disques durs, SSD et lecteurs de CD/DVD sont branchés dessus via des connecteurs dédiés, appelés des connecteurs S-ATA. De nos jours, ils sont branchés sur un autre connecteur, grâce à l'interface NVME. Toujours est-il qu'ils sont reliés à la carte mère par des câbles, ce qui montre que ce sont des sortes de périphériques interne. Ils sont placés dans le boitier, mais on aurait tout aussi bien pu les mettre à l'extérieur, vu qu'ils communiquent avec l'ordinateur par l'intermédiaire d'un câble ou d'un connecteur dédié.

Mais deux autres composants très importants sont eux placés sur la carte mère, directement. Ils ont chacun un connecteur dédié, sur lequel ils sont branchés directement, sans passer par l'intermédiaire d'un câble, mais sans être soudés non plus. Il s'agit du processeur et de la mémoire RAM, deux composants centraux des PC modernes.

[[File:Pentium III SL4CB.jpg|thumb|Processeur Pentium III.]]

Le '''processeur''' traite les données, les modifie, les manipule. Pour faire simple, il s’agit d’une grosse calculatrice hyper-puissante. Il comprend à la fois un circuit qui fait des calculs, et un circuit de contrôle qui s'occupe de séquencer les calculs dans l'ordre demandé. Il est souvent caché sous un radiateur, lui-même surmonté par un ventilateur. En effet, un processeur chauffe beaucoup, ce qui demande d'évacuer cette chaleur. Un chapitre entier expliquera pourquoi les processeurs chauffent, ainsi que les techniques utilisées pour limiter leur production de chaleur et leur consommation électrique.

La '''mémoire vive''' conserve des informations/données temporairement, tant que le processeur en a besoin. Elle prend la forme de barrettes de RAM, comme montré ci-dessous.

[[File:2 gb ddr2 667.jpg|centre|vignette|upright=2|Barrette de RAM.]]

Outre ces composants dits principaux, un ordinateur peut comprendre plusieurs composants moins importants, surtout présents sur les ordinateurs personnels. Ils sont techniquement facultatifs, mais sont très présents dans les ordinateurs personnels. Cependant, certains ordinateurs spécialisés s'en passent. Il s'agit des diverses '''cartes d'extension''' sont branchées sur la carte mère. Elles permettent d’accélérer certains calculs ou certaines applications, afin de décharger le processeur. Par exemple, la carte graphique s'occupe des calculs graphiques, qu'il s'agisse de graphismes 3D de jeux vidéos ou de l'affichage en 2D du bureau. Dans un autre registre, la carte son prend en charge le microphone et les haut-parleurs.

[[Fichier:Personal computer, exploded 4.svg|thumb|upright=1.0|Éclaté d'un ordinateur de type PC :&lt;br /&gt;
1 : Écran ;&lt;br /&gt;
2 : Carte mère ;&lt;br /&gt;
3 : Processeur ;&lt;br /&gt;
4 : Câble Parallel ATA ;&lt;br /&gt;
5 : Mémoire vive (RAM) ;&lt;br /&gt;
6 : Carte d'extension ;&lt;br /&gt;
7 : Alimentation électrique ;&lt;br /&gt;
8 : Lecteur de disque optique ;&lt;br /&gt;
9 : Disque dur ;&lt;br /&gt;
10 : Clavier ;&lt;br /&gt;
11 : Souris.]]

Si on regarde une carte mère de face, on voit un grand nombre de connecteurs, mais aussi des circuits électroniques soudés à la carte mère.

[[File:Architecture matérielle d'une carte mère.png|centre|vignette|upright=2.0|Architecture matérielle d'une carte mère]]

Les '''connecteurs''' sont là où on branche les périphériques, la carte graphique, le processeur, la mémoire, etc. Dans l'ensemble, toute carte mère contient les connecteurs suivants :
* Le processeur vient s’enchâsser dans la carte mère sur un connecteur particulier : le '''socket'''. Celui-ci varie suivant la carte mère et le processeur, ce qui est source d'incompatibilités.
* Les barrettes de mémoire RAM s’enchâssent dans un autre type de connecteurs: les '''slots mémoire'''.
* Les mémoires de masse disposent de leurs propres connecteurs : connecteurs P-ATA pour les anciens disques durs, et S-ATA pour les récents.
* Les périphériques (clavier, souris, USB, Firewire, ...) sont connectés sur un ensemble de connecteurs dédiés, localisés à l'arrière du boitier de l'unité centrale. 
* Les autres périphériques sont placés dans l'unité centrale et sont connectés via des connecteurs spécialisés. Ces périphériques sont des cartes imprimées, d'où leur nom de '''cartes filles'''. On peut notamment citer les cartes réseau, les cartes son, ou les cartes vidéo.

===Les ordinateurs portables===

[[File:Samsung QX-511 (2).JPG|vignette|Ordinateur portable Samsung QX-511 (2), pour illustration.]]

Un ordinateur portable est identique à un ordinateur de type PC. Si vous ouvrez votre ordinateur portable (attention à la garantie), vous retrouverez les mêmes composants qu'un PC à l'intérieur. Un point important est la présence d'une batterie à l'intérieur du PC portable, absente des PC fixes.

[[File:LG gram 14Z90Q mainboard with battery.jpg|centre|vignette|upright=2|LG gram 14Z90Q avec sa batterie.]]

Une fois la batterie et les circuits associés retiré, la seule différence notable est que tous les composants sont soudés sur la carte mère, au lieu d'être branchés sur des connecteurs, à part éventuellement la RAM et le disque dur.

[[File:LG gram 14Z90Q mainboard without battery.jpg|centre|vignette|upright=2|LG gram 14Z90Q sans sa batterie.]]

La RAM est parfois soudée sur la carte mère, d'autres fois sous la forme de barrettes de mémoire vive semblables à celles des PC. Dans le dernier cas, elle est connectée à des connecteurs spécifiques, ce qui permet de les changer/upgrader. Les PC portables sont parfois construits de manière à pouvoir changer la RAM facilement, en ouvrant un cache spécial, concu pour.

[[File:Lenovo G555 состав - Донор.JPG|centre|vignette|upright=2|Lenovo G555.]]

La conception d'un ordinateur portable est légèrement différente de celle d'un PC, pour des raisons thermiques. Un PC fixe a plus de place pour évacuer sa chaleur. Les ventilateurs peuvent plus facilement déplacer l'air dans le boitier, même si le flux d'air dans le boitier est éventuellement gêné par la carte graphique. Mais l'évacuation de la chaleur est assez efficace. Sur les PC portables, leur finesse fait que le trajet de l'air est beaucoup plus contraint. Évacuer la chaleur produite par l'ordinateur est plus complexe, ce qui demande d'utiliser des systèmes de refroidissement et de ventilation spécifiques.

Là où les PC fixes se débrouillent avec des radiateurs et des ventilateurs posés sur le processeur, les PC portables font autrement. Ils ne peuvent pas forcément mettre le ventilateur sur le processeur. A la place, ils mettent le ventilateur à côté, mais le processeur est surmonté par un mécanisme de transmission de la chaleur, qui transfère la chaleur du processeur vers le ventilateur.

[[File:Diagram - How a laptop cooling system works.png|centre|vignette|upright=2|Comment fonctionne le système de ventilation d'un ordinateur portable, en anglais.]]

Les difficultés pour dissiper la chaleur font que les ordinateurs portables utilisent souvent des composants peu performants, mais qui chauffent peu. En effet, nous verrons que plus un composant est puissant, plus il chauffe. La relation n'est pas parfaite, mais les processeurs haute performance chauffent plus que les modèles d'entrée ou milieu de gamme moins puissants. En conséquence, les PC portables sont souvent moins puissants que les PC fixes, même pour les modèles dit ''gaming''.

===Les serveurs et ''mainframes''===

Les grandes entreprises utilisent des ordinateurs de grande taille, très puissants, appelés des ''mainframes''. Ils sont souvent confondus avec les serveurs par le grand public, il y a une différence entre les deux. Un serveur est une fonction logicielle/réseau, pas un type d'ordinateur. Mais laissons cette différence de côté, ce qui est dit pour les ''mainframes'' sert pour les gros serveurs haute performance.

[[File:IBM Z15 mainframe.jpg|vignette|Exemple de ''mainframe''' de type IBM Z15.]]

Les anciens ''mainframes'' des années 50-80 avaient une taille pouvant être impressionnante, au point de prendre une pièce complète d'un bâtiment. Mais de nos jours, les ''mainframes'' tiennent dans une grosse armoire un peu haute. Les ''mainframes'' doivent rester allumé en permanence et ne doivent pas être éteint, sauf éventuellement quelques jours par an pour des opérations de maintenance. Ils utilisent pour cela des techniques spécifiques, avec beaucoup de redondance interne.

[[File:ACONIT hall grandes machines.jpg|centre|vignette|upright=2|''Mainframe'' ACONIT.]]

Les ''mainframes'' sont aussi conçus pour mutualiser au maximum leur utilisation, ils peuvent être utilisés par plusieurs utilisateurs à la suite, voire en même temps. Pour cela, les anciens ''mainframes'' étaient capables de faire tourner plusieurs applications distinctes l'une à la suite de l'autre, avec des commutations fréquentes entre logiciels. De nos jours, ils sont capables d'exécuter un grand nombre de tâches en même temps, grâce à la présence de plusieurs processeurs. Les ''mainframes'' modernes sont même capables de faire tourner plusieurs systèmes d'exploitation en même temps si besoin.

Les anciens ''mainframes'' étaient des ordinateurs assez simples, avec un processeur, de la mémoire RAM, un ou plusieurs disques durs, pas plus. Le ''mainframe'' était tellement énorme et cher que les entreprises n'en avaient qu'un seul pour toute l'entreprise. Les employés avaient sur leur bureau des terminaux, qui permettaient d'accéder à l'ordinateur central, mais n'étaient pas des ordinateurs. Les terminaux étaient des composants électroniques simples, avec un écran, un clavier et une souris, mais sans processeur. Ils envoyaient des données au ''mainframe'', ils en recevaient de sa part, mais tout traitement était réalisé sur le ''mainframe''. L'arrivée sur le marché des ordinateurs personnels, de type PC fixe/portable, a entrainé l'abandon de ce genre de pratique, tous les employés ont maintenant un ordinateur rien que pour eux.

{|
|-
! colspan=&quot;2&quot; | Exemples de terminaux
|-
|[[File:Terminal-in2-sm9400.jpg|centre|vignette|upright=1.5|Exemple de terminal. Notez la présence d'un écran et d'un clavier, mais l'asbence d'une unité centrale.]]
|[[File:Chromatics CT4100.jpg|vignette|upright=1.5|Autre exemple de terminal. Le clavier est couplé à un stylo CRT, qui remplacait la souris et agissait sur l'écran comme s'il était tactile.]]
|-
! colspan=&quot;2&quot; | Intérieur d'un terminal
|-
|[[File:CT1024 Monitor.jpg|vignette|upright=1.5|Terminal CT1024, sans le boitier extérieur.]]
|[[File:CT1024 Terminal System.jpg|vignette|upright=1.5|Terminal CT1024, description des composants interne.]]
|}

De nos jours, les ''mainframes'' contiennent en réalité plusieurs ordinateurs simples interconnectés via un réseau local. Un ''mainframe'' qui tient dans une armoire contient facilement une dizaine ou centaine de processeurs, plein de RAM, des disques durs séparés dans une armoire distincte, etc. Vu qu'ils communiquent uniquement via le réseau, ils n'ont pas d'interface, pas d'écran, 'entrée via clavier/souris. Le tout est commandé avec une console de commande, typiquement un ordinateur portable ou un terminal assez simple séparé de l'armoire, qui permet à un administrateur de faire des opérations de surveillance, configuration et maintenance. Il peut y avoir une console de commande pour plusieurs armoires séparées, la console peut même être dans un autre bâtiment et accéder au ''mainframe'' par le réseau.

[[File:IBM System Z9 (type 2094 inside).jpg|centre|vignette|upright=2|''Mainframe'' de type IBM System Z9. L'ordinateur portable sert de console pour qu'un administrateur fasse des opérations de surveillance, configuration et maintenance.]]

Les processeurs et la RAM sont typiquement installés sur des cartes amovibles, qui sont connectées au fond de l'armoire lors de l'installation. Il est même possible de retirer ou d'ajouter des cartes en fonctionnement, afin d'ajouter/retirer des processeurs, des disques durs, etc. Ce qui est très utile si un composant est en panne et qu'il faut le remplacer. 

[[File:IBM TotalStorage Exp400.jpg|centre|vignette|upright=2|IBM TotalStorage Exp400]]

==Un peu d'abstraction : qu'est-ce qu'un ordinateur ?==

Un ordinateur comprend donc un processeur, plusieurs mémoires, des cartes d'extension et une carte mère pour connecter le tout. Mais il s'agit là d'une description assez terre-à-terre de ce qu'est un ordinateur. Une autre description, plus abstraite, se base sur le fait qu'un ordinateur est une énorme calculatrice programmable. Elle permet d'expliquer pourquoi il y a une distinction entre processeur et mémoire, entre unité centrale et périphériques. Tout ce qui va suivre pourra vous paraitre assez abstrait, mais rassurez-vous : les prochains chapitres rendront tout cela plus concrets.

===La séparation entre entrées-sorties et traitement===

L'unité centrale peut être vue comme une énorme calculatrice ultra-puissante, qui exécute des commandes/opérations. Mais à elle seule, elle ne servirait à rien, il faut interagir avec par l'intermédiaire de plusieurs périphériques. Il existe deux types de périphériques, qui sont conceptuellement différents. Les périphériques comme le clavier ou la souris permettent d'envoyer des informations à l'ordinateur, d'agir sur celui-ci. A l'inverse, les écrans transmettent des informations dans le sens inverse : de l'ordinateur vers l'utilisateur. Les premiers sont appelés des '''entrées''', les seconds des '''sorties'''.

Dans un ordinateur, les informations sont représentées sous la forme de nombres. Toute donnée dans un ordinateur est codée avec un ou plusieurs nombres regroupés dans une donnée, un fichier, ou autre. Et la transmissions avec les entrées et sorties se fait là-encore avec des nombres. Par exemple, quand vous appuyez sur votre clavier, le clavier envoie un numéro de touche à l'unité centrale, qui indique quelle touche a été appuyée. L'image à afficher à l'écran est codée sous la forme d'une suite de nombres (un par pixel). L'image est envoyée à l'écran, qui traduit la suite de nombre en image à afficher. Les entrées traduisent des actions utilisateurs en nombres, on dit que les entrées encodent les actions utilisateur. Les sorties font la traduction inverse, elles transforment des suites de nombres en une action physique. On dit qu'elles décodent des informations.

Pour résumer, toute appareil électronique est composé par :
* Des '''entrées''' sur lesquelles l'utilisateur agit sur l'ordinateur. Les entrées transforment les actions de l'utilisateur en nombres, qui sont interprétés par l'ordinateur.
* Une '''unité de traitement''', qui manipule des nombres et fait des calculs/opérations dessus. Les nombres proviennent des entrées, du disque dur, ou d'autres sources, peu importe.
* Des '''sorties''', qui va récupèrent le résultat calculé par l'unité de traitement pour en faire quelque chose : écrire sur une imprimante ou sur un moniteur, émettre du son,...

[[File:Ordinateur théorique Simple 1.png|centre|vignette|upright=2|Ordinateur théorique Simple 1]]

L'unité de traitement proprement dite, celle qui fait les calculs, est couplée à une mémoire qui mémorise les opérandes et résultats des calculs. La séparation entre processeur et mémoire est nécessaire pour qu'un appareil électronique soit qualifié d'ordinateur. De nombreux appareils n'ont pas de séparation entre unité de traitement et mémoire, comme certaines vielles radios AM/FM.

[[File:Schéma de principe d'un ordinateur.png|centre|vignette|upright=2|Schéma de principe d'un ordinateur]]

===Un ordinateur est un appareil programmable===

Les appareils simples sont non-programmables, ce qui veut dire qu’ils sont conçus pour une utilisation particulière et qu’ils ne peuvent pas faire autre chose. Par exemple, les circuits électroniques d’un lecteur de DVD ne peuvent pas être transformé en lecteur audio ou en console de jeux... Les circuits non-programmables sont câblés une bonne fois pour toute, et on ne peut pas les modifier. On peut parfois reconfigurer le circuit, pour faire varier certains paramètres, via des interrupteurs ou des boutons, mais cela s’arrête là. Et cela pose un problème : à chaque problème qu'on veut résoudre en utilisant un automate, on doit recréer un nouveau circuit.

À l'inverse, un ordinateur n’est pas conçu pour une utilisation particulière, contrairement aux autres objets techniques. Il est possible de modifier leur fonction du jour au lendemain, on peut lui faire faire ce qu’on veut. On dit qu'ils sont '''programmables'''. Pour cela, il suffit d’utiliser un logiciel, une application, un programme (ces termes sont synonymes), qui fait ce que l'on souhaite. La totalité des logiciels présents sur un ordinateur sont des programmes comme les autres, même le système d'exploitation (Windows, Linux, ...) ne fait pas exception.

Un programme est une suite de d''''instructions machines''', chaque instruction effectuant une action dans l'ordinateur. Sur les ordinateurs modernes, les instructions les plus communes effectuent une opération arithmétique : une addition, une multiplication, une soustraction, etc. Les ordinateurs modernes sont donc de grosses calculettes très puissantes, capables d'effectuer des millions d'opérations par secondes.

Et qui dit opération dit nombres : un ordinateur gère nativement des nombres, qui sont codés en binaire sur la quasi-totalité des ordinateurs modernes. Les ordinateurs modernes sont capables de faire des calculs sur des nombres entiers, mais aussi des nombres à virgule. Il existe plusieurs manières de représenter des nombres en binaire, certaines représentant des nombres entiers dits naturels (0 et plus), d'autres des nombres signés (positifs ou négatifs), d'autres des nombres à virgule. Un chapitre entier détaillera comment sont encodés ces nombres.

Une instruction est représentée dans un ordinateur par une série de nombres entiers : un nombre qui indique quelle opération/commande effectuer et des autres nombres pour coder les données (ou de quoi les retrouver dans l'ordinateur). L'ordinateur récupére les commandes une par une, les traduit en opération à effectuer, exécuter l'opération, et enregistre le résultat. Puis il recommence avec la commande suivante.

[[File:Ordinateur Théorique Complexe 1.png|centre|vignette|upright=3|Ordinateur Théorique Complexe. En jaune, le programme informatique, la liste de commande. Le rectangle gris est l'ordinateur proprement dit.]]

De nombreux appareils sont programmables, mais tous ne sont pas des ordinateurs. Par exemple, certains circuits programmables nommés FPGA n'en sont pas. Pour être qualifié d'ordinateur, un appareil programmable doit avoir un processeur séparé de la mémoire. De plus, il doit utiliser un '''codage numérique''', chose que nous allons aborder dans le chapitre suivant.

===Les ordinateurs à programme mémorisé ou programme externe===

[[File:Blue-punch-card-front.png|vignette|upright=0.5|Carte Perforée.]]

Au tout début de l'informatique, les programmes étaient enregistrés sur des cartes perforées, à savoir des cartes en papier/plastique percées par endroits. Un 1 est codé par un trou dans le papier et un 0 par une absence de trou. Les programmes étaient exécutés par l'ordinateur quand on insérait la carte perforée dans le lecteur et qu'on appuyait sur un bouton.

Par la suite, les premiers ordinateurs grand public, comme les Amstrad ou les Commodore, utilisaient des cassettes audio magnétiques pour stocker les programmes. Dans le même style, les consoles de jeu utilisaient autrefois des cartouches de jeu, qui contenaient le programme du jeu à exécuter. Pour résumer, les anciens ordinateurs mémorisaient les programmes sur un support externe, lu par un périphérique. De tels ordinateurs sont dits à '''programme externe'''.

: D’anciens ordinateurs personnels, comme l’Amstrad ou le Commodore, permettaient de taper les programmes à exécuter à la main, au clavier, avant d’appuyer une touche pour les exécuter. Nul besoin de vous dire que les cassettes audio étaient plus pratiques.

Mais de nos jours, les programmes sont enregistrés sur le disque dur de l'ordinateur ou dans une mémoire intégrée à l'ordinateur. On dit qu'ils sont installés, ce qui est un mot bien compliqué pour dire que le programme est enregistré sur le disque dur de l’ordinateur. A défaut de disque dur, le programme/logiciel est enregistré dans une mémoire spécialisée pour le stockage. Par exemple, sur les cartes électroniques grand public de marque Arduino, les programmes sont envoyés à la carte via le port USB, mais les programmes sont enregistrés dans la carte Arduino, dans une mémoire FLASH dédiée. Disque dur ou non, le programme est mémorisé dans la mémoire de l'ordinateur. Il est possible d'installer ou de désinstaller les programmes en modifiant le contenu de la mémoire. Le terme utilisé est alors celui de '''programme stocké en mémoire'''.

Les programmes à installer sont disponibles soit sur un périphérique, comme un DVD ou une clé USB, soit sont téléchargés depuis internet. Les premiers PC fournissaient les logiciels sur des disquettes, qui contenaient un programme d'installation pour enregistrer le programme sur le disque dur de l'ordinateur. Par la suite, le support des logiciels a migré vers les CD et DVD, les logiciels devenant de plus en plus gros. De nos jours, la majorité des applications sont téléchargées depuis le net, l'usage de périphériques est devenu obsolète, même les consoles de jeu abandonnent cette méthode de distribution.

==Les générations d'ordinateurs : un historique rapide==

L'informatique a beaucoup évolué dans le temps. Et une bonne partie de cette évolution tient à l'évolution de l’électronique sous-jacente. Les ordinateurs actuels sont fabriqués avec des transistors, des petits composants électroniques qui servent d'interrupteurs programmables, qu'on détaillera dans ce qui suit. Mais ça n'a pas toujours été le cas. Et cela permet de distinguer plusieurs '''générations d'ordinateurs'''.

===Les ordinateurs électro-mécaniques : les premiers ordinateurs===

Le tout premier ordinateur est le '''Z1''', un modèle unique inventé par Konrad Suze entre 1936 et 1938. Son processeur gérait non pas des nombres entiers, mais des nombres à virgule (des nombres dits flottants, pour être précis), encodés sur 22 bits. Le processeur du Z1 était capable de faire des additions et des soustractions, car il intégrait un circuit additionneur-soustracteur basique. Des circuits annexes permettaient de faire des multiplications et des divisions en enchainant des additions/soustractions successives. Il fonctionnait à une fréquence de 1 Hz, ce qui fait qu'il pouvait faire une addition/soustraction par seconde maximum.

Niveau mémoire, la RAM de l'ordinateur était très limitée : seulement 16 nombres de 22 bits chacun. S'il s'agissait d'une mémoire électronique, les programmes étaient mémorisés sur une mémoire mécanique et précisémment sur des cartes perforées, à savoir des cartes en papier/plastique dans lesquelles un 1 est codé par un trou dans le papier et un 0 par une absence de trou. Les programmes étaient exécutés par l'ordinateur quand on insérait la carte perforée dans le lecteur et qu'on appuyait sur un bouton.

[[File:German Museum of Technology, Berlin 2017 024.jpg|centre|vignette|upright=2|Réplique du Z1 au ''German Museum of Technology'' de Berlin, 2017.]]

Après sa destruction dans un bombardement, le Z1 a été reconstruit et amélioré, ce qui donné les deux ordinateurs Z2 et Z3. Quelques années plus tard, quelques laboratoires de recherche ont fabriqués des ordinateurs dans leur coin, comme le Harvard Mark I et le Colossus Mark 1 (UK) qui ont été mis en service en 1944. Ils ont servi pour les cryptanalystes pour casser les codes utilisés par les Allemands pour leurs transmissions, pendant la seconde guerre mondiale.

Les ordinateurs cités dans le précédent paragraphe étaient tous des ordinateurs dit '''électro-mécaniques''', car ils mélangeaient des composants électroniques et des composants mécaniques (tout ce qui a trait aux cartes perforées, notamment). Les composants électroniques étaient généralement des relais, à savoir des interrupteurs commandables électriquement, qui sont plus ou moins équivalents aux transistors modernes. La majeure partie des ordinateurs des années 40 étaient de ce type, mais leur nombre n'a pas dépassé 30. Il faut dire qu'ils ont rapidement laissé la place à des ordinateurs purement électroniques, que nous allons voir dans ce qui suit.

===La première génération : les tubes à vide===

Les ordinateurs qui ont suivi les ordinateurs électromécaniques sont regroupés dans la '''première génération d'ordinateur'''. Ils étaient conçus avec des tubes à vide, des espèces d'interrupteurs commandables, les ancêtres des transistors modernes. Les tubes à vide étaient assez encombrants, ils consommaient beaucoup de courant, ils chauffaient et étaient assez peu fiables. Ils tombaient en panne assez souvent. Et ils étaient assez simples à fabriquer, mais restaient malgré tout chers.

Les tubes à vides étaient utilisés pour le processeur et quelques circuits annexes, mais les mémoires utilisaient d'autres technologies. Les mémoires de l'époque n'étaient pas du tout des mémoires électroniques. Il existait déjà des ancêtres des disques durs, à savoir des mémoire magnétiques appelées tambours magnétiques, bandes magnétiques, mémoires à tore de ferrite, etc. Les mémoires RAM, quant à elles, utilisaient elles des technologies totalement abandonnées : les mémoires à lignes de délai étaient des mémoires acoustiques, les tubes Williams étaient des écrans CRT modifiés, etc. Un chapitre entier sera dédié aux technologies des mémoires de l'époque.

[[File:Elektronenroehren-auswahl.jpg|centre|vignette|upright=2|Tubes à vides.]]

L'usage de tubes à vide les place entre les premiers ordinateurs électro-mécaniques et les ordinateurs utilisant des transistors. Au vu de la taille des tubes à vide, les ordinateurs de l'époque étaient composés de plusieurs milliers de ces tubes, guère plus. Et malgré cela, un ordinateur prenait facilement un étage de bâtiment entier, ou au moins plusieurs pièces. La conséquence est que les ordinateurs de première génération étaient très simples, rudimentaires quand on les compare aux ordinateurs modernes. Ils ne géraient que quelques opérations simples : l'addition, la soustraction, pas grand-chose de plus. À quelques exceptions près, ils ne géraient pas la multiplication et encore moins la division, cela aurait demandé trop de tubes à vides.

Une des toutes premières machines construite avec des tubes à vide était l'Atanasoff–Berry. Ce n'était pas un ordinateur, car elle ne pouvait pas exécuter de programme sans intervention humaine pour séquencer des opérations, mais c'était la première machine de calcul purement électronique, sans aucune pièce mécanique. Elle utilisait une mémoire RAM construite avec des condensateurs, ceux-ci étant placés sur des cylindres tournants. Les circuits de calcul étaient construits avec des tubes à vide et faisaient leur travail un bit à la fois. Elle fonctionnait à une fréquence de 60 Hz et pouvait faire 30 additions/soustractions par seconde. Les nombres étaient encodés sur 50 bits. 

[[File:Atanasoff Berry Computer.gif|centre|vignette|upright=2.5|Atanasoff–Berry.]]

L'arrivée de l'ENIAC en 1945 a changé la donne. Cet ordinateur a introduit plusieurs innovations majeures. La première est assez technique, il s'agit de la turing-complétude, elle a trait aux programmes qui peuvent être écrit pour un ordinateur, nous ne la détaillerons pas ici.

[[File:BabyArchitecture.png|vignette|Architecture de la Manchester Baby.]]

En 1948, le ''Manchester Baby'' a introduit une innovation extrêmement importante : le programme n'était plus mémorisé sur des cartes perforées, mais dans une mémoire électronique à l’intérieur de l'ordinateur lui-même. En clair, le ''Manchester Baby'' était le premier '''ordinateur à programme stocké en mémoire''' en français. Au-delà de ça, le Manchester Baby restait quand même très simple, c'était limite un prototype.

Niveau interface, l'ordinateur avait une console avec 32 boutons, des interrupteurs et un écran de sortie sur lequel afficher les résultats. A l'intérieur, il y avait un processeur et une RAM de 32 nombres de 32 bits, fabriquées avec des tubes Williams (abordés dans une annexe à la fin du cours). Une instruction prenant autant de place qu'un nombre en RAM, ce qui limitait les programmes à 32 instructions maximum. Le processeur gérait 8 instructions en tout, mais la seule instruction de calcul qu'il gérait était la soustraction. L'addition n'était pas supportée. Il pouvait cependant émuler l'addition à partir d'une soustraction et inversant l'opérande soustrait.

Le Manchester Mark 1 était une amélioration du Manchester Baby. Il utilisait 4500 tubes à vide. L'ordinateur gérait des nombres de 40 bits, mais les instructions étaient codées sur 20 bits. La RAM avait la même taille, à savoir 32 nombres, leur taille était simplement augmentée. Par contre, la RAM était complémentée par l’ancêtre du disque dur magnétique, à savoir un tambour magnétique, l’ancêtre du disque dur magnétique. Il contenait 40 pages, chacune ayant la même taille que la RAM. Contrairement à la Manchester Baby, son processeur gérait l'addition. Les multiplications étaient réalisées par des additions successives, mais le processeur intégrait des registres pour mémoriser les opérandes à multiplier.

Par la suite, les ordinateurs commerciaux ont vu le jour. Les ordinateurs précédents provenaient de projets de recherches, souvent publics. Mais les entreprises privées se sont mises à fabriquer des ordinateurs elle-mêmes, pour les vendre à d'autres entreprises. On peut notamment citer les ordinateurs comme le UNIVAC I, le Bull Gamma 3 ou les premiers ordinateurs IBM. La performance de ces ordinateurs était nettement plus importante que leurs prédécesseurs, avec des fréquences de l'ordre de la centaine de kilo-hertz. Par exemple, le Bull Gamma 3 allait à 281 kHz, l'IBM 650 allait à 50 Khz.

===La seconde génération : le remplacement des tubes à vides par des transistors===

[[File:IBM 7070.jpg|vignette|Cartes imprimées de l'IBM 704, avec des transistors et résistances dessus.]]

La '''seconde génération''' est celle des ordinateurs fabriqués avec des '''transistors''' isolés, reliés entre avec des fils électriques. Les transistors en question possèdent trois broches, des pattes métalliques sur lesquelles on connecte des fils électriques. Le transistor s'utilise le plus souvent comme un interrupteur commandé par sa troisième broche. Le courant qui traverse les deux premières broches passe ou ne passe pas selon ce qu'on met sur la troisième.

[[File:Transistor basic flow.svg|centre|vignette|Un transistor est un morceau de conducteur, dont la conductivité est contrôlée par sa troisième broche/borne.]]

Les ordinateurs de seconde génération avaient entre 1000 et 500 000 transistors. Les capacités des ordinateurs étaient donc nettement supérieures à celles des ordinateurs de première génération. Une part non négligeable des ordinateurs de seconde génération supportait l'opération de multiplication, absente sur les ordinateurs de première génération. Néanmoins, cela variait beaucoup selon les ordinateurs.

Un exemple assez hors du commun est celui du premier modèle de l'IBM 1620. Le tout premier modèle n'avait aucun circuit de calcul, il n'était même pas capable de faire une addition ou une multiplication. A la place, il utilisait une table d'addition et une table de multiplication en mémoire RAM. Les deux tables devaient être initialisées par le logiciel lors du démarrage de la machine. La table d'addition faisait une centaine de chiffres, la table de multiplication faisait le double. Le processeur de l'ordinateur gérait des instructions pour faire des additions ou des multiplications, mais ces opérations lisaient le résultat dans la table d'addition. Les calculs étaient faits chiffre par chiffre, avec un encodage partiellement décimal, partiellement binaire (des chiffres décimaux étaient encodés en binaire, nous en reparlerons quand nous parlerons du BCD) !

[[File:KL CoreMemory.jpg|vignette|Mémoire à tore de ferrite.]]

Les transistors n'étaient utilisés que pour le processeur et les circuits annexes. La mémoire n'était pas faite en transistors, pas à cette époque. La mémoire était une mémoire aujourd'hui abandonnée, appelée une '''mémoire à tores de ferrite'''. Elle sera détaillée dans un chapitre ultérieur. Mais sachez pour le moment qu'il s'agit d'une mémoire au support magnétique, les données étant stockées sur un support magnétique.

Transistors comme tubes à vide prenaient beaucoup de place, ce qui fait que les ordinateurs étaient assez gros. Concrètement, ils prenaient une pièce de bâtiment entière dans le meilleur des cas. C'était l'époque des gros ''mainframes'', reliés à des terminaux, peu puissants comparé aux standards actuels. Seules les grandes entreprises et les grands instituts de recherche pouvaient se payer les services de ce genre d'ordinateurs. Seuls les professionnels avaient accès à ce genre d'équipement.

===La troisième génération : le circuit intégré===

[[File:D8259AC-2.jpg|vignette|Exemple de circuit intégré.]]

La troisième génération est toujours fabriquée avec des transistors, mais dont la taille a été réduite. Avec l'évolution de la technologie, les transistors ont diminué en taille, de plus en plus. Ils sont devenus tellement petits qu'ils ont fini par être regroupés dans des '''circuits intégrés''', des circuits regroupent plusieurs transistors sur la même puce de silicium. Les circuits intégrés se présentent le plus souvent sous la forme de boitiers rectangulaires, comme illustré ci-contre. D'autres ont des boitiers de forme carrées, comme ceux que l'on peut trouver sur les barrettes de mémoire RAM, ou à l'intérieur des clés USB/ disques SSD.

Lors de cette génération, les processeurs étaient fournis en pièces détachées qu'il fallait relier entre elles. Le processeur était composé de plusieurs circuits intégrés séparés, impossible de mettre un processeur dans un seul boitier. Un exemple de processeur conçu en kit est la série des Intel 3000. Elle regroupe plusieurs circuits séparés aux noms à coucher dehors, mais dont vous comprendrez ce qu'ils veulent dire dans les chapitres adéquats : l'Intel 3001 est un séquenceur, l'Intel 3002 regroupe unité de calcul et registres, le 3003 est un circuit d'anticipation de retenue complémentaire du 3002, le 3212 est une mémoire tampon, le 3214 est une unité de gestion des interruptions, les 3216/3226 sont des interfaces de bus mémoire. On pourrait aussi citer la famille de circuits intégrés AMD Am2900.

Même si le processeur était en pièces détachées, utiliser une dizaine de circuits intégrés était nettement mieux que d'utiliser plusieurs milliers de transistors individuels. En conséquence, les ordinateurs ont vu leur taille grandement réduite, passant de pièces entières à une simple armoire, voire à quelques cartes intégrées superposées. De plus, le prix des circuits intégré était abordable, du moins comparé aux ordinateurs d'avant. Le prix des ordinateurs a alors grandement décru, permettant à des entreprises et administrations de taille modeste de s'équiper d'ordinateurs.

===La quatrième génération : le microprocesseur===

[[File:MOS6502.svg|vignette|Microprocesseur, ici un processeur MOS6502, de la quatrième génération.]]

Lors de la troisième génération, les circuits intégrés regroupaient plusieurs dizaines ou centaines de transistors, mais sont rapidement montés en gamme. De centaines de transistors, ils sont passés au millier de transistors, puis au million et maintenant au-delà du milliard. Les transistors étaient devenus tellement petits, tellement miniaturisés, qu'il était devenu possible de mettre un processeur entier dans un circuit intégré. C'est ainsi qu'est né le microprocesseur, à savoir un processeur qui tient tout entier dans un seul circuit imprimé. La quatrième génération d’ordinateur est celle des ordinateurs basés autour d'un microprocesseur.

Les tout premiers microprocesseurs étaient des processeurs à application militaire, comme le processeur du F-14 CADC ou celui de l'Air data computer. Le tout premier microprocesseur commercialisé au grand public est le 4004 d'Intel, sorti en 1971. L'intel 4004 comprenait environ 2300 transistors, avait une fréquence de 740 MHz, pouvait faire 46 opérations différentes, et manipulait des entiers de 4 bits. Il était au départ un processeur de commande, prévu pour être intégré dans la calculatrice Busicom calculator 141-P, mais il fut utilisé pour d'autres applications quelque temps plus tard. Immédiatement après le 4004, les premiers microprocesseurs 8 bits furent commercialisés. Le 4004 fut suivi par le 8008 et quelques autres processeurs 8 bits extrêmement connus, comme le 8080 d'Intel, le 68000 de Motorola, le 6502 ou le Z80.

Les microprocesseurs permirent encore uen fois de réduire la taille des ordinateurs, qui pouvaient tenir dans un boitier de PC, ou un boitier de console de jeu. Le prix des ordinateurs a aussi chuté en même temps que les transistors étaient miniaturisés. C'est cette invention qui permis l'invention des consoles de jeux et des mini-ordinateurs, à savoir les ordinateurs personnels. Sans miniaturisation, on n'aurait pas d'ordinateur personnel, pas de PC fixe ou portable.

==L'organisation du cours : les différents niveaux d'explication==

Le fonctionnement d'un ordinateur est assez complexe à expliquer car les explications peuvent se faire sur plusieurs niveaux. Par plusieurs niveaux, on veut dire qu'un ordinateur est composé de composants très simples, qui sont assemblés pour donner des composants eux-même plus complexes, qui sont eux-même regrouper, etc. Étudier tout cela demande de voir plusieurs niveaux, allant de transistors très petits à des processeurs multicœurs. Les niveaux les plus bas sont de l'électronique pur et dure, alors que ceux plus haut sont à mi-chemin entre électronique et informatique.

===Les niveaux d'abstraction en architecture des ordinateurs===

Les trois premiers niveaux sont de l'électronique pur et dure. Ils correspondent aux premiers chapitres du cours, qui porteront sur les circuits électroniques en général.
* Le premier niveau est celui des '''transistors''', des circuits intégrés, des ''wafer'' et autres circuits de très petite taille.
* Le second niveau est celui des '''portes logiques''', des circuits très basiques, très simples, à la base de tous les autres.
* Le troisième niveau est celui dit de la '''''Register Transfer Level''''', où un circuit électronique est construit à partir de circuits basiques, dont des registres et autres circuits dits combinatoires.
Les deux niveaux suivants sont de l'informatique proprement dit. C'est dans ces deux niveaux qu'on étudie les ordinateurs proprement dit, les circuits qu'il y a dedans et non l'électronique en général.
* Le quatrième niveau est celui de la '''microarchitecture''', qui étudie ce qu'il y a à l'intérieur d'un processeur, d'une mémoire, des périphériques et autres.
* Le cinquième niveau est celui de l''''architecture externe''', qui décrit l'interface du processeur, de la mémoire, d'un périphérique ou autre. Par décrire l'interface, on veut dire : comment un programmeur voit le processeur et la mémoire, comment il peut les manipuler. Une architecture externe unique peut avoir plusieurs microarchitecture, ce qui fait qu'on sépare les deux. Tout cela sera plus clair quand on passera aux chapitres sur le processeur et les mémoires.

Nous n'allons pas voir les 5 niveaux dans l'ordre, des transistors vers l'architecture externe. En réalité, nous allons procéder autrement. La première partie du cours portera sur les trois premiers niveaux, le reste sur les deux autres. Les 5 niveaux seront vus dans des chapitres séparés, du moins le plus possible. Au niveau pédagogique, tout est plus simple si on scinde les 5 niveaux. Bien sûr, il y a quelques explications qui demandent de voir plusieurs niveaux à la fois. Par exemple, dans le chapitre sur les mémoires caches, nous auront des explications portant sur la RTL, la microarchitecture du cache et son architecture externe. Mais le gros du cours tentera de séparer le plus possible les 5 niveaux.

===Les trois parties principales du cours===

Nous allons commencer par parler du binaire, avant de voir les portes logiques. Avec ces portes logiques, nous allons voir comment fabriquer des circuits basiques qui reviendront très souvent dans la suite du cours. Nous verrons les registres, les décodeurs, les additionneurs et plein d'autres circuits. Puis, nous reviendrons au niveau des transistors pour finir la première partie. La raison est que c'est plus simple de faire comme cela. Tout ce qui a trait aux transistors sert à expliquer comment fabriquer des portes logiques, et il faut expliquer les portes logiques pour voir le niveau de la RTL.

Une fois la première partie finie, nous allons voir les différents composants d'un ordinateur. Une première partie expliquera ce qu'il y a dans un ordinateur, quels sont ses composants. Nous y parlerons de l'architecture de base, de la hiérarchie mémoire, des tendances technologiques, et d'autres généralités qui serviront de base pour la suite. Puis, nous verrons dans l'ordre les bus électroniques, les mémoires RAM/ROM, le processeur, les périphériques, les mémoires de stockage (SSD et disques durs) et les mémoires caches. Pour chaque composant, nous allons voir leur architecture externe, avant de voir leur microarchitecture. La raison est que la microarchitecture ne peut se comprendre que quand on sait quelle architecture externe elle implémente.

Enfin, dans une troisième partie, nous allons voir les optimisations majeures présentes dans tous les ordinateurs modernes, avec une partie sur le pipeline et le parallélisme d'instruction, et une autre sur les architectures parallèles. Pour finir, les annexes de fin parlerons de sujets un peu à part.

&lt;noinclude&gt;
{{NavChapitre | book=Fonctionnement d'un ordinateur
           | next=L'encodage des données
           | nextText=L'encodage des données
}}
&lt;/noinclude&gt;</text>
      <sha1>os0cuco7xo0fudoyuuzvua93r1al2a3</sha1>
    </revision>
    <revision>
      <id>744163</id>
      <parentid>744162</parentid>
      <timestamp>2025-06-05T15:17:12Z</timestamp>
      <contributor>
        <username>Mewtow</username>
        <id>31375</id>
      </contributor>
      <minor />
      <comment>/* La seconde génération : le remplacement des tubes à vides par des transistors */</comment>
      <origin>744163</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="46946" sha1="fy2b6laufhnhkqjqmiovcw8aenezh6q" xml:space="preserve">Pour commencer, nous allons voir qu'il existe de nombreux types d'ordinateurs. Le plus connu est certainement le PC, l'ordinateur personnel, que vous avez sans doute dans votre salon. Les ordinateurs portables sont un deuxième type d'ordinateur assez intuitif, que vous avez peut-être. Mais il y a aussi d'autres types d'ordinateurs auxquels vous n'avez jamais été confrontés.

==Les différents types d'ordinateurs==

Dans cette section, nous allons décrire rapidement les ordinateurs les plus courant, mais surtout voir ce qu'il y a à l'intérieur d'un ordinateur.

===L'ordinateur de type PC fixe===

De l'extérieur, l'ordinateur est composé d'une unité centrale sur laquelle on branche des périphériques.

[[File:Typical computer architecture systems.jpg|vignette|upright=1.5|Exemples de périphériques, connectés à une unité centrale (ici appelée à tort ''operating system'').]]

Les '''périphériques''' regroupent l'écran, la souris, le clavier, l'imprimante, et bien d'autres choses. Ils permettent à l'utilisateur d'interagir avec l'ordinateur : un clavier permet de saisir du texte sous dans un fichier, une souris enregistre des déplacements de la main en déplacement du curseur, un écran affiche des données d’images/vidéos, un haut-parleur émet du son, etc. Tout ce qui est branché sur un ordinateur est, formellement un périphérique.

L''''unité centrale''' est là où se trouvent tous les composants importants d'un ordinateur, ceux qui font des calculs, qui exécutent des logiciels, qui mémorisent vos données, etc. Voici ce à quoi ressemble l'intérieur de l'unité centrale. Trois sections sont visibles : l'alimentation électrique en haut à gauche, la carte mère en bas à gauche et en jaune/orange, les disques et lecteurs à droite des câbles. Et on voit aussi beaucoup de câbles.

[[File:Asus P5K-SEIntel E6320.jpg|centre|vignette|upright=2|Exemple d'unité centrale.]]

Tout en haut à gauche, se trouve l''''alimentation électrique''', qui convertit le courant de la prise électrique en un courant plus faible, utilisable par les autres composants. Elle émet de nombreux câbles assez gros, qui sont reliés au reste. Les PC actuels utilisent des alimentations électriques standardisées, qui fournissent trois tensions au reste de l'ordinateur : une tension de 12 Volts, une de 5 Volts, une de 3,3 Volts.

À droite, caché par la partie &quot;métallique&quot; du boitier, se trouvent les lecteurs de CD/DVD, et les disques durs. Les lecteurs CD-ROM ou DVD-ROM permettaient de lire des CD ou des DVD. Je parle au passé, car ils ont aujourd'hui disparu des ordinateurs modernes. Les '''disques durs''' sont des mémoires de stockage, qui mémorisent vos données de manière permanente. De nos jours, ils sont remplacés par des SSD, qui sont des disques durs électroniques, là où les disques durs proprement dit sont des mémoires magnétiques. Nous verrons la différence dans deux chapitres dédiés, un sur les disques durs, l'autre sur les SSD.

En bas à droite, se trouve la '''carte mère''' un support plat, en plastique ou en céramique, sur laquelle sont soudés/connectés les autres composants. Sur celle-ci, de nombreux composants sont soudés, d'autres sont branchés dessus avec des câbles, d'autres sont connectés dessus avec des connecteurs. Ils sont reliés entre eux par des fils conducteurs, le plus souvent du cuivre ou de l’aluminium, ce qui leur permet de s’échanger des données. Sur les cartes simples, ces fils sont intégrés dans la carte électronique, dans des creux du plastique. Ils portent le nom de pistes.

Avant, les disques durs, SSD et lecteurs de CD/DVD sont branchés dessus via des connecteurs dédiés, appelés des connecteurs S-ATA. De nos jours, ils sont branchés sur un autre connecteur, grâce à l'interface NVME. Toujours est-il qu'ils sont reliés à la carte mère par des câbles, ce qui montre que ce sont des sortes de périphériques interne. Ils sont placés dans le boitier, mais on aurait tout aussi bien pu les mettre à l'extérieur, vu qu'ils communiquent avec l'ordinateur par l'intermédiaire d'un câble ou d'un connecteur dédié.

Mais deux autres composants très importants sont eux placés sur la carte mère, directement. Ils ont chacun un connecteur dédié, sur lequel ils sont branchés directement, sans passer par l'intermédiaire d'un câble, mais sans être soudés non plus. Il s'agit du processeur et de la mémoire RAM, deux composants centraux des PC modernes.

[[File:Pentium III SL4CB.jpg|thumb|Processeur Pentium III.]]

Le '''processeur''' traite les données, les modifie, les manipule. Pour faire simple, il s’agit d’une grosse calculatrice hyper-puissante. Il comprend à la fois un circuit qui fait des calculs, et un circuit de contrôle qui s'occupe de séquencer les calculs dans l'ordre demandé. Il est souvent caché sous un radiateur, lui-même surmonté par un ventilateur. En effet, un processeur chauffe beaucoup, ce qui demande d'évacuer cette chaleur. Un chapitre entier expliquera pourquoi les processeurs chauffent, ainsi que les techniques utilisées pour limiter leur production de chaleur et leur consommation électrique.

La '''mémoire vive''' conserve des informations/données temporairement, tant que le processeur en a besoin. Elle prend la forme de barrettes de RAM, comme montré ci-dessous.

[[File:2 gb ddr2 667.jpg|centre|vignette|upright=2|Barrette de RAM.]]

Outre ces composants dits principaux, un ordinateur peut comprendre plusieurs composants moins importants, surtout présents sur les ordinateurs personnels. Ils sont techniquement facultatifs, mais sont très présents dans les ordinateurs personnels. Cependant, certains ordinateurs spécialisés s'en passent. Il s'agit des diverses '''cartes d'extension''' sont branchées sur la carte mère. Elles permettent d’accélérer certains calculs ou certaines applications, afin de décharger le processeur. Par exemple, la carte graphique s'occupe des calculs graphiques, qu'il s'agisse de graphismes 3D de jeux vidéos ou de l'affichage en 2D du bureau. Dans un autre registre, la carte son prend en charge le microphone et les haut-parleurs.

[[Fichier:Personal computer, exploded 4.svg|thumb|upright=1.0|Éclaté d'un ordinateur de type PC :&lt;br /&gt;
1 : Écran ;&lt;br /&gt;
2 : Carte mère ;&lt;br /&gt;
3 : Processeur ;&lt;br /&gt;
4 : Câble Parallel ATA ;&lt;br /&gt;
5 : Mémoire vive (RAM) ;&lt;br /&gt;
6 : Carte d'extension ;&lt;br /&gt;
7 : Alimentation électrique ;&lt;br /&gt;
8 : Lecteur de disque optique ;&lt;br /&gt;
9 : Disque dur ;&lt;br /&gt;
10 : Clavier ;&lt;br /&gt;
11 : Souris.]]

Si on regarde une carte mère de face, on voit un grand nombre de connecteurs, mais aussi des circuits électroniques soudés à la carte mère.

[[File:Architecture matérielle d'une carte mère.png|centre|vignette|upright=2.0|Architecture matérielle d'une carte mère]]

Les '''connecteurs''' sont là où on branche les périphériques, la carte graphique, le processeur, la mémoire, etc. Dans l'ensemble, toute carte mère contient les connecteurs suivants :
* Le processeur vient s’enchâsser dans la carte mère sur un connecteur particulier : le '''socket'''. Celui-ci varie suivant la carte mère et le processeur, ce qui est source d'incompatibilités.
* Les barrettes de mémoire RAM s’enchâssent dans un autre type de connecteurs: les '''slots mémoire'''.
* Les mémoires de masse disposent de leurs propres connecteurs : connecteurs P-ATA pour les anciens disques durs, et S-ATA pour les récents.
* Les périphériques (clavier, souris, USB, Firewire, ...) sont connectés sur un ensemble de connecteurs dédiés, localisés à l'arrière du boitier de l'unité centrale. 
* Les autres périphériques sont placés dans l'unité centrale et sont connectés via des connecteurs spécialisés. Ces périphériques sont des cartes imprimées, d'où leur nom de '''cartes filles'''. On peut notamment citer les cartes réseau, les cartes son, ou les cartes vidéo.

===Les ordinateurs portables===

[[File:Samsung QX-511 (2).JPG|vignette|Ordinateur portable Samsung QX-511 (2), pour illustration.]]

Un ordinateur portable est identique à un ordinateur de type PC. Si vous ouvrez votre ordinateur portable (attention à la garantie), vous retrouverez les mêmes composants qu'un PC à l'intérieur. Un point important est la présence d'une batterie à l'intérieur du PC portable, absente des PC fixes.

[[File:LG gram 14Z90Q mainboard with battery.jpg|centre|vignette|upright=2|LG gram 14Z90Q avec sa batterie.]]

Une fois la batterie et les circuits associés retiré, la seule différence notable est que tous les composants sont soudés sur la carte mère, au lieu d'être branchés sur des connecteurs, à part éventuellement la RAM et le disque dur.

[[File:LG gram 14Z90Q mainboard without battery.jpg|centre|vignette|upright=2|LG gram 14Z90Q sans sa batterie.]]

La RAM est parfois soudée sur la carte mère, d'autres fois sous la forme de barrettes de mémoire vive semblables à celles des PC. Dans le dernier cas, elle est connectée à des connecteurs spécifiques, ce qui permet de les changer/upgrader. Les PC portables sont parfois construits de manière à pouvoir changer la RAM facilement, en ouvrant un cache spécial, concu pour.

[[File:Lenovo G555 состав - Донор.JPG|centre|vignette|upright=2|Lenovo G555.]]

La conception d'un ordinateur portable est légèrement différente de celle d'un PC, pour des raisons thermiques. Un PC fixe a plus de place pour évacuer sa chaleur. Les ventilateurs peuvent plus facilement déplacer l'air dans le boitier, même si le flux d'air dans le boitier est éventuellement gêné par la carte graphique. Mais l'évacuation de la chaleur est assez efficace. Sur les PC portables, leur finesse fait que le trajet de l'air est beaucoup plus contraint. Évacuer la chaleur produite par l'ordinateur est plus complexe, ce qui demande d'utiliser des systèmes de refroidissement et de ventilation spécifiques.

Là où les PC fixes se débrouillent avec des radiateurs et des ventilateurs posés sur le processeur, les PC portables font autrement. Ils ne peuvent pas forcément mettre le ventilateur sur le processeur. A la place, ils mettent le ventilateur à côté, mais le processeur est surmonté par un mécanisme de transmission de la chaleur, qui transfère la chaleur du processeur vers le ventilateur.

[[File:Diagram - How a laptop cooling system works.png|centre|vignette|upright=2|Comment fonctionne le système de ventilation d'un ordinateur portable, en anglais.]]

Les difficultés pour dissiper la chaleur font que les ordinateurs portables utilisent souvent des composants peu performants, mais qui chauffent peu. En effet, nous verrons que plus un composant est puissant, plus il chauffe. La relation n'est pas parfaite, mais les processeurs haute performance chauffent plus que les modèles d'entrée ou milieu de gamme moins puissants. En conséquence, les PC portables sont souvent moins puissants que les PC fixes, même pour les modèles dit ''gaming''.

===Les serveurs et ''mainframes''===

Les grandes entreprises utilisent des ordinateurs de grande taille, très puissants, appelés des ''mainframes''. Ils sont souvent confondus avec les serveurs par le grand public, il y a une différence entre les deux. Un serveur est une fonction logicielle/réseau, pas un type d'ordinateur. Mais laissons cette différence de côté, ce qui est dit pour les ''mainframes'' sert pour les gros serveurs haute performance.

[[File:IBM Z15 mainframe.jpg|vignette|Exemple de ''mainframe''' de type IBM Z15.]]

Les anciens ''mainframes'' des années 50-80 avaient une taille pouvant être impressionnante, au point de prendre une pièce complète d'un bâtiment. Mais de nos jours, les ''mainframes'' tiennent dans une grosse armoire un peu haute. Les ''mainframes'' doivent rester allumé en permanence et ne doivent pas être éteint, sauf éventuellement quelques jours par an pour des opérations de maintenance. Ils utilisent pour cela des techniques spécifiques, avec beaucoup de redondance interne.

[[File:ACONIT hall grandes machines.jpg|centre|vignette|upright=2|''Mainframe'' ACONIT.]]

Les ''mainframes'' sont aussi conçus pour mutualiser au maximum leur utilisation, ils peuvent être utilisés par plusieurs utilisateurs à la suite, voire en même temps. Pour cela, les anciens ''mainframes'' étaient capables de faire tourner plusieurs applications distinctes l'une à la suite de l'autre, avec des commutations fréquentes entre logiciels. De nos jours, ils sont capables d'exécuter un grand nombre de tâches en même temps, grâce à la présence de plusieurs processeurs. Les ''mainframes'' modernes sont même capables de faire tourner plusieurs systèmes d'exploitation en même temps si besoin.

Les anciens ''mainframes'' étaient des ordinateurs assez simples, avec un processeur, de la mémoire RAM, un ou plusieurs disques durs, pas plus. Le ''mainframe'' était tellement énorme et cher que les entreprises n'en avaient qu'un seul pour toute l'entreprise. Les employés avaient sur leur bureau des terminaux, qui permettaient d'accéder à l'ordinateur central, mais n'étaient pas des ordinateurs. Les terminaux étaient des composants électroniques simples, avec un écran, un clavier et une souris, mais sans processeur. Ils envoyaient des données au ''mainframe'', ils en recevaient de sa part, mais tout traitement était réalisé sur le ''mainframe''. L'arrivée sur le marché des ordinateurs personnels, de type PC fixe/portable, a entrainé l'abandon de ce genre de pratique, tous les employés ont maintenant un ordinateur rien que pour eux.

{|
|-
! colspan=&quot;2&quot; | Exemples de terminaux
|-
|[[File:Terminal-in2-sm9400.jpg|centre|vignette|upright=1.5|Exemple de terminal. Notez la présence d'un écran et d'un clavier, mais l'asbence d'une unité centrale.]]
|[[File:Chromatics CT4100.jpg|vignette|upright=1.5|Autre exemple de terminal. Le clavier est couplé à un stylo CRT, qui remplacait la souris et agissait sur l'écran comme s'il était tactile.]]
|-
! colspan=&quot;2&quot; | Intérieur d'un terminal
|-
|[[File:CT1024 Monitor.jpg|vignette|upright=1.5|Terminal CT1024, sans le boitier extérieur.]]
|[[File:CT1024 Terminal System.jpg|vignette|upright=1.5|Terminal CT1024, description des composants interne.]]
|}

De nos jours, les ''mainframes'' contiennent en réalité plusieurs ordinateurs simples interconnectés via un réseau local. Un ''mainframe'' qui tient dans une armoire contient facilement une dizaine ou centaine de processeurs, plein de RAM, des disques durs séparés dans une armoire distincte, etc. Vu qu'ils communiquent uniquement via le réseau, ils n'ont pas d'interface, pas d'écran, 'entrée via clavier/souris. Le tout est commandé avec une console de commande, typiquement un ordinateur portable ou un terminal assez simple séparé de l'armoire, qui permet à un administrateur de faire des opérations de surveillance, configuration et maintenance. Il peut y avoir une console de commande pour plusieurs armoires séparées, la console peut même être dans un autre bâtiment et accéder au ''mainframe'' par le réseau.

[[File:IBM System Z9 (type 2094 inside).jpg|centre|vignette|upright=2|''Mainframe'' de type IBM System Z9. L'ordinateur portable sert de console pour qu'un administrateur fasse des opérations de surveillance, configuration et maintenance.]]

Les processeurs et la RAM sont typiquement installés sur des cartes amovibles, qui sont connectées au fond de l'armoire lors de l'installation. Il est même possible de retirer ou d'ajouter des cartes en fonctionnement, afin d'ajouter/retirer des processeurs, des disques durs, etc. Ce qui est très utile si un composant est en panne et qu'il faut le remplacer. 

[[File:IBM TotalStorage Exp400.jpg|centre|vignette|upright=2|IBM TotalStorage Exp400]]

==Un peu d'abstraction : qu'est-ce qu'un ordinateur ?==

Un ordinateur comprend donc un processeur, plusieurs mémoires, des cartes d'extension et une carte mère pour connecter le tout. Mais il s'agit là d'une description assez terre-à-terre de ce qu'est un ordinateur. Une autre description, plus abstraite, se base sur le fait qu'un ordinateur est une énorme calculatrice programmable. Elle permet d'expliquer pourquoi il y a une distinction entre processeur et mémoire, entre unité centrale et périphériques. Tout ce qui va suivre pourra vous paraitre assez abstrait, mais rassurez-vous : les prochains chapitres rendront tout cela plus concrets.

===La séparation entre entrées-sorties et traitement===

L'unité centrale peut être vue comme une énorme calculatrice ultra-puissante, qui exécute des commandes/opérations. Mais à elle seule, elle ne servirait à rien, il faut interagir avec par l'intermédiaire de plusieurs périphériques. Il existe deux types de périphériques, qui sont conceptuellement différents. Les périphériques comme le clavier ou la souris permettent d'envoyer des informations à l'ordinateur, d'agir sur celui-ci. A l'inverse, les écrans transmettent des informations dans le sens inverse : de l'ordinateur vers l'utilisateur. Les premiers sont appelés des '''entrées''', les seconds des '''sorties'''.

Dans un ordinateur, les informations sont représentées sous la forme de nombres. Toute donnée dans un ordinateur est codée avec un ou plusieurs nombres regroupés dans une donnée, un fichier, ou autre. Et la transmissions avec les entrées et sorties se fait là-encore avec des nombres. Par exemple, quand vous appuyez sur votre clavier, le clavier envoie un numéro de touche à l'unité centrale, qui indique quelle touche a été appuyée. L'image à afficher à l'écran est codée sous la forme d'une suite de nombres (un par pixel). L'image est envoyée à l'écran, qui traduit la suite de nombre en image à afficher. Les entrées traduisent des actions utilisateurs en nombres, on dit que les entrées encodent les actions utilisateur. Les sorties font la traduction inverse, elles transforment des suites de nombres en une action physique. On dit qu'elles décodent des informations.

Pour résumer, toute appareil électronique est composé par :
* Des '''entrées''' sur lesquelles l'utilisateur agit sur l'ordinateur. Les entrées transforment les actions de l'utilisateur en nombres, qui sont interprétés par l'ordinateur.
* Une '''unité de traitement''', qui manipule des nombres et fait des calculs/opérations dessus. Les nombres proviennent des entrées, du disque dur, ou d'autres sources, peu importe.
* Des '''sorties''', qui va récupèrent le résultat calculé par l'unité de traitement pour en faire quelque chose : écrire sur une imprimante ou sur un moniteur, émettre du son,...

[[File:Ordinateur théorique Simple 1.png|centre|vignette|upright=2|Ordinateur théorique Simple 1]]

L'unité de traitement proprement dite, celle qui fait les calculs, est couplée à une mémoire qui mémorise les opérandes et résultats des calculs. La séparation entre processeur et mémoire est nécessaire pour qu'un appareil électronique soit qualifié d'ordinateur. De nombreux appareils n'ont pas de séparation entre unité de traitement et mémoire, comme certaines vielles radios AM/FM.

[[File:Schéma de principe d'un ordinateur.png|centre|vignette|upright=2|Schéma de principe d'un ordinateur]]

===Un ordinateur est un appareil programmable===

Les appareils simples sont non-programmables, ce qui veut dire qu’ils sont conçus pour une utilisation particulière et qu’ils ne peuvent pas faire autre chose. Par exemple, les circuits électroniques d’un lecteur de DVD ne peuvent pas être transformé en lecteur audio ou en console de jeux... Les circuits non-programmables sont câblés une bonne fois pour toute, et on ne peut pas les modifier. On peut parfois reconfigurer le circuit, pour faire varier certains paramètres, via des interrupteurs ou des boutons, mais cela s’arrête là. Et cela pose un problème : à chaque problème qu'on veut résoudre en utilisant un automate, on doit recréer un nouveau circuit.

À l'inverse, un ordinateur n’est pas conçu pour une utilisation particulière, contrairement aux autres objets techniques. Il est possible de modifier leur fonction du jour au lendemain, on peut lui faire faire ce qu’on veut. On dit qu'ils sont '''programmables'''. Pour cela, il suffit d’utiliser un logiciel, une application, un programme (ces termes sont synonymes), qui fait ce que l'on souhaite. La totalité des logiciels présents sur un ordinateur sont des programmes comme les autres, même le système d'exploitation (Windows, Linux, ...) ne fait pas exception.

Un programme est une suite de d''''instructions machines''', chaque instruction effectuant une action dans l'ordinateur. Sur les ordinateurs modernes, les instructions les plus communes effectuent une opération arithmétique : une addition, une multiplication, une soustraction, etc. Les ordinateurs modernes sont donc de grosses calculettes très puissantes, capables d'effectuer des millions d'opérations par secondes.

Et qui dit opération dit nombres : un ordinateur gère nativement des nombres, qui sont codés en binaire sur la quasi-totalité des ordinateurs modernes. Les ordinateurs modernes sont capables de faire des calculs sur des nombres entiers, mais aussi des nombres à virgule. Il existe plusieurs manières de représenter des nombres en binaire, certaines représentant des nombres entiers dits naturels (0 et plus), d'autres des nombres signés (positifs ou négatifs), d'autres des nombres à virgule. Un chapitre entier détaillera comment sont encodés ces nombres.

Une instruction est représentée dans un ordinateur par une série de nombres entiers : un nombre qui indique quelle opération/commande effectuer et des autres nombres pour coder les données (ou de quoi les retrouver dans l'ordinateur). L'ordinateur récupére les commandes une par une, les traduit en opération à effectuer, exécuter l'opération, et enregistre le résultat. Puis il recommence avec la commande suivante.

[[File:Ordinateur Théorique Complexe 1.png|centre|vignette|upright=3|Ordinateur Théorique Complexe. En jaune, le programme informatique, la liste de commande. Le rectangle gris est l'ordinateur proprement dit.]]

De nombreux appareils sont programmables, mais tous ne sont pas des ordinateurs. Par exemple, certains circuits programmables nommés FPGA n'en sont pas. Pour être qualifié d'ordinateur, un appareil programmable doit avoir un processeur séparé de la mémoire. De plus, il doit utiliser un '''codage numérique''', chose que nous allons aborder dans le chapitre suivant.

===Les ordinateurs à programme mémorisé ou programme externe===

[[File:Blue-punch-card-front.png|vignette|upright=0.5|Carte Perforée.]]

Au tout début de l'informatique, les programmes étaient enregistrés sur des cartes perforées, à savoir des cartes en papier/plastique percées par endroits. Un 1 est codé par un trou dans le papier et un 0 par une absence de trou. Les programmes étaient exécutés par l'ordinateur quand on insérait la carte perforée dans le lecteur et qu'on appuyait sur un bouton.

Par la suite, les premiers ordinateurs grand public, comme les Amstrad ou les Commodore, utilisaient des cassettes audio magnétiques pour stocker les programmes. Dans le même style, les consoles de jeu utilisaient autrefois des cartouches de jeu, qui contenaient le programme du jeu à exécuter. Pour résumer, les anciens ordinateurs mémorisaient les programmes sur un support externe, lu par un périphérique. De tels ordinateurs sont dits à '''programme externe'''.

: D’anciens ordinateurs personnels, comme l’Amstrad ou le Commodore, permettaient de taper les programmes à exécuter à la main, au clavier, avant d’appuyer une touche pour les exécuter. Nul besoin de vous dire que les cassettes audio étaient plus pratiques.

Mais de nos jours, les programmes sont enregistrés sur le disque dur de l'ordinateur ou dans une mémoire intégrée à l'ordinateur. On dit qu'ils sont installés, ce qui est un mot bien compliqué pour dire que le programme est enregistré sur le disque dur de l’ordinateur. A défaut de disque dur, le programme/logiciel est enregistré dans une mémoire spécialisée pour le stockage. Par exemple, sur les cartes électroniques grand public de marque Arduino, les programmes sont envoyés à la carte via le port USB, mais les programmes sont enregistrés dans la carte Arduino, dans une mémoire FLASH dédiée. Disque dur ou non, le programme est mémorisé dans la mémoire de l'ordinateur. Il est possible d'installer ou de désinstaller les programmes en modifiant le contenu de la mémoire. Le terme utilisé est alors celui de '''programme stocké en mémoire'''.

Les programmes à installer sont disponibles soit sur un périphérique, comme un DVD ou une clé USB, soit sont téléchargés depuis internet. Les premiers PC fournissaient les logiciels sur des disquettes, qui contenaient un programme d'installation pour enregistrer le programme sur le disque dur de l'ordinateur. Par la suite, le support des logiciels a migré vers les CD et DVD, les logiciels devenant de plus en plus gros. De nos jours, la majorité des applications sont téléchargées depuis le net, l'usage de périphériques est devenu obsolète, même les consoles de jeu abandonnent cette méthode de distribution.

==Les générations d'ordinateurs : un historique rapide==

L'informatique a beaucoup évolué dans le temps. Et une bonne partie de cette évolution tient à l'évolution de l’électronique sous-jacente. Les ordinateurs actuels sont fabriqués avec des transistors, des petits composants électroniques qui servent d'interrupteurs programmables, qu'on détaillera dans ce qui suit. Mais ça n'a pas toujours été le cas. Et cela permet de distinguer plusieurs '''générations d'ordinateurs'''.

===Les ordinateurs électro-mécaniques : les premiers ordinateurs===

Le tout premier ordinateur est le '''Z1''', un modèle unique inventé par Konrad Suze entre 1936 et 1938. Son processeur gérait non pas des nombres entiers, mais des nombres à virgule (des nombres dits flottants, pour être précis), encodés sur 22 bits. Le processeur du Z1 était capable de faire des additions et des soustractions, car il intégrait un circuit additionneur-soustracteur basique. Des circuits annexes permettaient de faire des multiplications et des divisions en enchainant des additions/soustractions successives. Il fonctionnait à une fréquence de 1 Hz, ce qui fait qu'il pouvait faire une addition/soustraction par seconde maximum.

Niveau mémoire, la RAM de l'ordinateur était très limitée : seulement 16 nombres de 22 bits chacun. S'il s'agissait d'une mémoire électronique, les programmes étaient mémorisés sur une mémoire mécanique et précisémment sur des cartes perforées, à savoir des cartes en papier/plastique dans lesquelles un 1 est codé par un trou dans le papier et un 0 par une absence de trou. Les programmes étaient exécutés par l'ordinateur quand on insérait la carte perforée dans le lecteur et qu'on appuyait sur un bouton.

[[File:German Museum of Technology, Berlin 2017 024.jpg|centre|vignette|upright=2|Réplique du Z1 au ''German Museum of Technology'' de Berlin, 2017.]]

Après sa destruction dans un bombardement, le Z1 a été reconstruit et amélioré, ce qui donné les deux ordinateurs Z2 et Z3. Quelques années plus tard, quelques laboratoires de recherche ont fabriqués des ordinateurs dans leur coin, comme le Harvard Mark I et le Colossus Mark 1 (UK) qui ont été mis en service en 1944. Ils ont servi pour les cryptanalystes pour casser les codes utilisés par les Allemands pour leurs transmissions, pendant la seconde guerre mondiale.

Les ordinateurs cités dans le précédent paragraphe étaient tous des ordinateurs dit '''électro-mécaniques''', car ils mélangeaient des composants électroniques et des composants mécaniques (tout ce qui a trait aux cartes perforées, notamment). Les composants électroniques étaient généralement des relais, à savoir des interrupteurs commandables électriquement, qui sont plus ou moins équivalents aux transistors modernes. La majeure partie des ordinateurs des années 40 étaient de ce type, mais leur nombre n'a pas dépassé 30. Il faut dire qu'ils ont rapidement laissé la place à des ordinateurs purement électroniques, que nous allons voir dans ce qui suit.

===La première génération : les tubes à vide===

Les ordinateurs qui ont suivi les ordinateurs électromécaniques sont regroupés dans la '''première génération d'ordinateur'''. Ils étaient conçus avec des tubes à vide, des espèces d'interrupteurs commandables, les ancêtres des transistors modernes. Les tubes à vide étaient assez encombrants, ils consommaient beaucoup de courant, ils chauffaient et étaient assez peu fiables. Ils tombaient en panne assez souvent. Et ils étaient assez simples à fabriquer, mais restaient malgré tout chers.

Les tubes à vides étaient utilisés pour le processeur et quelques circuits annexes, mais les mémoires utilisaient d'autres technologies. Les mémoires de l'époque n'étaient pas du tout des mémoires électroniques. Il existait déjà des ancêtres des disques durs, à savoir des mémoire magnétiques appelées tambours magnétiques, bandes magnétiques, mémoires à tore de ferrite, etc. Les mémoires RAM, quant à elles, utilisaient elles des technologies totalement abandonnées : les mémoires à lignes de délai étaient des mémoires acoustiques, les tubes Williams étaient des écrans CRT modifiés, etc. Un chapitre entier sera dédié aux technologies des mémoires de l'époque.

[[File:Elektronenroehren-auswahl.jpg|centre|vignette|upright=2|Tubes à vides.]]

L'usage de tubes à vide les place entre les premiers ordinateurs électro-mécaniques et les ordinateurs utilisant des transistors. Au vu de la taille des tubes à vide, les ordinateurs de l'époque étaient composés de plusieurs milliers de ces tubes, guère plus. Et malgré cela, un ordinateur prenait facilement un étage de bâtiment entier, ou au moins plusieurs pièces. La conséquence est que les ordinateurs de première génération étaient très simples, rudimentaires quand on les compare aux ordinateurs modernes. Ils ne géraient que quelques opérations simples : l'addition, la soustraction, pas grand-chose de plus. À quelques exceptions près, ils ne géraient pas la multiplication et encore moins la division, cela aurait demandé trop de tubes à vides.

Une des toutes premières machines construite avec des tubes à vide était l'Atanasoff–Berry. Ce n'était pas un ordinateur, car elle ne pouvait pas exécuter de programme sans intervention humaine pour séquencer des opérations, mais c'était la première machine de calcul purement électronique, sans aucune pièce mécanique. Elle utilisait une mémoire RAM construite avec des condensateurs, ceux-ci étant placés sur des cylindres tournants. Les circuits de calcul étaient construits avec des tubes à vide et faisaient leur travail un bit à la fois. Elle fonctionnait à une fréquence de 60 Hz et pouvait faire 30 additions/soustractions par seconde. Les nombres étaient encodés sur 50 bits. 

[[File:Atanasoff Berry Computer.gif|centre|vignette|upright=2.5|Atanasoff–Berry.]]

L'arrivée de l'ENIAC en 1945 a changé la donne. Cet ordinateur a introduit plusieurs innovations majeures. La première est assez technique, il s'agit de la turing-complétude, elle a trait aux programmes qui peuvent être écrit pour un ordinateur, nous ne la détaillerons pas ici.

[[File:BabyArchitecture.png|vignette|Architecture de la Manchester Baby.]]

En 1948, le ''Manchester Baby'' a introduit une innovation extrêmement importante : le programme n'était plus mémorisé sur des cartes perforées, mais dans une mémoire électronique à l’intérieur de l'ordinateur lui-même. En clair, le ''Manchester Baby'' était le premier '''ordinateur à programme stocké en mémoire''' en français. Au-delà de ça, le Manchester Baby restait quand même très simple, c'était limite un prototype.

Niveau interface, l'ordinateur avait une console avec 32 boutons, des interrupteurs et un écran de sortie sur lequel afficher les résultats. A l'intérieur, il y avait un processeur et une RAM de 32 nombres de 32 bits, fabriquées avec des tubes Williams (abordés dans une annexe à la fin du cours). Une instruction prenant autant de place qu'un nombre en RAM, ce qui limitait les programmes à 32 instructions maximum. Le processeur gérait 8 instructions en tout, mais la seule instruction de calcul qu'il gérait était la soustraction. L'addition n'était pas supportée. Il pouvait cependant émuler l'addition à partir d'une soustraction et inversant l'opérande soustrait.

Le Manchester Mark 1 était une amélioration du Manchester Baby. Il utilisait 4500 tubes à vide. L'ordinateur gérait des nombres de 40 bits, mais les instructions étaient codées sur 20 bits. La RAM avait la même taille, à savoir 32 nombres, leur taille était simplement augmentée. Par contre, la RAM était complémentée par l’ancêtre du disque dur magnétique, à savoir un tambour magnétique, l’ancêtre du disque dur magnétique. Il contenait 40 pages, chacune ayant la même taille que la RAM. Contrairement à la Manchester Baby, son processeur gérait l'addition. Les multiplications étaient réalisées par des additions successives, mais le processeur intégrait des registres pour mémoriser les opérandes à multiplier.

Par la suite, les ordinateurs commerciaux ont vu le jour. Les ordinateurs précédents provenaient de projets de recherches, souvent publics. Mais les entreprises privées se sont mises à fabriquer des ordinateurs elle-mêmes, pour les vendre à d'autres entreprises. On peut notamment citer les ordinateurs comme le UNIVAC I, le Bull Gamma 3 ou les premiers ordinateurs IBM. La performance de ces ordinateurs était nettement plus importante que leurs prédécesseurs, avec des fréquences de l'ordre de la centaine de kilo-hertz. Par exemple, le Bull Gamma 3 allait à 281 kHz, l'IBM 650 allait à 50 Khz.

===La seconde génération : le remplacement des tubes à vides par des transistors===

[[File:IBM 7070.jpg|vignette|Cartes imprimées de l'IBM 704, avec des transistors et résistances dessus.]]

La '''seconde génération''' est celle des ordinateurs fabriqués avec des '''transistors''' isolés, reliés entre avec des fils électriques. Les transistors en question possèdent trois broches, des pattes métalliques sur lesquelles on connecte des fils électriques. Le transistor s'utilise le plus souvent comme un interrupteur commandé par sa troisième broche. Le courant qui traverse les deux premières broches passe ou ne passe pas selon ce qu'on met sur la troisième.

[[File:Transistor basic flow.svg|centre|vignette|Un transistor est un morceau de conducteur, dont la conductivité est contrôlée par sa troisième broche/borne.]]

Les ordinateurs de seconde génération avaient entre 1000 et 500 000 transistors. Les capacités des ordinateurs étaient donc nettement supérieures à celles des ordinateurs de première génération. Une part non négligeable des ordinateurs de seconde génération supportait l'opération de multiplication, absente sur les ordinateurs de première génération. Néanmoins, cela variait beaucoup selon les ordinateurs.

Un exemple assez hors du commun est celui du premier modèle de l'IBM 1620. Le tout premier modèle n'avait aucun circuit de calcul, il n'était même pas capable de faire une addition ou une multiplication. A la place, il utilisait une table d'addition et une table de multiplication en mémoire RAM. Les deux tables devaient être initialisées par le logiciel lors du démarrage de la machine. La table d'addition faisait une centaine de chiffres, la table de multiplication faisait le double. Le processeur de l'ordinateur gérait des instructions pour faire des additions ou des multiplications, mais ces opérations lisaient le résultat dans la table d'addition. Les calculs étaient faits chiffre par chiffre, avec un encodage partiellement décimal, partiellement binaire (des chiffres décimaux étaient encodés en binaire, nous en reparlerons quand nous parlerons du BCD) !

[[File:KL CoreMemory.jpg|vignette|Mémoire à tore de ferrite.]]

Les transistors n'étaient utilisés que pour le processeur et les circuits annexes. La mémoire n'était pas faite en transistors, pas à cette époque. La mémoire était une mémoire aujourd'hui abandonnée, appelée une '''mémoire à tores de ferrite'''. Elle sera détaillée dans un chapitre ultérieur. Mais sachez pour le moment qu'il s'agit d'une mémoire au support magnétique, les données étant stockées sur un support magnétique.

Les transistors étaient au départ de la même taille que les tubes à vide, mais ils ont rapidement rétrécit. Ils prenaient encore beaucoup de place dans les 60-70, ce qui fait que les ordinateurs étaient assez gros. Concrètement, ils prenaient une pièce de bâtiment entière dans le meilleur des cas. C'était l'époque des gros ''mainframes'', reliés à des terminaux, peu puissants comparé aux standards actuels. Seules les grandes entreprises et les grands instituts de recherche pouvaient se payer les services de ce genre d'ordinateurs. Seuls les professionnels avaient accès à ce genre d'équipement.

===La troisième génération : le circuit intégré===

[[File:D8259AC-2.jpg|vignette|Exemple de circuit intégré.]]

La troisième génération est toujours fabriquée avec des transistors, mais dont la taille a été réduite. Avec l'évolution de la technologie, les transistors ont diminué en taille, de plus en plus. Ils sont devenus tellement petits qu'ils ont fini par être regroupés dans des '''circuits intégrés''', des circuits regroupent plusieurs transistors sur la même puce de silicium. Les circuits intégrés se présentent le plus souvent sous la forme de boitiers rectangulaires, comme illustré ci-contre. D'autres ont des boitiers de forme carrées, comme ceux que l'on peut trouver sur les barrettes de mémoire RAM, ou à l'intérieur des clés USB/ disques SSD.

Lors de cette génération, les processeurs étaient fournis en pièces détachées qu'il fallait relier entre elles. Le processeur était composé de plusieurs circuits intégrés séparés, impossible de mettre un processeur dans un seul boitier. Un exemple de processeur conçu en kit est la série des Intel 3000. Elle regroupe plusieurs circuits séparés aux noms à coucher dehors, mais dont vous comprendrez ce qu'ils veulent dire dans les chapitres adéquats : l'Intel 3001 est un séquenceur, l'Intel 3002 regroupe unité de calcul et registres, le 3003 est un circuit d'anticipation de retenue complémentaire du 3002, le 3212 est une mémoire tampon, le 3214 est une unité de gestion des interruptions, les 3216/3226 sont des interfaces de bus mémoire. On pourrait aussi citer la famille de circuits intégrés AMD Am2900.

Même si le processeur était en pièces détachées, utiliser une dizaine de circuits intégrés était nettement mieux que d'utiliser plusieurs milliers de transistors individuels. En conséquence, les ordinateurs ont vu leur taille grandement réduite, passant de pièces entières à une simple armoire, voire à quelques cartes intégrées superposées. De plus, le prix des circuits intégré était abordable, du moins comparé aux ordinateurs d'avant. Le prix des ordinateurs a alors grandement décru, permettant à des entreprises et administrations de taille modeste de s'équiper d'ordinateurs.

===La quatrième génération : le microprocesseur===

[[File:MOS6502.svg|vignette|Microprocesseur, ici un processeur MOS6502, de la quatrième génération.]]

Lors de la troisième génération, les circuits intégrés regroupaient plusieurs dizaines ou centaines de transistors, mais sont rapidement montés en gamme. De centaines de transistors, ils sont passés au millier de transistors, puis au million et maintenant au-delà du milliard. Les transistors étaient devenus tellement petits, tellement miniaturisés, qu'il était devenu possible de mettre un processeur entier dans un circuit intégré. C'est ainsi qu'est né le microprocesseur, à savoir un processeur qui tient tout entier dans un seul circuit imprimé. La quatrième génération d’ordinateur est celle des ordinateurs basés autour d'un microprocesseur.

Les tout premiers microprocesseurs étaient des processeurs à application militaire, comme le processeur du F-14 CADC ou celui de l'Air data computer. Le tout premier microprocesseur commercialisé au grand public est le 4004 d'Intel, sorti en 1971. L'intel 4004 comprenait environ 2300 transistors, avait une fréquence de 740 MHz, pouvait faire 46 opérations différentes, et manipulait des entiers de 4 bits. Il était au départ un processeur de commande, prévu pour être intégré dans la calculatrice Busicom calculator 141-P, mais il fut utilisé pour d'autres applications quelque temps plus tard. Immédiatement après le 4004, les premiers microprocesseurs 8 bits furent commercialisés. Le 4004 fut suivi par le 8008 et quelques autres processeurs 8 bits extrêmement connus, comme le 8080 d'Intel, le 68000 de Motorola, le 6502 ou le Z80.

Les microprocesseurs permirent encore uen fois de réduire la taille des ordinateurs, qui pouvaient tenir dans un boitier de PC, ou un boitier de console de jeu. Le prix des ordinateurs a aussi chuté en même temps que les transistors étaient miniaturisés. C'est cette invention qui permis l'invention des consoles de jeux et des mini-ordinateurs, à savoir les ordinateurs personnels. Sans miniaturisation, on n'aurait pas d'ordinateur personnel, pas de PC fixe ou portable.

==L'organisation du cours : les différents niveaux d'explication==

Le fonctionnement d'un ordinateur est assez complexe à expliquer car les explications peuvent se faire sur plusieurs niveaux. Par plusieurs niveaux, on veut dire qu'un ordinateur est composé de composants très simples, qui sont assemblés pour donner des composants eux-même plus complexes, qui sont eux-même regrouper, etc. Étudier tout cela demande de voir plusieurs niveaux, allant de transistors très petits à des processeurs multicœurs. Les niveaux les plus bas sont de l'électronique pur et dure, alors que ceux plus haut sont à mi-chemin entre électronique et informatique.

===Les niveaux d'abstraction en architecture des ordinateurs===

Les trois premiers niveaux sont de l'électronique pur et dure. Ils correspondent aux premiers chapitres du cours, qui porteront sur les circuits électroniques en général.
* Le premier niveau est celui des '''transistors''', des circuits intégrés, des ''wafer'' et autres circuits de très petite taille.
* Le second niveau est celui des '''portes logiques''', des circuits très basiques, très simples, à la base de tous les autres.
* Le troisième niveau est celui dit de la '''''Register Transfer Level''''', où un circuit électronique est construit à partir de circuits basiques, dont des registres et autres circuits dits combinatoires.
Les deux niveaux suivants sont de l'informatique proprement dit. C'est dans ces deux niveaux qu'on étudie les ordinateurs proprement dit, les circuits qu'il y a dedans et non l'électronique en général.
* Le quatrième niveau est celui de la '''microarchitecture''', qui étudie ce qu'il y a à l'intérieur d'un processeur, d'une mémoire, des périphériques et autres.
* Le cinquième niveau est celui de l''''architecture externe''', qui décrit l'interface du processeur, de la mémoire, d'un périphérique ou autre. Par décrire l'interface, on veut dire : comment un programmeur voit le processeur et la mémoire, comment il peut les manipuler. Une architecture externe unique peut avoir plusieurs microarchitecture, ce qui fait qu'on sépare les deux. Tout cela sera plus clair quand on passera aux chapitres sur le processeur et les mémoires.

Nous n'allons pas voir les 5 niveaux dans l'ordre, des transistors vers l'architecture externe. En réalité, nous allons procéder autrement. La première partie du cours portera sur les trois premiers niveaux, le reste sur les deux autres. Les 5 niveaux seront vus dans des chapitres séparés, du moins le plus possible. Au niveau pédagogique, tout est plus simple si on scinde les 5 niveaux. Bien sûr, il y a quelques explications qui demandent de voir plusieurs niveaux à la fois. Par exemple, dans le chapitre sur les mémoires caches, nous auront des explications portant sur la RTL, la microarchitecture du cache et son architecture externe. Mais le gros du cours tentera de séparer le plus possible les 5 niveaux.

===Les trois parties principales du cours===

Nous allons commencer par parler du binaire, avant de voir les portes logiques. Avec ces portes logiques, nous allons voir comment fabriquer des circuits basiques qui reviendront très souvent dans la suite du cours. Nous verrons les registres, les décodeurs, les additionneurs et plein d'autres circuits. Puis, nous reviendrons au niveau des transistors pour finir la première partie. La raison est que c'est plus simple de faire comme cela. Tout ce qui a trait aux transistors sert à expliquer comment fabriquer des portes logiques, et il faut expliquer les portes logiques pour voir le niveau de la RTL.

Une fois la première partie finie, nous allons voir les différents composants d'un ordinateur. Une première partie expliquera ce qu'il y a dans un ordinateur, quels sont ses composants. Nous y parlerons de l'architecture de base, de la hiérarchie mémoire, des tendances technologiques, et d'autres généralités qui serviront de base pour la suite. Puis, nous verrons dans l'ordre les bus électroniques, les mémoires RAM/ROM, le processeur, les périphériques, les mémoires de stockage (SSD et disques durs) et les mémoires caches. Pour chaque composant, nous allons voir leur architecture externe, avant de voir leur microarchitecture. La raison est que la microarchitecture ne peut se comprendre que quand on sait quelle architecture externe elle implémente.

Enfin, dans une troisième partie, nous allons voir les optimisations majeures présentes dans tous les ordinateurs modernes, avec une partie sur le pipeline et le parallélisme d'instruction, et une autre sur les architectures parallèles. Pour finir, les annexes de fin parlerons de sujets un peu à part.

&lt;noinclude&gt;
{{NavChapitre | book=Fonctionnement d'un ordinateur
           | next=L'encodage des données
           | nextText=L'encodage des données
}}
&lt;/noinclude&gt;</text>
      <sha1>fy2b6laufhnhkqjqmiovcw8aenezh6q</sha1>
    </revision>
    <revision>
      <id>744165</id>
      <parentid>744163</parentid>
      <timestamp>2025-06-05T15:28:27Z</timestamp>
      <contributor>
        <username>Mewtow</username>
        <id>31375</id>
      </contributor>
      <minor />
      <comment>/* La première génération : les tubes à vide */</comment>
      <origin>744165</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="48504" sha1="k84mj0kgzngoegspgqxsb3yb1xmbsoy" xml:space="preserve">Pour commencer, nous allons voir qu'il existe de nombreux types d'ordinateurs. Le plus connu est certainement le PC, l'ordinateur personnel, que vous avez sans doute dans votre salon. Les ordinateurs portables sont un deuxième type d'ordinateur assez intuitif, que vous avez peut-être. Mais il y a aussi d'autres types d'ordinateurs auxquels vous n'avez jamais été confrontés.

==Les différents types d'ordinateurs==

Dans cette section, nous allons décrire rapidement les ordinateurs les plus courant, mais surtout voir ce qu'il y a à l'intérieur d'un ordinateur.

===L'ordinateur de type PC fixe===

De l'extérieur, l'ordinateur est composé d'une unité centrale sur laquelle on branche des périphériques.

[[File:Typical computer architecture systems.jpg|vignette|upright=1.5|Exemples de périphériques, connectés à une unité centrale (ici appelée à tort ''operating system'').]]

Les '''périphériques''' regroupent l'écran, la souris, le clavier, l'imprimante, et bien d'autres choses. Ils permettent à l'utilisateur d'interagir avec l'ordinateur : un clavier permet de saisir du texte sous dans un fichier, une souris enregistre des déplacements de la main en déplacement du curseur, un écran affiche des données d’images/vidéos, un haut-parleur émet du son, etc. Tout ce qui est branché sur un ordinateur est, formellement un périphérique.

L''''unité centrale''' est là où se trouvent tous les composants importants d'un ordinateur, ceux qui font des calculs, qui exécutent des logiciels, qui mémorisent vos données, etc. Voici ce à quoi ressemble l'intérieur de l'unité centrale. Trois sections sont visibles : l'alimentation électrique en haut à gauche, la carte mère en bas à gauche et en jaune/orange, les disques et lecteurs à droite des câbles. Et on voit aussi beaucoup de câbles.

[[File:Asus P5K-SEIntel E6320.jpg|centre|vignette|upright=2|Exemple d'unité centrale.]]

Tout en haut à gauche, se trouve l''''alimentation électrique''', qui convertit le courant de la prise électrique en un courant plus faible, utilisable par les autres composants. Elle émet de nombreux câbles assez gros, qui sont reliés au reste. Les PC actuels utilisent des alimentations électriques standardisées, qui fournissent trois tensions au reste de l'ordinateur : une tension de 12 Volts, une de 5 Volts, une de 3,3 Volts.

À droite, caché par la partie &quot;métallique&quot; du boitier, se trouvent les lecteurs de CD/DVD, et les disques durs. Les lecteurs CD-ROM ou DVD-ROM permettaient de lire des CD ou des DVD. Je parle au passé, car ils ont aujourd'hui disparu des ordinateurs modernes. Les '''disques durs''' sont des mémoires de stockage, qui mémorisent vos données de manière permanente. De nos jours, ils sont remplacés par des SSD, qui sont des disques durs électroniques, là où les disques durs proprement dit sont des mémoires magnétiques. Nous verrons la différence dans deux chapitres dédiés, un sur les disques durs, l'autre sur les SSD.

En bas à droite, se trouve la '''carte mère''' un support plat, en plastique ou en céramique, sur laquelle sont soudés/connectés les autres composants. Sur celle-ci, de nombreux composants sont soudés, d'autres sont branchés dessus avec des câbles, d'autres sont connectés dessus avec des connecteurs. Ils sont reliés entre eux par des fils conducteurs, le plus souvent du cuivre ou de l’aluminium, ce qui leur permet de s’échanger des données. Sur les cartes simples, ces fils sont intégrés dans la carte électronique, dans des creux du plastique. Ils portent le nom de pistes.

Avant, les disques durs, SSD et lecteurs de CD/DVD sont branchés dessus via des connecteurs dédiés, appelés des connecteurs S-ATA. De nos jours, ils sont branchés sur un autre connecteur, grâce à l'interface NVME. Toujours est-il qu'ils sont reliés à la carte mère par des câbles, ce qui montre que ce sont des sortes de périphériques interne. Ils sont placés dans le boitier, mais on aurait tout aussi bien pu les mettre à l'extérieur, vu qu'ils communiquent avec l'ordinateur par l'intermédiaire d'un câble ou d'un connecteur dédié.

Mais deux autres composants très importants sont eux placés sur la carte mère, directement. Ils ont chacun un connecteur dédié, sur lequel ils sont branchés directement, sans passer par l'intermédiaire d'un câble, mais sans être soudés non plus. Il s'agit du processeur et de la mémoire RAM, deux composants centraux des PC modernes.

[[File:Pentium III SL4CB.jpg|thumb|Processeur Pentium III.]]

Le '''processeur''' traite les données, les modifie, les manipule. Pour faire simple, il s’agit d’une grosse calculatrice hyper-puissante. Il comprend à la fois un circuit qui fait des calculs, et un circuit de contrôle qui s'occupe de séquencer les calculs dans l'ordre demandé. Il est souvent caché sous un radiateur, lui-même surmonté par un ventilateur. En effet, un processeur chauffe beaucoup, ce qui demande d'évacuer cette chaleur. Un chapitre entier expliquera pourquoi les processeurs chauffent, ainsi que les techniques utilisées pour limiter leur production de chaleur et leur consommation électrique.

La '''mémoire vive''' conserve des informations/données temporairement, tant que le processeur en a besoin. Elle prend la forme de barrettes de RAM, comme montré ci-dessous.

[[File:2 gb ddr2 667.jpg|centre|vignette|upright=2|Barrette de RAM.]]

Outre ces composants dits principaux, un ordinateur peut comprendre plusieurs composants moins importants, surtout présents sur les ordinateurs personnels. Ils sont techniquement facultatifs, mais sont très présents dans les ordinateurs personnels. Cependant, certains ordinateurs spécialisés s'en passent. Il s'agit des diverses '''cartes d'extension''' sont branchées sur la carte mère. Elles permettent d’accélérer certains calculs ou certaines applications, afin de décharger le processeur. Par exemple, la carte graphique s'occupe des calculs graphiques, qu'il s'agisse de graphismes 3D de jeux vidéos ou de l'affichage en 2D du bureau. Dans un autre registre, la carte son prend en charge le microphone et les haut-parleurs.

[[Fichier:Personal computer, exploded 4.svg|thumb|upright=1.0|Éclaté d'un ordinateur de type PC :&lt;br /&gt;
1 : Écran ;&lt;br /&gt;
2 : Carte mère ;&lt;br /&gt;
3 : Processeur ;&lt;br /&gt;
4 : Câble Parallel ATA ;&lt;br /&gt;
5 : Mémoire vive (RAM) ;&lt;br /&gt;
6 : Carte d'extension ;&lt;br /&gt;
7 : Alimentation électrique ;&lt;br /&gt;
8 : Lecteur de disque optique ;&lt;br /&gt;
9 : Disque dur ;&lt;br /&gt;
10 : Clavier ;&lt;br /&gt;
11 : Souris.]]

Si on regarde une carte mère de face, on voit un grand nombre de connecteurs, mais aussi des circuits électroniques soudés à la carte mère.

[[File:Architecture matérielle d'une carte mère.png|centre|vignette|upright=2.0|Architecture matérielle d'une carte mère]]

Les '''connecteurs''' sont là où on branche les périphériques, la carte graphique, le processeur, la mémoire, etc. Dans l'ensemble, toute carte mère contient les connecteurs suivants :
* Le processeur vient s’enchâsser dans la carte mère sur un connecteur particulier : le '''socket'''. Celui-ci varie suivant la carte mère et le processeur, ce qui est source d'incompatibilités.
* Les barrettes de mémoire RAM s’enchâssent dans un autre type de connecteurs: les '''slots mémoire'''.
* Les mémoires de masse disposent de leurs propres connecteurs : connecteurs P-ATA pour les anciens disques durs, et S-ATA pour les récents.
* Les périphériques (clavier, souris, USB, Firewire, ...) sont connectés sur un ensemble de connecteurs dédiés, localisés à l'arrière du boitier de l'unité centrale. 
* Les autres périphériques sont placés dans l'unité centrale et sont connectés via des connecteurs spécialisés. Ces périphériques sont des cartes imprimées, d'où leur nom de '''cartes filles'''. On peut notamment citer les cartes réseau, les cartes son, ou les cartes vidéo.

===Les ordinateurs portables===

[[File:Samsung QX-511 (2).JPG|vignette|Ordinateur portable Samsung QX-511 (2), pour illustration.]]

Un ordinateur portable est identique à un ordinateur de type PC. Si vous ouvrez votre ordinateur portable (attention à la garantie), vous retrouverez les mêmes composants qu'un PC à l'intérieur. Un point important est la présence d'une batterie à l'intérieur du PC portable, absente des PC fixes.

[[File:LG gram 14Z90Q mainboard with battery.jpg|centre|vignette|upright=2|LG gram 14Z90Q avec sa batterie.]]

Une fois la batterie et les circuits associés retiré, la seule différence notable est que tous les composants sont soudés sur la carte mère, au lieu d'être branchés sur des connecteurs, à part éventuellement la RAM et le disque dur.

[[File:LG gram 14Z90Q mainboard without battery.jpg|centre|vignette|upright=2|LG gram 14Z90Q sans sa batterie.]]

La RAM est parfois soudée sur la carte mère, d'autres fois sous la forme de barrettes de mémoire vive semblables à celles des PC. Dans le dernier cas, elle est connectée à des connecteurs spécifiques, ce qui permet de les changer/upgrader. Les PC portables sont parfois construits de manière à pouvoir changer la RAM facilement, en ouvrant un cache spécial, concu pour.

[[File:Lenovo G555 состав - Донор.JPG|centre|vignette|upright=2|Lenovo G555.]]

La conception d'un ordinateur portable est légèrement différente de celle d'un PC, pour des raisons thermiques. Un PC fixe a plus de place pour évacuer sa chaleur. Les ventilateurs peuvent plus facilement déplacer l'air dans le boitier, même si le flux d'air dans le boitier est éventuellement gêné par la carte graphique. Mais l'évacuation de la chaleur est assez efficace. Sur les PC portables, leur finesse fait que le trajet de l'air est beaucoup plus contraint. Évacuer la chaleur produite par l'ordinateur est plus complexe, ce qui demande d'utiliser des systèmes de refroidissement et de ventilation spécifiques.

Là où les PC fixes se débrouillent avec des radiateurs et des ventilateurs posés sur le processeur, les PC portables font autrement. Ils ne peuvent pas forcément mettre le ventilateur sur le processeur. A la place, ils mettent le ventilateur à côté, mais le processeur est surmonté par un mécanisme de transmission de la chaleur, qui transfère la chaleur du processeur vers le ventilateur.

[[File:Diagram - How a laptop cooling system works.png|centre|vignette|upright=2|Comment fonctionne le système de ventilation d'un ordinateur portable, en anglais.]]

Les difficultés pour dissiper la chaleur font que les ordinateurs portables utilisent souvent des composants peu performants, mais qui chauffent peu. En effet, nous verrons que plus un composant est puissant, plus il chauffe. La relation n'est pas parfaite, mais les processeurs haute performance chauffent plus que les modèles d'entrée ou milieu de gamme moins puissants. En conséquence, les PC portables sont souvent moins puissants que les PC fixes, même pour les modèles dit ''gaming''.

===Les serveurs et ''mainframes''===

Les grandes entreprises utilisent des ordinateurs de grande taille, très puissants, appelés des ''mainframes''. Ils sont souvent confondus avec les serveurs par le grand public, il y a une différence entre les deux. Un serveur est une fonction logicielle/réseau, pas un type d'ordinateur. Mais laissons cette différence de côté, ce qui est dit pour les ''mainframes'' sert pour les gros serveurs haute performance.

[[File:IBM Z15 mainframe.jpg|vignette|Exemple de ''mainframe''' de type IBM Z15.]]

Les anciens ''mainframes'' des années 50-80 avaient une taille pouvant être impressionnante, au point de prendre une pièce complète d'un bâtiment. Mais de nos jours, les ''mainframes'' tiennent dans une grosse armoire un peu haute. Les ''mainframes'' doivent rester allumé en permanence et ne doivent pas être éteint, sauf éventuellement quelques jours par an pour des opérations de maintenance. Ils utilisent pour cela des techniques spécifiques, avec beaucoup de redondance interne.

[[File:ACONIT hall grandes machines.jpg|centre|vignette|upright=2|''Mainframe'' ACONIT.]]

Les ''mainframes'' sont aussi conçus pour mutualiser au maximum leur utilisation, ils peuvent être utilisés par plusieurs utilisateurs à la suite, voire en même temps. Pour cela, les anciens ''mainframes'' étaient capables de faire tourner plusieurs applications distinctes l'une à la suite de l'autre, avec des commutations fréquentes entre logiciels. De nos jours, ils sont capables d'exécuter un grand nombre de tâches en même temps, grâce à la présence de plusieurs processeurs. Les ''mainframes'' modernes sont même capables de faire tourner plusieurs systèmes d'exploitation en même temps si besoin.

Les anciens ''mainframes'' étaient des ordinateurs assez simples, avec un processeur, de la mémoire RAM, un ou plusieurs disques durs, pas plus. Le ''mainframe'' était tellement énorme et cher que les entreprises n'en avaient qu'un seul pour toute l'entreprise. Les employés avaient sur leur bureau des terminaux, qui permettaient d'accéder à l'ordinateur central, mais n'étaient pas des ordinateurs. Les terminaux étaient des composants électroniques simples, avec un écran, un clavier et une souris, mais sans processeur. Ils envoyaient des données au ''mainframe'', ils en recevaient de sa part, mais tout traitement était réalisé sur le ''mainframe''. L'arrivée sur le marché des ordinateurs personnels, de type PC fixe/portable, a entrainé l'abandon de ce genre de pratique, tous les employés ont maintenant un ordinateur rien que pour eux.

{|
|-
! colspan=&quot;2&quot; | Exemples de terminaux
|-
|[[File:Terminal-in2-sm9400.jpg|centre|vignette|upright=1.5|Exemple de terminal. Notez la présence d'un écran et d'un clavier, mais l'asbence d'une unité centrale.]]
|[[File:Chromatics CT4100.jpg|vignette|upright=1.5|Autre exemple de terminal. Le clavier est couplé à un stylo CRT, qui remplacait la souris et agissait sur l'écran comme s'il était tactile.]]
|-
! colspan=&quot;2&quot; | Intérieur d'un terminal
|-
|[[File:CT1024 Monitor.jpg|vignette|upright=1.5|Terminal CT1024, sans le boitier extérieur.]]
|[[File:CT1024 Terminal System.jpg|vignette|upright=1.5|Terminal CT1024, description des composants interne.]]
|}

De nos jours, les ''mainframes'' contiennent en réalité plusieurs ordinateurs simples interconnectés via un réseau local. Un ''mainframe'' qui tient dans une armoire contient facilement une dizaine ou centaine de processeurs, plein de RAM, des disques durs séparés dans une armoire distincte, etc. Vu qu'ils communiquent uniquement via le réseau, ils n'ont pas d'interface, pas d'écran, 'entrée via clavier/souris. Le tout est commandé avec une console de commande, typiquement un ordinateur portable ou un terminal assez simple séparé de l'armoire, qui permet à un administrateur de faire des opérations de surveillance, configuration et maintenance. Il peut y avoir une console de commande pour plusieurs armoires séparées, la console peut même être dans un autre bâtiment et accéder au ''mainframe'' par le réseau.

[[File:IBM System Z9 (type 2094 inside).jpg|centre|vignette|upright=2|''Mainframe'' de type IBM System Z9. L'ordinateur portable sert de console pour qu'un administrateur fasse des opérations de surveillance, configuration et maintenance.]]

Les processeurs et la RAM sont typiquement installés sur des cartes amovibles, qui sont connectées au fond de l'armoire lors de l'installation. Il est même possible de retirer ou d'ajouter des cartes en fonctionnement, afin d'ajouter/retirer des processeurs, des disques durs, etc. Ce qui est très utile si un composant est en panne et qu'il faut le remplacer. 

[[File:IBM TotalStorage Exp400.jpg|centre|vignette|upright=2|IBM TotalStorage Exp400]]

==Un peu d'abstraction : qu'est-ce qu'un ordinateur ?==

Un ordinateur comprend donc un processeur, plusieurs mémoires, des cartes d'extension et une carte mère pour connecter le tout. Mais il s'agit là d'une description assez terre-à-terre de ce qu'est un ordinateur. Une autre description, plus abstraite, se base sur le fait qu'un ordinateur est une énorme calculatrice programmable. Elle permet d'expliquer pourquoi il y a une distinction entre processeur et mémoire, entre unité centrale et périphériques. Tout ce qui va suivre pourra vous paraitre assez abstrait, mais rassurez-vous : les prochains chapitres rendront tout cela plus concrets.

===La séparation entre entrées-sorties et traitement===

L'unité centrale peut être vue comme une énorme calculatrice ultra-puissante, qui exécute des commandes/opérations. Mais à elle seule, elle ne servirait à rien, il faut interagir avec par l'intermédiaire de plusieurs périphériques. Il existe deux types de périphériques, qui sont conceptuellement différents. Les périphériques comme le clavier ou la souris permettent d'envoyer des informations à l'ordinateur, d'agir sur celui-ci. A l'inverse, les écrans transmettent des informations dans le sens inverse : de l'ordinateur vers l'utilisateur. Les premiers sont appelés des '''entrées''', les seconds des '''sorties'''.

Dans un ordinateur, les informations sont représentées sous la forme de nombres. Toute donnée dans un ordinateur est codée avec un ou plusieurs nombres regroupés dans une donnée, un fichier, ou autre. Et la transmissions avec les entrées et sorties se fait là-encore avec des nombres. Par exemple, quand vous appuyez sur votre clavier, le clavier envoie un numéro de touche à l'unité centrale, qui indique quelle touche a été appuyée. L'image à afficher à l'écran est codée sous la forme d'une suite de nombres (un par pixel). L'image est envoyée à l'écran, qui traduit la suite de nombre en image à afficher. Les entrées traduisent des actions utilisateurs en nombres, on dit que les entrées encodent les actions utilisateur. Les sorties font la traduction inverse, elles transforment des suites de nombres en une action physique. On dit qu'elles décodent des informations.

Pour résumer, toute appareil électronique est composé par :
* Des '''entrées''' sur lesquelles l'utilisateur agit sur l'ordinateur. Les entrées transforment les actions de l'utilisateur en nombres, qui sont interprétés par l'ordinateur.
* Une '''unité de traitement''', qui manipule des nombres et fait des calculs/opérations dessus. Les nombres proviennent des entrées, du disque dur, ou d'autres sources, peu importe.
* Des '''sorties''', qui va récupèrent le résultat calculé par l'unité de traitement pour en faire quelque chose : écrire sur une imprimante ou sur un moniteur, émettre du son,...

[[File:Ordinateur théorique Simple 1.png|centre|vignette|upright=2|Ordinateur théorique Simple 1]]

L'unité de traitement proprement dite, celle qui fait les calculs, est couplée à une mémoire qui mémorise les opérandes et résultats des calculs. La séparation entre processeur et mémoire est nécessaire pour qu'un appareil électronique soit qualifié d'ordinateur. De nombreux appareils n'ont pas de séparation entre unité de traitement et mémoire, comme certaines vielles radios AM/FM.

[[File:Schéma de principe d'un ordinateur.png|centre|vignette|upright=2|Schéma de principe d'un ordinateur]]

===Un ordinateur est un appareil programmable===

Les appareils simples sont non-programmables, ce qui veut dire qu’ils sont conçus pour une utilisation particulière et qu’ils ne peuvent pas faire autre chose. Par exemple, les circuits électroniques d’un lecteur de DVD ne peuvent pas être transformé en lecteur audio ou en console de jeux... Les circuits non-programmables sont câblés une bonne fois pour toute, et on ne peut pas les modifier. On peut parfois reconfigurer le circuit, pour faire varier certains paramètres, via des interrupteurs ou des boutons, mais cela s’arrête là. Et cela pose un problème : à chaque problème qu'on veut résoudre en utilisant un automate, on doit recréer un nouveau circuit.

À l'inverse, un ordinateur n’est pas conçu pour une utilisation particulière, contrairement aux autres objets techniques. Il est possible de modifier leur fonction du jour au lendemain, on peut lui faire faire ce qu’on veut. On dit qu'ils sont '''programmables'''. Pour cela, il suffit d’utiliser un logiciel, une application, un programme (ces termes sont synonymes), qui fait ce que l'on souhaite. La totalité des logiciels présents sur un ordinateur sont des programmes comme les autres, même le système d'exploitation (Windows, Linux, ...) ne fait pas exception.

Un programme est une suite de d''''instructions machines''', chaque instruction effectuant une action dans l'ordinateur. Sur les ordinateurs modernes, les instructions les plus communes effectuent une opération arithmétique : une addition, une multiplication, une soustraction, etc. Les ordinateurs modernes sont donc de grosses calculettes très puissantes, capables d'effectuer des millions d'opérations par secondes.

Et qui dit opération dit nombres : un ordinateur gère nativement des nombres, qui sont codés en binaire sur la quasi-totalité des ordinateurs modernes. Les ordinateurs modernes sont capables de faire des calculs sur des nombres entiers, mais aussi des nombres à virgule. Il existe plusieurs manières de représenter des nombres en binaire, certaines représentant des nombres entiers dits naturels (0 et plus), d'autres des nombres signés (positifs ou négatifs), d'autres des nombres à virgule. Un chapitre entier détaillera comment sont encodés ces nombres.

Une instruction est représentée dans un ordinateur par une série de nombres entiers : un nombre qui indique quelle opération/commande effectuer et des autres nombres pour coder les données (ou de quoi les retrouver dans l'ordinateur). L'ordinateur récupére les commandes une par une, les traduit en opération à effectuer, exécuter l'opération, et enregistre le résultat. Puis il recommence avec la commande suivante.

[[File:Ordinateur Théorique Complexe 1.png|centre|vignette|upright=3|Ordinateur Théorique Complexe. En jaune, le programme informatique, la liste de commande. Le rectangle gris est l'ordinateur proprement dit.]]

De nombreux appareils sont programmables, mais tous ne sont pas des ordinateurs. Par exemple, certains circuits programmables nommés FPGA n'en sont pas. Pour être qualifié d'ordinateur, un appareil programmable doit avoir un processeur séparé de la mémoire. De plus, il doit utiliser un '''codage numérique''', chose que nous allons aborder dans le chapitre suivant.

===Les ordinateurs à programme mémorisé ou programme externe===

[[File:Blue-punch-card-front.png|vignette|upright=0.5|Carte Perforée.]]

Au tout début de l'informatique, les programmes étaient enregistrés sur des cartes perforées, à savoir des cartes en papier/plastique percées par endroits. Un 1 est codé par un trou dans le papier et un 0 par une absence de trou. Les programmes étaient exécutés par l'ordinateur quand on insérait la carte perforée dans le lecteur et qu'on appuyait sur un bouton.

Par la suite, les premiers ordinateurs grand public, comme les Amstrad ou les Commodore, utilisaient des cassettes audio magnétiques pour stocker les programmes. Dans le même style, les consoles de jeu utilisaient autrefois des cartouches de jeu, qui contenaient le programme du jeu à exécuter. Pour résumer, les anciens ordinateurs mémorisaient les programmes sur un support externe, lu par un périphérique. De tels ordinateurs sont dits à '''programme externe'''.

: D’anciens ordinateurs personnels, comme l’Amstrad ou le Commodore, permettaient de taper les programmes à exécuter à la main, au clavier, avant d’appuyer une touche pour les exécuter. Nul besoin de vous dire que les cassettes audio étaient plus pratiques.

Mais de nos jours, les programmes sont enregistrés sur le disque dur de l'ordinateur ou dans une mémoire intégrée à l'ordinateur. On dit qu'ils sont installés, ce qui est un mot bien compliqué pour dire que le programme est enregistré sur le disque dur de l’ordinateur. A défaut de disque dur, le programme/logiciel est enregistré dans une mémoire spécialisée pour le stockage. Par exemple, sur les cartes électroniques grand public de marque Arduino, les programmes sont envoyés à la carte via le port USB, mais les programmes sont enregistrés dans la carte Arduino, dans une mémoire FLASH dédiée. Disque dur ou non, le programme est mémorisé dans la mémoire de l'ordinateur. Il est possible d'installer ou de désinstaller les programmes en modifiant le contenu de la mémoire. Le terme utilisé est alors celui de '''programme stocké en mémoire'''.

Les programmes à installer sont disponibles soit sur un périphérique, comme un DVD ou une clé USB, soit sont téléchargés depuis internet. Les premiers PC fournissaient les logiciels sur des disquettes, qui contenaient un programme d'installation pour enregistrer le programme sur le disque dur de l'ordinateur. Par la suite, le support des logiciels a migré vers les CD et DVD, les logiciels devenant de plus en plus gros. De nos jours, la majorité des applications sont téléchargées depuis le net, l'usage de périphériques est devenu obsolète, même les consoles de jeu abandonnent cette méthode de distribution.

==Les générations d'ordinateurs : un historique rapide==

L'informatique a beaucoup évolué dans le temps. Et une bonne partie de cette évolution tient à l'évolution de l’électronique sous-jacente. Les ordinateurs actuels sont fabriqués avec des transistors, des petits composants électroniques qui servent d'interrupteurs programmables, qu'on détaillera dans ce qui suit. Mais ça n'a pas toujours été le cas. Et cela permet de distinguer plusieurs '''générations d'ordinateurs'''.

===Les ordinateurs électro-mécaniques : les premiers ordinateurs===

Le tout premier ordinateur est le '''Z1''', un modèle unique inventé par Konrad Suze entre 1936 et 1938. Son processeur gérait non pas des nombres entiers, mais des nombres à virgule (des nombres dits flottants, pour être précis), encodés sur 22 bits. Le processeur du Z1 était capable de faire des additions et des soustractions, car il intégrait un circuit additionneur-soustracteur basique. Des circuits annexes permettaient de faire des multiplications et des divisions en enchainant des additions/soustractions successives. Il fonctionnait à une fréquence de 1 Hz, ce qui fait qu'il pouvait faire une addition/soustraction par seconde maximum.

Niveau mémoire, la RAM de l'ordinateur était très limitée : seulement 16 nombres de 22 bits chacun. S'il s'agissait d'une mémoire électronique, les programmes étaient mémorisés sur une mémoire mécanique et précisémment sur des cartes perforées, à savoir des cartes en papier/plastique dans lesquelles un 1 est codé par un trou dans le papier et un 0 par une absence de trou. Les programmes étaient exécutés par l'ordinateur quand on insérait la carte perforée dans le lecteur et qu'on appuyait sur un bouton.

[[File:German Museum of Technology, Berlin 2017 024.jpg|centre|vignette|upright=2|Réplique du Z1 au ''German Museum of Technology'' de Berlin, 2017.]]

Après sa destruction dans un bombardement, le Z1 a été reconstruit et amélioré, ce qui donné les deux ordinateurs Z2 et Z3. Quelques années plus tard, quelques laboratoires de recherche ont fabriqués des ordinateurs dans leur coin, comme le Harvard Mark I et le Colossus Mark 1 (UK) qui ont été mis en service en 1944. Ils ont servi pour les cryptanalystes pour casser les codes utilisés par les Allemands pour leurs transmissions, pendant la seconde guerre mondiale.

Les ordinateurs cités dans le précédent paragraphe étaient tous des ordinateurs dit '''électro-mécaniques''', car ils mélangeaient des composants électroniques et des composants mécaniques (tout ce qui a trait aux cartes perforées, notamment). Les composants électroniques étaient généralement des relais, à savoir des interrupteurs commandables électriquement, qui sont plus ou moins équivalents aux transistors modernes. La majeure partie des ordinateurs des années 40 étaient de ce type, mais leur nombre n'a pas dépassé 30. Il faut dire qu'ils ont rapidement laissé la place à des ordinateurs purement électroniques, que nous allons voir dans ce qui suit.

===La première génération : les tubes à vide===

Les ordinateurs qui ont suivi les ordinateurs électromécaniques sont regroupés dans la '''première génération d'ordinateur'''. Ils étaient conçus avec des tubes à vide, des espèces d'interrupteurs commandables, les ancêtres des transistors modernes. Les tubes à vide étaient assez encombrants, ils consommaient beaucoup de courant, ils chauffaient et étaient assez peu fiables. Ils tombaient en panne assez souvent. Et ils étaient assez simples à fabriquer, mais restaient malgré tout chers.

Les tubes à vide sont des ampoules à filament améliorées. Pour rappel, les ampoules à filament étaient des ampoules en verre dans lesquelles on plaçait un filament métallique. Le filament chauffait quand on envoyait du courant dedans et émettait de la lumière. Mais dans les tubes à vide, le filament n'émet pas de lumière quand on le chauffe : il émet des électrons, de l'électricité. De plus, ils ajoutent une électrode, une plaque en métal qui émet ou capte des électrons. Ici, l'électrode capte des électrons émis par le filament quand il chauffe. Vu qu'elle capte des électrons, on l'appelle l''''anode'''. Le résultat est un circuit qui laisse passer le courant, mais seulement dans un sens : du filament vers l'anode, l'autre sens n'est pas possible vu que l'anode ne peut pas émettre d'électrons. Un tel circuit est appelé une '''diode'''.

{|
|[[File:Diode vide schema explicatif.png|vignette|upright=1.5|Tube à vide basique.]]
|[[File:Diode à vide schéma de fonctionnement.png|vignette|upright=1.5|Diode à vide, schéma de fonctionnement]]
|}

[[File:Diode à vide.png|vignette|Diode à vide]]

Une amélioration des tubes à vide précédent rajoute une seconde plaque de métal, appelée la '''cathode'''. Elle est située juste après le filament. C'est elle qui émet les électrons, non pas le filament. Cependant, elle n'émet des électrons que si elle est chauffée par le filament. Le filament doit donc chauffer, ce qui réchauffe la cathode, qui elle-même émet des électrons en direction de l'anode.

Les tubes à vides étaient utilisés pour le processeur et quelques circuits annexes, mais les mémoires utilisaient d'autres technologies. Les mémoires de l'époque n'étaient pas du tout des mémoires électroniques. Il existait déjà des ancêtres des disques durs, à savoir des mémoire magnétiques appelées tambours magnétiques, bandes magnétiques, mémoires à tore de ferrite, etc. Les mémoires RAM, quant à elles, utilisaient elles des technologies totalement abandonnées : les mémoires à lignes de délai étaient des mémoires acoustiques, les tubes Williams étaient des écrans CRT modifiés, etc. Un chapitre entier sera dédié aux technologies des mémoires de l'époque.

[[File:Elektronenroehren-auswahl.jpg|centre|vignette|upright=2|Tubes à vides.]]

L'usage de tubes à vide les place entre les premiers ordinateurs électro-mécaniques et les ordinateurs utilisant des transistors. Au vu de la taille des tubes à vide, les ordinateurs de l'époque étaient composés de plusieurs milliers de ces tubes, guère plus. Et malgré cela, un ordinateur prenait facilement un étage de bâtiment entier, ou au moins plusieurs pièces. La conséquence est que les ordinateurs de première génération étaient très simples, rudimentaires quand on les compare aux ordinateurs modernes. Ils ne géraient que quelques opérations simples : l'addition, la soustraction, pas grand-chose de plus. À quelques exceptions près, ils ne géraient pas la multiplication et encore moins la division, cela aurait demandé trop de tubes à vides.

Une des toutes premières machines construite avec des tubes à vide était l'Atanasoff–Berry. Ce n'était pas un ordinateur, car elle ne pouvait pas exécuter de programme sans intervention humaine pour séquencer des opérations, mais c'était la première machine de calcul purement électronique, sans aucune pièce mécanique. Elle utilisait une mémoire RAM construite avec des condensateurs, ceux-ci étant placés sur des cylindres tournants. Les circuits de calcul étaient construits avec des tubes à vide et faisaient leur travail un bit à la fois. Elle fonctionnait à une fréquence de 60 Hz et pouvait faire 30 additions/soustractions par seconde. Les nombres étaient encodés sur 50 bits. 

[[File:Atanasoff Berry Computer.gif|centre|vignette|upright=2.5|Atanasoff–Berry.]]

L'arrivée de l'ENIAC en 1945 a changé la donne. Cet ordinateur a introduit plusieurs innovations majeures. La première est assez technique, il s'agit de la turing-complétude, elle a trait aux programmes qui peuvent être écrit pour un ordinateur, nous ne la détaillerons pas ici.

[[File:BabyArchitecture.png|vignette|Architecture de la Manchester Baby.]]

En 1948, le ''Manchester Baby'' a introduit une innovation extrêmement importante : le programme n'était plus mémorisé sur des cartes perforées, mais dans une mémoire électronique à l’intérieur de l'ordinateur lui-même. En clair, le ''Manchester Baby'' était le premier '''ordinateur à programme stocké en mémoire''' en français. Au-delà de ça, le Manchester Baby restait quand même très simple, c'était limite un prototype.

Niveau interface, l'ordinateur avait une console avec 32 boutons, des interrupteurs et un écran de sortie sur lequel afficher les résultats. A l'intérieur, il y avait un processeur et une RAM de 32 nombres de 32 bits, fabriquées avec des tubes Williams (abordés dans une annexe à la fin du cours). Une instruction prenant autant de place qu'un nombre en RAM, ce qui limitait les programmes à 32 instructions maximum. Le processeur gérait 8 instructions en tout, mais la seule instruction de calcul qu'il gérait était la soustraction. L'addition n'était pas supportée. Il pouvait cependant émuler l'addition à partir d'une soustraction et inversant l'opérande soustrait.

Le Manchester Mark 1 était une amélioration du Manchester Baby. Il utilisait 4500 tubes à vide. L'ordinateur gérait des nombres de 40 bits, mais les instructions étaient codées sur 20 bits. La RAM avait la même taille, à savoir 32 nombres, leur taille était simplement augmentée. Par contre, la RAM était complémentée par l’ancêtre du disque dur magnétique, à savoir un tambour magnétique, l’ancêtre du disque dur magnétique. Il contenait 40 pages, chacune ayant la même taille que la RAM. Contrairement à la Manchester Baby, son processeur gérait l'addition. Les multiplications étaient réalisées par des additions successives, mais le processeur intégrait des registres pour mémoriser les opérandes à multiplier.

Par la suite, les ordinateurs commerciaux ont vu le jour. Les ordinateurs précédents provenaient de projets de recherches, souvent publics. Mais les entreprises privées se sont mises à fabriquer des ordinateurs elle-mêmes, pour les vendre à d'autres entreprises. On peut notamment citer les ordinateurs comme le UNIVAC I, le Bull Gamma 3 ou les premiers ordinateurs IBM. La performance de ces ordinateurs était nettement plus importante que leurs prédécesseurs, avec des fréquences de l'ordre de la centaine de kilo-hertz. Par exemple, le Bull Gamma 3 allait à 281 kHz, l'IBM 650 allait à 50 Khz.

===La seconde génération : le remplacement des tubes à vides par des transistors===

[[File:IBM 7070.jpg|vignette|Cartes imprimées de l'IBM 704, avec des transistors et résistances dessus.]]

La '''seconde génération''' est celle des ordinateurs fabriqués avec des '''transistors''' isolés, reliés entre avec des fils électriques. Les transistors en question possèdent trois broches, des pattes métalliques sur lesquelles on connecte des fils électriques. Le transistor s'utilise le plus souvent comme un interrupteur commandé par sa troisième broche. Le courant qui traverse les deux premières broches passe ou ne passe pas selon ce qu'on met sur la troisième.

[[File:Transistor basic flow.svg|centre|vignette|Un transistor est un morceau de conducteur, dont la conductivité est contrôlée par sa troisième broche/borne.]]

Les ordinateurs de seconde génération avaient entre 1000 et 500 000 transistors. Les capacités des ordinateurs étaient donc nettement supérieures à celles des ordinateurs de première génération. Une part non négligeable des ordinateurs de seconde génération supportait l'opération de multiplication, absente sur les ordinateurs de première génération. Néanmoins, cela variait beaucoup selon les ordinateurs.

Un exemple assez hors du commun est celui du premier modèle de l'IBM 1620. Le tout premier modèle n'avait aucun circuit de calcul, il n'était même pas capable de faire une addition ou une multiplication. A la place, il utilisait une table d'addition et une table de multiplication en mémoire RAM. Les deux tables devaient être initialisées par le logiciel lors du démarrage de la machine. La table d'addition faisait une centaine de chiffres, la table de multiplication faisait le double. Le processeur de l'ordinateur gérait des instructions pour faire des additions ou des multiplications, mais ces opérations lisaient le résultat dans la table d'addition. Les calculs étaient faits chiffre par chiffre, avec un encodage partiellement décimal, partiellement binaire (des chiffres décimaux étaient encodés en binaire, nous en reparlerons quand nous parlerons du BCD) !

[[File:KL CoreMemory.jpg|vignette|Mémoire à tore de ferrite.]]

Les transistors n'étaient utilisés que pour le processeur et les circuits annexes. La mémoire n'était pas faite en transistors, pas à cette époque. La mémoire était une mémoire aujourd'hui abandonnée, appelée une '''mémoire à tores de ferrite'''. Elle sera détaillée dans un chapitre ultérieur. Mais sachez pour le moment qu'il s'agit d'une mémoire au support magnétique, les données étant stockées sur un support magnétique.

Les transistors étaient au départ de la même taille que les tubes à vide, mais ils ont rapidement rétrécit. Ils prenaient encore beaucoup de place dans les 60-70, ce qui fait que les ordinateurs étaient assez gros. Concrètement, ils prenaient une pièce de bâtiment entière dans le meilleur des cas. C'était l'époque des gros ''mainframes'', reliés à des terminaux, peu puissants comparé aux standards actuels. Seules les grandes entreprises et les grands instituts de recherche pouvaient se payer les services de ce genre d'ordinateurs. Seuls les professionnels avaient accès à ce genre d'équipement.

===La troisième génération : le circuit intégré===

[[File:D8259AC-2.jpg|vignette|Exemple de circuit intégré.]]

La troisième génération est toujours fabriquée avec des transistors, mais dont la taille a été réduite. Avec l'évolution de la technologie, les transistors ont diminué en taille, de plus en plus. Ils sont devenus tellement petits qu'ils ont fini par être regroupés dans des '''circuits intégrés''', des circuits regroupent plusieurs transistors sur la même puce de silicium. Les circuits intégrés se présentent le plus souvent sous la forme de boitiers rectangulaires, comme illustré ci-contre. D'autres ont des boitiers de forme carrées, comme ceux que l'on peut trouver sur les barrettes de mémoire RAM, ou à l'intérieur des clés USB/ disques SSD.

Lors de cette génération, les processeurs étaient fournis en pièces détachées qu'il fallait relier entre elles. Le processeur était composé de plusieurs circuits intégrés séparés, impossible de mettre un processeur dans un seul boitier. Un exemple de processeur conçu en kit est la série des Intel 3000. Elle regroupe plusieurs circuits séparés aux noms à coucher dehors, mais dont vous comprendrez ce qu'ils veulent dire dans les chapitres adéquats : l'Intel 3001 est un séquenceur, l'Intel 3002 regroupe unité de calcul et registres, le 3003 est un circuit d'anticipation de retenue complémentaire du 3002, le 3212 est une mémoire tampon, le 3214 est une unité de gestion des interruptions, les 3216/3226 sont des interfaces de bus mémoire. On pourrait aussi citer la famille de circuits intégrés AMD Am2900.

Même si le processeur était en pièces détachées, utiliser une dizaine de circuits intégrés était nettement mieux que d'utiliser plusieurs milliers de transistors individuels. En conséquence, les ordinateurs ont vu leur taille grandement réduite, passant de pièces entières à une simple armoire, voire à quelques cartes intégrées superposées. De plus, le prix des circuits intégré était abordable, du moins comparé aux ordinateurs d'avant. Le prix des ordinateurs a alors grandement décru, permettant à des entreprises et administrations de taille modeste de s'équiper d'ordinateurs.

===La quatrième génération : le microprocesseur===

[[File:MOS6502.svg|vignette|Microprocesseur, ici un processeur MOS6502, de la quatrième génération.]]

Lors de la troisième génération, les circuits intégrés regroupaient plusieurs dizaines ou centaines de transistors, mais sont rapidement montés en gamme. De centaines de transistors, ils sont passés au millier de transistors, puis au million et maintenant au-delà du milliard. Les transistors étaient devenus tellement petits, tellement miniaturisés, qu'il était devenu possible de mettre un processeur entier dans un circuit intégré. C'est ainsi qu'est né le microprocesseur, à savoir un processeur qui tient tout entier dans un seul circuit imprimé. La quatrième génération d’ordinateur est celle des ordinateurs basés autour d'un microprocesseur.

Les tout premiers microprocesseurs étaient des processeurs à application militaire, comme le processeur du F-14 CADC ou celui de l'Air data computer. Le tout premier microprocesseur commercialisé au grand public est le 4004 d'Intel, sorti en 1971. L'intel 4004 comprenait environ 2300 transistors, avait une fréquence de 740 MHz, pouvait faire 46 opérations différentes, et manipulait des entiers de 4 bits. Il était au départ un processeur de commande, prévu pour être intégré dans la calculatrice Busicom calculator 141-P, mais il fut utilisé pour d'autres applications quelque temps plus tard. Immédiatement après le 4004, les premiers microprocesseurs 8 bits furent commercialisés. Le 4004 fut suivi par le 8008 et quelques autres processeurs 8 bits extrêmement connus, comme le 8080 d'Intel, le 68000 de Motorola, le 6502 ou le Z80.

Les microprocesseurs permirent encore uen fois de réduire la taille des ordinateurs, qui pouvaient tenir dans un boitier de PC, ou un boitier de console de jeu. Le prix des ordinateurs a aussi chuté en même temps que les transistors étaient miniaturisés. C'est cette invention qui permis l'invention des consoles de jeux et des mini-ordinateurs, à savoir les ordinateurs personnels. Sans miniaturisation, on n'aurait pas d'ordinateur personnel, pas de PC fixe ou portable.

==L'organisation du cours : les différents niveaux d'explication==

Le fonctionnement d'un ordinateur est assez complexe à expliquer car les explications peuvent se faire sur plusieurs niveaux. Par plusieurs niveaux, on veut dire qu'un ordinateur est composé de composants très simples, qui sont assemblés pour donner des composants eux-même plus complexes, qui sont eux-même regrouper, etc. Étudier tout cela demande de voir plusieurs niveaux, allant de transistors très petits à des processeurs multicœurs. Les niveaux les plus bas sont de l'électronique pur et dure, alors que ceux plus haut sont à mi-chemin entre électronique et informatique.

===Les niveaux d'abstraction en architecture des ordinateurs===

Les trois premiers niveaux sont de l'électronique pur et dure. Ils correspondent aux premiers chapitres du cours, qui porteront sur les circuits électroniques en général.
* Le premier niveau est celui des '''transistors''', des circuits intégrés, des ''wafer'' et autres circuits de très petite taille.
* Le second niveau est celui des '''portes logiques''', des circuits très basiques, très simples, à la base de tous les autres.
* Le troisième niveau est celui dit de la '''''Register Transfer Level''''', où un circuit électronique est construit à partir de circuits basiques, dont des registres et autres circuits dits combinatoires.
Les deux niveaux suivants sont de l'informatique proprement dit. C'est dans ces deux niveaux qu'on étudie les ordinateurs proprement dit, les circuits qu'il y a dedans et non l'électronique en général.
* Le quatrième niveau est celui de la '''microarchitecture''', qui étudie ce qu'il y a à l'intérieur d'un processeur, d'une mémoire, des périphériques et autres.
* Le cinquième niveau est celui de l''''architecture externe''', qui décrit l'interface du processeur, de la mémoire, d'un périphérique ou autre. Par décrire l'interface, on veut dire : comment un programmeur voit le processeur et la mémoire, comment il peut les manipuler. Une architecture externe unique peut avoir plusieurs microarchitecture, ce qui fait qu'on sépare les deux. Tout cela sera plus clair quand on passera aux chapitres sur le processeur et les mémoires.

Nous n'allons pas voir les 5 niveaux dans l'ordre, des transistors vers l'architecture externe. En réalité, nous allons procéder autrement. La première partie du cours portera sur les trois premiers niveaux, le reste sur les deux autres. Les 5 niveaux seront vus dans des chapitres séparés, du moins le plus possible. Au niveau pédagogique, tout est plus simple si on scinde les 5 niveaux. Bien sûr, il y a quelques explications qui demandent de voir plusieurs niveaux à la fois. Par exemple, dans le chapitre sur les mémoires caches, nous auront des explications portant sur la RTL, la microarchitecture du cache et son architecture externe. Mais le gros du cours tentera de séparer le plus possible les 5 niveaux.

===Les trois parties principales du cours===

Nous allons commencer par parler du binaire, avant de voir les portes logiques. Avec ces portes logiques, nous allons voir comment fabriquer des circuits basiques qui reviendront très souvent dans la suite du cours. Nous verrons les registres, les décodeurs, les additionneurs et plein d'autres circuits. Puis, nous reviendrons au niveau des transistors pour finir la première partie. La raison est que c'est plus simple de faire comme cela. Tout ce qui a trait aux transistors sert à expliquer comment fabriquer des portes logiques, et il faut expliquer les portes logiques pour voir le niveau de la RTL.

Une fois la première partie finie, nous allons voir les différents composants d'un ordinateur. Une première partie expliquera ce qu'il y a dans un ordinateur, quels sont ses composants. Nous y parlerons de l'architecture de base, de la hiérarchie mémoire, des tendances technologiques, et d'autres généralités qui serviront de base pour la suite. Puis, nous verrons dans l'ordre les bus électroniques, les mémoires RAM/ROM, le processeur, les périphériques, les mémoires de stockage (SSD et disques durs) et les mémoires caches. Pour chaque composant, nous allons voir leur architecture externe, avant de voir leur microarchitecture. La raison est que la microarchitecture ne peut se comprendre que quand on sait quelle architecture externe elle implémente.

Enfin, dans une troisième partie, nous allons voir les optimisations majeures présentes dans tous les ordinateurs modernes, avec une partie sur le pipeline et le parallélisme d'instruction, et une autre sur les architectures parallèles. Pour finir, les annexes de fin parlerons de sujets un peu à part.

&lt;noinclude&gt;
{{NavChapitre | book=Fonctionnement d'un ordinateur
           | next=L'encodage des données
           | nextText=L'encodage des données
}}
&lt;/noinclude&gt;</text>
      <sha1>k84mj0kgzngoegspgqxsb3yb1xmbsoy</sha1>
    </revision>
    <revision>
      <id>744166</id>
      <parentid>744165</parentid>
      <timestamp>2025-06-05T15:29:11Z</timestamp>
      <contributor>
        <username>Mewtow</username>
        <id>31375</id>
      </contributor>
      <minor />
      <comment>/* La première génération : les tubes à vide */</comment>
      <origin>744166</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="48657" sha1="1lhtwfhvk3fl7482qmnphab9jbpul6c" xml:space="preserve">Pour commencer, nous allons voir qu'il existe de nombreux types d'ordinateurs. Le plus connu est certainement le PC, l'ordinateur personnel, que vous avez sans doute dans votre salon. Les ordinateurs portables sont un deuxième type d'ordinateur assez intuitif, que vous avez peut-être. Mais il y a aussi d'autres types d'ordinateurs auxquels vous n'avez jamais été confrontés.

==Les différents types d'ordinateurs==

Dans cette section, nous allons décrire rapidement les ordinateurs les plus courant, mais surtout voir ce qu'il y a à l'intérieur d'un ordinateur.

===L'ordinateur de type PC fixe===

De l'extérieur, l'ordinateur est composé d'une unité centrale sur laquelle on branche des périphériques.

[[File:Typical computer architecture systems.jpg|vignette|upright=1.5|Exemples de périphériques, connectés à une unité centrale (ici appelée à tort ''operating system'').]]

Les '''périphériques''' regroupent l'écran, la souris, le clavier, l'imprimante, et bien d'autres choses. Ils permettent à l'utilisateur d'interagir avec l'ordinateur : un clavier permet de saisir du texte sous dans un fichier, une souris enregistre des déplacements de la main en déplacement du curseur, un écran affiche des données d’images/vidéos, un haut-parleur émet du son, etc. Tout ce qui est branché sur un ordinateur est, formellement un périphérique.

L''''unité centrale''' est là où se trouvent tous les composants importants d'un ordinateur, ceux qui font des calculs, qui exécutent des logiciels, qui mémorisent vos données, etc. Voici ce à quoi ressemble l'intérieur de l'unité centrale. Trois sections sont visibles : l'alimentation électrique en haut à gauche, la carte mère en bas à gauche et en jaune/orange, les disques et lecteurs à droite des câbles. Et on voit aussi beaucoup de câbles.

[[File:Asus P5K-SEIntel E6320.jpg|centre|vignette|upright=2|Exemple d'unité centrale.]]

Tout en haut à gauche, se trouve l''''alimentation électrique''', qui convertit le courant de la prise électrique en un courant plus faible, utilisable par les autres composants. Elle émet de nombreux câbles assez gros, qui sont reliés au reste. Les PC actuels utilisent des alimentations électriques standardisées, qui fournissent trois tensions au reste de l'ordinateur : une tension de 12 Volts, une de 5 Volts, une de 3,3 Volts.

À droite, caché par la partie &quot;métallique&quot; du boitier, se trouvent les lecteurs de CD/DVD, et les disques durs. Les lecteurs CD-ROM ou DVD-ROM permettaient de lire des CD ou des DVD. Je parle au passé, car ils ont aujourd'hui disparu des ordinateurs modernes. Les '''disques durs''' sont des mémoires de stockage, qui mémorisent vos données de manière permanente. De nos jours, ils sont remplacés par des SSD, qui sont des disques durs électroniques, là où les disques durs proprement dit sont des mémoires magnétiques. Nous verrons la différence dans deux chapitres dédiés, un sur les disques durs, l'autre sur les SSD.

En bas à droite, se trouve la '''carte mère''' un support plat, en plastique ou en céramique, sur laquelle sont soudés/connectés les autres composants. Sur celle-ci, de nombreux composants sont soudés, d'autres sont branchés dessus avec des câbles, d'autres sont connectés dessus avec des connecteurs. Ils sont reliés entre eux par des fils conducteurs, le plus souvent du cuivre ou de l’aluminium, ce qui leur permet de s’échanger des données. Sur les cartes simples, ces fils sont intégrés dans la carte électronique, dans des creux du plastique. Ils portent le nom de pistes.

Avant, les disques durs, SSD et lecteurs de CD/DVD sont branchés dessus via des connecteurs dédiés, appelés des connecteurs S-ATA. De nos jours, ils sont branchés sur un autre connecteur, grâce à l'interface NVME. Toujours est-il qu'ils sont reliés à la carte mère par des câbles, ce qui montre que ce sont des sortes de périphériques interne. Ils sont placés dans le boitier, mais on aurait tout aussi bien pu les mettre à l'extérieur, vu qu'ils communiquent avec l'ordinateur par l'intermédiaire d'un câble ou d'un connecteur dédié.

Mais deux autres composants très importants sont eux placés sur la carte mère, directement. Ils ont chacun un connecteur dédié, sur lequel ils sont branchés directement, sans passer par l'intermédiaire d'un câble, mais sans être soudés non plus. Il s'agit du processeur et de la mémoire RAM, deux composants centraux des PC modernes.

[[File:Pentium III SL4CB.jpg|thumb|Processeur Pentium III.]]

Le '''processeur''' traite les données, les modifie, les manipule. Pour faire simple, il s’agit d’une grosse calculatrice hyper-puissante. Il comprend à la fois un circuit qui fait des calculs, et un circuit de contrôle qui s'occupe de séquencer les calculs dans l'ordre demandé. Il est souvent caché sous un radiateur, lui-même surmonté par un ventilateur. En effet, un processeur chauffe beaucoup, ce qui demande d'évacuer cette chaleur. Un chapitre entier expliquera pourquoi les processeurs chauffent, ainsi que les techniques utilisées pour limiter leur production de chaleur et leur consommation électrique.

La '''mémoire vive''' conserve des informations/données temporairement, tant que le processeur en a besoin. Elle prend la forme de barrettes de RAM, comme montré ci-dessous.

[[File:2 gb ddr2 667.jpg|centre|vignette|upright=2|Barrette de RAM.]]

Outre ces composants dits principaux, un ordinateur peut comprendre plusieurs composants moins importants, surtout présents sur les ordinateurs personnels. Ils sont techniquement facultatifs, mais sont très présents dans les ordinateurs personnels. Cependant, certains ordinateurs spécialisés s'en passent. Il s'agit des diverses '''cartes d'extension''' sont branchées sur la carte mère. Elles permettent d’accélérer certains calculs ou certaines applications, afin de décharger le processeur. Par exemple, la carte graphique s'occupe des calculs graphiques, qu'il s'agisse de graphismes 3D de jeux vidéos ou de l'affichage en 2D du bureau. Dans un autre registre, la carte son prend en charge le microphone et les haut-parleurs.

[[Fichier:Personal computer, exploded 4.svg|thumb|upright=1.0|Éclaté d'un ordinateur de type PC :&lt;br /&gt;
1 : Écran ;&lt;br /&gt;
2 : Carte mère ;&lt;br /&gt;
3 : Processeur ;&lt;br /&gt;
4 : Câble Parallel ATA ;&lt;br /&gt;
5 : Mémoire vive (RAM) ;&lt;br /&gt;
6 : Carte d'extension ;&lt;br /&gt;
7 : Alimentation électrique ;&lt;br /&gt;
8 : Lecteur de disque optique ;&lt;br /&gt;
9 : Disque dur ;&lt;br /&gt;
10 : Clavier ;&lt;br /&gt;
11 : Souris.]]

Si on regarde une carte mère de face, on voit un grand nombre de connecteurs, mais aussi des circuits électroniques soudés à la carte mère.

[[File:Architecture matérielle d'une carte mère.png|centre|vignette|upright=2.0|Architecture matérielle d'une carte mère]]

Les '''connecteurs''' sont là où on branche les périphériques, la carte graphique, le processeur, la mémoire, etc. Dans l'ensemble, toute carte mère contient les connecteurs suivants :
* Le processeur vient s’enchâsser dans la carte mère sur un connecteur particulier : le '''socket'''. Celui-ci varie suivant la carte mère et le processeur, ce qui est source d'incompatibilités.
* Les barrettes de mémoire RAM s’enchâssent dans un autre type de connecteurs: les '''slots mémoire'''.
* Les mémoires de masse disposent de leurs propres connecteurs : connecteurs P-ATA pour les anciens disques durs, et S-ATA pour les récents.
* Les périphériques (clavier, souris, USB, Firewire, ...) sont connectés sur un ensemble de connecteurs dédiés, localisés à l'arrière du boitier de l'unité centrale. 
* Les autres périphériques sont placés dans l'unité centrale et sont connectés via des connecteurs spécialisés. Ces périphériques sont des cartes imprimées, d'où leur nom de '''cartes filles'''. On peut notamment citer les cartes réseau, les cartes son, ou les cartes vidéo.

===Les ordinateurs portables===

[[File:Samsung QX-511 (2).JPG|vignette|Ordinateur portable Samsung QX-511 (2), pour illustration.]]

Un ordinateur portable est identique à un ordinateur de type PC. Si vous ouvrez votre ordinateur portable (attention à la garantie), vous retrouverez les mêmes composants qu'un PC à l'intérieur. Un point important est la présence d'une batterie à l'intérieur du PC portable, absente des PC fixes.

[[File:LG gram 14Z90Q mainboard with battery.jpg|centre|vignette|upright=2|LG gram 14Z90Q avec sa batterie.]]

Une fois la batterie et les circuits associés retiré, la seule différence notable est que tous les composants sont soudés sur la carte mère, au lieu d'être branchés sur des connecteurs, à part éventuellement la RAM et le disque dur.

[[File:LG gram 14Z90Q mainboard without battery.jpg|centre|vignette|upright=2|LG gram 14Z90Q sans sa batterie.]]

La RAM est parfois soudée sur la carte mère, d'autres fois sous la forme de barrettes de mémoire vive semblables à celles des PC. Dans le dernier cas, elle est connectée à des connecteurs spécifiques, ce qui permet de les changer/upgrader. Les PC portables sont parfois construits de manière à pouvoir changer la RAM facilement, en ouvrant un cache spécial, concu pour.

[[File:Lenovo G555 состав - Донор.JPG|centre|vignette|upright=2|Lenovo G555.]]

La conception d'un ordinateur portable est légèrement différente de celle d'un PC, pour des raisons thermiques. Un PC fixe a plus de place pour évacuer sa chaleur. Les ventilateurs peuvent plus facilement déplacer l'air dans le boitier, même si le flux d'air dans le boitier est éventuellement gêné par la carte graphique. Mais l'évacuation de la chaleur est assez efficace. Sur les PC portables, leur finesse fait que le trajet de l'air est beaucoup plus contraint. Évacuer la chaleur produite par l'ordinateur est plus complexe, ce qui demande d'utiliser des systèmes de refroidissement et de ventilation spécifiques.

Là où les PC fixes se débrouillent avec des radiateurs et des ventilateurs posés sur le processeur, les PC portables font autrement. Ils ne peuvent pas forcément mettre le ventilateur sur le processeur. A la place, ils mettent le ventilateur à côté, mais le processeur est surmonté par un mécanisme de transmission de la chaleur, qui transfère la chaleur du processeur vers le ventilateur.

[[File:Diagram - How a laptop cooling system works.png|centre|vignette|upright=2|Comment fonctionne le système de ventilation d'un ordinateur portable, en anglais.]]

Les difficultés pour dissiper la chaleur font que les ordinateurs portables utilisent souvent des composants peu performants, mais qui chauffent peu. En effet, nous verrons que plus un composant est puissant, plus il chauffe. La relation n'est pas parfaite, mais les processeurs haute performance chauffent plus que les modèles d'entrée ou milieu de gamme moins puissants. En conséquence, les PC portables sont souvent moins puissants que les PC fixes, même pour les modèles dit ''gaming''.

===Les serveurs et ''mainframes''===

Les grandes entreprises utilisent des ordinateurs de grande taille, très puissants, appelés des ''mainframes''. Ils sont souvent confondus avec les serveurs par le grand public, il y a une différence entre les deux. Un serveur est une fonction logicielle/réseau, pas un type d'ordinateur. Mais laissons cette différence de côté, ce qui est dit pour les ''mainframes'' sert pour les gros serveurs haute performance.

[[File:IBM Z15 mainframe.jpg|vignette|Exemple de ''mainframe''' de type IBM Z15.]]

Les anciens ''mainframes'' des années 50-80 avaient une taille pouvant être impressionnante, au point de prendre une pièce complète d'un bâtiment. Mais de nos jours, les ''mainframes'' tiennent dans une grosse armoire un peu haute. Les ''mainframes'' doivent rester allumé en permanence et ne doivent pas être éteint, sauf éventuellement quelques jours par an pour des opérations de maintenance. Ils utilisent pour cela des techniques spécifiques, avec beaucoup de redondance interne.

[[File:ACONIT hall grandes machines.jpg|centre|vignette|upright=2|''Mainframe'' ACONIT.]]

Les ''mainframes'' sont aussi conçus pour mutualiser au maximum leur utilisation, ils peuvent être utilisés par plusieurs utilisateurs à la suite, voire en même temps. Pour cela, les anciens ''mainframes'' étaient capables de faire tourner plusieurs applications distinctes l'une à la suite de l'autre, avec des commutations fréquentes entre logiciels. De nos jours, ils sont capables d'exécuter un grand nombre de tâches en même temps, grâce à la présence de plusieurs processeurs. Les ''mainframes'' modernes sont même capables de faire tourner plusieurs systèmes d'exploitation en même temps si besoin.

Les anciens ''mainframes'' étaient des ordinateurs assez simples, avec un processeur, de la mémoire RAM, un ou plusieurs disques durs, pas plus. Le ''mainframe'' était tellement énorme et cher que les entreprises n'en avaient qu'un seul pour toute l'entreprise. Les employés avaient sur leur bureau des terminaux, qui permettaient d'accéder à l'ordinateur central, mais n'étaient pas des ordinateurs. Les terminaux étaient des composants électroniques simples, avec un écran, un clavier et une souris, mais sans processeur. Ils envoyaient des données au ''mainframe'', ils en recevaient de sa part, mais tout traitement était réalisé sur le ''mainframe''. L'arrivée sur le marché des ordinateurs personnels, de type PC fixe/portable, a entrainé l'abandon de ce genre de pratique, tous les employés ont maintenant un ordinateur rien que pour eux.

{|
|-
! colspan=&quot;2&quot; | Exemples de terminaux
|-
|[[File:Terminal-in2-sm9400.jpg|centre|vignette|upright=1.5|Exemple de terminal. Notez la présence d'un écran et d'un clavier, mais l'asbence d'une unité centrale.]]
|[[File:Chromatics CT4100.jpg|vignette|upright=1.5|Autre exemple de terminal. Le clavier est couplé à un stylo CRT, qui remplacait la souris et agissait sur l'écran comme s'il était tactile.]]
|-
! colspan=&quot;2&quot; | Intérieur d'un terminal
|-
|[[File:CT1024 Monitor.jpg|vignette|upright=1.5|Terminal CT1024, sans le boitier extérieur.]]
|[[File:CT1024 Terminal System.jpg|vignette|upright=1.5|Terminal CT1024, description des composants interne.]]
|}

De nos jours, les ''mainframes'' contiennent en réalité plusieurs ordinateurs simples interconnectés via un réseau local. Un ''mainframe'' qui tient dans une armoire contient facilement une dizaine ou centaine de processeurs, plein de RAM, des disques durs séparés dans une armoire distincte, etc. Vu qu'ils communiquent uniquement via le réseau, ils n'ont pas d'interface, pas d'écran, 'entrée via clavier/souris. Le tout est commandé avec une console de commande, typiquement un ordinateur portable ou un terminal assez simple séparé de l'armoire, qui permet à un administrateur de faire des opérations de surveillance, configuration et maintenance. Il peut y avoir une console de commande pour plusieurs armoires séparées, la console peut même être dans un autre bâtiment et accéder au ''mainframe'' par le réseau.

[[File:IBM System Z9 (type 2094 inside).jpg|centre|vignette|upright=2|''Mainframe'' de type IBM System Z9. L'ordinateur portable sert de console pour qu'un administrateur fasse des opérations de surveillance, configuration et maintenance.]]

Les processeurs et la RAM sont typiquement installés sur des cartes amovibles, qui sont connectées au fond de l'armoire lors de l'installation. Il est même possible de retirer ou d'ajouter des cartes en fonctionnement, afin d'ajouter/retirer des processeurs, des disques durs, etc. Ce qui est très utile si un composant est en panne et qu'il faut le remplacer. 

[[File:IBM TotalStorage Exp400.jpg|centre|vignette|upright=2|IBM TotalStorage Exp400]]

==Un peu d'abstraction : qu'est-ce qu'un ordinateur ?==

Un ordinateur comprend donc un processeur, plusieurs mémoires, des cartes d'extension et une carte mère pour connecter le tout. Mais il s'agit là d'une description assez terre-à-terre de ce qu'est un ordinateur. Une autre description, plus abstraite, se base sur le fait qu'un ordinateur est une énorme calculatrice programmable. Elle permet d'expliquer pourquoi il y a une distinction entre processeur et mémoire, entre unité centrale et périphériques. Tout ce qui va suivre pourra vous paraitre assez abstrait, mais rassurez-vous : les prochains chapitres rendront tout cela plus concrets.

===La séparation entre entrées-sorties et traitement===

L'unité centrale peut être vue comme une énorme calculatrice ultra-puissante, qui exécute des commandes/opérations. Mais à elle seule, elle ne servirait à rien, il faut interagir avec par l'intermédiaire de plusieurs périphériques. Il existe deux types de périphériques, qui sont conceptuellement différents. Les périphériques comme le clavier ou la souris permettent d'envoyer des informations à l'ordinateur, d'agir sur celui-ci. A l'inverse, les écrans transmettent des informations dans le sens inverse : de l'ordinateur vers l'utilisateur. Les premiers sont appelés des '''entrées''', les seconds des '''sorties'''.

Dans un ordinateur, les informations sont représentées sous la forme de nombres. Toute donnée dans un ordinateur est codée avec un ou plusieurs nombres regroupés dans une donnée, un fichier, ou autre. Et la transmissions avec les entrées et sorties se fait là-encore avec des nombres. Par exemple, quand vous appuyez sur votre clavier, le clavier envoie un numéro de touche à l'unité centrale, qui indique quelle touche a été appuyée. L'image à afficher à l'écran est codée sous la forme d'une suite de nombres (un par pixel). L'image est envoyée à l'écran, qui traduit la suite de nombre en image à afficher. Les entrées traduisent des actions utilisateurs en nombres, on dit que les entrées encodent les actions utilisateur. Les sorties font la traduction inverse, elles transforment des suites de nombres en une action physique. On dit qu'elles décodent des informations.

Pour résumer, toute appareil électronique est composé par :
* Des '''entrées''' sur lesquelles l'utilisateur agit sur l'ordinateur. Les entrées transforment les actions de l'utilisateur en nombres, qui sont interprétés par l'ordinateur.
* Une '''unité de traitement''', qui manipule des nombres et fait des calculs/opérations dessus. Les nombres proviennent des entrées, du disque dur, ou d'autres sources, peu importe.
* Des '''sorties''', qui va récupèrent le résultat calculé par l'unité de traitement pour en faire quelque chose : écrire sur une imprimante ou sur un moniteur, émettre du son,...

[[File:Ordinateur théorique Simple 1.png|centre|vignette|upright=2|Ordinateur théorique Simple 1]]

L'unité de traitement proprement dite, celle qui fait les calculs, est couplée à une mémoire qui mémorise les opérandes et résultats des calculs. La séparation entre processeur et mémoire est nécessaire pour qu'un appareil électronique soit qualifié d'ordinateur. De nombreux appareils n'ont pas de séparation entre unité de traitement et mémoire, comme certaines vielles radios AM/FM.

[[File:Schéma de principe d'un ordinateur.png|centre|vignette|upright=2|Schéma de principe d'un ordinateur]]

===Un ordinateur est un appareil programmable===

Les appareils simples sont non-programmables, ce qui veut dire qu’ils sont conçus pour une utilisation particulière et qu’ils ne peuvent pas faire autre chose. Par exemple, les circuits électroniques d’un lecteur de DVD ne peuvent pas être transformé en lecteur audio ou en console de jeux... Les circuits non-programmables sont câblés une bonne fois pour toute, et on ne peut pas les modifier. On peut parfois reconfigurer le circuit, pour faire varier certains paramètres, via des interrupteurs ou des boutons, mais cela s’arrête là. Et cela pose un problème : à chaque problème qu'on veut résoudre en utilisant un automate, on doit recréer un nouveau circuit.

À l'inverse, un ordinateur n’est pas conçu pour une utilisation particulière, contrairement aux autres objets techniques. Il est possible de modifier leur fonction du jour au lendemain, on peut lui faire faire ce qu’on veut. On dit qu'ils sont '''programmables'''. Pour cela, il suffit d’utiliser un logiciel, une application, un programme (ces termes sont synonymes), qui fait ce que l'on souhaite. La totalité des logiciels présents sur un ordinateur sont des programmes comme les autres, même le système d'exploitation (Windows, Linux, ...) ne fait pas exception.

Un programme est une suite de d''''instructions machines''', chaque instruction effectuant une action dans l'ordinateur. Sur les ordinateurs modernes, les instructions les plus communes effectuent une opération arithmétique : une addition, une multiplication, une soustraction, etc. Les ordinateurs modernes sont donc de grosses calculettes très puissantes, capables d'effectuer des millions d'opérations par secondes.

Et qui dit opération dit nombres : un ordinateur gère nativement des nombres, qui sont codés en binaire sur la quasi-totalité des ordinateurs modernes. Les ordinateurs modernes sont capables de faire des calculs sur des nombres entiers, mais aussi des nombres à virgule. Il existe plusieurs manières de représenter des nombres en binaire, certaines représentant des nombres entiers dits naturels (0 et plus), d'autres des nombres signés (positifs ou négatifs), d'autres des nombres à virgule. Un chapitre entier détaillera comment sont encodés ces nombres.

Une instruction est représentée dans un ordinateur par une série de nombres entiers : un nombre qui indique quelle opération/commande effectuer et des autres nombres pour coder les données (ou de quoi les retrouver dans l'ordinateur). L'ordinateur récupére les commandes une par une, les traduit en opération à effectuer, exécuter l'opération, et enregistre le résultat. Puis il recommence avec la commande suivante.

[[File:Ordinateur Théorique Complexe 1.png|centre|vignette|upright=3|Ordinateur Théorique Complexe. En jaune, le programme informatique, la liste de commande. Le rectangle gris est l'ordinateur proprement dit.]]

De nombreux appareils sont programmables, mais tous ne sont pas des ordinateurs. Par exemple, certains circuits programmables nommés FPGA n'en sont pas. Pour être qualifié d'ordinateur, un appareil programmable doit avoir un processeur séparé de la mémoire. De plus, il doit utiliser un '''codage numérique''', chose que nous allons aborder dans le chapitre suivant.

===Les ordinateurs à programme mémorisé ou programme externe===

[[File:Blue-punch-card-front.png|vignette|upright=0.5|Carte Perforée.]]

Au tout début de l'informatique, les programmes étaient enregistrés sur des cartes perforées, à savoir des cartes en papier/plastique percées par endroits. Un 1 est codé par un trou dans le papier et un 0 par une absence de trou. Les programmes étaient exécutés par l'ordinateur quand on insérait la carte perforée dans le lecteur et qu'on appuyait sur un bouton.

Par la suite, les premiers ordinateurs grand public, comme les Amstrad ou les Commodore, utilisaient des cassettes audio magnétiques pour stocker les programmes. Dans le même style, les consoles de jeu utilisaient autrefois des cartouches de jeu, qui contenaient le programme du jeu à exécuter. Pour résumer, les anciens ordinateurs mémorisaient les programmes sur un support externe, lu par un périphérique. De tels ordinateurs sont dits à '''programme externe'''.

: D’anciens ordinateurs personnels, comme l’Amstrad ou le Commodore, permettaient de taper les programmes à exécuter à la main, au clavier, avant d’appuyer une touche pour les exécuter. Nul besoin de vous dire que les cassettes audio étaient plus pratiques.

Mais de nos jours, les programmes sont enregistrés sur le disque dur de l'ordinateur ou dans une mémoire intégrée à l'ordinateur. On dit qu'ils sont installés, ce qui est un mot bien compliqué pour dire que le programme est enregistré sur le disque dur de l’ordinateur. A défaut de disque dur, le programme/logiciel est enregistré dans une mémoire spécialisée pour le stockage. Par exemple, sur les cartes électroniques grand public de marque Arduino, les programmes sont envoyés à la carte via le port USB, mais les programmes sont enregistrés dans la carte Arduino, dans une mémoire FLASH dédiée. Disque dur ou non, le programme est mémorisé dans la mémoire de l'ordinateur. Il est possible d'installer ou de désinstaller les programmes en modifiant le contenu de la mémoire. Le terme utilisé est alors celui de '''programme stocké en mémoire'''.

Les programmes à installer sont disponibles soit sur un périphérique, comme un DVD ou une clé USB, soit sont téléchargés depuis internet. Les premiers PC fournissaient les logiciels sur des disquettes, qui contenaient un programme d'installation pour enregistrer le programme sur le disque dur de l'ordinateur. Par la suite, le support des logiciels a migré vers les CD et DVD, les logiciels devenant de plus en plus gros. De nos jours, la majorité des applications sont téléchargées depuis le net, l'usage de périphériques est devenu obsolète, même les consoles de jeu abandonnent cette méthode de distribution.

==Les générations d'ordinateurs : un historique rapide==

L'informatique a beaucoup évolué dans le temps. Et une bonne partie de cette évolution tient à l'évolution de l’électronique sous-jacente. Les ordinateurs actuels sont fabriqués avec des transistors, des petits composants électroniques qui servent d'interrupteurs programmables, qu'on détaillera dans ce qui suit. Mais ça n'a pas toujours été le cas. Et cela permet de distinguer plusieurs '''générations d'ordinateurs'''.

===Les ordinateurs électro-mécaniques : les premiers ordinateurs===

Le tout premier ordinateur est le '''Z1''', un modèle unique inventé par Konrad Suze entre 1936 et 1938. Son processeur gérait non pas des nombres entiers, mais des nombres à virgule (des nombres dits flottants, pour être précis), encodés sur 22 bits. Le processeur du Z1 était capable de faire des additions et des soustractions, car il intégrait un circuit additionneur-soustracteur basique. Des circuits annexes permettaient de faire des multiplications et des divisions en enchainant des additions/soustractions successives. Il fonctionnait à une fréquence de 1 Hz, ce qui fait qu'il pouvait faire une addition/soustraction par seconde maximum.

Niveau mémoire, la RAM de l'ordinateur était très limitée : seulement 16 nombres de 22 bits chacun. S'il s'agissait d'une mémoire électronique, les programmes étaient mémorisés sur une mémoire mécanique et précisémment sur des cartes perforées, à savoir des cartes en papier/plastique dans lesquelles un 1 est codé par un trou dans le papier et un 0 par une absence de trou. Les programmes étaient exécutés par l'ordinateur quand on insérait la carte perforée dans le lecteur et qu'on appuyait sur un bouton.

[[File:German Museum of Technology, Berlin 2017 024.jpg|centre|vignette|upright=2|Réplique du Z1 au ''German Museum of Technology'' de Berlin, 2017.]]

Après sa destruction dans un bombardement, le Z1 a été reconstruit et amélioré, ce qui donné les deux ordinateurs Z2 et Z3. Quelques années plus tard, quelques laboratoires de recherche ont fabriqués des ordinateurs dans leur coin, comme le Harvard Mark I et le Colossus Mark 1 (UK) qui ont été mis en service en 1944. Ils ont servi pour les cryptanalystes pour casser les codes utilisés par les Allemands pour leurs transmissions, pendant la seconde guerre mondiale.

Les ordinateurs cités dans le précédent paragraphe étaient tous des ordinateurs dit '''électro-mécaniques''', car ils mélangeaient des composants électroniques et des composants mécaniques (tout ce qui a trait aux cartes perforées, notamment). Les composants électroniques étaient généralement des relais, à savoir des interrupteurs commandables électriquement, qui sont plus ou moins équivalents aux transistors modernes. La majeure partie des ordinateurs des années 40 étaient de ce type, mais leur nombre n'a pas dépassé 30. Il faut dire qu'ils ont rapidement laissé la place à des ordinateurs purement électroniques, que nous allons voir dans ce qui suit.

===La première génération : les tubes à vide===

Les ordinateurs qui ont suivi les ordinateurs électromécaniques sont regroupés dans la '''première génération d'ordinateur'''. Ils étaient conçus avec des tubes à vide, des espèces d'interrupteurs commandables, les ancêtres des transistors modernes. Les tubes à vide étaient assez encombrants, ils consommaient beaucoup de courant, ils chauffaient et étaient assez peu fiables. Ils tombaient en panne assez souvent. Et ils étaient assez simples à fabriquer, mais restaient malgré tout chers.

Les tubes à vide sont des ampoules à filament améliorées. Pour rappel, les ampoules à filament étaient des ampoules en verre dans lesquelles on plaçait un filament métallique. Le filament chauffait quand on envoyait du courant dedans et émettait de la lumière. Mais dans les tubes à vide, le filament n'émet pas de lumière quand on le chauffe : il émet des électrons, de l'électricité. De plus, ils ajoutent une électrode, une plaque en métal qui émet ou capte des électrons. Ici, l'électrode capte des électrons émis par le filament quand il chauffe. Vu qu'elle capte des électrons, on l'appelle l''''anode'''. Le résultat est un circuit qui laisse passer le courant, mais seulement dans un sens : du filament vers l'anode, l'autre sens n'est pas possible vu que l'anode ne peut pas émettre d'électrons. Un tel circuit est appelé une '''diode'''.

{|
|[[File:Diode vide schema explicatif.png|vignette|upright=1.5|Tube à vide basique.]]
|[[File:Diode à vide schéma de fonctionnement.png|vignette|upright=1.5|Diode à vide, schéma de fonctionnement.]]
|}

Une amélioration des tubes à vide précédent rajoute une seconde plaque de métal, appelée la '''cathode'''. Elle est située juste après le filament. C'est elle qui émet les électrons, non pas le filament. Cependant, elle n'émet des électrons que si elle est chauffée par le filament. Le filament doit donc chauffer, ce qui réchauffe la cathode, qui elle-même émet des électrons en direction de l'anode.

{|
|[[File:Diode à vide.png|vignette|upright=1.5|Diode à vide, avec cathode.]]
|[[File:Vacuum tubes (multilingual).svg|vignette|upright=1.5|Diode à vide avec cathode, schéma de fonctionnement.]]
|}

Les tubes à vides étaient utilisés pour le processeur et quelques circuits annexes, mais les mémoires utilisaient d'autres technologies. Les mémoires de l'époque n'étaient pas du tout des mémoires électroniques. Il existait déjà des ancêtres des disques durs, à savoir des mémoire magnétiques appelées tambours magnétiques, bandes magnétiques, mémoires à tore de ferrite, etc. Les mémoires RAM, quant à elles, utilisaient elles des technologies totalement abandonnées : les mémoires à lignes de délai étaient des mémoires acoustiques, les tubes Williams étaient des écrans CRT modifiés, etc. Un chapitre entier sera dédié aux technologies des mémoires de l'époque.

[[File:Elektronenroehren-auswahl.jpg|centre|vignette|upright=2|Tubes à vides.]]

L'usage de tubes à vide les place entre les premiers ordinateurs électro-mécaniques et les ordinateurs utilisant des transistors. Au vu de la taille des tubes à vide, les ordinateurs de l'époque étaient composés de plusieurs milliers de ces tubes, guère plus. Et malgré cela, un ordinateur prenait facilement un étage de bâtiment entier, ou au moins plusieurs pièces. La conséquence est que les ordinateurs de première génération étaient très simples, rudimentaires quand on les compare aux ordinateurs modernes. Ils ne géraient que quelques opérations simples : l'addition, la soustraction, pas grand-chose de plus. À quelques exceptions près, ils ne géraient pas la multiplication et encore moins la division, cela aurait demandé trop de tubes à vides.

Une des toutes premières machines construite avec des tubes à vide était l'Atanasoff–Berry. Ce n'était pas un ordinateur, car elle ne pouvait pas exécuter de programme sans intervention humaine pour séquencer des opérations, mais c'était la première machine de calcul purement électronique, sans aucune pièce mécanique. Elle utilisait une mémoire RAM construite avec des condensateurs, ceux-ci étant placés sur des cylindres tournants. Les circuits de calcul étaient construits avec des tubes à vide et faisaient leur travail un bit à la fois. Elle fonctionnait à une fréquence de 60 Hz et pouvait faire 30 additions/soustractions par seconde. Les nombres étaient encodés sur 50 bits. 

[[File:Atanasoff Berry Computer.gif|centre|vignette|upright=2.5|Atanasoff–Berry.]]

L'arrivée de l'ENIAC en 1945 a changé la donne. Cet ordinateur a introduit plusieurs innovations majeures. La première est assez technique, il s'agit de la turing-complétude, elle a trait aux programmes qui peuvent être écrit pour un ordinateur, nous ne la détaillerons pas ici.

[[File:BabyArchitecture.png|vignette|Architecture de la Manchester Baby.]]

En 1948, le ''Manchester Baby'' a introduit une innovation extrêmement importante : le programme n'était plus mémorisé sur des cartes perforées, mais dans une mémoire électronique à l’intérieur de l'ordinateur lui-même. En clair, le ''Manchester Baby'' était le premier '''ordinateur à programme stocké en mémoire''' en français. Au-delà de ça, le Manchester Baby restait quand même très simple, c'était limite un prototype.

Niveau interface, l'ordinateur avait une console avec 32 boutons, des interrupteurs et un écran de sortie sur lequel afficher les résultats. A l'intérieur, il y avait un processeur et une RAM de 32 nombres de 32 bits, fabriquées avec des tubes Williams (abordés dans une annexe à la fin du cours). Une instruction prenant autant de place qu'un nombre en RAM, ce qui limitait les programmes à 32 instructions maximum. Le processeur gérait 8 instructions en tout, mais la seule instruction de calcul qu'il gérait était la soustraction. L'addition n'était pas supportée. Il pouvait cependant émuler l'addition à partir d'une soustraction et inversant l'opérande soustrait.

Le Manchester Mark 1 était une amélioration du Manchester Baby. Il utilisait 4500 tubes à vide. L'ordinateur gérait des nombres de 40 bits, mais les instructions étaient codées sur 20 bits. La RAM avait la même taille, à savoir 32 nombres, leur taille était simplement augmentée. Par contre, la RAM était complémentée par l’ancêtre du disque dur magnétique, à savoir un tambour magnétique, l’ancêtre du disque dur magnétique. Il contenait 40 pages, chacune ayant la même taille que la RAM. Contrairement à la Manchester Baby, son processeur gérait l'addition. Les multiplications étaient réalisées par des additions successives, mais le processeur intégrait des registres pour mémoriser les opérandes à multiplier.

Par la suite, les ordinateurs commerciaux ont vu le jour. Les ordinateurs précédents provenaient de projets de recherches, souvent publics. Mais les entreprises privées se sont mises à fabriquer des ordinateurs elle-mêmes, pour les vendre à d'autres entreprises. On peut notamment citer les ordinateurs comme le UNIVAC I, le Bull Gamma 3 ou les premiers ordinateurs IBM. La performance de ces ordinateurs était nettement plus importante que leurs prédécesseurs, avec des fréquences de l'ordre de la centaine de kilo-hertz. Par exemple, le Bull Gamma 3 allait à 281 kHz, l'IBM 650 allait à 50 Khz.

===La seconde génération : le remplacement des tubes à vides par des transistors===

[[File:IBM 7070.jpg|vignette|Cartes imprimées de l'IBM 704, avec des transistors et résistances dessus.]]

La '''seconde génération''' est celle des ordinateurs fabriqués avec des '''transistors''' isolés, reliés entre avec des fils électriques. Les transistors en question possèdent trois broches, des pattes métalliques sur lesquelles on connecte des fils électriques. Le transistor s'utilise le plus souvent comme un interrupteur commandé par sa troisième broche. Le courant qui traverse les deux premières broches passe ou ne passe pas selon ce qu'on met sur la troisième.

[[File:Transistor basic flow.svg|centre|vignette|Un transistor est un morceau de conducteur, dont la conductivité est contrôlée par sa troisième broche/borne.]]

Les ordinateurs de seconde génération avaient entre 1000 et 500 000 transistors. Les capacités des ordinateurs étaient donc nettement supérieures à celles des ordinateurs de première génération. Une part non négligeable des ordinateurs de seconde génération supportait l'opération de multiplication, absente sur les ordinateurs de première génération. Néanmoins, cela variait beaucoup selon les ordinateurs.

Un exemple assez hors du commun est celui du premier modèle de l'IBM 1620. Le tout premier modèle n'avait aucun circuit de calcul, il n'était même pas capable de faire une addition ou une multiplication. A la place, il utilisait une table d'addition et une table de multiplication en mémoire RAM. Les deux tables devaient être initialisées par le logiciel lors du démarrage de la machine. La table d'addition faisait une centaine de chiffres, la table de multiplication faisait le double. Le processeur de l'ordinateur gérait des instructions pour faire des additions ou des multiplications, mais ces opérations lisaient le résultat dans la table d'addition. Les calculs étaient faits chiffre par chiffre, avec un encodage partiellement décimal, partiellement binaire (des chiffres décimaux étaient encodés en binaire, nous en reparlerons quand nous parlerons du BCD) !

[[File:KL CoreMemory.jpg|vignette|Mémoire à tore de ferrite.]]

Les transistors n'étaient utilisés que pour le processeur et les circuits annexes. La mémoire n'était pas faite en transistors, pas à cette époque. La mémoire était une mémoire aujourd'hui abandonnée, appelée une '''mémoire à tores de ferrite'''. Elle sera détaillée dans un chapitre ultérieur. Mais sachez pour le moment qu'il s'agit d'une mémoire au support magnétique, les données étant stockées sur un support magnétique.

Les transistors étaient au départ de la même taille que les tubes à vide, mais ils ont rapidement rétrécit. Ils prenaient encore beaucoup de place dans les 60-70, ce qui fait que les ordinateurs étaient assez gros. Concrètement, ils prenaient une pièce de bâtiment entière dans le meilleur des cas. C'était l'époque des gros ''mainframes'', reliés à des terminaux, peu puissants comparé aux standards actuels. Seules les grandes entreprises et les grands instituts de recherche pouvaient se payer les services de ce genre d'ordinateurs. Seuls les professionnels avaient accès à ce genre d'équipement.

===La troisième génération : le circuit intégré===

[[File:D8259AC-2.jpg|vignette|Exemple de circuit intégré.]]

La troisième génération est toujours fabriquée avec des transistors, mais dont la taille a été réduite. Avec l'évolution de la technologie, les transistors ont diminué en taille, de plus en plus. Ils sont devenus tellement petits qu'ils ont fini par être regroupés dans des '''circuits intégrés''', des circuits regroupent plusieurs transistors sur la même puce de silicium. Les circuits intégrés se présentent le plus souvent sous la forme de boitiers rectangulaires, comme illustré ci-contre. D'autres ont des boitiers de forme carrées, comme ceux que l'on peut trouver sur les barrettes de mémoire RAM, ou à l'intérieur des clés USB/ disques SSD.

Lors de cette génération, les processeurs étaient fournis en pièces détachées qu'il fallait relier entre elles. Le processeur était composé de plusieurs circuits intégrés séparés, impossible de mettre un processeur dans un seul boitier. Un exemple de processeur conçu en kit est la série des Intel 3000. Elle regroupe plusieurs circuits séparés aux noms à coucher dehors, mais dont vous comprendrez ce qu'ils veulent dire dans les chapitres adéquats : l'Intel 3001 est un séquenceur, l'Intel 3002 regroupe unité de calcul et registres, le 3003 est un circuit d'anticipation de retenue complémentaire du 3002, le 3212 est une mémoire tampon, le 3214 est une unité de gestion des interruptions, les 3216/3226 sont des interfaces de bus mémoire. On pourrait aussi citer la famille de circuits intégrés AMD Am2900.

Même si le processeur était en pièces détachées, utiliser une dizaine de circuits intégrés était nettement mieux que d'utiliser plusieurs milliers de transistors individuels. En conséquence, les ordinateurs ont vu leur taille grandement réduite, passant de pièces entières à une simple armoire, voire à quelques cartes intégrées superposées. De plus, le prix des circuits intégré était abordable, du moins comparé aux ordinateurs d'avant. Le prix des ordinateurs a alors grandement décru, permettant à des entreprises et administrations de taille modeste de s'équiper d'ordinateurs.

===La quatrième génération : le microprocesseur===

[[File:MOS6502.svg|vignette|Microprocesseur, ici un processeur MOS6502, de la quatrième génération.]]

Lors de la troisième génération, les circuits intégrés regroupaient plusieurs dizaines ou centaines de transistors, mais sont rapidement montés en gamme. De centaines de transistors, ils sont passés au millier de transistors, puis au million et maintenant au-delà du milliard. Les transistors étaient devenus tellement petits, tellement miniaturisés, qu'il était devenu possible de mettre un processeur entier dans un circuit intégré. C'est ainsi qu'est né le microprocesseur, à savoir un processeur qui tient tout entier dans un seul circuit imprimé. La quatrième génération d’ordinateur est celle des ordinateurs basés autour d'un microprocesseur.

Les tout premiers microprocesseurs étaient des processeurs à application militaire, comme le processeur du F-14 CADC ou celui de l'Air data computer. Le tout premier microprocesseur commercialisé au grand public est le 4004 d'Intel, sorti en 1971. L'intel 4004 comprenait environ 2300 transistors, avait une fréquence de 740 MHz, pouvait faire 46 opérations différentes, et manipulait des entiers de 4 bits. Il était au départ un processeur de commande, prévu pour être intégré dans la calculatrice Busicom calculator 141-P, mais il fut utilisé pour d'autres applications quelque temps plus tard. Immédiatement après le 4004, les premiers microprocesseurs 8 bits furent commercialisés. Le 4004 fut suivi par le 8008 et quelques autres processeurs 8 bits extrêmement connus, comme le 8080 d'Intel, le 68000 de Motorola, le 6502 ou le Z80.

Les microprocesseurs permirent encore uen fois de réduire la taille des ordinateurs, qui pouvaient tenir dans un boitier de PC, ou un boitier de console de jeu. Le prix des ordinateurs a aussi chuté en même temps que les transistors étaient miniaturisés. C'est cette invention qui permis l'invention des consoles de jeux et des mini-ordinateurs, à savoir les ordinateurs personnels. Sans miniaturisation, on n'aurait pas d'ordinateur personnel, pas de PC fixe ou portable.

==L'organisation du cours : les différents niveaux d'explication==

Le fonctionnement d'un ordinateur est assez complexe à expliquer car les explications peuvent se faire sur plusieurs niveaux. Par plusieurs niveaux, on veut dire qu'un ordinateur est composé de composants très simples, qui sont assemblés pour donner des composants eux-même plus complexes, qui sont eux-même regrouper, etc. Étudier tout cela demande de voir plusieurs niveaux, allant de transistors très petits à des processeurs multicœurs. Les niveaux les plus bas sont de l'électronique pur et dure, alors que ceux plus haut sont à mi-chemin entre électronique et informatique.

===Les niveaux d'abstraction en architecture des ordinateurs===

Les trois premiers niveaux sont de l'électronique pur et dure. Ils correspondent aux premiers chapitres du cours, qui porteront sur les circuits électroniques en général.
* Le premier niveau est celui des '''transistors''', des circuits intégrés, des ''wafer'' et autres circuits de très petite taille.
* Le second niveau est celui des '''portes logiques''', des circuits très basiques, très simples, à la base de tous les autres.
* Le troisième niveau est celui dit de la '''''Register Transfer Level''''', où un circuit électronique est construit à partir de circuits basiques, dont des registres et autres circuits dits combinatoires.
Les deux niveaux suivants sont de l'informatique proprement dit. C'est dans ces deux niveaux qu'on étudie les ordinateurs proprement dit, les circuits qu'il y a dedans et non l'électronique en général.
* Le quatrième niveau est celui de la '''microarchitecture''', qui étudie ce qu'il y a à l'intérieur d'un processeur, d'une mémoire, des périphériques et autres.
* Le cinquième niveau est celui de l''''architecture externe''', qui décrit l'interface du processeur, de la mémoire, d'un périphérique ou autre. Par décrire l'interface, on veut dire : comment un programmeur voit le processeur et la mémoire, comment il peut les manipuler. Une architecture externe unique peut avoir plusieurs microarchitecture, ce qui fait qu'on sépare les deux. Tout cela sera plus clair quand on passera aux chapitres sur le processeur et les mémoires.

Nous n'allons pas voir les 5 niveaux dans l'ordre, des transistors vers l'architecture externe. En réalité, nous allons procéder autrement. La première partie du cours portera sur les trois premiers niveaux, le reste sur les deux autres. Les 5 niveaux seront vus dans des chapitres séparés, du moins le plus possible. Au niveau pédagogique, tout est plus simple si on scinde les 5 niveaux. Bien sûr, il y a quelques explications qui demandent de voir plusieurs niveaux à la fois. Par exemple, dans le chapitre sur les mémoires caches, nous auront des explications portant sur la RTL, la microarchitecture du cache et son architecture externe. Mais le gros du cours tentera de séparer le plus possible les 5 niveaux.

===Les trois parties principales du cours===

Nous allons commencer par parler du binaire, avant de voir les portes logiques. Avec ces portes logiques, nous allons voir comment fabriquer des circuits basiques qui reviendront très souvent dans la suite du cours. Nous verrons les registres, les décodeurs, les additionneurs et plein d'autres circuits. Puis, nous reviendrons au niveau des transistors pour finir la première partie. La raison est que c'est plus simple de faire comme cela. Tout ce qui a trait aux transistors sert à expliquer comment fabriquer des portes logiques, et il faut expliquer les portes logiques pour voir le niveau de la RTL.

Une fois la première partie finie, nous allons voir les différents composants d'un ordinateur. Une première partie expliquera ce qu'il y a dans un ordinateur, quels sont ses composants. Nous y parlerons de l'architecture de base, de la hiérarchie mémoire, des tendances technologiques, et d'autres généralités qui serviront de base pour la suite. Puis, nous verrons dans l'ordre les bus électroniques, les mémoires RAM/ROM, le processeur, les périphériques, les mémoires de stockage (SSD et disques durs) et les mémoires caches. Pour chaque composant, nous allons voir leur architecture externe, avant de voir leur microarchitecture. La raison est que la microarchitecture ne peut se comprendre que quand on sait quelle architecture externe elle implémente.

Enfin, dans une troisième partie, nous allons voir les optimisations majeures présentes dans tous les ordinateurs modernes, avec une partie sur le pipeline et le parallélisme d'instruction, et une autre sur les architectures parallèles. Pour finir, les annexes de fin parlerons de sujets un peu à part.

&lt;noinclude&gt;
{{NavChapitre | book=Fonctionnement d'un ordinateur
           | next=L'encodage des données
           | nextText=L'encodage des données
}}
&lt;/noinclude&gt;</text>
      <sha1>1lhtwfhvk3fl7482qmnphab9jbpul6c</sha1>
    </revision>
    <revision>
      <id>744167</id>
      <parentid>744166</parentid>
      <timestamp>2025-06-05T15:29:58Z</timestamp>
      <contributor>
        <username>Mewtow</username>
        <id>31375</id>
      </contributor>
      <minor />
      <comment>/* La première génération : les tubes à vide */</comment>
      <origin>744167</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="48743" sha1="1i9p8rx97v4wdh2u8grpre5xf880egc" xml:space="preserve">Pour commencer, nous allons voir qu'il existe de nombreux types d'ordinateurs. Le plus connu est certainement le PC, l'ordinateur personnel, que vous avez sans doute dans votre salon. Les ordinateurs portables sont un deuxième type d'ordinateur assez intuitif, que vous avez peut-être. Mais il y a aussi d'autres types d'ordinateurs auxquels vous n'avez jamais été confrontés.

==Les différents types d'ordinateurs==

Dans cette section, nous allons décrire rapidement les ordinateurs les plus courant, mais surtout voir ce qu'il y a à l'intérieur d'un ordinateur.

===L'ordinateur de type PC fixe===

De l'extérieur, l'ordinateur est composé d'une unité centrale sur laquelle on branche des périphériques.

[[File:Typical computer architecture systems.jpg|vignette|upright=1.5|Exemples de périphériques, connectés à une unité centrale (ici appelée à tort ''operating system'').]]

Les '''périphériques''' regroupent l'écran, la souris, le clavier, l'imprimante, et bien d'autres choses. Ils permettent à l'utilisateur d'interagir avec l'ordinateur : un clavier permet de saisir du texte sous dans un fichier, une souris enregistre des déplacements de la main en déplacement du curseur, un écran affiche des données d’images/vidéos, un haut-parleur émet du son, etc. Tout ce qui est branché sur un ordinateur est, formellement un périphérique.

L''''unité centrale''' est là où se trouvent tous les composants importants d'un ordinateur, ceux qui font des calculs, qui exécutent des logiciels, qui mémorisent vos données, etc. Voici ce à quoi ressemble l'intérieur de l'unité centrale. Trois sections sont visibles : l'alimentation électrique en haut à gauche, la carte mère en bas à gauche et en jaune/orange, les disques et lecteurs à droite des câbles. Et on voit aussi beaucoup de câbles.

[[File:Asus P5K-SEIntel E6320.jpg|centre|vignette|upright=2|Exemple d'unité centrale.]]

Tout en haut à gauche, se trouve l''''alimentation électrique''', qui convertit le courant de la prise électrique en un courant plus faible, utilisable par les autres composants. Elle émet de nombreux câbles assez gros, qui sont reliés au reste. Les PC actuels utilisent des alimentations électriques standardisées, qui fournissent trois tensions au reste de l'ordinateur : une tension de 12 Volts, une de 5 Volts, une de 3,3 Volts.

À droite, caché par la partie &quot;métallique&quot; du boitier, se trouvent les lecteurs de CD/DVD, et les disques durs. Les lecteurs CD-ROM ou DVD-ROM permettaient de lire des CD ou des DVD. Je parle au passé, car ils ont aujourd'hui disparu des ordinateurs modernes. Les '''disques durs''' sont des mémoires de stockage, qui mémorisent vos données de manière permanente. De nos jours, ils sont remplacés par des SSD, qui sont des disques durs électroniques, là où les disques durs proprement dit sont des mémoires magnétiques. Nous verrons la différence dans deux chapitres dédiés, un sur les disques durs, l'autre sur les SSD.

En bas à droite, se trouve la '''carte mère''' un support plat, en plastique ou en céramique, sur laquelle sont soudés/connectés les autres composants. Sur celle-ci, de nombreux composants sont soudés, d'autres sont branchés dessus avec des câbles, d'autres sont connectés dessus avec des connecteurs. Ils sont reliés entre eux par des fils conducteurs, le plus souvent du cuivre ou de l’aluminium, ce qui leur permet de s’échanger des données. Sur les cartes simples, ces fils sont intégrés dans la carte électronique, dans des creux du plastique. Ils portent le nom de pistes.

Avant, les disques durs, SSD et lecteurs de CD/DVD sont branchés dessus via des connecteurs dédiés, appelés des connecteurs S-ATA. De nos jours, ils sont branchés sur un autre connecteur, grâce à l'interface NVME. Toujours est-il qu'ils sont reliés à la carte mère par des câbles, ce qui montre que ce sont des sortes de périphériques interne. Ils sont placés dans le boitier, mais on aurait tout aussi bien pu les mettre à l'extérieur, vu qu'ils communiquent avec l'ordinateur par l'intermédiaire d'un câble ou d'un connecteur dédié.

Mais deux autres composants très importants sont eux placés sur la carte mère, directement. Ils ont chacun un connecteur dédié, sur lequel ils sont branchés directement, sans passer par l'intermédiaire d'un câble, mais sans être soudés non plus. Il s'agit du processeur et de la mémoire RAM, deux composants centraux des PC modernes.

[[File:Pentium III SL4CB.jpg|thumb|Processeur Pentium III.]]

Le '''processeur''' traite les données, les modifie, les manipule. Pour faire simple, il s’agit d’une grosse calculatrice hyper-puissante. Il comprend à la fois un circuit qui fait des calculs, et un circuit de contrôle qui s'occupe de séquencer les calculs dans l'ordre demandé. Il est souvent caché sous un radiateur, lui-même surmonté par un ventilateur. En effet, un processeur chauffe beaucoup, ce qui demande d'évacuer cette chaleur. Un chapitre entier expliquera pourquoi les processeurs chauffent, ainsi que les techniques utilisées pour limiter leur production de chaleur et leur consommation électrique.

La '''mémoire vive''' conserve des informations/données temporairement, tant que le processeur en a besoin. Elle prend la forme de barrettes de RAM, comme montré ci-dessous.

[[File:2 gb ddr2 667.jpg|centre|vignette|upright=2|Barrette de RAM.]]

Outre ces composants dits principaux, un ordinateur peut comprendre plusieurs composants moins importants, surtout présents sur les ordinateurs personnels. Ils sont techniquement facultatifs, mais sont très présents dans les ordinateurs personnels. Cependant, certains ordinateurs spécialisés s'en passent. Il s'agit des diverses '''cartes d'extension''' sont branchées sur la carte mère. Elles permettent d’accélérer certains calculs ou certaines applications, afin de décharger le processeur. Par exemple, la carte graphique s'occupe des calculs graphiques, qu'il s'agisse de graphismes 3D de jeux vidéos ou de l'affichage en 2D du bureau. Dans un autre registre, la carte son prend en charge le microphone et les haut-parleurs.

[[Fichier:Personal computer, exploded 4.svg|thumb|upright=1.0|Éclaté d'un ordinateur de type PC :&lt;br /&gt;
1 : Écran ;&lt;br /&gt;
2 : Carte mère ;&lt;br /&gt;
3 : Processeur ;&lt;br /&gt;
4 : Câble Parallel ATA ;&lt;br /&gt;
5 : Mémoire vive (RAM) ;&lt;br /&gt;
6 : Carte d'extension ;&lt;br /&gt;
7 : Alimentation électrique ;&lt;br /&gt;
8 : Lecteur de disque optique ;&lt;br /&gt;
9 : Disque dur ;&lt;br /&gt;
10 : Clavier ;&lt;br /&gt;
11 : Souris.]]

Si on regarde une carte mère de face, on voit un grand nombre de connecteurs, mais aussi des circuits électroniques soudés à la carte mère.

[[File:Architecture matérielle d'une carte mère.png|centre|vignette|upright=2.0|Architecture matérielle d'une carte mère]]

Les '''connecteurs''' sont là où on branche les périphériques, la carte graphique, le processeur, la mémoire, etc. Dans l'ensemble, toute carte mère contient les connecteurs suivants :
* Le processeur vient s’enchâsser dans la carte mère sur un connecteur particulier : le '''socket'''. Celui-ci varie suivant la carte mère et le processeur, ce qui est source d'incompatibilités.
* Les barrettes de mémoire RAM s’enchâssent dans un autre type de connecteurs: les '''slots mémoire'''.
* Les mémoires de masse disposent de leurs propres connecteurs : connecteurs P-ATA pour les anciens disques durs, et S-ATA pour les récents.
* Les périphériques (clavier, souris, USB, Firewire, ...) sont connectés sur un ensemble de connecteurs dédiés, localisés à l'arrière du boitier de l'unité centrale. 
* Les autres périphériques sont placés dans l'unité centrale et sont connectés via des connecteurs spécialisés. Ces périphériques sont des cartes imprimées, d'où leur nom de '''cartes filles'''. On peut notamment citer les cartes réseau, les cartes son, ou les cartes vidéo.

===Les ordinateurs portables===

[[File:Samsung QX-511 (2).JPG|vignette|Ordinateur portable Samsung QX-511 (2), pour illustration.]]

Un ordinateur portable est identique à un ordinateur de type PC. Si vous ouvrez votre ordinateur portable (attention à la garantie), vous retrouverez les mêmes composants qu'un PC à l'intérieur. Un point important est la présence d'une batterie à l'intérieur du PC portable, absente des PC fixes.

[[File:LG gram 14Z90Q mainboard with battery.jpg|centre|vignette|upright=2|LG gram 14Z90Q avec sa batterie.]]

Une fois la batterie et les circuits associés retiré, la seule différence notable est que tous les composants sont soudés sur la carte mère, au lieu d'être branchés sur des connecteurs, à part éventuellement la RAM et le disque dur.

[[File:LG gram 14Z90Q mainboard without battery.jpg|centre|vignette|upright=2|LG gram 14Z90Q sans sa batterie.]]

La RAM est parfois soudée sur la carte mère, d'autres fois sous la forme de barrettes de mémoire vive semblables à celles des PC. Dans le dernier cas, elle est connectée à des connecteurs spécifiques, ce qui permet de les changer/upgrader. Les PC portables sont parfois construits de manière à pouvoir changer la RAM facilement, en ouvrant un cache spécial, concu pour.

[[File:Lenovo G555 состав - Донор.JPG|centre|vignette|upright=2|Lenovo G555.]]

La conception d'un ordinateur portable est légèrement différente de celle d'un PC, pour des raisons thermiques. Un PC fixe a plus de place pour évacuer sa chaleur. Les ventilateurs peuvent plus facilement déplacer l'air dans le boitier, même si le flux d'air dans le boitier est éventuellement gêné par la carte graphique. Mais l'évacuation de la chaleur est assez efficace. Sur les PC portables, leur finesse fait que le trajet de l'air est beaucoup plus contraint. Évacuer la chaleur produite par l'ordinateur est plus complexe, ce qui demande d'utiliser des systèmes de refroidissement et de ventilation spécifiques.

Là où les PC fixes se débrouillent avec des radiateurs et des ventilateurs posés sur le processeur, les PC portables font autrement. Ils ne peuvent pas forcément mettre le ventilateur sur le processeur. A la place, ils mettent le ventilateur à côté, mais le processeur est surmonté par un mécanisme de transmission de la chaleur, qui transfère la chaleur du processeur vers le ventilateur.

[[File:Diagram - How a laptop cooling system works.png|centre|vignette|upright=2|Comment fonctionne le système de ventilation d'un ordinateur portable, en anglais.]]

Les difficultés pour dissiper la chaleur font que les ordinateurs portables utilisent souvent des composants peu performants, mais qui chauffent peu. En effet, nous verrons que plus un composant est puissant, plus il chauffe. La relation n'est pas parfaite, mais les processeurs haute performance chauffent plus que les modèles d'entrée ou milieu de gamme moins puissants. En conséquence, les PC portables sont souvent moins puissants que les PC fixes, même pour les modèles dit ''gaming''.

===Les serveurs et ''mainframes''===

Les grandes entreprises utilisent des ordinateurs de grande taille, très puissants, appelés des ''mainframes''. Ils sont souvent confondus avec les serveurs par le grand public, il y a une différence entre les deux. Un serveur est une fonction logicielle/réseau, pas un type d'ordinateur. Mais laissons cette différence de côté, ce qui est dit pour les ''mainframes'' sert pour les gros serveurs haute performance.

[[File:IBM Z15 mainframe.jpg|vignette|Exemple de ''mainframe''' de type IBM Z15.]]

Les anciens ''mainframes'' des années 50-80 avaient une taille pouvant être impressionnante, au point de prendre une pièce complète d'un bâtiment. Mais de nos jours, les ''mainframes'' tiennent dans une grosse armoire un peu haute. Les ''mainframes'' doivent rester allumé en permanence et ne doivent pas être éteint, sauf éventuellement quelques jours par an pour des opérations de maintenance. Ils utilisent pour cela des techniques spécifiques, avec beaucoup de redondance interne.

[[File:ACONIT hall grandes machines.jpg|centre|vignette|upright=2|''Mainframe'' ACONIT.]]

Les ''mainframes'' sont aussi conçus pour mutualiser au maximum leur utilisation, ils peuvent être utilisés par plusieurs utilisateurs à la suite, voire en même temps. Pour cela, les anciens ''mainframes'' étaient capables de faire tourner plusieurs applications distinctes l'une à la suite de l'autre, avec des commutations fréquentes entre logiciels. De nos jours, ils sont capables d'exécuter un grand nombre de tâches en même temps, grâce à la présence de plusieurs processeurs. Les ''mainframes'' modernes sont même capables de faire tourner plusieurs systèmes d'exploitation en même temps si besoin.

Les anciens ''mainframes'' étaient des ordinateurs assez simples, avec un processeur, de la mémoire RAM, un ou plusieurs disques durs, pas plus. Le ''mainframe'' était tellement énorme et cher que les entreprises n'en avaient qu'un seul pour toute l'entreprise. Les employés avaient sur leur bureau des terminaux, qui permettaient d'accéder à l'ordinateur central, mais n'étaient pas des ordinateurs. Les terminaux étaient des composants électroniques simples, avec un écran, un clavier et une souris, mais sans processeur. Ils envoyaient des données au ''mainframe'', ils en recevaient de sa part, mais tout traitement était réalisé sur le ''mainframe''. L'arrivée sur le marché des ordinateurs personnels, de type PC fixe/portable, a entrainé l'abandon de ce genre de pratique, tous les employés ont maintenant un ordinateur rien que pour eux.

{|
|-
! colspan=&quot;2&quot; | Exemples de terminaux
|-
|[[File:Terminal-in2-sm9400.jpg|centre|vignette|upright=1.5|Exemple de terminal. Notez la présence d'un écran et d'un clavier, mais l'asbence d'une unité centrale.]]
|[[File:Chromatics CT4100.jpg|vignette|upright=1.5|Autre exemple de terminal. Le clavier est couplé à un stylo CRT, qui remplacait la souris et agissait sur l'écran comme s'il était tactile.]]
|-
! colspan=&quot;2&quot; | Intérieur d'un terminal
|-
|[[File:CT1024 Monitor.jpg|vignette|upright=1.5|Terminal CT1024, sans le boitier extérieur.]]
|[[File:CT1024 Terminal System.jpg|vignette|upright=1.5|Terminal CT1024, description des composants interne.]]
|}

De nos jours, les ''mainframes'' contiennent en réalité plusieurs ordinateurs simples interconnectés via un réseau local. Un ''mainframe'' qui tient dans une armoire contient facilement une dizaine ou centaine de processeurs, plein de RAM, des disques durs séparés dans une armoire distincte, etc. Vu qu'ils communiquent uniquement via le réseau, ils n'ont pas d'interface, pas d'écran, 'entrée via clavier/souris. Le tout est commandé avec une console de commande, typiquement un ordinateur portable ou un terminal assez simple séparé de l'armoire, qui permet à un administrateur de faire des opérations de surveillance, configuration et maintenance. Il peut y avoir une console de commande pour plusieurs armoires séparées, la console peut même être dans un autre bâtiment et accéder au ''mainframe'' par le réseau.

[[File:IBM System Z9 (type 2094 inside).jpg|centre|vignette|upright=2|''Mainframe'' de type IBM System Z9. L'ordinateur portable sert de console pour qu'un administrateur fasse des opérations de surveillance, configuration et maintenance.]]

Les processeurs et la RAM sont typiquement installés sur des cartes amovibles, qui sont connectées au fond de l'armoire lors de l'installation. Il est même possible de retirer ou d'ajouter des cartes en fonctionnement, afin d'ajouter/retirer des processeurs, des disques durs, etc. Ce qui est très utile si un composant est en panne et qu'il faut le remplacer. 

[[File:IBM TotalStorage Exp400.jpg|centre|vignette|upright=2|IBM TotalStorage Exp400]]

==Un peu d'abstraction : qu'est-ce qu'un ordinateur ?==

Un ordinateur comprend donc un processeur, plusieurs mémoires, des cartes d'extension et une carte mère pour connecter le tout. Mais il s'agit là d'une description assez terre-à-terre de ce qu'est un ordinateur. Une autre description, plus abstraite, se base sur le fait qu'un ordinateur est une énorme calculatrice programmable. Elle permet d'expliquer pourquoi il y a une distinction entre processeur et mémoire, entre unité centrale et périphériques. Tout ce qui va suivre pourra vous paraitre assez abstrait, mais rassurez-vous : les prochains chapitres rendront tout cela plus concrets.

===La séparation entre entrées-sorties et traitement===

L'unité centrale peut être vue comme une énorme calculatrice ultra-puissante, qui exécute des commandes/opérations. Mais à elle seule, elle ne servirait à rien, il faut interagir avec par l'intermédiaire de plusieurs périphériques. Il existe deux types de périphériques, qui sont conceptuellement différents. Les périphériques comme le clavier ou la souris permettent d'envoyer des informations à l'ordinateur, d'agir sur celui-ci. A l'inverse, les écrans transmettent des informations dans le sens inverse : de l'ordinateur vers l'utilisateur. Les premiers sont appelés des '''entrées''', les seconds des '''sorties'''.

Dans un ordinateur, les informations sont représentées sous la forme de nombres. Toute donnée dans un ordinateur est codée avec un ou plusieurs nombres regroupés dans une donnée, un fichier, ou autre. Et la transmissions avec les entrées et sorties se fait là-encore avec des nombres. Par exemple, quand vous appuyez sur votre clavier, le clavier envoie un numéro de touche à l'unité centrale, qui indique quelle touche a été appuyée. L'image à afficher à l'écran est codée sous la forme d'une suite de nombres (un par pixel). L'image est envoyée à l'écran, qui traduit la suite de nombre en image à afficher. Les entrées traduisent des actions utilisateurs en nombres, on dit que les entrées encodent les actions utilisateur. Les sorties font la traduction inverse, elles transforment des suites de nombres en une action physique. On dit qu'elles décodent des informations.

Pour résumer, toute appareil électronique est composé par :
* Des '''entrées''' sur lesquelles l'utilisateur agit sur l'ordinateur. Les entrées transforment les actions de l'utilisateur en nombres, qui sont interprétés par l'ordinateur.
* Une '''unité de traitement''', qui manipule des nombres et fait des calculs/opérations dessus. Les nombres proviennent des entrées, du disque dur, ou d'autres sources, peu importe.
* Des '''sorties''', qui va récupèrent le résultat calculé par l'unité de traitement pour en faire quelque chose : écrire sur une imprimante ou sur un moniteur, émettre du son,...

[[File:Ordinateur théorique Simple 1.png|centre|vignette|upright=2|Ordinateur théorique Simple 1]]

L'unité de traitement proprement dite, celle qui fait les calculs, est couplée à une mémoire qui mémorise les opérandes et résultats des calculs. La séparation entre processeur et mémoire est nécessaire pour qu'un appareil électronique soit qualifié d'ordinateur. De nombreux appareils n'ont pas de séparation entre unité de traitement et mémoire, comme certaines vielles radios AM/FM.

[[File:Schéma de principe d'un ordinateur.png|centre|vignette|upright=2|Schéma de principe d'un ordinateur]]

===Un ordinateur est un appareil programmable===

Les appareils simples sont non-programmables, ce qui veut dire qu’ils sont conçus pour une utilisation particulière et qu’ils ne peuvent pas faire autre chose. Par exemple, les circuits électroniques d’un lecteur de DVD ne peuvent pas être transformé en lecteur audio ou en console de jeux... Les circuits non-programmables sont câblés une bonne fois pour toute, et on ne peut pas les modifier. On peut parfois reconfigurer le circuit, pour faire varier certains paramètres, via des interrupteurs ou des boutons, mais cela s’arrête là. Et cela pose un problème : à chaque problème qu'on veut résoudre en utilisant un automate, on doit recréer un nouveau circuit.

À l'inverse, un ordinateur n’est pas conçu pour une utilisation particulière, contrairement aux autres objets techniques. Il est possible de modifier leur fonction du jour au lendemain, on peut lui faire faire ce qu’on veut. On dit qu'ils sont '''programmables'''. Pour cela, il suffit d’utiliser un logiciel, une application, un programme (ces termes sont synonymes), qui fait ce que l'on souhaite. La totalité des logiciels présents sur un ordinateur sont des programmes comme les autres, même le système d'exploitation (Windows, Linux, ...) ne fait pas exception.

Un programme est une suite de d''''instructions machines''', chaque instruction effectuant une action dans l'ordinateur. Sur les ordinateurs modernes, les instructions les plus communes effectuent une opération arithmétique : une addition, une multiplication, une soustraction, etc. Les ordinateurs modernes sont donc de grosses calculettes très puissantes, capables d'effectuer des millions d'opérations par secondes.

Et qui dit opération dit nombres : un ordinateur gère nativement des nombres, qui sont codés en binaire sur la quasi-totalité des ordinateurs modernes. Les ordinateurs modernes sont capables de faire des calculs sur des nombres entiers, mais aussi des nombres à virgule. Il existe plusieurs manières de représenter des nombres en binaire, certaines représentant des nombres entiers dits naturels (0 et plus), d'autres des nombres signés (positifs ou négatifs), d'autres des nombres à virgule. Un chapitre entier détaillera comment sont encodés ces nombres.

Une instruction est représentée dans un ordinateur par une série de nombres entiers : un nombre qui indique quelle opération/commande effectuer et des autres nombres pour coder les données (ou de quoi les retrouver dans l'ordinateur). L'ordinateur récupére les commandes une par une, les traduit en opération à effectuer, exécuter l'opération, et enregistre le résultat. Puis il recommence avec la commande suivante.

[[File:Ordinateur Théorique Complexe 1.png|centre|vignette|upright=3|Ordinateur Théorique Complexe. En jaune, le programme informatique, la liste de commande. Le rectangle gris est l'ordinateur proprement dit.]]

De nombreux appareils sont programmables, mais tous ne sont pas des ordinateurs. Par exemple, certains circuits programmables nommés FPGA n'en sont pas. Pour être qualifié d'ordinateur, un appareil programmable doit avoir un processeur séparé de la mémoire. De plus, il doit utiliser un '''codage numérique''', chose que nous allons aborder dans le chapitre suivant.

===Les ordinateurs à programme mémorisé ou programme externe===

[[File:Blue-punch-card-front.png|vignette|upright=0.5|Carte Perforée.]]

Au tout début de l'informatique, les programmes étaient enregistrés sur des cartes perforées, à savoir des cartes en papier/plastique percées par endroits. Un 1 est codé par un trou dans le papier et un 0 par une absence de trou. Les programmes étaient exécutés par l'ordinateur quand on insérait la carte perforée dans le lecteur et qu'on appuyait sur un bouton.

Par la suite, les premiers ordinateurs grand public, comme les Amstrad ou les Commodore, utilisaient des cassettes audio magnétiques pour stocker les programmes. Dans le même style, les consoles de jeu utilisaient autrefois des cartouches de jeu, qui contenaient le programme du jeu à exécuter. Pour résumer, les anciens ordinateurs mémorisaient les programmes sur un support externe, lu par un périphérique. De tels ordinateurs sont dits à '''programme externe'''.

: D’anciens ordinateurs personnels, comme l’Amstrad ou le Commodore, permettaient de taper les programmes à exécuter à la main, au clavier, avant d’appuyer une touche pour les exécuter. Nul besoin de vous dire que les cassettes audio étaient plus pratiques.

Mais de nos jours, les programmes sont enregistrés sur le disque dur de l'ordinateur ou dans une mémoire intégrée à l'ordinateur. On dit qu'ils sont installés, ce qui est un mot bien compliqué pour dire que le programme est enregistré sur le disque dur de l’ordinateur. A défaut de disque dur, le programme/logiciel est enregistré dans une mémoire spécialisée pour le stockage. Par exemple, sur les cartes électroniques grand public de marque Arduino, les programmes sont envoyés à la carte via le port USB, mais les programmes sont enregistrés dans la carte Arduino, dans une mémoire FLASH dédiée. Disque dur ou non, le programme est mémorisé dans la mémoire de l'ordinateur. Il est possible d'installer ou de désinstaller les programmes en modifiant le contenu de la mémoire. Le terme utilisé est alors celui de '''programme stocké en mémoire'''.

Les programmes à installer sont disponibles soit sur un périphérique, comme un DVD ou une clé USB, soit sont téléchargés depuis internet. Les premiers PC fournissaient les logiciels sur des disquettes, qui contenaient un programme d'installation pour enregistrer le programme sur le disque dur de l'ordinateur. Par la suite, le support des logiciels a migré vers les CD et DVD, les logiciels devenant de plus en plus gros. De nos jours, la majorité des applications sont téléchargées depuis le net, l'usage de périphériques est devenu obsolète, même les consoles de jeu abandonnent cette méthode de distribution.

==Les générations d'ordinateurs : un historique rapide==

L'informatique a beaucoup évolué dans le temps. Et une bonne partie de cette évolution tient à l'évolution de l’électronique sous-jacente. Les ordinateurs actuels sont fabriqués avec des transistors, des petits composants électroniques qui servent d'interrupteurs programmables, qu'on détaillera dans ce qui suit. Mais ça n'a pas toujours été le cas. Et cela permet de distinguer plusieurs '''générations d'ordinateurs'''.

===Les ordinateurs électro-mécaniques : les premiers ordinateurs===

Le tout premier ordinateur est le '''Z1''', un modèle unique inventé par Konrad Suze entre 1936 et 1938. Son processeur gérait non pas des nombres entiers, mais des nombres à virgule (des nombres dits flottants, pour être précis), encodés sur 22 bits. Le processeur du Z1 était capable de faire des additions et des soustractions, car il intégrait un circuit additionneur-soustracteur basique. Des circuits annexes permettaient de faire des multiplications et des divisions en enchainant des additions/soustractions successives. Il fonctionnait à une fréquence de 1 Hz, ce qui fait qu'il pouvait faire une addition/soustraction par seconde maximum.

Niveau mémoire, la RAM de l'ordinateur était très limitée : seulement 16 nombres de 22 bits chacun. S'il s'agissait d'une mémoire électronique, les programmes étaient mémorisés sur une mémoire mécanique et précisémment sur des cartes perforées, à savoir des cartes en papier/plastique dans lesquelles un 1 est codé par un trou dans le papier et un 0 par une absence de trou. Les programmes étaient exécutés par l'ordinateur quand on insérait la carte perforée dans le lecteur et qu'on appuyait sur un bouton.

[[File:German Museum of Technology, Berlin 2017 024.jpg|centre|vignette|upright=2|Réplique du Z1 au ''German Museum of Technology'' de Berlin, 2017.]]

Après sa destruction dans un bombardement, le Z1 a été reconstruit et amélioré, ce qui donné les deux ordinateurs Z2 et Z3. Quelques années plus tard, quelques laboratoires de recherche ont fabriqués des ordinateurs dans leur coin, comme le Harvard Mark I et le Colossus Mark 1 (UK) qui ont été mis en service en 1944. Ils ont servi pour les cryptanalystes pour casser les codes utilisés par les Allemands pour leurs transmissions, pendant la seconde guerre mondiale.

Les ordinateurs cités dans le précédent paragraphe étaient tous des ordinateurs dit '''électro-mécaniques''', car ils mélangeaient des composants électroniques et des composants mécaniques (tout ce qui a trait aux cartes perforées, notamment). Les composants électroniques étaient généralement des relais, à savoir des interrupteurs commandables électriquement, qui sont plus ou moins équivalents aux transistors modernes. La majeure partie des ordinateurs des années 40 étaient de ce type, mais leur nombre n'a pas dépassé 30. Il faut dire qu'ils ont rapidement laissé la place à des ordinateurs purement électroniques, que nous allons voir dans ce qui suit.

===La première génération : les tubes à vide===

Les ordinateurs qui ont suivi les ordinateurs électromécaniques sont regroupés dans la '''première génération d'ordinateur'''. Ils étaient conçus avec des tubes à vide, des espèces d'interrupteurs commandables, les ancêtres des transistors modernes. Les tubes à vide étaient assez encombrants, ils consommaient beaucoup de courant, ils chauffaient et étaient assez peu fiables. Ils tombaient en panne assez souvent. Et ils étaient assez simples à fabriquer, mais restaient malgré tout chers.

Les tubes à vide sont des ampoules à filament améliorées. Pour rappel, les ampoules à filament étaient des ampoules en verre dans lesquelles on plaçait un filament métallique. Le filament chauffait quand on envoyait du courant dedans et émettait de la lumière. Mais dans les tubes à vide, le filament n'émet pas de lumière quand on le chauffe : il émet des électrons, de l'électricité. De plus, ils ajoutent une électrode, une plaque en métal qui émet ou capte des électrons. Ici, l'électrode capte des électrons émis par le filament quand il chauffe. Vu qu'elle capte des électrons, on l'appelle l''''anode'''. Le résultat est un circuit qui laisse passer le courant, mais seulement dans un sens : du filament vers l'anode, l'autre sens n'est pas possible vu que l'anode ne peut pas émettre d'électrons. Un tel circuit est appelé une '''diode'''.

{|
|[[File:Diode vide schema explicatif.png|vignette|upright=1.5|Tube à vide basique.]]
|[[File:Diode à vide schéma de fonctionnement.png|vignette|upright=1.5|Diode à vide, schéma de fonctionnement. Le filament X chauffe la cathode (2), qui émet des électrons (3), vers l'anode (4).]]
|}

Une amélioration des tubes à vide précédent rajoute une seconde plaque de métal, appelée la '''cathode'''. Elle est située juste après le filament. C'est elle qui émet les électrons, non pas le filament. Cependant, elle n'émet des électrons que si elle est chauffée par le filament. Le filament doit donc chauffer, ce qui réchauffe la cathode, qui elle-même émet des électrons en direction de l'anode.

{|
|[[File:Diode à vide.png|vignette|upright=1.5|Diode à vide, avec cathode.]]
|[[File:Vacuum tubes (multilingual).svg|vignette|upright=1.5|Diode à vide avec cathode, schéma de fonctionnement.]]
|}

Les tubes à vides étaient utilisés pour le processeur et quelques circuits annexes, mais les mémoires utilisaient d'autres technologies. Les mémoires de l'époque n'étaient pas du tout des mémoires électroniques. Il existait déjà des ancêtres des disques durs, à savoir des mémoire magnétiques appelées tambours magnétiques, bandes magnétiques, mémoires à tore de ferrite, etc. Les mémoires RAM, quant à elles, utilisaient elles des technologies totalement abandonnées : les mémoires à lignes de délai étaient des mémoires acoustiques, les tubes Williams étaient des écrans CRT modifiés, etc. Un chapitre entier sera dédié aux technologies des mémoires de l'époque.

[[File:Elektronenroehren-auswahl.jpg|centre|vignette|upright=2|Tubes à vides.]]

L'usage de tubes à vide les place entre les premiers ordinateurs électro-mécaniques et les ordinateurs utilisant des transistors. Au vu de la taille des tubes à vide, les ordinateurs de l'époque étaient composés de plusieurs milliers de ces tubes, guère plus. Et malgré cela, un ordinateur prenait facilement un étage de bâtiment entier, ou au moins plusieurs pièces. La conséquence est que les ordinateurs de première génération étaient très simples, rudimentaires quand on les compare aux ordinateurs modernes. Ils ne géraient que quelques opérations simples : l'addition, la soustraction, pas grand-chose de plus. À quelques exceptions près, ils ne géraient pas la multiplication et encore moins la division, cela aurait demandé trop de tubes à vides.

Une des toutes premières machines construite avec des tubes à vide était l'Atanasoff–Berry. Ce n'était pas un ordinateur, car elle ne pouvait pas exécuter de programme sans intervention humaine pour séquencer des opérations, mais c'était la première machine de calcul purement électronique, sans aucune pièce mécanique. Elle utilisait une mémoire RAM construite avec des condensateurs, ceux-ci étant placés sur des cylindres tournants. Les circuits de calcul étaient construits avec des tubes à vide et faisaient leur travail un bit à la fois. Elle fonctionnait à une fréquence de 60 Hz et pouvait faire 30 additions/soustractions par seconde. Les nombres étaient encodés sur 50 bits. 

[[File:Atanasoff Berry Computer.gif|centre|vignette|upright=2.5|Atanasoff–Berry.]]

L'arrivée de l'ENIAC en 1945 a changé la donne. Cet ordinateur a introduit plusieurs innovations majeures. La première est assez technique, il s'agit de la turing-complétude, elle a trait aux programmes qui peuvent être écrit pour un ordinateur, nous ne la détaillerons pas ici.

[[File:BabyArchitecture.png|vignette|Architecture de la Manchester Baby.]]

En 1948, le ''Manchester Baby'' a introduit une innovation extrêmement importante : le programme n'était plus mémorisé sur des cartes perforées, mais dans une mémoire électronique à l’intérieur de l'ordinateur lui-même. En clair, le ''Manchester Baby'' était le premier '''ordinateur à programme stocké en mémoire''' en français. Au-delà de ça, le Manchester Baby restait quand même très simple, c'était limite un prototype.

Niveau interface, l'ordinateur avait une console avec 32 boutons, des interrupteurs et un écran de sortie sur lequel afficher les résultats. A l'intérieur, il y avait un processeur et une RAM de 32 nombres de 32 bits, fabriquées avec des tubes Williams (abordés dans une annexe à la fin du cours). Une instruction prenant autant de place qu'un nombre en RAM, ce qui limitait les programmes à 32 instructions maximum. Le processeur gérait 8 instructions en tout, mais la seule instruction de calcul qu'il gérait était la soustraction. L'addition n'était pas supportée. Il pouvait cependant émuler l'addition à partir d'une soustraction et inversant l'opérande soustrait.

Le Manchester Mark 1 était une amélioration du Manchester Baby. Il utilisait 4500 tubes à vide. L'ordinateur gérait des nombres de 40 bits, mais les instructions étaient codées sur 20 bits. La RAM avait la même taille, à savoir 32 nombres, leur taille était simplement augmentée. Par contre, la RAM était complémentée par l’ancêtre du disque dur magnétique, à savoir un tambour magnétique, l’ancêtre du disque dur magnétique. Il contenait 40 pages, chacune ayant la même taille que la RAM. Contrairement à la Manchester Baby, son processeur gérait l'addition. Les multiplications étaient réalisées par des additions successives, mais le processeur intégrait des registres pour mémoriser les opérandes à multiplier.

Par la suite, les ordinateurs commerciaux ont vu le jour. Les ordinateurs précédents provenaient de projets de recherches, souvent publics. Mais les entreprises privées se sont mises à fabriquer des ordinateurs elle-mêmes, pour les vendre à d'autres entreprises. On peut notamment citer les ordinateurs comme le UNIVAC I, le Bull Gamma 3 ou les premiers ordinateurs IBM. La performance de ces ordinateurs était nettement plus importante que leurs prédécesseurs, avec des fréquences de l'ordre de la centaine de kilo-hertz. Par exemple, le Bull Gamma 3 allait à 281 kHz, l'IBM 650 allait à 50 Khz.

===La seconde génération : le remplacement des tubes à vides par des transistors===

[[File:IBM 7070.jpg|vignette|Cartes imprimées de l'IBM 704, avec des transistors et résistances dessus.]]

La '''seconde génération''' est celle des ordinateurs fabriqués avec des '''transistors''' isolés, reliés entre avec des fils électriques. Les transistors en question possèdent trois broches, des pattes métalliques sur lesquelles on connecte des fils électriques. Le transistor s'utilise le plus souvent comme un interrupteur commandé par sa troisième broche. Le courant qui traverse les deux premières broches passe ou ne passe pas selon ce qu'on met sur la troisième.

[[File:Transistor basic flow.svg|centre|vignette|Un transistor est un morceau de conducteur, dont la conductivité est contrôlée par sa troisième broche/borne.]]

Les ordinateurs de seconde génération avaient entre 1000 et 500 000 transistors. Les capacités des ordinateurs étaient donc nettement supérieures à celles des ordinateurs de première génération. Une part non négligeable des ordinateurs de seconde génération supportait l'opération de multiplication, absente sur les ordinateurs de première génération. Néanmoins, cela variait beaucoup selon les ordinateurs.

Un exemple assez hors du commun est celui du premier modèle de l'IBM 1620. Le tout premier modèle n'avait aucun circuit de calcul, il n'était même pas capable de faire une addition ou une multiplication. A la place, il utilisait une table d'addition et une table de multiplication en mémoire RAM. Les deux tables devaient être initialisées par le logiciel lors du démarrage de la machine. La table d'addition faisait une centaine de chiffres, la table de multiplication faisait le double. Le processeur de l'ordinateur gérait des instructions pour faire des additions ou des multiplications, mais ces opérations lisaient le résultat dans la table d'addition. Les calculs étaient faits chiffre par chiffre, avec un encodage partiellement décimal, partiellement binaire (des chiffres décimaux étaient encodés en binaire, nous en reparlerons quand nous parlerons du BCD) !

[[File:KL CoreMemory.jpg|vignette|Mémoire à tore de ferrite.]]

Les transistors n'étaient utilisés que pour le processeur et les circuits annexes. La mémoire n'était pas faite en transistors, pas à cette époque. La mémoire était une mémoire aujourd'hui abandonnée, appelée une '''mémoire à tores de ferrite'''. Elle sera détaillée dans un chapitre ultérieur. Mais sachez pour le moment qu'il s'agit d'une mémoire au support magnétique, les données étant stockées sur un support magnétique.

Les transistors étaient au départ de la même taille que les tubes à vide, mais ils ont rapidement rétrécit. Ils prenaient encore beaucoup de place dans les 60-70, ce qui fait que les ordinateurs étaient assez gros. Concrètement, ils prenaient une pièce de bâtiment entière dans le meilleur des cas. C'était l'époque des gros ''mainframes'', reliés à des terminaux, peu puissants comparé aux standards actuels. Seules les grandes entreprises et les grands instituts de recherche pouvaient se payer les services de ce genre d'ordinateurs. Seuls les professionnels avaient accès à ce genre d'équipement.

===La troisième génération : le circuit intégré===

[[File:D8259AC-2.jpg|vignette|Exemple de circuit intégré.]]

La troisième génération est toujours fabriquée avec des transistors, mais dont la taille a été réduite. Avec l'évolution de la technologie, les transistors ont diminué en taille, de plus en plus. Ils sont devenus tellement petits qu'ils ont fini par être regroupés dans des '''circuits intégrés''', des circuits regroupent plusieurs transistors sur la même puce de silicium. Les circuits intégrés se présentent le plus souvent sous la forme de boitiers rectangulaires, comme illustré ci-contre. D'autres ont des boitiers de forme carrées, comme ceux que l'on peut trouver sur les barrettes de mémoire RAM, ou à l'intérieur des clés USB/ disques SSD.

Lors de cette génération, les processeurs étaient fournis en pièces détachées qu'il fallait relier entre elles. Le processeur était composé de plusieurs circuits intégrés séparés, impossible de mettre un processeur dans un seul boitier. Un exemple de processeur conçu en kit est la série des Intel 3000. Elle regroupe plusieurs circuits séparés aux noms à coucher dehors, mais dont vous comprendrez ce qu'ils veulent dire dans les chapitres adéquats : l'Intel 3001 est un séquenceur, l'Intel 3002 regroupe unité de calcul et registres, le 3003 est un circuit d'anticipation de retenue complémentaire du 3002, le 3212 est une mémoire tampon, le 3214 est une unité de gestion des interruptions, les 3216/3226 sont des interfaces de bus mémoire. On pourrait aussi citer la famille de circuits intégrés AMD Am2900.

Même si le processeur était en pièces détachées, utiliser une dizaine de circuits intégrés était nettement mieux que d'utiliser plusieurs milliers de transistors individuels. En conséquence, les ordinateurs ont vu leur taille grandement réduite, passant de pièces entières à une simple armoire, voire à quelques cartes intégrées superposées. De plus, le prix des circuits intégré était abordable, du moins comparé aux ordinateurs d'avant. Le prix des ordinateurs a alors grandement décru, permettant à des entreprises et administrations de taille modeste de s'équiper d'ordinateurs.

===La quatrième génération : le microprocesseur===

[[File:MOS6502.svg|vignette|Microprocesseur, ici un processeur MOS6502, de la quatrième génération.]]

Lors de la troisième génération, les circuits intégrés regroupaient plusieurs dizaines ou centaines de transistors, mais sont rapidement montés en gamme. De centaines de transistors, ils sont passés au millier de transistors, puis au million et maintenant au-delà du milliard. Les transistors étaient devenus tellement petits, tellement miniaturisés, qu'il était devenu possible de mettre un processeur entier dans un circuit intégré. C'est ainsi qu'est né le microprocesseur, à savoir un processeur qui tient tout entier dans un seul circuit imprimé. La quatrième génération d’ordinateur est celle des ordinateurs basés autour d'un microprocesseur.

Les tout premiers microprocesseurs étaient des processeurs à application militaire, comme le processeur du F-14 CADC ou celui de l'Air data computer. Le tout premier microprocesseur commercialisé au grand public est le 4004 d'Intel, sorti en 1971. L'intel 4004 comprenait environ 2300 transistors, avait une fréquence de 740 MHz, pouvait faire 46 opérations différentes, et manipulait des entiers de 4 bits. Il était au départ un processeur de commande, prévu pour être intégré dans la calculatrice Busicom calculator 141-P, mais il fut utilisé pour d'autres applications quelque temps plus tard. Immédiatement après le 4004, les premiers microprocesseurs 8 bits furent commercialisés. Le 4004 fut suivi par le 8008 et quelques autres processeurs 8 bits extrêmement connus, comme le 8080 d'Intel, le 68000 de Motorola, le 6502 ou le Z80.

Les microprocesseurs permirent encore uen fois de réduire la taille des ordinateurs, qui pouvaient tenir dans un boitier de PC, ou un boitier de console de jeu. Le prix des ordinateurs a aussi chuté en même temps que les transistors étaient miniaturisés. C'est cette invention qui permis l'invention des consoles de jeux et des mini-ordinateurs, à savoir les ordinateurs personnels. Sans miniaturisation, on n'aurait pas d'ordinateur personnel, pas de PC fixe ou portable.

==L'organisation du cours : les différents niveaux d'explication==

Le fonctionnement d'un ordinateur est assez complexe à expliquer car les explications peuvent se faire sur plusieurs niveaux. Par plusieurs niveaux, on veut dire qu'un ordinateur est composé de composants très simples, qui sont assemblés pour donner des composants eux-même plus complexes, qui sont eux-même regrouper, etc. Étudier tout cela demande de voir plusieurs niveaux, allant de transistors très petits à des processeurs multicœurs. Les niveaux les plus bas sont de l'électronique pur et dure, alors que ceux plus haut sont à mi-chemin entre électronique et informatique.

===Les niveaux d'abstraction en architecture des ordinateurs===

Les trois premiers niveaux sont de l'électronique pur et dure. Ils correspondent aux premiers chapitres du cours, qui porteront sur les circuits électroniques en général.
* Le premier niveau est celui des '''transistors''', des circuits intégrés, des ''wafer'' et autres circuits de très petite taille.
* Le second niveau est celui des '''portes logiques''', des circuits très basiques, très simples, à la base de tous les autres.
* Le troisième niveau est celui dit de la '''''Register Transfer Level''''', où un circuit électronique est construit à partir de circuits basiques, dont des registres et autres circuits dits combinatoires.
Les deux niveaux suivants sont de l'informatique proprement dit. C'est dans ces deux niveaux qu'on étudie les ordinateurs proprement dit, les circuits qu'il y a dedans et non l'électronique en général.
* Le quatrième niveau est celui de la '''microarchitecture''', qui étudie ce qu'il y a à l'intérieur d'un processeur, d'une mémoire, des périphériques et autres.
* Le cinquième niveau est celui de l''''architecture externe''', qui décrit l'interface du processeur, de la mémoire, d'un périphérique ou autre. Par décrire l'interface, on veut dire : comment un programmeur voit le processeur et la mémoire, comment il peut les manipuler. Une architecture externe unique peut avoir plusieurs microarchitecture, ce qui fait qu'on sépare les deux. Tout cela sera plus clair quand on passera aux chapitres sur le processeur et les mémoires.

Nous n'allons pas voir les 5 niveaux dans l'ordre, des transistors vers l'architecture externe. En réalité, nous allons procéder autrement. La première partie du cours portera sur les trois premiers niveaux, le reste sur les deux autres. Les 5 niveaux seront vus dans des chapitres séparés, du moins le plus possible. Au niveau pédagogique, tout est plus simple si on scinde les 5 niveaux. Bien sûr, il y a quelques explications qui demandent de voir plusieurs niveaux à la fois. Par exemple, dans le chapitre sur les mémoires caches, nous auront des explications portant sur la RTL, la microarchitecture du cache et son architecture externe. Mais le gros du cours tentera de séparer le plus possible les 5 niveaux.

===Les trois parties principales du cours===

Nous allons commencer par parler du binaire, avant de voir les portes logiques. Avec ces portes logiques, nous allons voir comment fabriquer des circuits basiques qui reviendront très souvent dans la suite du cours. Nous verrons les registres, les décodeurs, les additionneurs et plein d'autres circuits. Puis, nous reviendrons au niveau des transistors pour finir la première partie. La raison est que c'est plus simple de faire comme cela. Tout ce qui a trait aux transistors sert à expliquer comment fabriquer des portes logiques, et il faut expliquer les portes logiques pour voir le niveau de la RTL.

Une fois la première partie finie, nous allons voir les différents composants d'un ordinateur. Une première partie expliquera ce qu'il y a dans un ordinateur, quels sont ses composants. Nous y parlerons de l'architecture de base, de la hiérarchie mémoire, des tendances technologiques, et d'autres généralités qui serviront de base pour la suite. Puis, nous verrons dans l'ordre les bus électroniques, les mémoires RAM/ROM, le processeur, les périphériques, les mémoires de stockage (SSD et disques durs) et les mémoires caches. Pour chaque composant, nous allons voir leur architecture externe, avant de voir leur microarchitecture. La raison est que la microarchitecture ne peut se comprendre que quand on sait quelle architecture externe elle implémente.

Enfin, dans une troisième partie, nous allons voir les optimisations majeures présentes dans tous les ordinateurs modernes, avec une partie sur le pipeline et le parallélisme d'instruction, et une autre sur les architectures parallèles. Pour finir, les annexes de fin parlerons de sujets un peu à part.

&lt;noinclude&gt;
{{NavChapitre | book=Fonctionnement d'un ordinateur
           | next=L'encodage des données
           | nextText=L'encodage des données
}}
&lt;/noinclude&gt;</text>
      <sha1>1i9p8rx97v4wdh2u8grpre5xf880egc</sha1>
    </revision>
    <revision>
      <id>744168</id>
      <parentid>744167</parentid>
      <timestamp>2025-06-05T15:40:04Z</timestamp>
      <contributor>
        <username>Mewtow</username>
        <id>31375</id>
      </contributor>
      <minor />
      <comment>/* La première génération : les tubes à vide */</comment>
      <origin>744168</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="49389" sha1="45p6l328e2vj7isj23c1pr9hvkm5j23" xml:space="preserve">Pour commencer, nous allons voir qu'il existe de nombreux types d'ordinateurs. Le plus connu est certainement le PC, l'ordinateur personnel, que vous avez sans doute dans votre salon. Les ordinateurs portables sont un deuxième type d'ordinateur assez intuitif, que vous avez peut-être. Mais il y a aussi d'autres types d'ordinateurs auxquels vous n'avez jamais été confrontés.

==Les différents types d'ordinateurs==

Dans cette section, nous allons décrire rapidement les ordinateurs les plus courant, mais surtout voir ce qu'il y a à l'intérieur d'un ordinateur.

===L'ordinateur de type PC fixe===

De l'extérieur, l'ordinateur est composé d'une unité centrale sur laquelle on branche des périphériques.

[[File:Typical computer architecture systems.jpg|vignette|upright=1.5|Exemples de périphériques, connectés à une unité centrale (ici appelée à tort ''operating system'').]]

Les '''périphériques''' regroupent l'écran, la souris, le clavier, l'imprimante, et bien d'autres choses. Ils permettent à l'utilisateur d'interagir avec l'ordinateur : un clavier permet de saisir du texte sous dans un fichier, une souris enregistre des déplacements de la main en déplacement du curseur, un écran affiche des données d’images/vidéos, un haut-parleur émet du son, etc. Tout ce qui est branché sur un ordinateur est, formellement un périphérique.

L''''unité centrale''' est là où se trouvent tous les composants importants d'un ordinateur, ceux qui font des calculs, qui exécutent des logiciels, qui mémorisent vos données, etc. Voici ce à quoi ressemble l'intérieur de l'unité centrale. Trois sections sont visibles : l'alimentation électrique en haut à gauche, la carte mère en bas à gauche et en jaune/orange, les disques et lecteurs à droite des câbles. Et on voit aussi beaucoup de câbles.

[[File:Asus P5K-SEIntel E6320.jpg|centre|vignette|upright=2|Exemple d'unité centrale.]]

Tout en haut à gauche, se trouve l''''alimentation électrique''', qui convertit le courant de la prise électrique en un courant plus faible, utilisable par les autres composants. Elle émet de nombreux câbles assez gros, qui sont reliés au reste. Les PC actuels utilisent des alimentations électriques standardisées, qui fournissent trois tensions au reste de l'ordinateur : une tension de 12 Volts, une de 5 Volts, une de 3,3 Volts.

À droite, caché par la partie &quot;métallique&quot; du boitier, se trouvent les lecteurs de CD/DVD, et les disques durs. Les lecteurs CD-ROM ou DVD-ROM permettaient de lire des CD ou des DVD. Je parle au passé, car ils ont aujourd'hui disparu des ordinateurs modernes. Les '''disques durs''' sont des mémoires de stockage, qui mémorisent vos données de manière permanente. De nos jours, ils sont remplacés par des SSD, qui sont des disques durs électroniques, là où les disques durs proprement dit sont des mémoires magnétiques. Nous verrons la différence dans deux chapitres dédiés, un sur les disques durs, l'autre sur les SSD.

En bas à droite, se trouve la '''carte mère''' un support plat, en plastique ou en céramique, sur laquelle sont soudés/connectés les autres composants. Sur celle-ci, de nombreux composants sont soudés, d'autres sont branchés dessus avec des câbles, d'autres sont connectés dessus avec des connecteurs. Ils sont reliés entre eux par des fils conducteurs, le plus souvent du cuivre ou de l’aluminium, ce qui leur permet de s’échanger des données. Sur les cartes simples, ces fils sont intégrés dans la carte électronique, dans des creux du plastique. Ils portent le nom de pistes.

Avant, les disques durs, SSD et lecteurs de CD/DVD sont branchés dessus via des connecteurs dédiés, appelés des connecteurs S-ATA. De nos jours, ils sont branchés sur un autre connecteur, grâce à l'interface NVME. Toujours est-il qu'ils sont reliés à la carte mère par des câbles, ce qui montre que ce sont des sortes de périphériques interne. Ils sont placés dans le boitier, mais on aurait tout aussi bien pu les mettre à l'extérieur, vu qu'ils communiquent avec l'ordinateur par l'intermédiaire d'un câble ou d'un connecteur dédié.

Mais deux autres composants très importants sont eux placés sur la carte mère, directement. Ils ont chacun un connecteur dédié, sur lequel ils sont branchés directement, sans passer par l'intermédiaire d'un câble, mais sans être soudés non plus. Il s'agit du processeur et de la mémoire RAM, deux composants centraux des PC modernes.

[[File:Pentium III SL4CB.jpg|thumb|Processeur Pentium III.]]

Le '''processeur''' traite les données, les modifie, les manipule. Pour faire simple, il s’agit d’une grosse calculatrice hyper-puissante. Il comprend à la fois un circuit qui fait des calculs, et un circuit de contrôle qui s'occupe de séquencer les calculs dans l'ordre demandé. Il est souvent caché sous un radiateur, lui-même surmonté par un ventilateur. En effet, un processeur chauffe beaucoup, ce qui demande d'évacuer cette chaleur. Un chapitre entier expliquera pourquoi les processeurs chauffent, ainsi que les techniques utilisées pour limiter leur production de chaleur et leur consommation électrique.

La '''mémoire vive''' conserve des informations/données temporairement, tant que le processeur en a besoin. Elle prend la forme de barrettes de RAM, comme montré ci-dessous.

[[File:2 gb ddr2 667.jpg|centre|vignette|upright=2|Barrette de RAM.]]

Outre ces composants dits principaux, un ordinateur peut comprendre plusieurs composants moins importants, surtout présents sur les ordinateurs personnels. Ils sont techniquement facultatifs, mais sont très présents dans les ordinateurs personnels. Cependant, certains ordinateurs spécialisés s'en passent. Il s'agit des diverses '''cartes d'extension''' sont branchées sur la carte mère. Elles permettent d’accélérer certains calculs ou certaines applications, afin de décharger le processeur. Par exemple, la carte graphique s'occupe des calculs graphiques, qu'il s'agisse de graphismes 3D de jeux vidéos ou de l'affichage en 2D du bureau. Dans un autre registre, la carte son prend en charge le microphone et les haut-parleurs.

[[Fichier:Personal computer, exploded 4.svg|thumb|upright=1.0|Éclaté d'un ordinateur de type PC :&lt;br /&gt;
1 : Écran ;&lt;br /&gt;
2 : Carte mère ;&lt;br /&gt;
3 : Processeur ;&lt;br /&gt;
4 : Câble Parallel ATA ;&lt;br /&gt;
5 : Mémoire vive (RAM) ;&lt;br /&gt;
6 : Carte d'extension ;&lt;br /&gt;
7 : Alimentation électrique ;&lt;br /&gt;
8 : Lecteur de disque optique ;&lt;br /&gt;
9 : Disque dur ;&lt;br /&gt;
10 : Clavier ;&lt;br /&gt;
11 : Souris.]]

Si on regarde une carte mère de face, on voit un grand nombre de connecteurs, mais aussi des circuits électroniques soudés à la carte mère.

[[File:Architecture matérielle d'une carte mère.png|centre|vignette|upright=2.0|Architecture matérielle d'une carte mère]]

Les '''connecteurs''' sont là où on branche les périphériques, la carte graphique, le processeur, la mémoire, etc. Dans l'ensemble, toute carte mère contient les connecteurs suivants :
* Le processeur vient s’enchâsser dans la carte mère sur un connecteur particulier : le '''socket'''. Celui-ci varie suivant la carte mère et le processeur, ce qui est source d'incompatibilités.
* Les barrettes de mémoire RAM s’enchâssent dans un autre type de connecteurs: les '''slots mémoire'''.
* Les mémoires de masse disposent de leurs propres connecteurs : connecteurs P-ATA pour les anciens disques durs, et S-ATA pour les récents.
* Les périphériques (clavier, souris, USB, Firewire, ...) sont connectés sur un ensemble de connecteurs dédiés, localisés à l'arrière du boitier de l'unité centrale. 
* Les autres périphériques sont placés dans l'unité centrale et sont connectés via des connecteurs spécialisés. Ces périphériques sont des cartes imprimées, d'où leur nom de '''cartes filles'''. On peut notamment citer les cartes réseau, les cartes son, ou les cartes vidéo.

===Les ordinateurs portables===

[[File:Samsung QX-511 (2).JPG|vignette|Ordinateur portable Samsung QX-511 (2), pour illustration.]]

Un ordinateur portable est identique à un ordinateur de type PC. Si vous ouvrez votre ordinateur portable (attention à la garantie), vous retrouverez les mêmes composants qu'un PC à l'intérieur. Un point important est la présence d'une batterie à l'intérieur du PC portable, absente des PC fixes.

[[File:LG gram 14Z90Q mainboard with battery.jpg|centre|vignette|upright=2|LG gram 14Z90Q avec sa batterie.]]

Une fois la batterie et les circuits associés retiré, la seule différence notable est que tous les composants sont soudés sur la carte mère, au lieu d'être branchés sur des connecteurs, à part éventuellement la RAM et le disque dur.

[[File:LG gram 14Z90Q mainboard without battery.jpg|centre|vignette|upright=2|LG gram 14Z90Q sans sa batterie.]]

La RAM est parfois soudée sur la carte mère, d'autres fois sous la forme de barrettes de mémoire vive semblables à celles des PC. Dans le dernier cas, elle est connectée à des connecteurs spécifiques, ce qui permet de les changer/upgrader. Les PC portables sont parfois construits de manière à pouvoir changer la RAM facilement, en ouvrant un cache spécial, concu pour.

[[File:Lenovo G555 состав - Донор.JPG|centre|vignette|upright=2|Lenovo G555.]]

La conception d'un ordinateur portable est légèrement différente de celle d'un PC, pour des raisons thermiques. Un PC fixe a plus de place pour évacuer sa chaleur. Les ventilateurs peuvent plus facilement déplacer l'air dans le boitier, même si le flux d'air dans le boitier est éventuellement gêné par la carte graphique. Mais l'évacuation de la chaleur est assez efficace. Sur les PC portables, leur finesse fait que le trajet de l'air est beaucoup plus contraint. Évacuer la chaleur produite par l'ordinateur est plus complexe, ce qui demande d'utiliser des systèmes de refroidissement et de ventilation spécifiques.

Là où les PC fixes se débrouillent avec des radiateurs et des ventilateurs posés sur le processeur, les PC portables font autrement. Ils ne peuvent pas forcément mettre le ventilateur sur le processeur. A la place, ils mettent le ventilateur à côté, mais le processeur est surmonté par un mécanisme de transmission de la chaleur, qui transfère la chaleur du processeur vers le ventilateur.

[[File:Diagram - How a laptop cooling system works.png|centre|vignette|upright=2|Comment fonctionne le système de ventilation d'un ordinateur portable, en anglais.]]

Les difficultés pour dissiper la chaleur font que les ordinateurs portables utilisent souvent des composants peu performants, mais qui chauffent peu. En effet, nous verrons que plus un composant est puissant, plus il chauffe. La relation n'est pas parfaite, mais les processeurs haute performance chauffent plus que les modèles d'entrée ou milieu de gamme moins puissants. En conséquence, les PC portables sont souvent moins puissants que les PC fixes, même pour les modèles dit ''gaming''.

===Les serveurs et ''mainframes''===

Les grandes entreprises utilisent des ordinateurs de grande taille, très puissants, appelés des ''mainframes''. Ils sont souvent confondus avec les serveurs par le grand public, il y a une différence entre les deux. Un serveur est une fonction logicielle/réseau, pas un type d'ordinateur. Mais laissons cette différence de côté, ce qui est dit pour les ''mainframes'' sert pour les gros serveurs haute performance.

[[File:IBM Z15 mainframe.jpg|vignette|Exemple de ''mainframe''' de type IBM Z15.]]

Les anciens ''mainframes'' des années 50-80 avaient une taille pouvant être impressionnante, au point de prendre une pièce complète d'un bâtiment. Mais de nos jours, les ''mainframes'' tiennent dans une grosse armoire un peu haute. Les ''mainframes'' doivent rester allumé en permanence et ne doivent pas être éteint, sauf éventuellement quelques jours par an pour des opérations de maintenance. Ils utilisent pour cela des techniques spécifiques, avec beaucoup de redondance interne.

[[File:ACONIT hall grandes machines.jpg|centre|vignette|upright=2|''Mainframe'' ACONIT.]]

Les ''mainframes'' sont aussi conçus pour mutualiser au maximum leur utilisation, ils peuvent être utilisés par plusieurs utilisateurs à la suite, voire en même temps. Pour cela, les anciens ''mainframes'' étaient capables de faire tourner plusieurs applications distinctes l'une à la suite de l'autre, avec des commutations fréquentes entre logiciels. De nos jours, ils sont capables d'exécuter un grand nombre de tâches en même temps, grâce à la présence de plusieurs processeurs. Les ''mainframes'' modernes sont même capables de faire tourner plusieurs systèmes d'exploitation en même temps si besoin.

Les anciens ''mainframes'' étaient des ordinateurs assez simples, avec un processeur, de la mémoire RAM, un ou plusieurs disques durs, pas plus. Le ''mainframe'' était tellement énorme et cher que les entreprises n'en avaient qu'un seul pour toute l'entreprise. Les employés avaient sur leur bureau des terminaux, qui permettaient d'accéder à l'ordinateur central, mais n'étaient pas des ordinateurs. Les terminaux étaient des composants électroniques simples, avec un écran, un clavier et une souris, mais sans processeur. Ils envoyaient des données au ''mainframe'', ils en recevaient de sa part, mais tout traitement était réalisé sur le ''mainframe''. L'arrivée sur le marché des ordinateurs personnels, de type PC fixe/portable, a entrainé l'abandon de ce genre de pratique, tous les employés ont maintenant un ordinateur rien que pour eux.

{|
|-
! colspan=&quot;2&quot; | Exemples de terminaux
|-
|[[File:Terminal-in2-sm9400.jpg|centre|vignette|upright=1.5|Exemple de terminal. Notez la présence d'un écran et d'un clavier, mais l'asbence d'une unité centrale.]]
|[[File:Chromatics CT4100.jpg|vignette|upright=1.5|Autre exemple de terminal. Le clavier est couplé à un stylo CRT, qui remplacait la souris et agissait sur l'écran comme s'il était tactile.]]
|-
! colspan=&quot;2&quot; | Intérieur d'un terminal
|-
|[[File:CT1024 Monitor.jpg|vignette|upright=1.5|Terminal CT1024, sans le boitier extérieur.]]
|[[File:CT1024 Terminal System.jpg|vignette|upright=1.5|Terminal CT1024, description des composants interne.]]
|}

De nos jours, les ''mainframes'' contiennent en réalité plusieurs ordinateurs simples interconnectés via un réseau local. Un ''mainframe'' qui tient dans une armoire contient facilement une dizaine ou centaine de processeurs, plein de RAM, des disques durs séparés dans une armoire distincte, etc. Vu qu'ils communiquent uniquement via le réseau, ils n'ont pas d'interface, pas d'écran, 'entrée via clavier/souris. Le tout est commandé avec une console de commande, typiquement un ordinateur portable ou un terminal assez simple séparé de l'armoire, qui permet à un administrateur de faire des opérations de surveillance, configuration et maintenance. Il peut y avoir une console de commande pour plusieurs armoires séparées, la console peut même être dans un autre bâtiment et accéder au ''mainframe'' par le réseau.

[[File:IBM System Z9 (type 2094 inside).jpg|centre|vignette|upright=2|''Mainframe'' de type IBM System Z9. L'ordinateur portable sert de console pour qu'un administrateur fasse des opérations de surveillance, configuration et maintenance.]]

Les processeurs et la RAM sont typiquement installés sur des cartes amovibles, qui sont connectées au fond de l'armoire lors de l'installation. Il est même possible de retirer ou d'ajouter des cartes en fonctionnement, afin d'ajouter/retirer des processeurs, des disques durs, etc. Ce qui est très utile si un composant est en panne et qu'il faut le remplacer. 

[[File:IBM TotalStorage Exp400.jpg|centre|vignette|upright=2|IBM TotalStorage Exp400]]

==Un peu d'abstraction : qu'est-ce qu'un ordinateur ?==

Un ordinateur comprend donc un processeur, plusieurs mémoires, des cartes d'extension et une carte mère pour connecter le tout. Mais il s'agit là d'une description assez terre-à-terre de ce qu'est un ordinateur. Une autre description, plus abstraite, se base sur le fait qu'un ordinateur est une énorme calculatrice programmable. Elle permet d'expliquer pourquoi il y a une distinction entre processeur et mémoire, entre unité centrale et périphériques. Tout ce qui va suivre pourra vous paraitre assez abstrait, mais rassurez-vous : les prochains chapitres rendront tout cela plus concrets.

===La séparation entre entrées-sorties et traitement===

L'unité centrale peut être vue comme une énorme calculatrice ultra-puissante, qui exécute des commandes/opérations. Mais à elle seule, elle ne servirait à rien, il faut interagir avec par l'intermédiaire de plusieurs périphériques. Il existe deux types de périphériques, qui sont conceptuellement différents. Les périphériques comme le clavier ou la souris permettent d'envoyer des informations à l'ordinateur, d'agir sur celui-ci. A l'inverse, les écrans transmettent des informations dans le sens inverse : de l'ordinateur vers l'utilisateur. Les premiers sont appelés des '''entrées''', les seconds des '''sorties'''.

Dans un ordinateur, les informations sont représentées sous la forme de nombres. Toute donnée dans un ordinateur est codée avec un ou plusieurs nombres regroupés dans une donnée, un fichier, ou autre. Et la transmissions avec les entrées et sorties se fait là-encore avec des nombres. Par exemple, quand vous appuyez sur votre clavier, le clavier envoie un numéro de touche à l'unité centrale, qui indique quelle touche a été appuyée. L'image à afficher à l'écran est codée sous la forme d'une suite de nombres (un par pixel). L'image est envoyée à l'écran, qui traduit la suite de nombre en image à afficher. Les entrées traduisent des actions utilisateurs en nombres, on dit que les entrées encodent les actions utilisateur. Les sorties font la traduction inverse, elles transforment des suites de nombres en une action physique. On dit qu'elles décodent des informations.

Pour résumer, toute appareil électronique est composé par :
* Des '''entrées''' sur lesquelles l'utilisateur agit sur l'ordinateur. Les entrées transforment les actions de l'utilisateur en nombres, qui sont interprétés par l'ordinateur.
* Une '''unité de traitement''', qui manipule des nombres et fait des calculs/opérations dessus. Les nombres proviennent des entrées, du disque dur, ou d'autres sources, peu importe.
* Des '''sorties''', qui va récupèrent le résultat calculé par l'unité de traitement pour en faire quelque chose : écrire sur une imprimante ou sur un moniteur, émettre du son,...

[[File:Ordinateur théorique Simple 1.png|centre|vignette|upright=2|Ordinateur théorique Simple 1]]

L'unité de traitement proprement dite, celle qui fait les calculs, est couplée à une mémoire qui mémorise les opérandes et résultats des calculs. La séparation entre processeur et mémoire est nécessaire pour qu'un appareil électronique soit qualifié d'ordinateur. De nombreux appareils n'ont pas de séparation entre unité de traitement et mémoire, comme certaines vielles radios AM/FM.

[[File:Schéma de principe d'un ordinateur.png|centre|vignette|upright=2|Schéma de principe d'un ordinateur]]

===Un ordinateur est un appareil programmable===

Les appareils simples sont non-programmables, ce qui veut dire qu’ils sont conçus pour une utilisation particulière et qu’ils ne peuvent pas faire autre chose. Par exemple, les circuits électroniques d’un lecteur de DVD ne peuvent pas être transformé en lecteur audio ou en console de jeux... Les circuits non-programmables sont câblés une bonne fois pour toute, et on ne peut pas les modifier. On peut parfois reconfigurer le circuit, pour faire varier certains paramètres, via des interrupteurs ou des boutons, mais cela s’arrête là. Et cela pose un problème : à chaque problème qu'on veut résoudre en utilisant un automate, on doit recréer un nouveau circuit.

À l'inverse, un ordinateur n’est pas conçu pour une utilisation particulière, contrairement aux autres objets techniques. Il est possible de modifier leur fonction du jour au lendemain, on peut lui faire faire ce qu’on veut. On dit qu'ils sont '''programmables'''. Pour cela, il suffit d’utiliser un logiciel, une application, un programme (ces termes sont synonymes), qui fait ce que l'on souhaite. La totalité des logiciels présents sur un ordinateur sont des programmes comme les autres, même le système d'exploitation (Windows, Linux, ...) ne fait pas exception.

Un programme est une suite de d''''instructions machines''', chaque instruction effectuant une action dans l'ordinateur. Sur les ordinateurs modernes, les instructions les plus communes effectuent une opération arithmétique : une addition, une multiplication, une soustraction, etc. Les ordinateurs modernes sont donc de grosses calculettes très puissantes, capables d'effectuer des millions d'opérations par secondes.

Et qui dit opération dit nombres : un ordinateur gère nativement des nombres, qui sont codés en binaire sur la quasi-totalité des ordinateurs modernes. Les ordinateurs modernes sont capables de faire des calculs sur des nombres entiers, mais aussi des nombres à virgule. Il existe plusieurs manières de représenter des nombres en binaire, certaines représentant des nombres entiers dits naturels (0 et plus), d'autres des nombres signés (positifs ou négatifs), d'autres des nombres à virgule. Un chapitre entier détaillera comment sont encodés ces nombres.

Une instruction est représentée dans un ordinateur par une série de nombres entiers : un nombre qui indique quelle opération/commande effectuer et des autres nombres pour coder les données (ou de quoi les retrouver dans l'ordinateur). L'ordinateur récupére les commandes une par une, les traduit en opération à effectuer, exécuter l'opération, et enregistre le résultat. Puis il recommence avec la commande suivante.

[[File:Ordinateur Théorique Complexe 1.png|centre|vignette|upright=3|Ordinateur Théorique Complexe. En jaune, le programme informatique, la liste de commande. Le rectangle gris est l'ordinateur proprement dit.]]

De nombreux appareils sont programmables, mais tous ne sont pas des ordinateurs. Par exemple, certains circuits programmables nommés FPGA n'en sont pas. Pour être qualifié d'ordinateur, un appareil programmable doit avoir un processeur séparé de la mémoire. De plus, il doit utiliser un '''codage numérique''', chose que nous allons aborder dans le chapitre suivant.

===Les ordinateurs à programme mémorisé ou programme externe===

[[File:Blue-punch-card-front.png|vignette|upright=0.5|Carte Perforée.]]

Au tout début de l'informatique, les programmes étaient enregistrés sur des cartes perforées, à savoir des cartes en papier/plastique percées par endroits. Un 1 est codé par un trou dans le papier et un 0 par une absence de trou. Les programmes étaient exécutés par l'ordinateur quand on insérait la carte perforée dans le lecteur et qu'on appuyait sur un bouton.

Par la suite, les premiers ordinateurs grand public, comme les Amstrad ou les Commodore, utilisaient des cassettes audio magnétiques pour stocker les programmes. Dans le même style, les consoles de jeu utilisaient autrefois des cartouches de jeu, qui contenaient le programme du jeu à exécuter. Pour résumer, les anciens ordinateurs mémorisaient les programmes sur un support externe, lu par un périphérique. De tels ordinateurs sont dits à '''programme externe'''.

: D’anciens ordinateurs personnels, comme l’Amstrad ou le Commodore, permettaient de taper les programmes à exécuter à la main, au clavier, avant d’appuyer une touche pour les exécuter. Nul besoin de vous dire que les cassettes audio étaient plus pratiques.

Mais de nos jours, les programmes sont enregistrés sur le disque dur de l'ordinateur ou dans une mémoire intégrée à l'ordinateur. On dit qu'ils sont installés, ce qui est un mot bien compliqué pour dire que le programme est enregistré sur le disque dur de l’ordinateur. A défaut de disque dur, le programme/logiciel est enregistré dans une mémoire spécialisée pour le stockage. Par exemple, sur les cartes électroniques grand public de marque Arduino, les programmes sont envoyés à la carte via le port USB, mais les programmes sont enregistrés dans la carte Arduino, dans une mémoire FLASH dédiée. Disque dur ou non, le programme est mémorisé dans la mémoire de l'ordinateur. Il est possible d'installer ou de désinstaller les programmes en modifiant le contenu de la mémoire. Le terme utilisé est alors celui de '''programme stocké en mémoire'''.

Les programmes à installer sont disponibles soit sur un périphérique, comme un DVD ou une clé USB, soit sont téléchargés depuis internet. Les premiers PC fournissaient les logiciels sur des disquettes, qui contenaient un programme d'installation pour enregistrer le programme sur le disque dur de l'ordinateur. Par la suite, le support des logiciels a migré vers les CD et DVD, les logiciels devenant de plus en plus gros. De nos jours, la majorité des applications sont téléchargées depuis le net, l'usage de périphériques est devenu obsolète, même les consoles de jeu abandonnent cette méthode de distribution.

==Les générations d'ordinateurs : un historique rapide==

L'informatique a beaucoup évolué dans le temps. Et une bonne partie de cette évolution tient à l'évolution de l’électronique sous-jacente. Les ordinateurs actuels sont fabriqués avec des transistors, des petits composants électroniques qui servent d'interrupteurs programmables, qu'on détaillera dans ce qui suit. Mais ça n'a pas toujours été le cas. Et cela permet de distinguer plusieurs '''générations d'ordinateurs'''.

===Les ordinateurs électro-mécaniques : les premiers ordinateurs===

Le tout premier ordinateur est le '''Z1''', un modèle unique inventé par Konrad Suze entre 1936 et 1938. Son processeur gérait non pas des nombres entiers, mais des nombres à virgule (des nombres dits flottants, pour être précis), encodés sur 22 bits. Le processeur du Z1 était capable de faire des additions et des soustractions, car il intégrait un circuit additionneur-soustracteur basique. Des circuits annexes permettaient de faire des multiplications et des divisions en enchainant des additions/soustractions successives. Il fonctionnait à une fréquence de 1 Hz, ce qui fait qu'il pouvait faire une addition/soustraction par seconde maximum.

Niveau mémoire, la RAM de l'ordinateur était très limitée : seulement 16 nombres de 22 bits chacun. S'il s'agissait d'une mémoire électronique, les programmes étaient mémorisés sur une mémoire mécanique et précisémment sur des cartes perforées, à savoir des cartes en papier/plastique dans lesquelles un 1 est codé par un trou dans le papier et un 0 par une absence de trou. Les programmes étaient exécutés par l'ordinateur quand on insérait la carte perforée dans le lecteur et qu'on appuyait sur un bouton.

[[File:German Museum of Technology, Berlin 2017 024.jpg|centre|vignette|upright=2|Réplique du Z1 au ''German Museum of Technology'' de Berlin, 2017.]]

Après sa destruction dans un bombardement, le Z1 a été reconstruit et amélioré, ce qui donné les deux ordinateurs Z2 et Z3. Quelques années plus tard, quelques laboratoires de recherche ont fabriqués des ordinateurs dans leur coin, comme le Harvard Mark I et le Colossus Mark 1 (UK) qui ont été mis en service en 1944. Ils ont servi pour les cryptanalystes pour casser les codes utilisés par les Allemands pour leurs transmissions, pendant la seconde guerre mondiale.

Les ordinateurs cités dans le précédent paragraphe étaient tous des ordinateurs dit '''électro-mécaniques''', car ils mélangeaient des composants électroniques et des composants mécaniques (tout ce qui a trait aux cartes perforées, notamment). Les composants électroniques étaient généralement des relais, à savoir des interrupteurs commandables électriquement, qui sont plus ou moins équivalents aux transistors modernes. La majeure partie des ordinateurs des années 40 étaient de ce type, mais leur nombre n'a pas dépassé 30. Il faut dire qu'ils ont rapidement laissé la place à des ordinateurs purement électroniques, que nous allons voir dans ce qui suit.

===La première génération : les tubes à vide===

Les ordinateurs qui ont suivi les ordinateurs électromécaniques sont regroupés dans la '''première génération d'ordinateur'''. Ils étaient conçus avec des tubes à vide, des espèces d'interrupteurs commandables, les ancêtres des transistors modernes. Les tubes à vide étaient assez encombrants, ils consommaient beaucoup de courant, ils chauffaient et étaient assez peu fiables. Ils tombaient en panne assez souvent. Et ils étaient assez simples à fabriquer, mais restaient malgré tout chers.

Les tubes à vide sont des ampoules à filament améliorées. Pour rappel, les ampoules à filament étaient des ampoules en verre dans lesquelles on plaçait un filament métallique. Le filament chauffait quand on envoyait du courant dedans et émettait de la lumière. Mais dans les tubes à vide, le filament n'émet pas de lumière quand on le chauffe : il émet des électrons, de l'électricité. De plus, ils ajoutent une électrode, une plaque en métal qui émet ou capte des électrons. Ici, l'électrode capte des électrons émis par le filament quand il chauffe. Vu qu'elle capte des électrons, on l'appelle l''''anode'''.

Le résultat est un circuit qui laisse passer le courant, mais seulement dans un sens : du filament vers l'anode, l'autre sens n'est pas possible vu que l'anode ne peut pas émettre d'électrons. Un tel circuit est appelé une '''diode'''.

Une amélioration des tubes à vide précédent rajoute une seconde plaque de métal, appelée la '''cathode''', située juste après le filament. C'est elle qui émet les électrons, , mais seulement si elle est chauffée par le filament. Le filament doit donc chauffer, ce qui réchauffe la cathode, qui elle-même émet des électrons en direction de l'anode.

{|
|[[File:Diode à vide.png|vignette|upright=1.5|Diode à vide, avec cathode.]]
|[[File:Diode à vide schéma de fonctionnement.png|vignette|upright=1.5|Diode à vide, schéma de fonctionnement. Le filament X chauffe la cathode (2), qui émet des électrons (3), vers l'anode (4).]]
|}

Les tubes à vide précédent peuvent être modifiés en ajoutant une grille métallique entre la cathode et l'anode. La grille est alimentée avec une tension électrique, ce qui la charge électriquement. Suivant sa charge, elle laisse plus ou moins passer les électrons de la cathode vers l'anode. Si elle n'est pas chargée, que la tension est de 0 Volts, elle ne fera pas obstacle aux électrons et le tube à vide fonctionnera comme une diode basique. Mais si la grille est chargée avec une tension négative, sa charge électrique va repousser les électrons et les empêcher de passer de la cathode vers l'anode. Le tube à vide se comportera alors comme un interrupteur : fermé ou ouvert suivant ce qu'on met sur la grille. De tels interrupteurs commandables électriquement sont combinés pour fabriquer des circuits plus élaborés, comme les portes logiques qu'on verra d'ici quelques chapitres.

Les tubes à vides étaient utilisés pour le processeur et quelques circuits annexes, mais les mémoires utilisaient d'autres technologies. Les mémoires de l'époque n'étaient pas du tout des mémoires électroniques. Il existait déjà des ancêtres des disques durs, à savoir des mémoire magnétiques appelées tambours magnétiques, bandes magnétiques, mémoires à tore de ferrite, etc. Les mémoires RAM, quant à elles, utilisaient elles des technologies totalement abandonnées : les mémoires à lignes de délai étaient des mémoires acoustiques, les tubes Williams étaient des écrans CRT modifiés, etc. Un chapitre entier sera dédié aux technologies des mémoires de l'époque.

[[File:Elektronenroehren-auswahl.jpg|centre|vignette|upright=2|Tubes à vides.]]

L'usage de tubes à vide les place entre les premiers ordinateurs électro-mécaniques et les ordinateurs utilisant des transistors. Au vu de la taille des tubes à vide, les ordinateurs de l'époque étaient composés de plusieurs milliers de ces tubes, guère plus. Et malgré cela, un ordinateur prenait facilement un étage de bâtiment entier, ou au moins plusieurs pièces. La conséquence est que les ordinateurs de première génération étaient très simples, rudimentaires quand on les compare aux ordinateurs modernes. Ils ne géraient que quelques opérations simples : l'addition, la soustraction, pas grand-chose de plus. À quelques exceptions près, ils ne géraient pas la multiplication et encore moins la division, cela aurait demandé trop de tubes à vides.

Une des toutes premières machines construite avec des tubes à vide était l'Atanasoff–Berry. Ce n'était pas un ordinateur, car elle ne pouvait pas exécuter de programme sans intervention humaine pour séquencer des opérations, mais c'était la première machine de calcul purement électronique, sans aucune pièce mécanique. Elle utilisait une mémoire RAM construite avec des condensateurs, ceux-ci étant placés sur des cylindres tournants. Les circuits de calcul étaient construits avec des tubes à vide et faisaient leur travail un bit à la fois. Elle fonctionnait à une fréquence de 60 Hz et pouvait faire 30 additions/soustractions par seconde. Les nombres étaient encodés sur 50 bits. 

[[File:Atanasoff Berry Computer.gif|centre|vignette|upright=2.5|Atanasoff–Berry.]]

L'arrivée de l'ENIAC en 1945 a changé la donne. Cet ordinateur a introduit plusieurs innovations majeures. La première est assez technique, il s'agit de la turing-complétude, elle a trait aux programmes qui peuvent être écrit pour un ordinateur, nous ne la détaillerons pas ici.

[[File:BabyArchitecture.png|vignette|Architecture de la Manchester Baby.]]

En 1948, le ''Manchester Baby'' a introduit une innovation extrêmement importante : le programme n'était plus mémorisé sur des cartes perforées, mais dans une mémoire électronique à l’intérieur de l'ordinateur lui-même. En clair, le ''Manchester Baby'' était le premier '''ordinateur à programme stocké en mémoire''' en français. Au-delà de ça, le Manchester Baby restait quand même très simple, c'était limite un prototype.

Niveau interface, l'ordinateur avait une console avec 32 boutons, des interrupteurs et un écran de sortie sur lequel afficher les résultats. A l'intérieur, il y avait un processeur et une RAM de 32 nombres de 32 bits, fabriquées avec des tubes Williams (abordés dans une annexe à la fin du cours). Une instruction prenant autant de place qu'un nombre en RAM, ce qui limitait les programmes à 32 instructions maximum. Le processeur gérait 8 instructions en tout, mais la seule instruction de calcul qu'il gérait était la soustraction. L'addition n'était pas supportée. Il pouvait cependant émuler l'addition à partir d'une soustraction et inversant l'opérande soustrait.

Le Manchester Mark 1 était une amélioration du Manchester Baby. Il utilisait 4500 tubes à vide. L'ordinateur gérait des nombres de 40 bits, mais les instructions étaient codées sur 20 bits. La RAM avait la même taille, à savoir 32 nombres, leur taille était simplement augmentée. Par contre, la RAM était complémentée par l’ancêtre du disque dur magnétique, à savoir un tambour magnétique, l’ancêtre du disque dur magnétique. Il contenait 40 pages, chacune ayant la même taille que la RAM. Contrairement à la Manchester Baby, son processeur gérait l'addition. Les multiplications étaient réalisées par des additions successives, mais le processeur intégrait des registres pour mémoriser les opérandes à multiplier.

Par la suite, les ordinateurs commerciaux ont vu le jour. Les ordinateurs précédents provenaient de projets de recherches, souvent publics. Mais les entreprises privées se sont mises à fabriquer des ordinateurs elle-mêmes, pour les vendre à d'autres entreprises. On peut notamment citer les ordinateurs comme le UNIVAC I, le Bull Gamma 3 ou les premiers ordinateurs IBM. La performance de ces ordinateurs était nettement plus importante que leurs prédécesseurs, avec des fréquences de l'ordre de la centaine de kilo-hertz. Par exemple, le Bull Gamma 3 allait à 281 kHz, l'IBM 650 allait à 50 Khz.

===La seconde génération : le remplacement des tubes à vides par des transistors===

[[File:IBM 7070.jpg|vignette|Cartes imprimées de l'IBM 704, avec des transistors et résistances dessus.]]

La '''seconde génération''' est celle des ordinateurs fabriqués avec des '''transistors''' isolés, reliés entre avec des fils électriques. Les transistors en question possèdent trois broches, des pattes métalliques sur lesquelles on connecte des fils électriques. Le transistor s'utilise le plus souvent comme un interrupteur commandé par sa troisième broche. Le courant qui traverse les deux premières broches passe ou ne passe pas selon ce qu'on met sur la troisième.

[[File:Transistor basic flow.svg|centre|vignette|Un transistor est un morceau de conducteur, dont la conductivité est contrôlée par sa troisième broche/borne.]]

Les ordinateurs de seconde génération avaient entre 1000 et 500 000 transistors. Les capacités des ordinateurs étaient donc nettement supérieures à celles des ordinateurs de première génération. Une part non négligeable des ordinateurs de seconde génération supportait l'opération de multiplication, absente sur les ordinateurs de première génération. Néanmoins, cela variait beaucoup selon les ordinateurs.

Un exemple assez hors du commun est celui du premier modèle de l'IBM 1620. Le tout premier modèle n'avait aucun circuit de calcul, il n'était même pas capable de faire une addition ou une multiplication. A la place, il utilisait une table d'addition et une table de multiplication en mémoire RAM. Les deux tables devaient être initialisées par le logiciel lors du démarrage de la machine. La table d'addition faisait une centaine de chiffres, la table de multiplication faisait le double. Le processeur de l'ordinateur gérait des instructions pour faire des additions ou des multiplications, mais ces opérations lisaient le résultat dans la table d'addition. Les calculs étaient faits chiffre par chiffre, avec un encodage partiellement décimal, partiellement binaire (des chiffres décimaux étaient encodés en binaire, nous en reparlerons quand nous parlerons du BCD) !

[[File:KL CoreMemory.jpg|vignette|Mémoire à tore de ferrite.]]

Les transistors n'étaient utilisés que pour le processeur et les circuits annexes. La mémoire n'était pas faite en transistors, pas à cette époque. La mémoire était une mémoire aujourd'hui abandonnée, appelée une '''mémoire à tores de ferrite'''. Elle sera détaillée dans un chapitre ultérieur. Mais sachez pour le moment qu'il s'agit d'une mémoire au support magnétique, les données étant stockées sur un support magnétique.

Les transistors étaient au départ de la même taille que les tubes à vide, mais ils ont rapidement rétrécit. Ils prenaient encore beaucoup de place dans les 60-70, ce qui fait que les ordinateurs étaient assez gros. Concrètement, ils prenaient une pièce de bâtiment entière dans le meilleur des cas. C'était l'époque des gros ''mainframes'', reliés à des terminaux, peu puissants comparé aux standards actuels. Seules les grandes entreprises et les grands instituts de recherche pouvaient se payer les services de ce genre d'ordinateurs. Seuls les professionnels avaient accès à ce genre d'équipement.

===La troisième génération : le circuit intégré===

[[File:D8259AC-2.jpg|vignette|Exemple de circuit intégré.]]

La troisième génération est toujours fabriquée avec des transistors, mais dont la taille a été réduite. Avec l'évolution de la technologie, les transistors ont diminué en taille, de plus en plus. Ils sont devenus tellement petits qu'ils ont fini par être regroupés dans des '''circuits intégrés''', des circuits regroupent plusieurs transistors sur la même puce de silicium. Les circuits intégrés se présentent le plus souvent sous la forme de boitiers rectangulaires, comme illustré ci-contre. D'autres ont des boitiers de forme carrées, comme ceux que l'on peut trouver sur les barrettes de mémoire RAM, ou à l'intérieur des clés USB/ disques SSD.

Lors de cette génération, les processeurs étaient fournis en pièces détachées qu'il fallait relier entre elles. Le processeur était composé de plusieurs circuits intégrés séparés, impossible de mettre un processeur dans un seul boitier. Un exemple de processeur conçu en kit est la série des Intel 3000. Elle regroupe plusieurs circuits séparés aux noms à coucher dehors, mais dont vous comprendrez ce qu'ils veulent dire dans les chapitres adéquats : l'Intel 3001 est un séquenceur, l'Intel 3002 regroupe unité de calcul et registres, le 3003 est un circuit d'anticipation de retenue complémentaire du 3002, le 3212 est une mémoire tampon, le 3214 est une unité de gestion des interruptions, les 3216/3226 sont des interfaces de bus mémoire. On pourrait aussi citer la famille de circuits intégrés AMD Am2900.

Même si le processeur était en pièces détachées, utiliser une dizaine de circuits intégrés était nettement mieux que d'utiliser plusieurs milliers de transistors individuels. En conséquence, les ordinateurs ont vu leur taille grandement réduite, passant de pièces entières à une simple armoire, voire à quelques cartes intégrées superposées. De plus, le prix des circuits intégré était abordable, du moins comparé aux ordinateurs d'avant. Le prix des ordinateurs a alors grandement décru, permettant à des entreprises et administrations de taille modeste de s'équiper d'ordinateurs.

===La quatrième génération : le microprocesseur===

[[File:MOS6502.svg|vignette|Microprocesseur, ici un processeur MOS6502, de la quatrième génération.]]

Lors de la troisième génération, les circuits intégrés regroupaient plusieurs dizaines ou centaines de transistors, mais sont rapidement montés en gamme. De centaines de transistors, ils sont passés au millier de transistors, puis au million et maintenant au-delà du milliard. Les transistors étaient devenus tellement petits, tellement miniaturisés, qu'il était devenu possible de mettre un processeur entier dans un circuit intégré. C'est ainsi qu'est né le microprocesseur, à savoir un processeur qui tient tout entier dans un seul circuit imprimé. La quatrième génération d’ordinateur est celle des ordinateurs basés autour d'un microprocesseur.

Les tout premiers microprocesseurs étaient des processeurs à application militaire, comme le processeur du F-14 CADC ou celui de l'Air data computer. Le tout premier microprocesseur commercialisé au grand public est le 4004 d'Intel, sorti en 1971. L'intel 4004 comprenait environ 2300 transistors, avait une fréquence de 740 MHz, pouvait faire 46 opérations différentes, et manipulait des entiers de 4 bits. Il était au départ un processeur de commande, prévu pour être intégré dans la calculatrice Busicom calculator 141-P, mais il fut utilisé pour d'autres applications quelque temps plus tard. Immédiatement après le 4004, les premiers microprocesseurs 8 bits furent commercialisés. Le 4004 fut suivi par le 8008 et quelques autres processeurs 8 bits extrêmement connus, comme le 8080 d'Intel, le 68000 de Motorola, le 6502 ou le Z80.

Les microprocesseurs permirent encore uen fois de réduire la taille des ordinateurs, qui pouvaient tenir dans un boitier de PC, ou un boitier de console de jeu. Le prix des ordinateurs a aussi chuté en même temps que les transistors étaient miniaturisés. C'est cette invention qui permis l'invention des consoles de jeux et des mini-ordinateurs, à savoir les ordinateurs personnels. Sans miniaturisation, on n'aurait pas d'ordinateur personnel, pas de PC fixe ou portable.

==L'organisation du cours : les différents niveaux d'explication==

Le fonctionnement d'un ordinateur est assez complexe à expliquer car les explications peuvent se faire sur plusieurs niveaux. Par plusieurs niveaux, on veut dire qu'un ordinateur est composé de composants très simples, qui sont assemblés pour donner des composants eux-même plus complexes, qui sont eux-même regrouper, etc. Étudier tout cela demande de voir plusieurs niveaux, allant de transistors très petits à des processeurs multicœurs. Les niveaux les plus bas sont de l'électronique pur et dure, alors que ceux plus haut sont à mi-chemin entre électronique et informatique.

===Les niveaux d'abstraction en architecture des ordinateurs===

Les trois premiers niveaux sont de l'électronique pur et dure. Ils correspondent aux premiers chapitres du cours, qui porteront sur les circuits électroniques en général.
* Le premier niveau est celui des '''transistors''', des circuits intégrés, des ''wafer'' et autres circuits de très petite taille.
* Le second niveau est celui des '''portes logiques''', des circuits très basiques, très simples, à la base de tous les autres.
* Le troisième niveau est celui dit de la '''''Register Transfer Level''''', où un circuit électronique est construit à partir de circuits basiques, dont des registres et autres circuits dits combinatoires.
Les deux niveaux suivants sont de l'informatique proprement dit. C'est dans ces deux niveaux qu'on étudie les ordinateurs proprement dit, les circuits qu'il y a dedans et non l'électronique en général.
* Le quatrième niveau est celui de la '''microarchitecture''', qui étudie ce qu'il y a à l'intérieur d'un processeur, d'une mémoire, des périphériques et autres.
* Le cinquième niveau est celui de l''''architecture externe''', qui décrit l'interface du processeur, de la mémoire, d'un périphérique ou autre. Par décrire l'interface, on veut dire : comment un programmeur voit le processeur et la mémoire, comment il peut les manipuler. Une architecture externe unique peut avoir plusieurs microarchitecture, ce qui fait qu'on sépare les deux. Tout cela sera plus clair quand on passera aux chapitres sur le processeur et les mémoires.

Nous n'allons pas voir les 5 niveaux dans l'ordre, des transistors vers l'architecture externe. En réalité, nous allons procéder autrement. La première partie du cours portera sur les trois premiers niveaux, le reste sur les deux autres. Les 5 niveaux seront vus dans des chapitres séparés, du moins le plus possible. Au niveau pédagogique, tout est plus simple si on scinde les 5 niveaux. Bien sûr, il y a quelques explications qui demandent de voir plusieurs niveaux à la fois. Par exemple, dans le chapitre sur les mémoires caches, nous auront des explications portant sur la RTL, la microarchitecture du cache et son architecture externe. Mais le gros du cours tentera de séparer le plus possible les 5 niveaux.

===Les trois parties principales du cours===

Nous allons commencer par parler du binaire, avant de voir les portes logiques. Avec ces portes logiques, nous allons voir comment fabriquer des circuits basiques qui reviendront très souvent dans la suite du cours. Nous verrons les registres, les décodeurs, les additionneurs et plein d'autres circuits. Puis, nous reviendrons au niveau des transistors pour finir la première partie. La raison est que c'est plus simple de faire comme cela. Tout ce qui a trait aux transistors sert à expliquer comment fabriquer des portes logiques, et il faut expliquer les portes logiques pour voir le niveau de la RTL.

Une fois la première partie finie, nous allons voir les différents composants d'un ordinateur. Une première partie expliquera ce qu'il y a dans un ordinateur, quels sont ses composants. Nous y parlerons de l'architecture de base, de la hiérarchie mémoire, des tendances technologiques, et d'autres généralités qui serviront de base pour la suite. Puis, nous verrons dans l'ordre les bus électroniques, les mémoires RAM/ROM, le processeur, les périphériques, les mémoires de stockage (SSD et disques durs) et les mémoires caches. Pour chaque composant, nous allons voir leur architecture externe, avant de voir leur microarchitecture. La raison est que la microarchitecture ne peut se comprendre que quand on sait quelle architecture externe elle implémente.

Enfin, dans une troisième partie, nous allons voir les optimisations majeures présentes dans tous les ordinateurs modernes, avec une partie sur le pipeline et le parallélisme d'instruction, et une autre sur les architectures parallèles. Pour finir, les annexes de fin parlerons de sujets un peu à part.

&lt;noinclude&gt;
{{NavChapitre | book=Fonctionnement d'un ordinateur
           | next=L'encodage des données
           | nextText=L'encodage des données
}}
&lt;/noinclude&gt;</text>
      <sha1>45p6l328e2vj7isj23c1pr9hvkm5j23</sha1>
    </revision>
    <revision>
      <id>744169</id>
      <parentid>744168</parentid>
      <timestamp>2025-06-05T15:40:38Z</timestamp>
      <contributor>
        <username>Mewtow</username>
        <id>31375</id>
      </contributor>
      <minor />
      <comment>/* La première génération : les tubes à vide */</comment>
      <origin>744169</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="49446" sha1="578yd676ktcvh2bsq6zh99cen4iu2u6" xml:space="preserve">Pour commencer, nous allons voir qu'il existe de nombreux types d'ordinateurs. Le plus connu est certainement le PC, l'ordinateur personnel, que vous avez sans doute dans votre salon. Les ordinateurs portables sont un deuxième type d'ordinateur assez intuitif, que vous avez peut-être. Mais il y a aussi d'autres types d'ordinateurs auxquels vous n'avez jamais été confrontés.

==Les différents types d'ordinateurs==

Dans cette section, nous allons décrire rapidement les ordinateurs les plus courant, mais surtout voir ce qu'il y a à l'intérieur d'un ordinateur.

===L'ordinateur de type PC fixe===

De l'extérieur, l'ordinateur est composé d'une unité centrale sur laquelle on branche des périphériques.

[[File:Typical computer architecture systems.jpg|vignette|upright=1.5|Exemples de périphériques, connectés à une unité centrale (ici appelée à tort ''operating system'').]]

Les '''périphériques''' regroupent l'écran, la souris, le clavier, l'imprimante, et bien d'autres choses. Ils permettent à l'utilisateur d'interagir avec l'ordinateur : un clavier permet de saisir du texte sous dans un fichier, une souris enregistre des déplacements de la main en déplacement du curseur, un écran affiche des données d’images/vidéos, un haut-parleur émet du son, etc. Tout ce qui est branché sur un ordinateur est, formellement un périphérique.

L''''unité centrale''' est là où se trouvent tous les composants importants d'un ordinateur, ceux qui font des calculs, qui exécutent des logiciels, qui mémorisent vos données, etc. Voici ce à quoi ressemble l'intérieur de l'unité centrale. Trois sections sont visibles : l'alimentation électrique en haut à gauche, la carte mère en bas à gauche et en jaune/orange, les disques et lecteurs à droite des câbles. Et on voit aussi beaucoup de câbles.

[[File:Asus P5K-SEIntel E6320.jpg|centre|vignette|upright=2|Exemple d'unité centrale.]]

Tout en haut à gauche, se trouve l''''alimentation électrique''', qui convertit le courant de la prise électrique en un courant plus faible, utilisable par les autres composants. Elle émet de nombreux câbles assez gros, qui sont reliés au reste. Les PC actuels utilisent des alimentations électriques standardisées, qui fournissent trois tensions au reste de l'ordinateur : une tension de 12 Volts, une de 5 Volts, une de 3,3 Volts.

À droite, caché par la partie &quot;métallique&quot; du boitier, se trouvent les lecteurs de CD/DVD, et les disques durs. Les lecteurs CD-ROM ou DVD-ROM permettaient de lire des CD ou des DVD. Je parle au passé, car ils ont aujourd'hui disparu des ordinateurs modernes. Les '''disques durs''' sont des mémoires de stockage, qui mémorisent vos données de manière permanente. De nos jours, ils sont remplacés par des SSD, qui sont des disques durs électroniques, là où les disques durs proprement dit sont des mémoires magnétiques. Nous verrons la différence dans deux chapitres dédiés, un sur les disques durs, l'autre sur les SSD.

En bas à droite, se trouve la '''carte mère''' un support plat, en plastique ou en céramique, sur laquelle sont soudés/connectés les autres composants. Sur celle-ci, de nombreux composants sont soudés, d'autres sont branchés dessus avec des câbles, d'autres sont connectés dessus avec des connecteurs. Ils sont reliés entre eux par des fils conducteurs, le plus souvent du cuivre ou de l’aluminium, ce qui leur permet de s’échanger des données. Sur les cartes simples, ces fils sont intégrés dans la carte électronique, dans des creux du plastique. Ils portent le nom de pistes.

Avant, les disques durs, SSD et lecteurs de CD/DVD sont branchés dessus via des connecteurs dédiés, appelés des connecteurs S-ATA. De nos jours, ils sont branchés sur un autre connecteur, grâce à l'interface NVME. Toujours est-il qu'ils sont reliés à la carte mère par des câbles, ce qui montre que ce sont des sortes de périphériques interne. Ils sont placés dans le boitier, mais on aurait tout aussi bien pu les mettre à l'extérieur, vu qu'ils communiquent avec l'ordinateur par l'intermédiaire d'un câble ou d'un connecteur dédié.

Mais deux autres composants très importants sont eux placés sur la carte mère, directement. Ils ont chacun un connecteur dédié, sur lequel ils sont branchés directement, sans passer par l'intermédiaire d'un câble, mais sans être soudés non plus. Il s'agit du processeur et de la mémoire RAM, deux composants centraux des PC modernes.

[[File:Pentium III SL4CB.jpg|thumb|Processeur Pentium III.]]

Le '''processeur''' traite les données, les modifie, les manipule. Pour faire simple, il s’agit d’une grosse calculatrice hyper-puissante. Il comprend à la fois un circuit qui fait des calculs, et un circuit de contrôle qui s'occupe de séquencer les calculs dans l'ordre demandé. Il est souvent caché sous un radiateur, lui-même surmonté par un ventilateur. En effet, un processeur chauffe beaucoup, ce qui demande d'évacuer cette chaleur. Un chapitre entier expliquera pourquoi les processeurs chauffent, ainsi que les techniques utilisées pour limiter leur production de chaleur et leur consommation électrique.

La '''mémoire vive''' conserve des informations/données temporairement, tant que le processeur en a besoin. Elle prend la forme de barrettes de RAM, comme montré ci-dessous.

[[File:2 gb ddr2 667.jpg|centre|vignette|upright=2|Barrette de RAM.]]

Outre ces composants dits principaux, un ordinateur peut comprendre plusieurs composants moins importants, surtout présents sur les ordinateurs personnels. Ils sont techniquement facultatifs, mais sont très présents dans les ordinateurs personnels. Cependant, certains ordinateurs spécialisés s'en passent. Il s'agit des diverses '''cartes d'extension''' sont branchées sur la carte mère. Elles permettent d’accélérer certains calculs ou certaines applications, afin de décharger le processeur. Par exemple, la carte graphique s'occupe des calculs graphiques, qu'il s'agisse de graphismes 3D de jeux vidéos ou de l'affichage en 2D du bureau. Dans un autre registre, la carte son prend en charge le microphone et les haut-parleurs.

[[Fichier:Personal computer, exploded 4.svg|thumb|upright=1.0|Éclaté d'un ordinateur de type PC :&lt;br /&gt;
1 : Écran ;&lt;br /&gt;
2 : Carte mère ;&lt;br /&gt;
3 : Processeur ;&lt;br /&gt;
4 : Câble Parallel ATA ;&lt;br /&gt;
5 : Mémoire vive (RAM) ;&lt;br /&gt;
6 : Carte d'extension ;&lt;br /&gt;
7 : Alimentation électrique ;&lt;br /&gt;
8 : Lecteur de disque optique ;&lt;br /&gt;
9 : Disque dur ;&lt;br /&gt;
10 : Clavier ;&lt;br /&gt;
11 : Souris.]]

Si on regarde une carte mère de face, on voit un grand nombre de connecteurs, mais aussi des circuits électroniques soudés à la carte mère.

[[File:Architecture matérielle d'une carte mère.png|centre|vignette|upright=2.0|Architecture matérielle d'une carte mère]]

Les '''connecteurs''' sont là où on branche les périphériques, la carte graphique, le processeur, la mémoire, etc. Dans l'ensemble, toute carte mère contient les connecteurs suivants :
* Le processeur vient s’enchâsser dans la carte mère sur un connecteur particulier : le '''socket'''. Celui-ci varie suivant la carte mère et le processeur, ce qui est source d'incompatibilités.
* Les barrettes de mémoire RAM s’enchâssent dans un autre type de connecteurs: les '''slots mémoire'''.
* Les mémoires de masse disposent de leurs propres connecteurs : connecteurs P-ATA pour les anciens disques durs, et S-ATA pour les récents.
* Les périphériques (clavier, souris, USB, Firewire, ...) sont connectés sur un ensemble de connecteurs dédiés, localisés à l'arrière du boitier de l'unité centrale. 
* Les autres périphériques sont placés dans l'unité centrale et sont connectés via des connecteurs spécialisés. Ces périphériques sont des cartes imprimées, d'où leur nom de '''cartes filles'''. On peut notamment citer les cartes réseau, les cartes son, ou les cartes vidéo.

===Les ordinateurs portables===

[[File:Samsung QX-511 (2).JPG|vignette|Ordinateur portable Samsung QX-511 (2), pour illustration.]]

Un ordinateur portable est identique à un ordinateur de type PC. Si vous ouvrez votre ordinateur portable (attention à la garantie), vous retrouverez les mêmes composants qu'un PC à l'intérieur. Un point important est la présence d'une batterie à l'intérieur du PC portable, absente des PC fixes.

[[File:LG gram 14Z90Q mainboard with battery.jpg|centre|vignette|upright=2|LG gram 14Z90Q avec sa batterie.]]

Une fois la batterie et les circuits associés retiré, la seule différence notable est que tous les composants sont soudés sur la carte mère, au lieu d'être branchés sur des connecteurs, à part éventuellement la RAM et le disque dur.

[[File:LG gram 14Z90Q mainboard without battery.jpg|centre|vignette|upright=2|LG gram 14Z90Q sans sa batterie.]]

La RAM est parfois soudée sur la carte mère, d'autres fois sous la forme de barrettes de mémoire vive semblables à celles des PC. Dans le dernier cas, elle est connectée à des connecteurs spécifiques, ce qui permet de les changer/upgrader. Les PC portables sont parfois construits de manière à pouvoir changer la RAM facilement, en ouvrant un cache spécial, concu pour.

[[File:Lenovo G555 состав - Донор.JPG|centre|vignette|upright=2|Lenovo G555.]]

La conception d'un ordinateur portable est légèrement différente de celle d'un PC, pour des raisons thermiques. Un PC fixe a plus de place pour évacuer sa chaleur. Les ventilateurs peuvent plus facilement déplacer l'air dans le boitier, même si le flux d'air dans le boitier est éventuellement gêné par la carte graphique. Mais l'évacuation de la chaleur est assez efficace. Sur les PC portables, leur finesse fait que le trajet de l'air est beaucoup plus contraint. Évacuer la chaleur produite par l'ordinateur est plus complexe, ce qui demande d'utiliser des systèmes de refroidissement et de ventilation spécifiques.

Là où les PC fixes se débrouillent avec des radiateurs et des ventilateurs posés sur le processeur, les PC portables font autrement. Ils ne peuvent pas forcément mettre le ventilateur sur le processeur. A la place, ils mettent le ventilateur à côté, mais le processeur est surmonté par un mécanisme de transmission de la chaleur, qui transfère la chaleur du processeur vers le ventilateur.

[[File:Diagram - How a laptop cooling system works.png|centre|vignette|upright=2|Comment fonctionne le système de ventilation d'un ordinateur portable, en anglais.]]

Les difficultés pour dissiper la chaleur font que les ordinateurs portables utilisent souvent des composants peu performants, mais qui chauffent peu. En effet, nous verrons que plus un composant est puissant, plus il chauffe. La relation n'est pas parfaite, mais les processeurs haute performance chauffent plus que les modèles d'entrée ou milieu de gamme moins puissants. En conséquence, les PC portables sont souvent moins puissants que les PC fixes, même pour les modèles dit ''gaming''.

===Les serveurs et ''mainframes''===

Les grandes entreprises utilisent des ordinateurs de grande taille, très puissants, appelés des ''mainframes''. Ils sont souvent confondus avec les serveurs par le grand public, il y a une différence entre les deux. Un serveur est une fonction logicielle/réseau, pas un type d'ordinateur. Mais laissons cette différence de côté, ce qui est dit pour les ''mainframes'' sert pour les gros serveurs haute performance.

[[File:IBM Z15 mainframe.jpg|vignette|Exemple de ''mainframe''' de type IBM Z15.]]

Les anciens ''mainframes'' des années 50-80 avaient une taille pouvant être impressionnante, au point de prendre une pièce complète d'un bâtiment. Mais de nos jours, les ''mainframes'' tiennent dans une grosse armoire un peu haute. Les ''mainframes'' doivent rester allumé en permanence et ne doivent pas être éteint, sauf éventuellement quelques jours par an pour des opérations de maintenance. Ils utilisent pour cela des techniques spécifiques, avec beaucoup de redondance interne.

[[File:ACONIT hall grandes machines.jpg|centre|vignette|upright=2|''Mainframe'' ACONIT.]]

Les ''mainframes'' sont aussi conçus pour mutualiser au maximum leur utilisation, ils peuvent être utilisés par plusieurs utilisateurs à la suite, voire en même temps. Pour cela, les anciens ''mainframes'' étaient capables de faire tourner plusieurs applications distinctes l'une à la suite de l'autre, avec des commutations fréquentes entre logiciels. De nos jours, ils sont capables d'exécuter un grand nombre de tâches en même temps, grâce à la présence de plusieurs processeurs. Les ''mainframes'' modernes sont même capables de faire tourner plusieurs systèmes d'exploitation en même temps si besoin.

Les anciens ''mainframes'' étaient des ordinateurs assez simples, avec un processeur, de la mémoire RAM, un ou plusieurs disques durs, pas plus. Le ''mainframe'' était tellement énorme et cher que les entreprises n'en avaient qu'un seul pour toute l'entreprise. Les employés avaient sur leur bureau des terminaux, qui permettaient d'accéder à l'ordinateur central, mais n'étaient pas des ordinateurs. Les terminaux étaient des composants électroniques simples, avec un écran, un clavier et une souris, mais sans processeur. Ils envoyaient des données au ''mainframe'', ils en recevaient de sa part, mais tout traitement était réalisé sur le ''mainframe''. L'arrivée sur le marché des ordinateurs personnels, de type PC fixe/portable, a entrainé l'abandon de ce genre de pratique, tous les employés ont maintenant un ordinateur rien que pour eux.

{|
|-
! colspan=&quot;2&quot; | Exemples de terminaux
|-
|[[File:Terminal-in2-sm9400.jpg|centre|vignette|upright=1.5|Exemple de terminal. Notez la présence d'un écran et d'un clavier, mais l'asbence d'une unité centrale.]]
|[[File:Chromatics CT4100.jpg|vignette|upright=1.5|Autre exemple de terminal. Le clavier est couplé à un stylo CRT, qui remplacait la souris et agissait sur l'écran comme s'il était tactile.]]
|-
! colspan=&quot;2&quot; | Intérieur d'un terminal
|-
|[[File:CT1024 Monitor.jpg|vignette|upright=1.5|Terminal CT1024, sans le boitier extérieur.]]
|[[File:CT1024 Terminal System.jpg|vignette|upright=1.5|Terminal CT1024, description des composants interne.]]
|}

De nos jours, les ''mainframes'' contiennent en réalité plusieurs ordinateurs simples interconnectés via un réseau local. Un ''mainframe'' qui tient dans une armoire contient facilement une dizaine ou centaine de processeurs, plein de RAM, des disques durs séparés dans une armoire distincte, etc. Vu qu'ils communiquent uniquement via le réseau, ils n'ont pas d'interface, pas d'écran, 'entrée via clavier/souris. Le tout est commandé avec une console de commande, typiquement un ordinateur portable ou un terminal assez simple séparé de l'armoire, qui permet à un administrateur de faire des opérations de surveillance, configuration et maintenance. Il peut y avoir une console de commande pour plusieurs armoires séparées, la console peut même être dans un autre bâtiment et accéder au ''mainframe'' par le réseau.

[[File:IBM System Z9 (type 2094 inside).jpg|centre|vignette|upright=2|''Mainframe'' de type IBM System Z9. L'ordinateur portable sert de console pour qu'un administrateur fasse des opérations de surveillance, configuration et maintenance.]]

Les processeurs et la RAM sont typiquement installés sur des cartes amovibles, qui sont connectées au fond de l'armoire lors de l'installation. Il est même possible de retirer ou d'ajouter des cartes en fonctionnement, afin d'ajouter/retirer des processeurs, des disques durs, etc. Ce qui est très utile si un composant est en panne et qu'il faut le remplacer. 

[[File:IBM TotalStorage Exp400.jpg|centre|vignette|upright=2|IBM TotalStorage Exp400]]

==Un peu d'abstraction : qu'est-ce qu'un ordinateur ?==

Un ordinateur comprend donc un processeur, plusieurs mémoires, des cartes d'extension et une carte mère pour connecter le tout. Mais il s'agit là d'une description assez terre-à-terre de ce qu'est un ordinateur. Une autre description, plus abstraite, se base sur le fait qu'un ordinateur est une énorme calculatrice programmable. Elle permet d'expliquer pourquoi il y a une distinction entre processeur et mémoire, entre unité centrale et périphériques. Tout ce qui va suivre pourra vous paraitre assez abstrait, mais rassurez-vous : les prochains chapitres rendront tout cela plus concrets.

===La séparation entre entrées-sorties et traitement===

L'unité centrale peut être vue comme une énorme calculatrice ultra-puissante, qui exécute des commandes/opérations. Mais à elle seule, elle ne servirait à rien, il faut interagir avec par l'intermédiaire de plusieurs périphériques. Il existe deux types de périphériques, qui sont conceptuellement différents. Les périphériques comme le clavier ou la souris permettent d'envoyer des informations à l'ordinateur, d'agir sur celui-ci. A l'inverse, les écrans transmettent des informations dans le sens inverse : de l'ordinateur vers l'utilisateur. Les premiers sont appelés des '''entrées''', les seconds des '''sorties'''.

Dans un ordinateur, les informations sont représentées sous la forme de nombres. Toute donnée dans un ordinateur est codée avec un ou plusieurs nombres regroupés dans une donnée, un fichier, ou autre. Et la transmissions avec les entrées et sorties se fait là-encore avec des nombres. Par exemple, quand vous appuyez sur votre clavier, le clavier envoie un numéro de touche à l'unité centrale, qui indique quelle touche a été appuyée. L'image à afficher à l'écran est codée sous la forme d'une suite de nombres (un par pixel). L'image est envoyée à l'écran, qui traduit la suite de nombre en image à afficher. Les entrées traduisent des actions utilisateurs en nombres, on dit que les entrées encodent les actions utilisateur. Les sorties font la traduction inverse, elles transforment des suites de nombres en une action physique. On dit qu'elles décodent des informations.

Pour résumer, toute appareil électronique est composé par :
* Des '''entrées''' sur lesquelles l'utilisateur agit sur l'ordinateur. Les entrées transforment les actions de l'utilisateur en nombres, qui sont interprétés par l'ordinateur.
* Une '''unité de traitement''', qui manipule des nombres et fait des calculs/opérations dessus. Les nombres proviennent des entrées, du disque dur, ou d'autres sources, peu importe.
* Des '''sorties''', qui va récupèrent le résultat calculé par l'unité de traitement pour en faire quelque chose : écrire sur une imprimante ou sur un moniteur, émettre du son,...

[[File:Ordinateur théorique Simple 1.png|centre|vignette|upright=2|Ordinateur théorique Simple 1]]

L'unité de traitement proprement dite, celle qui fait les calculs, est couplée à une mémoire qui mémorise les opérandes et résultats des calculs. La séparation entre processeur et mémoire est nécessaire pour qu'un appareil électronique soit qualifié d'ordinateur. De nombreux appareils n'ont pas de séparation entre unité de traitement et mémoire, comme certaines vielles radios AM/FM.

[[File:Schéma de principe d'un ordinateur.png|centre|vignette|upright=2|Schéma de principe d'un ordinateur]]

===Un ordinateur est un appareil programmable===

Les appareils simples sont non-programmables, ce qui veut dire qu’ils sont conçus pour une utilisation particulière et qu’ils ne peuvent pas faire autre chose. Par exemple, les circuits électroniques d’un lecteur de DVD ne peuvent pas être transformé en lecteur audio ou en console de jeux... Les circuits non-programmables sont câblés une bonne fois pour toute, et on ne peut pas les modifier. On peut parfois reconfigurer le circuit, pour faire varier certains paramètres, via des interrupteurs ou des boutons, mais cela s’arrête là. Et cela pose un problème : à chaque problème qu'on veut résoudre en utilisant un automate, on doit recréer un nouveau circuit.

À l'inverse, un ordinateur n’est pas conçu pour une utilisation particulière, contrairement aux autres objets techniques. Il est possible de modifier leur fonction du jour au lendemain, on peut lui faire faire ce qu’on veut. On dit qu'ils sont '''programmables'''. Pour cela, il suffit d’utiliser un logiciel, une application, un programme (ces termes sont synonymes), qui fait ce que l'on souhaite. La totalité des logiciels présents sur un ordinateur sont des programmes comme les autres, même le système d'exploitation (Windows, Linux, ...) ne fait pas exception.

Un programme est une suite de d''''instructions machines''', chaque instruction effectuant une action dans l'ordinateur. Sur les ordinateurs modernes, les instructions les plus communes effectuent une opération arithmétique : une addition, une multiplication, une soustraction, etc. Les ordinateurs modernes sont donc de grosses calculettes très puissantes, capables d'effectuer des millions d'opérations par secondes.

Et qui dit opération dit nombres : un ordinateur gère nativement des nombres, qui sont codés en binaire sur la quasi-totalité des ordinateurs modernes. Les ordinateurs modernes sont capables de faire des calculs sur des nombres entiers, mais aussi des nombres à virgule. Il existe plusieurs manières de représenter des nombres en binaire, certaines représentant des nombres entiers dits naturels (0 et plus), d'autres des nombres signés (positifs ou négatifs), d'autres des nombres à virgule. Un chapitre entier détaillera comment sont encodés ces nombres.

Une instruction est représentée dans un ordinateur par une série de nombres entiers : un nombre qui indique quelle opération/commande effectuer et des autres nombres pour coder les données (ou de quoi les retrouver dans l'ordinateur). L'ordinateur récupére les commandes une par une, les traduit en opération à effectuer, exécuter l'opération, et enregistre le résultat. Puis il recommence avec la commande suivante.

[[File:Ordinateur Théorique Complexe 1.png|centre|vignette|upright=3|Ordinateur Théorique Complexe. En jaune, le programme informatique, la liste de commande. Le rectangle gris est l'ordinateur proprement dit.]]

De nombreux appareils sont programmables, mais tous ne sont pas des ordinateurs. Par exemple, certains circuits programmables nommés FPGA n'en sont pas. Pour être qualifié d'ordinateur, un appareil programmable doit avoir un processeur séparé de la mémoire. De plus, il doit utiliser un '''codage numérique''', chose que nous allons aborder dans le chapitre suivant.

===Les ordinateurs à programme mémorisé ou programme externe===

[[File:Blue-punch-card-front.png|vignette|upright=0.5|Carte Perforée.]]

Au tout début de l'informatique, les programmes étaient enregistrés sur des cartes perforées, à savoir des cartes en papier/plastique percées par endroits. Un 1 est codé par un trou dans le papier et un 0 par une absence de trou. Les programmes étaient exécutés par l'ordinateur quand on insérait la carte perforée dans le lecteur et qu'on appuyait sur un bouton.

Par la suite, les premiers ordinateurs grand public, comme les Amstrad ou les Commodore, utilisaient des cassettes audio magnétiques pour stocker les programmes. Dans le même style, les consoles de jeu utilisaient autrefois des cartouches de jeu, qui contenaient le programme du jeu à exécuter. Pour résumer, les anciens ordinateurs mémorisaient les programmes sur un support externe, lu par un périphérique. De tels ordinateurs sont dits à '''programme externe'''.

: D’anciens ordinateurs personnels, comme l’Amstrad ou le Commodore, permettaient de taper les programmes à exécuter à la main, au clavier, avant d’appuyer une touche pour les exécuter. Nul besoin de vous dire que les cassettes audio étaient plus pratiques.

Mais de nos jours, les programmes sont enregistrés sur le disque dur de l'ordinateur ou dans une mémoire intégrée à l'ordinateur. On dit qu'ils sont installés, ce qui est un mot bien compliqué pour dire que le programme est enregistré sur le disque dur de l’ordinateur. A défaut de disque dur, le programme/logiciel est enregistré dans une mémoire spécialisée pour le stockage. Par exemple, sur les cartes électroniques grand public de marque Arduino, les programmes sont envoyés à la carte via le port USB, mais les programmes sont enregistrés dans la carte Arduino, dans une mémoire FLASH dédiée. Disque dur ou non, le programme est mémorisé dans la mémoire de l'ordinateur. Il est possible d'installer ou de désinstaller les programmes en modifiant le contenu de la mémoire. Le terme utilisé est alors celui de '''programme stocké en mémoire'''.

Les programmes à installer sont disponibles soit sur un périphérique, comme un DVD ou une clé USB, soit sont téléchargés depuis internet. Les premiers PC fournissaient les logiciels sur des disquettes, qui contenaient un programme d'installation pour enregistrer le programme sur le disque dur de l'ordinateur. Par la suite, le support des logiciels a migré vers les CD et DVD, les logiciels devenant de plus en plus gros. De nos jours, la majorité des applications sont téléchargées depuis le net, l'usage de périphériques est devenu obsolète, même les consoles de jeu abandonnent cette méthode de distribution.

==Les générations d'ordinateurs : un historique rapide==

L'informatique a beaucoup évolué dans le temps. Et une bonne partie de cette évolution tient à l'évolution de l’électronique sous-jacente. Les ordinateurs actuels sont fabriqués avec des transistors, des petits composants électroniques qui servent d'interrupteurs programmables, qu'on détaillera dans ce qui suit. Mais ça n'a pas toujours été le cas. Et cela permet de distinguer plusieurs '''générations d'ordinateurs'''.

===Les ordinateurs électro-mécaniques : les premiers ordinateurs===

Le tout premier ordinateur est le '''Z1''', un modèle unique inventé par Konrad Suze entre 1936 et 1938. Son processeur gérait non pas des nombres entiers, mais des nombres à virgule (des nombres dits flottants, pour être précis), encodés sur 22 bits. Le processeur du Z1 était capable de faire des additions et des soustractions, car il intégrait un circuit additionneur-soustracteur basique. Des circuits annexes permettaient de faire des multiplications et des divisions en enchainant des additions/soustractions successives. Il fonctionnait à une fréquence de 1 Hz, ce qui fait qu'il pouvait faire une addition/soustraction par seconde maximum.

Niveau mémoire, la RAM de l'ordinateur était très limitée : seulement 16 nombres de 22 bits chacun. S'il s'agissait d'une mémoire électronique, les programmes étaient mémorisés sur une mémoire mécanique et précisémment sur des cartes perforées, à savoir des cartes en papier/plastique dans lesquelles un 1 est codé par un trou dans le papier et un 0 par une absence de trou. Les programmes étaient exécutés par l'ordinateur quand on insérait la carte perforée dans le lecteur et qu'on appuyait sur un bouton.

[[File:German Museum of Technology, Berlin 2017 024.jpg|centre|vignette|upright=2|Réplique du Z1 au ''German Museum of Technology'' de Berlin, 2017.]]

Après sa destruction dans un bombardement, le Z1 a été reconstruit et amélioré, ce qui donné les deux ordinateurs Z2 et Z3. Quelques années plus tard, quelques laboratoires de recherche ont fabriqués des ordinateurs dans leur coin, comme le Harvard Mark I et le Colossus Mark 1 (UK) qui ont été mis en service en 1944. Ils ont servi pour les cryptanalystes pour casser les codes utilisés par les Allemands pour leurs transmissions, pendant la seconde guerre mondiale.

Les ordinateurs cités dans le précédent paragraphe étaient tous des ordinateurs dit '''électro-mécaniques''', car ils mélangeaient des composants électroniques et des composants mécaniques (tout ce qui a trait aux cartes perforées, notamment). Les composants électroniques étaient généralement des relais, à savoir des interrupteurs commandables électriquement, qui sont plus ou moins équivalents aux transistors modernes. La majeure partie des ordinateurs des années 40 étaient de ce type, mais leur nombre n'a pas dépassé 30. Il faut dire qu'ils ont rapidement laissé la place à des ordinateurs purement électroniques, que nous allons voir dans ce qui suit.

===La première génération : les tubes à vide===

Les ordinateurs qui ont suivi les ordinateurs électromécaniques sont regroupés dans la '''première génération d'ordinateur'''. Ils étaient conçus avec des tubes à vide, des espèces d'interrupteurs commandables, les ancêtres des transistors modernes. Les tubes à vide étaient assez encombrants, ils consommaient beaucoup de courant, ils chauffaient et étaient assez peu fiables. Ils tombaient en panne assez souvent. Et ils étaient assez simples à fabriquer, mais restaient malgré tout chers.

Les tubes à vide sont des ampoules à filament améliorées. Pour rappel, les ampoules à filament étaient des ampoules en verre dans lesquelles on plaçait un filament métallique. Le filament chauffait quand on envoyait du courant dedans et émettait de la lumière. Mais dans les tubes à vide, le filament n'émet pas de lumière quand on le chauffe : il émet des électrons, de l'électricité. De plus, ils ajoutent une électrode, une plaque en métal qui émet ou capte des électrons. Ici, l'électrode capte des électrons émis par le filament quand il chauffe. Vu qu'elle capte des électrons, on l'appelle l''''anode'''.

Le résultat est un circuit qui laisse passer le courant, mais seulement dans un sens : du filament vers l'anode, l'autre sens n'est pas possible vu que l'anode ne peut pas émettre d'électrons. Un tel circuit est appelé une '''diode'''.

Une amélioration des tubes à vide précédent rajoute une seconde plaque de métal, appelée la '''cathode''', située juste après le filament. C'est elle qui émet les électrons, , mais seulement si elle est chauffée par le filament. Le filament doit donc chauffer, ce qui réchauffe la cathode, qui elle-même émet des électrons en direction de l'anode.

{|
|[[File:Diode à vide.png|vignette|upright=1.5|Diode à vide, avec cathode.]]
|[[File:Diode à vide schéma de fonctionnement.png|vignette|upright=1.5|Diode à vide, schéma de fonctionnement. Le filament X chauffe la cathode (2), qui émet des électrons (3), vers l'anode (4).]]
|}

Les tubes à vide précédent peuvent être modifiés en ajoutant une grille métallique entre la cathode et l'anode. La grille est alimentée avec une tension électrique, ce qui la charge électriquement. Suivant sa charge, elle laisse plus ou moins passer les électrons de la cathode vers l'anode. Si elle n'est pas chargée, que la tension est de 0 Volts, elle ne fera pas obstacle aux électrons et le tube à vide fonctionnera comme une diode basique. Mais si la grille est chargée avec une tension négative, sa charge électrique va repousser les électrons et les empêcher de passer de la cathode vers l'anode. Le tube à vide se comportera alors comme un interrupteur : fermé ou ouvert suivant ce qu'on met sur la grille. De tels interrupteurs commandables électriquement sont combinés pour fabriquer des circuits plus élaborés, comme les portes logiques qu'on verra d'ici quelques chapitres.

[[File:Triode.png|centre|vignette|upright=1.5||Triode]]

Les tubes à vides étaient utilisés pour le processeur et quelques circuits annexes, mais les mémoires utilisaient d'autres technologies. Les mémoires de l'époque n'étaient pas du tout des mémoires électroniques. Il existait déjà des ancêtres des disques durs, à savoir des mémoire magnétiques appelées tambours magnétiques, bandes magnétiques, mémoires à tore de ferrite, etc. Les mémoires RAM, quant à elles, utilisaient elles des technologies totalement abandonnées : les mémoires à lignes de délai étaient des mémoires acoustiques, les tubes Williams étaient des écrans CRT modifiés, etc. Un chapitre entier sera dédié aux technologies des mémoires de l'époque.

[[File:Elektronenroehren-auswahl.jpg|centre|vignette|upright=2|Tubes à vides.]]

L'usage de tubes à vide les place entre les premiers ordinateurs électro-mécaniques et les ordinateurs utilisant des transistors. Au vu de la taille des tubes à vide, les ordinateurs de l'époque étaient composés de plusieurs milliers de ces tubes, guère plus. Et malgré cela, un ordinateur prenait facilement un étage de bâtiment entier, ou au moins plusieurs pièces. La conséquence est que les ordinateurs de première génération étaient très simples, rudimentaires quand on les compare aux ordinateurs modernes. Ils ne géraient que quelques opérations simples : l'addition, la soustraction, pas grand-chose de plus. À quelques exceptions près, ils ne géraient pas la multiplication et encore moins la division, cela aurait demandé trop de tubes à vides.

Une des toutes premières machines construite avec des tubes à vide était l'Atanasoff–Berry. Ce n'était pas un ordinateur, car elle ne pouvait pas exécuter de programme sans intervention humaine pour séquencer des opérations, mais c'était la première machine de calcul purement électronique, sans aucune pièce mécanique. Elle utilisait une mémoire RAM construite avec des condensateurs, ceux-ci étant placés sur des cylindres tournants. Les circuits de calcul étaient construits avec des tubes à vide et faisaient leur travail un bit à la fois. Elle fonctionnait à une fréquence de 60 Hz et pouvait faire 30 additions/soustractions par seconde. Les nombres étaient encodés sur 50 bits. 

[[File:Atanasoff Berry Computer.gif|centre|vignette|upright=2.5|Atanasoff–Berry.]]

L'arrivée de l'ENIAC en 1945 a changé la donne. Cet ordinateur a introduit plusieurs innovations majeures. La première est assez technique, il s'agit de la turing-complétude, elle a trait aux programmes qui peuvent être écrit pour un ordinateur, nous ne la détaillerons pas ici.

[[File:BabyArchitecture.png|vignette|Architecture de la Manchester Baby.]]

En 1948, le ''Manchester Baby'' a introduit une innovation extrêmement importante : le programme n'était plus mémorisé sur des cartes perforées, mais dans une mémoire électronique à l’intérieur de l'ordinateur lui-même. En clair, le ''Manchester Baby'' était le premier '''ordinateur à programme stocké en mémoire''' en français. Au-delà de ça, le Manchester Baby restait quand même très simple, c'était limite un prototype.

Niveau interface, l'ordinateur avait une console avec 32 boutons, des interrupteurs et un écran de sortie sur lequel afficher les résultats. A l'intérieur, il y avait un processeur et une RAM de 32 nombres de 32 bits, fabriquées avec des tubes Williams (abordés dans une annexe à la fin du cours). Une instruction prenant autant de place qu'un nombre en RAM, ce qui limitait les programmes à 32 instructions maximum. Le processeur gérait 8 instructions en tout, mais la seule instruction de calcul qu'il gérait était la soustraction. L'addition n'était pas supportée. Il pouvait cependant émuler l'addition à partir d'une soustraction et inversant l'opérande soustrait.

Le Manchester Mark 1 était une amélioration du Manchester Baby. Il utilisait 4500 tubes à vide. L'ordinateur gérait des nombres de 40 bits, mais les instructions étaient codées sur 20 bits. La RAM avait la même taille, à savoir 32 nombres, leur taille était simplement augmentée. Par contre, la RAM était complémentée par l’ancêtre du disque dur magnétique, à savoir un tambour magnétique, l’ancêtre du disque dur magnétique. Il contenait 40 pages, chacune ayant la même taille que la RAM. Contrairement à la Manchester Baby, son processeur gérait l'addition. Les multiplications étaient réalisées par des additions successives, mais le processeur intégrait des registres pour mémoriser les opérandes à multiplier.

Par la suite, les ordinateurs commerciaux ont vu le jour. Les ordinateurs précédents provenaient de projets de recherches, souvent publics. Mais les entreprises privées se sont mises à fabriquer des ordinateurs elle-mêmes, pour les vendre à d'autres entreprises. On peut notamment citer les ordinateurs comme le UNIVAC I, le Bull Gamma 3 ou les premiers ordinateurs IBM. La performance de ces ordinateurs était nettement plus importante que leurs prédécesseurs, avec des fréquences de l'ordre de la centaine de kilo-hertz. Par exemple, le Bull Gamma 3 allait à 281 kHz, l'IBM 650 allait à 50 Khz.

===La seconde génération : le remplacement des tubes à vides par des transistors===

[[File:IBM 7070.jpg|vignette|Cartes imprimées de l'IBM 704, avec des transistors et résistances dessus.]]

La '''seconde génération''' est celle des ordinateurs fabriqués avec des '''transistors''' isolés, reliés entre avec des fils électriques. Les transistors en question possèdent trois broches, des pattes métalliques sur lesquelles on connecte des fils électriques. Le transistor s'utilise le plus souvent comme un interrupteur commandé par sa troisième broche. Le courant qui traverse les deux premières broches passe ou ne passe pas selon ce qu'on met sur la troisième.

[[File:Transistor basic flow.svg|centre|vignette|Un transistor est un morceau de conducteur, dont la conductivité est contrôlée par sa troisième broche/borne.]]

Les ordinateurs de seconde génération avaient entre 1000 et 500 000 transistors. Les capacités des ordinateurs étaient donc nettement supérieures à celles des ordinateurs de première génération. Une part non négligeable des ordinateurs de seconde génération supportait l'opération de multiplication, absente sur les ordinateurs de première génération. Néanmoins, cela variait beaucoup selon les ordinateurs.

Un exemple assez hors du commun est celui du premier modèle de l'IBM 1620. Le tout premier modèle n'avait aucun circuit de calcul, il n'était même pas capable de faire une addition ou une multiplication. A la place, il utilisait une table d'addition et une table de multiplication en mémoire RAM. Les deux tables devaient être initialisées par le logiciel lors du démarrage de la machine. La table d'addition faisait une centaine de chiffres, la table de multiplication faisait le double. Le processeur de l'ordinateur gérait des instructions pour faire des additions ou des multiplications, mais ces opérations lisaient le résultat dans la table d'addition. Les calculs étaient faits chiffre par chiffre, avec un encodage partiellement décimal, partiellement binaire (des chiffres décimaux étaient encodés en binaire, nous en reparlerons quand nous parlerons du BCD) !

[[File:KL CoreMemory.jpg|vignette|Mémoire à tore de ferrite.]]

Les transistors n'étaient utilisés que pour le processeur et les circuits annexes. La mémoire n'était pas faite en transistors, pas à cette époque. La mémoire était une mémoire aujourd'hui abandonnée, appelée une '''mémoire à tores de ferrite'''. Elle sera détaillée dans un chapitre ultérieur. Mais sachez pour le moment qu'il s'agit d'une mémoire au support magnétique, les données étant stockées sur un support magnétique.

Les transistors étaient au départ de la même taille que les tubes à vide, mais ils ont rapidement rétrécit. Ils prenaient encore beaucoup de place dans les 60-70, ce qui fait que les ordinateurs étaient assez gros. Concrètement, ils prenaient une pièce de bâtiment entière dans le meilleur des cas. C'était l'époque des gros ''mainframes'', reliés à des terminaux, peu puissants comparé aux standards actuels. Seules les grandes entreprises et les grands instituts de recherche pouvaient se payer les services de ce genre d'ordinateurs. Seuls les professionnels avaient accès à ce genre d'équipement.

===La troisième génération : le circuit intégré===

[[File:D8259AC-2.jpg|vignette|Exemple de circuit intégré.]]

La troisième génération est toujours fabriquée avec des transistors, mais dont la taille a été réduite. Avec l'évolution de la technologie, les transistors ont diminué en taille, de plus en plus. Ils sont devenus tellement petits qu'ils ont fini par être regroupés dans des '''circuits intégrés''', des circuits regroupent plusieurs transistors sur la même puce de silicium. Les circuits intégrés se présentent le plus souvent sous la forme de boitiers rectangulaires, comme illustré ci-contre. D'autres ont des boitiers de forme carrées, comme ceux que l'on peut trouver sur les barrettes de mémoire RAM, ou à l'intérieur des clés USB/ disques SSD.

Lors de cette génération, les processeurs étaient fournis en pièces détachées qu'il fallait relier entre elles. Le processeur était composé de plusieurs circuits intégrés séparés, impossible de mettre un processeur dans un seul boitier. Un exemple de processeur conçu en kit est la série des Intel 3000. Elle regroupe plusieurs circuits séparés aux noms à coucher dehors, mais dont vous comprendrez ce qu'ils veulent dire dans les chapitres adéquats : l'Intel 3001 est un séquenceur, l'Intel 3002 regroupe unité de calcul et registres, le 3003 est un circuit d'anticipation de retenue complémentaire du 3002, le 3212 est une mémoire tampon, le 3214 est une unité de gestion des interruptions, les 3216/3226 sont des interfaces de bus mémoire. On pourrait aussi citer la famille de circuits intégrés AMD Am2900.

Même si le processeur était en pièces détachées, utiliser une dizaine de circuits intégrés était nettement mieux que d'utiliser plusieurs milliers de transistors individuels. En conséquence, les ordinateurs ont vu leur taille grandement réduite, passant de pièces entières à une simple armoire, voire à quelques cartes intégrées superposées. De plus, le prix des circuits intégré était abordable, du moins comparé aux ordinateurs d'avant. Le prix des ordinateurs a alors grandement décru, permettant à des entreprises et administrations de taille modeste de s'équiper d'ordinateurs.

===La quatrième génération : le microprocesseur===

[[File:MOS6502.svg|vignette|Microprocesseur, ici un processeur MOS6502, de la quatrième génération.]]

Lors de la troisième génération, les circuits intégrés regroupaient plusieurs dizaines ou centaines de transistors, mais sont rapidement montés en gamme. De centaines de transistors, ils sont passés au millier de transistors, puis au million et maintenant au-delà du milliard. Les transistors étaient devenus tellement petits, tellement miniaturisés, qu'il était devenu possible de mettre un processeur entier dans un circuit intégré. C'est ainsi qu'est né le microprocesseur, à savoir un processeur qui tient tout entier dans un seul circuit imprimé. La quatrième génération d’ordinateur est celle des ordinateurs basés autour d'un microprocesseur.

Les tout premiers microprocesseurs étaient des processeurs à application militaire, comme le processeur du F-14 CADC ou celui de l'Air data computer. Le tout premier microprocesseur commercialisé au grand public est le 4004 d'Intel, sorti en 1971. L'intel 4004 comprenait environ 2300 transistors, avait une fréquence de 740 MHz, pouvait faire 46 opérations différentes, et manipulait des entiers de 4 bits. Il était au départ un processeur de commande, prévu pour être intégré dans la calculatrice Busicom calculator 141-P, mais il fut utilisé pour d'autres applications quelque temps plus tard. Immédiatement après le 4004, les premiers microprocesseurs 8 bits furent commercialisés. Le 4004 fut suivi par le 8008 et quelques autres processeurs 8 bits extrêmement connus, comme le 8080 d'Intel, le 68000 de Motorola, le 6502 ou le Z80.

Les microprocesseurs permirent encore uen fois de réduire la taille des ordinateurs, qui pouvaient tenir dans un boitier de PC, ou un boitier de console de jeu. Le prix des ordinateurs a aussi chuté en même temps que les transistors étaient miniaturisés. C'est cette invention qui permis l'invention des consoles de jeux et des mini-ordinateurs, à savoir les ordinateurs personnels. Sans miniaturisation, on n'aurait pas d'ordinateur personnel, pas de PC fixe ou portable.

==L'organisation du cours : les différents niveaux d'explication==

Le fonctionnement d'un ordinateur est assez complexe à expliquer car les explications peuvent se faire sur plusieurs niveaux. Par plusieurs niveaux, on veut dire qu'un ordinateur est composé de composants très simples, qui sont assemblés pour donner des composants eux-même plus complexes, qui sont eux-même regrouper, etc. Étudier tout cela demande de voir plusieurs niveaux, allant de transistors très petits à des processeurs multicœurs. Les niveaux les plus bas sont de l'électronique pur et dure, alors que ceux plus haut sont à mi-chemin entre électronique et informatique.

===Les niveaux d'abstraction en architecture des ordinateurs===

Les trois premiers niveaux sont de l'électronique pur et dure. Ils correspondent aux premiers chapitres du cours, qui porteront sur les circuits électroniques en général.
* Le premier niveau est celui des '''transistors''', des circuits intégrés, des ''wafer'' et autres circuits de très petite taille.
* Le second niveau est celui des '''portes logiques''', des circuits très basiques, très simples, à la base de tous les autres.
* Le troisième niveau est celui dit de la '''''Register Transfer Level''''', où un circuit électronique est construit à partir de circuits basiques, dont des registres et autres circuits dits combinatoires.
Les deux niveaux suivants sont de l'informatique proprement dit. C'est dans ces deux niveaux qu'on étudie les ordinateurs proprement dit, les circuits qu'il y a dedans et non l'électronique en général.
* Le quatrième niveau est celui de la '''microarchitecture''', qui étudie ce qu'il y a à l'intérieur d'un processeur, d'une mémoire, des périphériques et autres.
* Le cinquième niveau est celui de l''''architecture externe''', qui décrit l'interface du processeur, de la mémoire, d'un périphérique ou autre. Par décrire l'interface, on veut dire : comment un programmeur voit le processeur et la mémoire, comment il peut les manipuler. Une architecture externe unique peut avoir plusieurs microarchitecture, ce qui fait qu'on sépare les deux. Tout cela sera plus clair quand on passera aux chapitres sur le processeur et les mémoires.

Nous n'allons pas voir les 5 niveaux dans l'ordre, des transistors vers l'architecture externe. En réalité, nous allons procéder autrement. La première partie du cours portera sur les trois premiers niveaux, le reste sur les deux autres. Les 5 niveaux seront vus dans des chapitres séparés, du moins le plus possible. Au niveau pédagogique, tout est plus simple si on scinde les 5 niveaux. Bien sûr, il y a quelques explications qui demandent de voir plusieurs niveaux à la fois. Par exemple, dans le chapitre sur les mémoires caches, nous auront des explications portant sur la RTL, la microarchitecture du cache et son architecture externe. Mais le gros du cours tentera de séparer le plus possible les 5 niveaux.

===Les trois parties principales du cours===

Nous allons commencer par parler du binaire, avant de voir les portes logiques. Avec ces portes logiques, nous allons voir comment fabriquer des circuits basiques qui reviendront très souvent dans la suite du cours. Nous verrons les registres, les décodeurs, les additionneurs et plein d'autres circuits. Puis, nous reviendrons au niveau des transistors pour finir la première partie. La raison est que c'est plus simple de faire comme cela. Tout ce qui a trait aux transistors sert à expliquer comment fabriquer des portes logiques, et il faut expliquer les portes logiques pour voir le niveau de la RTL.

Une fois la première partie finie, nous allons voir les différents composants d'un ordinateur. Une première partie expliquera ce qu'il y a dans un ordinateur, quels sont ses composants. Nous y parlerons de l'architecture de base, de la hiérarchie mémoire, des tendances technologiques, et d'autres généralités qui serviront de base pour la suite. Puis, nous verrons dans l'ordre les bus électroniques, les mémoires RAM/ROM, le processeur, les périphériques, les mémoires de stockage (SSD et disques durs) et les mémoires caches. Pour chaque composant, nous allons voir leur architecture externe, avant de voir leur microarchitecture. La raison est que la microarchitecture ne peut se comprendre que quand on sait quelle architecture externe elle implémente.

Enfin, dans une troisième partie, nous allons voir les optimisations majeures présentes dans tous les ordinateurs modernes, avec une partie sur le pipeline et le parallélisme d'instruction, et une autre sur les architectures parallèles. Pour finir, les annexes de fin parlerons de sujets un peu à part.

&lt;noinclude&gt;
{{NavChapitre | book=Fonctionnement d'un ordinateur
           | next=L'encodage des données
           | nextText=L'encodage des données
}}
&lt;/noinclude&gt;</text>
      <sha1>578yd676ktcvh2bsq6zh99cen4iu2u6</sha1>
    </revision>
    <revision>
      <id>744170</id>
      <parentid>744169</parentid>
      <timestamp>2025-06-05T15:41:34Z</timestamp>
      <contributor>
        <username>Mewtow</username>
        <id>31375</id>
      </contributor>
      <minor />
      <comment>/* La première génération : les tubes à vide */</comment>
      <origin>744170</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="49600" sha1="mgot873unhnil3b2yrcrl19776ipzzy" xml:space="preserve">Pour commencer, nous allons voir qu'il existe de nombreux types d'ordinateurs. Le plus connu est certainement le PC, l'ordinateur personnel, que vous avez sans doute dans votre salon. Les ordinateurs portables sont un deuxième type d'ordinateur assez intuitif, que vous avez peut-être. Mais il y a aussi d'autres types d'ordinateurs auxquels vous n'avez jamais été confrontés.

==Les différents types d'ordinateurs==

Dans cette section, nous allons décrire rapidement les ordinateurs les plus courant, mais surtout voir ce qu'il y a à l'intérieur d'un ordinateur.

===L'ordinateur de type PC fixe===

De l'extérieur, l'ordinateur est composé d'une unité centrale sur laquelle on branche des périphériques.

[[File:Typical computer architecture systems.jpg|vignette|upright=1.5|Exemples de périphériques, connectés à une unité centrale (ici appelée à tort ''operating system'').]]

Les '''périphériques''' regroupent l'écran, la souris, le clavier, l'imprimante, et bien d'autres choses. Ils permettent à l'utilisateur d'interagir avec l'ordinateur : un clavier permet de saisir du texte sous dans un fichier, une souris enregistre des déplacements de la main en déplacement du curseur, un écran affiche des données d’images/vidéos, un haut-parleur émet du son, etc. Tout ce qui est branché sur un ordinateur est, formellement un périphérique.

L''''unité centrale''' est là où se trouvent tous les composants importants d'un ordinateur, ceux qui font des calculs, qui exécutent des logiciels, qui mémorisent vos données, etc. Voici ce à quoi ressemble l'intérieur de l'unité centrale. Trois sections sont visibles : l'alimentation électrique en haut à gauche, la carte mère en bas à gauche et en jaune/orange, les disques et lecteurs à droite des câbles. Et on voit aussi beaucoup de câbles.

[[File:Asus P5K-SEIntel E6320.jpg|centre|vignette|upright=2|Exemple d'unité centrale.]]

Tout en haut à gauche, se trouve l''''alimentation électrique''', qui convertit le courant de la prise électrique en un courant plus faible, utilisable par les autres composants. Elle émet de nombreux câbles assez gros, qui sont reliés au reste. Les PC actuels utilisent des alimentations électriques standardisées, qui fournissent trois tensions au reste de l'ordinateur : une tension de 12 Volts, une de 5 Volts, une de 3,3 Volts.

À droite, caché par la partie &quot;métallique&quot; du boitier, se trouvent les lecteurs de CD/DVD, et les disques durs. Les lecteurs CD-ROM ou DVD-ROM permettaient de lire des CD ou des DVD. Je parle au passé, car ils ont aujourd'hui disparu des ordinateurs modernes. Les '''disques durs''' sont des mémoires de stockage, qui mémorisent vos données de manière permanente. De nos jours, ils sont remplacés par des SSD, qui sont des disques durs électroniques, là où les disques durs proprement dit sont des mémoires magnétiques. Nous verrons la différence dans deux chapitres dédiés, un sur les disques durs, l'autre sur les SSD.

En bas à droite, se trouve la '''carte mère''' un support plat, en plastique ou en céramique, sur laquelle sont soudés/connectés les autres composants. Sur celle-ci, de nombreux composants sont soudés, d'autres sont branchés dessus avec des câbles, d'autres sont connectés dessus avec des connecteurs. Ils sont reliés entre eux par des fils conducteurs, le plus souvent du cuivre ou de l’aluminium, ce qui leur permet de s’échanger des données. Sur les cartes simples, ces fils sont intégrés dans la carte électronique, dans des creux du plastique. Ils portent le nom de pistes.

Avant, les disques durs, SSD et lecteurs de CD/DVD sont branchés dessus via des connecteurs dédiés, appelés des connecteurs S-ATA. De nos jours, ils sont branchés sur un autre connecteur, grâce à l'interface NVME. Toujours est-il qu'ils sont reliés à la carte mère par des câbles, ce qui montre que ce sont des sortes de périphériques interne. Ils sont placés dans le boitier, mais on aurait tout aussi bien pu les mettre à l'extérieur, vu qu'ils communiquent avec l'ordinateur par l'intermédiaire d'un câble ou d'un connecteur dédié.

Mais deux autres composants très importants sont eux placés sur la carte mère, directement. Ils ont chacun un connecteur dédié, sur lequel ils sont branchés directement, sans passer par l'intermédiaire d'un câble, mais sans être soudés non plus. Il s'agit du processeur et de la mémoire RAM, deux composants centraux des PC modernes.

[[File:Pentium III SL4CB.jpg|thumb|Processeur Pentium III.]]

Le '''processeur''' traite les données, les modifie, les manipule. Pour faire simple, il s’agit d’une grosse calculatrice hyper-puissante. Il comprend à la fois un circuit qui fait des calculs, et un circuit de contrôle qui s'occupe de séquencer les calculs dans l'ordre demandé. Il est souvent caché sous un radiateur, lui-même surmonté par un ventilateur. En effet, un processeur chauffe beaucoup, ce qui demande d'évacuer cette chaleur. Un chapitre entier expliquera pourquoi les processeurs chauffent, ainsi que les techniques utilisées pour limiter leur production de chaleur et leur consommation électrique.

La '''mémoire vive''' conserve des informations/données temporairement, tant que le processeur en a besoin. Elle prend la forme de barrettes de RAM, comme montré ci-dessous.

[[File:2 gb ddr2 667.jpg|centre|vignette|upright=2|Barrette de RAM.]]

Outre ces composants dits principaux, un ordinateur peut comprendre plusieurs composants moins importants, surtout présents sur les ordinateurs personnels. Ils sont techniquement facultatifs, mais sont très présents dans les ordinateurs personnels. Cependant, certains ordinateurs spécialisés s'en passent. Il s'agit des diverses '''cartes d'extension''' sont branchées sur la carte mère. Elles permettent d’accélérer certains calculs ou certaines applications, afin de décharger le processeur. Par exemple, la carte graphique s'occupe des calculs graphiques, qu'il s'agisse de graphismes 3D de jeux vidéos ou de l'affichage en 2D du bureau. Dans un autre registre, la carte son prend en charge le microphone et les haut-parleurs.

[[Fichier:Personal computer, exploded 4.svg|thumb|upright=1.0|Éclaté d'un ordinateur de type PC :&lt;br /&gt;
1 : Écran ;&lt;br /&gt;
2 : Carte mère ;&lt;br /&gt;
3 : Processeur ;&lt;br /&gt;
4 : Câble Parallel ATA ;&lt;br /&gt;
5 : Mémoire vive (RAM) ;&lt;br /&gt;
6 : Carte d'extension ;&lt;br /&gt;
7 : Alimentation électrique ;&lt;br /&gt;
8 : Lecteur de disque optique ;&lt;br /&gt;
9 : Disque dur ;&lt;br /&gt;
10 : Clavier ;&lt;br /&gt;
11 : Souris.]]

Si on regarde une carte mère de face, on voit un grand nombre de connecteurs, mais aussi des circuits électroniques soudés à la carte mère.

[[File:Architecture matérielle d'une carte mère.png|centre|vignette|upright=2.0|Architecture matérielle d'une carte mère]]

Les '''connecteurs''' sont là où on branche les périphériques, la carte graphique, le processeur, la mémoire, etc. Dans l'ensemble, toute carte mère contient les connecteurs suivants :
* Le processeur vient s’enchâsser dans la carte mère sur un connecteur particulier : le '''socket'''. Celui-ci varie suivant la carte mère et le processeur, ce qui est source d'incompatibilités.
* Les barrettes de mémoire RAM s’enchâssent dans un autre type de connecteurs: les '''slots mémoire'''.
* Les mémoires de masse disposent de leurs propres connecteurs : connecteurs P-ATA pour les anciens disques durs, et S-ATA pour les récents.
* Les périphériques (clavier, souris, USB, Firewire, ...) sont connectés sur un ensemble de connecteurs dédiés, localisés à l'arrière du boitier de l'unité centrale. 
* Les autres périphériques sont placés dans l'unité centrale et sont connectés via des connecteurs spécialisés. Ces périphériques sont des cartes imprimées, d'où leur nom de '''cartes filles'''. On peut notamment citer les cartes réseau, les cartes son, ou les cartes vidéo.

===Les ordinateurs portables===

[[File:Samsung QX-511 (2).JPG|vignette|Ordinateur portable Samsung QX-511 (2), pour illustration.]]

Un ordinateur portable est identique à un ordinateur de type PC. Si vous ouvrez votre ordinateur portable (attention à la garantie), vous retrouverez les mêmes composants qu'un PC à l'intérieur. Un point important est la présence d'une batterie à l'intérieur du PC portable, absente des PC fixes.

[[File:LG gram 14Z90Q mainboard with battery.jpg|centre|vignette|upright=2|LG gram 14Z90Q avec sa batterie.]]

Une fois la batterie et les circuits associés retiré, la seule différence notable est que tous les composants sont soudés sur la carte mère, au lieu d'être branchés sur des connecteurs, à part éventuellement la RAM et le disque dur.

[[File:LG gram 14Z90Q mainboard without battery.jpg|centre|vignette|upright=2|LG gram 14Z90Q sans sa batterie.]]

La RAM est parfois soudée sur la carte mère, d'autres fois sous la forme de barrettes de mémoire vive semblables à celles des PC. Dans le dernier cas, elle est connectée à des connecteurs spécifiques, ce qui permet de les changer/upgrader. Les PC portables sont parfois construits de manière à pouvoir changer la RAM facilement, en ouvrant un cache spécial, concu pour.

[[File:Lenovo G555 состав - Донор.JPG|centre|vignette|upright=2|Lenovo G555.]]

La conception d'un ordinateur portable est légèrement différente de celle d'un PC, pour des raisons thermiques. Un PC fixe a plus de place pour évacuer sa chaleur. Les ventilateurs peuvent plus facilement déplacer l'air dans le boitier, même si le flux d'air dans le boitier est éventuellement gêné par la carte graphique. Mais l'évacuation de la chaleur est assez efficace. Sur les PC portables, leur finesse fait que le trajet de l'air est beaucoup plus contraint. Évacuer la chaleur produite par l'ordinateur est plus complexe, ce qui demande d'utiliser des systèmes de refroidissement et de ventilation spécifiques.

Là où les PC fixes se débrouillent avec des radiateurs et des ventilateurs posés sur le processeur, les PC portables font autrement. Ils ne peuvent pas forcément mettre le ventilateur sur le processeur. A la place, ils mettent le ventilateur à côté, mais le processeur est surmonté par un mécanisme de transmission de la chaleur, qui transfère la chaleur du processeur vers le ventilateur.

[[File:Diagram - How a laptop cooling system works.png|centre|vignette|upright=2|Comment fonctionne le système de ventilation d'un ordinateur portable, en anglais.]]

Les difficultés pour dissiper la chaleur font que les ordinateurs portables utilisent souvent des composants peu performants, mais qui chauffent peu. En effet, nous verrons que plus un composant est puissant, plus il chauffe. La relation n'est pas parfaite, mais les processeurs haute performance chauffent plus que les modèles d'entrée ou milieu de gamme moins puissants. En conséquence, les PC portables sont souvent moins puissants que les PC fixes, même pour les modèles dit ''gaming''.

===Les serveurs et ''mainframes''===

Les grandes entreprises utilisent des ordinateurs de grande taille, très puissants, appelés des ''mainframes''. Ils sont souvent confondus avec les serveurs par le grand public, il y a une différence entre les deux. Un serveur est une fonction logicielle/réseau, pas un type d'ordinateur. Mais laissons cette différence de côté, ce qui est dit pour les ''mainframes'' sert pour les gros serveurs haute performance.

[[File:IBM Z15 mainframe.jpg|vignette|Exemple de ''mainframe''' de type IBM Z15.]]

Les anciens ''mainframes'' des années 50-80 avaient une taille pouvant être impressionnante, au point de prendre une pièce complète d'un bâtiment. Mais de nos jours, les ''mainframes'' tiennent dans une grosse armoire un peu haute. Les ''mainframes'' doivent rester allumé en permanence et ne doivent pas être éteint, sauf éventuellement quelques jours par an pour des opérations de maintenance. Ils utilisent pour cela des techniques spécifiques, avec beaucoup de redondance interne.

[[File:ACONIT hall grandes machines.jpg|centre|vignette|upright=2|''Mainframe'' ACONIT.]]

Les ''mainframes'' sont aussi conçus pour mutualiser au maximum leur utilisation, ils peuvent être utilisés par plusieurs utilisateurs à la suite, voire en même temps. Pour cela, les anciens ''mainframes'' étaient capables de faire tourner plusieurs applications distinctes l'une à la suite de l'autre, avec des commutations fréquentes entre logiciels. De nos jours, ils sont capables d'exécuter un grand nombre de tâches en même temps, grâce à la présence de plusieurs processeurs. Les ''mainframes'' modernes sont même capables de faire tourner plusieurs systèmes d'exploitation en même temps si besoin.

Les anciens ''mainframes'' étaient des ordinateurs assez simples, avec un processeur, de la mémoire RAM, un ou plusieurs disques durs, pas plus. Le ''mainframe'' était tellement énorme et cher que les entreprises n'en avaient qu'un seul pour toute l'entreprise. Les employés avaient sur leur bureau des terminaux, qui permettaient d'accéder à l'ordinateur central, mais n'étaient pas des ordinateurs. Les terminaux étaient des composants électroniques simples, avec un écran, un clavier et une souris, mais sans processeur. Ils envoyaient des données au ''mainframe'', ils en recevaient de sa part, mais tout traitement était réalisé sur le ''mainframe''. L'arrivée sur le marché des ordinateurs personnels, de type PC fixe/portable, a entrainé l'abandon de ce genre de pratique, tous les employés ont maintenant un ordinateur rien que pour eux.

{|
|-
! colspan=&quot;2&quot; | Exemples de terminaux
|-
|[[File:Terminal-in2-sm9400.jpg|centre|vignette|upright=1.5|Exemple de terminal. Notez la présence d'un écran et d'un clavier, mais l'asbence d'une unité centrale.]]
|[[File:Chromatics CT4100.jpg|vignette|upright=1.5|Autre exemple de terminal. Le clavier est couplé à un stylo CRT, qui remplacait la souris et agissait sur l'écran comme s'il était tactile.]]
|-
! colspan=&quot;2&quot; | Intérieur d'un terminal
|-
|[[File:CT1024 Monitor.jpg|vignette|upright=1.5|Terminal CT1024, sans le boitier extérieur.]]
|[[File:CT1024 Terminal System.jpg|vignette|upright=1.5|Terminal CT1024, description des composants interne.]]
|}

De nos jours, les ''mainframes'' contiennent en réalité plusieurs ordinateurs simples interconnectés via un réseau local. Un ''mainframe'' qui tient dans une armoire contient facilement une dizaine ou centaine de processeurs, plein de RAM, des disques durs séparés dans une armoire distincte, etc. Vu qu'ils communiquent uniquement via le réseau, ils n'ont pas d'interface, pas d'écran, 'entrée via clavier/souris. Le tout est commandé avec une console de commande, typiquement un ordinateur portable ou un terminal assez simple séparé de l'armoire, qui permet à un administrateur de faire des opérations de surveillance, configuration et maintenance. Il peut y avoir une console de commande pour plusieurs armoires séparées, la console peut même être dans un autre bâtiment et accéder au ''mainframe'' par le réseau.

[[File:IBM System Z9 (type 2094 inside).jpg|centre|vignette|upright=2|''Mainframe'' de type IBM System Z9. L'ordinateur portable sert de console pour qu'un administrateur fasse des opérations de surveillance, configuration et maintenance.]]

Les processeurs et la RAM sont typiquement installés sur des cartes amovibles, qui sont connectées au fond de l'armoire lors de l'installation. Il est même possible de retirer ou d'ajouter des cartes en fonctionnement, afin d'ajouter/retirer des processeurs, des disques durs, etc. Ce qui est très utile si un composant est en panne et qu'il faut le remplacer. 

[[File:IBM TotalStorage Exp400.jpg|centre|vignette|upright=2|IBM TotalStorage Exp400]]

==Un peu d'abstraction : qu'est-ce qu'un ordinateur ?==

Un ordinateur comprend donc un processeur, plusieurs mémoires, des cartes d'extension et une carte mère pour connecter le tout. Mais il s'agit là d'une description assez terre-à-terre de ce qu'est un ordinateur. Une autre description, plus abstraite, se base sur le fait qu'un ordinateur est une énorme calculatrice programmable. Elle permet d'expliquer pourquoi il y a une distinction entre processeur et mémoire, entre unité centrale et périphériques. Tout ce qui va suivre pourra vous paraitre assez abstrait, mais rassurez-vous : les prochains chapitres rendront tout cela plus concrets.

===La séparation entre entrées-sorties et traitement===

L'unité centrale peut être vue comme une énorme calculatrice ultra-puissante, qui exécute des commandes/opérations. Mais à elle seule, elle ne servirait à rien, il faut interagir avec par l'intermédiaire de plusieurs périphériques. Il existe deux types de périphériques, qui sont conceptuellement différents. Les périphériques comme le clavier ou la souris permettent d'envoyer des informations à l'ordinateur, d'agir sur celui-ci. A l'inverse, les écrans transmettent des informations dans le sens inverse : de l'ordinateur vers l'utilisateur. Les premiers sont appelés des '''entrées''', les seconds des '''sorties'''.

Dans un ordinateur, les informations sont représentées sous la forme de nombres. Toute donnée dans un ordinateur est codée avec un ou plusieurs nombres regroupés dans une donnée, un fichier, ou autre. Et la transmissions avec les entrées et sorties se fait là-encore avec des nombres. Par exemple, quand vous appuyez sur votre clavier, le clavier envoie un numéro de touche à l'unité centrale, qui indique quelle touche a été appuyée. L'image à afficher à l'écran est codée sous la forme d'une suite de nombres (un par pixel). L'image est envoyée à l'écran, qui traduit la suite de nombre en image à afficher. Les entrées traduisent des actions utilisateurs en nombres, on dit que les entrées encodent les actions utilisateur. Les sorties font la traduction inverse, elles transforment des suites de nombres en une action physique. On dit qu'elles décodent des informations.

Pour résumer, toute appareil électronique est composé par :
* Des '''entrées''' sur lesquelles l'utilisateur agit sur l'ordinateur. Les entrées transforment les actions de l'utilisateur en nombres, qui sont interprétés par l'ordinateur.
* Une '''unité de traitement''', qui manipule des nombres et fait des calculs/opérations dessus. Les nombres proviennent des entrées, du disque dur, ou d'autres sources, peu importe.
* Des '''sorties''', qui va récupèrent le résultat calculé par l'unité de traitement pour en faire quelque chose : écrire sur une imprimante ou sur un moniteur, émettre du son,...

[[File:Ordinateur théorique Simple 1.png|centre|vignette|upright=2|Ordinateur théorique Simple 1]]

L'unité de traitement proprement dite, celle qui fait les calculs, est couplée à une mémoire qui mémorise les opérandes et résultats des calculs. La séparation entre processeur et mémoire est nécessaire pour qu'un appareil électronique soit qualifié d'ordinateur. De nombreux appareils n'ont pas de séparation entre unité de traitement et mémoire, comme certaines vielles radios AM/FM.

[[File:Schéma de principe d'un ordinateur.png|centre|vignette|upright=2|Schéma de principe d'un ordinateur]]

===Un ordinateur est un appareil programmable===

Les appareils simples sont non-programmables, ce qui veut dire qu’ils sont conçus pour une utilisation particulière et qu’ils ne peuvent pas faire autre chose. Par exemple, les circuits électroniques d’un lecteur de DVD ne peuvent pas être transformé en lecteur audio ou en console de jeux... Les circuits non-programmables sont câblés une bonne fois pour toute, et on ne peut pas les modifier. On peut parfois reconfigurer le circuit, pour faire varier certains paramètres, via des interrupteurs ou des boutons, mais cela s’arrête là. Et cela pose un problème : à chaque problème qu'on veut résoudre en utilisant un automate, on doit recréer un nouveau circuit.

À l'inverse, un ordinateur n’est pas conçu pour une utilisation particulière, contrairement aux autres objets techniques. Il est possible de modifier leur fonction du jour au lendemain, on peut lui faire faire ce qu’on veut. On dit qu'ils sont '''programmables'''. Pour cela, il suffit d’utiliser un logiciel, une application, un programme (ces termes sont synonymes), qui fait ce que l'on souhaite. La totalité des logiciels présents sur un ordinateur sont des programmes comme les autres, même le système d'exploitation (Windows, Linux, ...) ne fait pas exception.

Un programme est une suite de d''''instructions machines''', chaque instruction effectuant une action dans l'ordinateur. Sur les ordinateurs modernes, les instructions les plus communes effectuent une opération arithmétique : une addition, une multiplication, une soustraction, etc. Les ordinateurs modernes sont donc de grosses calculettes très puissantes, capables d'effectuer des millions d'opérations par secondes.

Et qui dit opération dit nombres : un ordinateur gère nativement des nombres, qui sont codés en binaire sur la quasi-totalité des ordinateurs modernes. Les ordinateurs modernes sont capables de faire des calculs sur des nombres entiers, mais aussi des nombres à virgule. Il existe plusieurs manières de représenter des nombres en binaire, certaines représentant des nombres entiers dits naturels (0 et plus), d'autres des nombres signés (positifs ou négatifs), d'autres des nombres à virgule. Un chapitre entier détaillera comment sont encodés ces nombres.

Une instruction est représentée dans un ordinateur par une série de nombres entiers : un nombre qui indique quelle opération/commande effectuer et des autres nombres pour coder les données (ou de quoi les retrouver dans l'ordinateur). L'ordinateur récupére les commandes une par une, les traduit en opération à effectuer, exécuter l'opération, et enregistre le résultat. Puis il recommence avec la commande suivante.

[[File:Ordinateur Théorique Complexe 1.png|centre|vignette|upright=3|Ordinateur Théorique Complexe. En jaune, le programme informatique, la liste de commande. Le rectangle gris est l'ordinateur proprement dit.]]

De nombreux appareils sont programmables, mais tous ne sont pas des ordinateurs. Par exemple, certains circuits programmables nommés FPGA n'en sont pas. Pour être qualifié d'ordinateur, un appareil programmable doit avoir un processeur séparé de la mémoire. De plus, il doit utiliser un '''codage numérique''', chose que nous allons aborder dans le chapitre suivant.

===Les ordinateurs à programme mémorisé ou programme externe===

[[File:Blue-punch-card-front.png|vignette|upright=0.5|Carte Perforée.]]

Au tout début de l'informatique, les programmes étaient enregistrés sur des cartes perforées, à savoir des cartes en papier/plastique percées par endroits. Un 1 est codé par un trou dans le papier et un 0 par une absence de trou. Les programmes étaient exécutés par l'ordinateur quand on insérait la carte perforée dans le lecteur et qu'on appuyait sur un bouton.

Par la suite, les premiers ordinateurs grand public, comme les Amstrad ou les Commodore, utilisaient des cassettes audio magnétiques pour stocker les programmes. Dans le même style, les consoles de jeu utilisaient autrefois des cartouches de jeu, qui contenaient le programme du jeu à exécuter. Pour résumer, les anciens ordinateurs mémorisaient les programmes sur un support externe, lu par un périphérique. De tels ordinateurs sont dits à '''programme externe'''.

: D’anciens ordinateurs personnels, comme l’Amstrad ou le Commodore, permettaient de taper les programmes à exécuter à la main, au clavier, avant d’appuyer une touche pour les exécuter. Nul besoin de vous dire que les cassettes audio étaient plus pratiques.

Mais de nos jours, les programmes sont enregistrés sur le disque dur de l'ordinateur ou dans une mémoire intégrée à l'ordinateur. On dit qu'ils sont installés, ce qui est un mot bien compliqué pour dire que le programme est enregistré sur le disque dur de l’ordinateur. A défaut de disque dur, le programme/logiciel est enregistré dans une mémoire spécialisée pour le stockage. Par exemple, sur les cartes électroniques grand public de marque Arduino, les programmes sont envoyés à la carte via le port USB, mais les programmes sont enregistrés dans la carte Arduino, dans une mémoire FLASH dédiée. Disque dur ou non, le programme est mémorisé dans la mémoire de l'ordinateur. Il est possible d'installer ou de désinstaller les programmes en modifiant le contenu de la mémoire. Le terme utilisé est alors celui de '''programme stocké en mémoire'''.

Les programmes à installer sont disponibles soit sur un périphérique, comme un DVD ou une clé USB, soit sont téléchargés depuis internet. Les premiers PC fournissaient les logiciels sur des disquettes, qui contenaient un programme d'installation pour enregistrer le programme sur le disque dur de l'ordinateur. Par la suite, le support des logiciels a migré vers les CD et DVD, les logiciels devenant de plus en plus gros. De nos jours, la majorité des applications sont téléchargées depuis le net, l'usage de périphériques est devenu obsolète, même les consoles de jeu abandonnent cette méthode de distribution.

==Les générations d'ordinateurs : un historique rapide==

L'informatique a beaucoup évolué dans le temps. Et une bonne partie de cette évolution tient à l'évolution de l’électronique sous-jacente. Les ordinateurs actuels sont fabriqués avec des transistors, des petits composants électroniques qui servent d'interrupteurs programmables, qu'on détaillera dans ce qui suit. Mais ça n'a pas toujours été le cas. Et cela permet de distinguer plusieurs '''générations d'ordinateurs'''.

===Les ordinateurs électro-mécaniques : les premiers ordinateurs===

Le tout premier ordinateur est le '''Z1''', un modèle unique inventé par Konrad Suze entre 1936 et 1938. Son processeur gérait non pas des nombres entiers, mais des nombres à virgule (des nombres dits flottants, pour être précis), encodés sur 22 bits. Le processeur du Z1 était capable de faire des additions et des soustractions, car il intégrait un circuit additionneur-soustracteur basique. Des circuits annexes permettaient de faire des multiplications et des divisions en enchainant des additions/soustractions successives. Il fonctionnait à une fréquence de 1 Hz, ce qui fait qu'il pouvait faire une addition/soustraction par seconde maximum.

Niveau mémoire, la RAM de l'ordinateur était très limitée : seulement 16 nombres de 22 bits chacun. S'il s'agissait d'une mémoire électronique, les programmes étaient mémorisés sur une mémoire mécanique et précisémment sur des cartes perforées, à savoir des cartes en papier/plastique dans lesquelles un 1 est codé par un trou dans le papier et un 0 par une absence de trou. Les programmes étaient exécutés par l'ordinateur quand on insérait la carte perforée dans le lecteur et qu'on appuyait sur un bouton.

[[File:German Museum of Technology, Berlin 2017 024.jpg|centre|vignette|upright=2|Réplique du Z1 au ''German Museum of Technology'' de Berlin, 2017.]]

Après sa destruction dans un bombardement, le Z1 a été reconstruit et amélioré, ce qui donné les deux ordinateurs Z2 et Z3. Quelques années plus tard, quelques laboratoires de recherche ont fabriqués des ordinateurs dans leur coin, comme le Harvard Mark I et le Colossus Mark 1 (UK) qui ont été mis en service en 1944. Ils ont servi pour les cryptanalystes pour casser les codes utilisés par les Allemands pour leurs transmissions, pendant la seconde guerre mondiale.

Les ordinateurs cités dans le précédent paragraphe étaient tous des ordinateurs dit '''électro-mécaniques''', car ils mélangeaient des composants électroniques et des composants mécaniques (tout ce qui a trait aux cartes perforées, notamment). Les composants électroniques étaient généralement des relais, à savoir des interrupteurs commandables électriquement, qui sont plus ou moins équivalents aux transistors modernes. La majeure partie des ordinateurs des années 40 étaient de ce type, mais leur nombre n'a pas dépassé 30. Il faut dire qu'ils ont rapidement laissé la place à des ordinateurs purement électroniques, que nous allons voir dans ce qui suit.

===La première génération : les tubes à vide===

Les ordinateurs qui ont suivi les ordinateurs électromécaniques sont regroupés dans la '''première génération d'ordinateur'''. Ils étaient conçus avec des tubes à vide, des espèces d'interrupteurs commandables, les ancêtres des transistors modernes. Les tubes à vide étaient assez encombrants, ils consommaient beaucoup de courant, ils chauffaient et étaient assez peu fiables. Ils tombaient en panne assez souvent. Et ils étaient assez simples à fabriquer, mais restaient malgré tout chers.

Les tubes à vide sont des ampoules à filament améliorées. Pour rappel, les ampoules à filament étaient des ampoules en verre dans lesquelles on plaçait un filament métallique. Le filament chauffait quand on envoyait du courant dedans et émettait de la lumière. Mais dans les tubes à vide, le filament n'émet pas de lumière quand on le chauffe : il émet des électrons, de l'électricité. De plus, ils ajoutent une électrode, une plaque en métal qui émet ou capte des électrons. Ici, l'électrode capte des électrons émis par le filament quand il chauffe. Vu qu'elle capte des électrons, on l'appelle l''''anode'''.

Le résultat est un circuit qui laisse passer le courant, mais seulement dans un sens : du filament vers l'anode, l'autre sens n'est pas possible vu que l'anode ne peut pas émettre d'électrons. Un tel circuit est appelé une '''diode'''.

Une amélioration des tubes à vide précédent rajoute une seconde plaque de métal, appelée la '''cathode''', située juste après le filament. C'est elle qui émet les électrons, , mais seulement si elle est chauffée par le filament. Le filament doit donc chauffer, ce qui réchauffe la cathode, qui elle-même émet des électrons en direction de l'anode.

{|
|[[File:Diode à vide.png|vignette|upright=1.5|Diode à vide, avec cathode.]]
|[[File:Diode à vide schéma de fonctionnement.png|vignette|upright=1.5|Diode à vide, schéma de fonctionnement. Le filament X chauffe la cathode (2), qui émet des électrons (3), vers l'anode (4).]]
|}

Les tubes à vide précédent peuvent être modifiés en ajoutant une grille métallique entre la cathode et l'anode. La grille est alimentée avec une tension électrique, ce qui la charge électriquement. Suivant sa charge, elle laisse plus ou moins passer les électrons de la cathode vers l'anode. Si elle n'est pas chargée, que la tension est de 0 Volts, elle ne fera pas obstacle aux électrons et le tube à vide fonctionnera comme une diode basique. Mais si la grille est chargée avec une tension négative, sa charge électrique va repousser les électrons et les empêcher de passer de la cathode vers l'anode.

Le tube à vide se comporte alors comme un interrupteur : fermé ou ouvert suivant ce qu'on met sur la grille. Un tel tube à vide est appelée une '''triode''', car c'est une diode à laquelle on a ajouté une entrée pour charger la grille. De tels interrupteurs commandables électriquement sont combinés pour fabriquer des circuits plus élaborés, comme les portes logiques qu'on verra d'ici quelques chapitres.

[[File:Triode.png|centre|vignette|upright=2.5|Triode, ancêtre du transistor]]

Les tubes à vides étaient utilisés pour le processeur et quelques circuits annexes, mais les mémoires utilisaient d'autres technologies. Les mémoires de l'époque n'étaient pas du tout des mémoires électroniques. Il existait déjà des ancêtres des disques durs, à savoir des mémoire magnétiques appelées tambours magnétiques, bandes magnétiques, mémoires à tore de ferrite, etc. Les mémoires RAM, quant à elles, utilisaient elles des technologies totalement abandonnées : les mémoires à lignes de délai étaient des mémoires acoustiques, les tubes Williams étaient des écrans CRT modifiés, etc. Un chapitre entier sera dédié aux technologies des mémoires de l'époque.

[[File:Elektronenroehren-auswahl.jpg|centre|vignette|upright=2|Tubes à vides.]]

L'usage de tubes à vide les place entre les premiers ordinateurs électro-mécaniques et les ordinateurs utilisant des transistors. Au vu de la taille des tubes à vide, les ordinateurs de l'époque étaient composés de plusieurs milliers de ces tubes, guère plus. Et malgré cela, un ordinateur prenait facilement un étage de bâtiment entier, ou au moins plusieurs pièces. La conséquence est que les ordinateurs de première génération étaient très simples, rudimentaires quand on les compare aux ordinateurs modernes. Ils ne géraient que quelques opérations simples : l'addition, la soustraction, pas grand-chose de plus. À quelques exceptions près, ils ne géraient pas la multiplication et encore moins la division, cela aurait demandé trop de tubes à vides.

Une des toutes premières machines construite avec des tubes à vide était l'Atanasoff–Berry. Ce n'était pas un ordinateur, car elle ne pouvait pas exécuter de programme sans intervention humaine pour séquencer des opérations, mais c'était la première machine de calcul purement électronique, sans aucune pièce mécanique. Elle utilisait une mémoire RAM construite avec des condensateurs, ceux-ci étant placés sur des cylindres tournants. Les circuits de calcul étaient construits avec des tubes à vide et faisaient leur travail un bit à la fois. Elle fonctionnait à une fréquence de 60 Hz et pouvait faire 30 additions/soustractions par seconde. Les nombres étaient encodés sur 50 bits. 

[[File:Atanasoff Berry Computer.gif|centre|vignette|upright=2.5|Atanasoff–Berry.]]

L'arrivée de l'ENIAC en 1945 a changé la donne. Cet ordinateur a introduit plusieurs innovations majeures. La première est assez technique, il s'agit de la turing-complétude, elle a trait aux programmes qui peuvent être écrit pour un ordinateur, nous ne la détaillerons pas ici.

[[File:BabyArchitecture.png|vignette|Architecture de la Manchester Baby.]]

En 1948, le ''Manchester Baby'' a introduit une innovation extrêmement importante : le programme n'était plus mémorisé sur des cartes perforées, mais dans une mémoire électronique à l’intérieur de l'ordinateur lui-même. En clair, le ''Manchester Baby'' était le premier '''ordinateur à programme stocké en mémoire''' en français. Au-delà de ça, le Manchester Baby restait quand même très simple, c'était limite un prototype.

Niveau interface, l'ordinateur avait une console avec 32 boutons, des interrupteurs et un écran de sortie sur lequel afficher les résultats. A l'intérieur, il y avait un processeur et une RAM de 32 nombres de 32 bits, fabriquées avec des tubes Williams (abordés dans une annexe à la fin du cours). Une instruction prenant autant de place qu'un nombre en RAM, ce qui limitait les programmes à 32 instructions maximum. Le processeur gérait 8 instructions en tout, mais la seule instruction de calcul qu'il gérait était la soustraction. L'addition n'était pas supportée. Il pouvait cependant émuler l'addition à partir d'une soustraction et inversant l'opérande soustrait.

Le Manchester Mark 1 était une amélioration du Manchester Baby. Il utilisait 4500 tubes à vide. L'ordinateur gérait des nombres de 40 bits, mais les instructions étaient codées sur 20 bits. La RAM avait la même taille, à savoir 32 nombres, leur taille était simplement augmentée. Par contre, la RAM était complémentée par l’ancêtre du disque dur magnétique, à savoir un tambour magnétique, l’ancêtre du disque dur magnétique. Il contenait 40 pages, chacune ayant la même taille que la RAM. Contrairement à la Manchester Baby, son processeur gérait l'addition. Les multiplications étaient réalisées par des additions successives, mais le processeur intégrait des registres pour mémoriser les opérandes à multiplier.

Par la suite, les ordinateurs commerciaux ont vu le jour. Les ordinateurs précédents provenaient de projets de recherches, souvent publics. Mais les entreprises privées se sont mises à fabriquer des ordinateurs elle-mêmes, pour les vendre à d'autres entreprises. On peut notamment citer les ordinateurs comme le UNIVAC I, le Bull Gamma 3 ou les premiers ordinateurs IBM. La performance de ces ordinateurs était nettement plus importante que leurs prédécesseurs, avec des fréquences de l'ordre de la centaine de kilo-hertz. Par exemple, le Bull Gamma 3 allait à 281 kHz, l'IBM 650 allait à 50 Khz.

===La seconde génération : le remplacement des tubes à vides par des transistors===

[[File:IBM 7070.jpg|vignette|Cartes imprimées de l'IBM 704, avec des transistors et résistances dessus.]]

La '''seconde génération''' est celle des ordinateurs fabriqués avec des '''transistors''' isolés, reliés entre avec des fils électriques. Les transistors en question possèdent trois broches, des pattes métalliques sur lesquelles on connecte des fils électriques. Le transistor s'utilise le plus souvent comme un interrupteur commandé par sa troisième broche. Le courant qui traverse les deux premières broches passe ou ne passe pas selon ce qu'on met sur la troisième.

[[File:Transistor basic flow.svg|centre|vignette|Un transistor est un morceau de conducteur, dont la conductivité est contrôlée par sa troisième broche/borne.]]

Les ordinateurs de seconde génération avaient entre 1000 et 500 000 transistors. Les capacités des ordinateurs étaient donc nettement supérieures à celles des ordinateurs de première génération. Une part non négligeable des ordinateurs de seconde génération supportait l'opération de multiplication, absente sur les ordinateurs de première génération. Néanmoins, cela variait beaucoup selon les ordinateurs.

Un exemple assez hors du commun est celui du premier modèle de l'IBM 1620. Le tout premier modèle n'avait aucun circuit de calcul, il n'était même pas capable de faire une addition ou une multiplication. A la place, il utilisait une table d'addition et une table de multiplication en mémoire RAM. Les deux tables devaient être initialisées par le logiciel lors du démarrage de la machine. La table d'addition faisait une centaine de chiffres, la table de multiplication faisait le double. Le processeur de l'ordinateur gérait des instructions pour faire des additions ou des multiplications, mais ces opérations lisaient le résultat dans la table d'addition. Les calculs étaient faits chiffre par chiffre, avec un encodage partiellement décimal, partiellement binaire (des chiffres décimaux étaient encodés en binaire, nous en reparlerons quand nous parlerons du BCD) !

[[File:KL CoreMemory.jpg|vignette|Mémoire à tore de ferrite.]]

Les transistors n'étaient utilisés que pour le processeur et les circuits annexes. La mémoire n'était pas faite en transistors, pas à cette époque. La mémoire était une mémoire aujourd'hui abandonnée, appelée une '''mémoire à tores de ferrite'''. Elle sera détaillée dans un chapitre ultérieur. Mais sachez pour le moment qu'il s'agit d'une mémoire au support magnétique, les données étant stockées sur un support magnétique.

Les transistors étaient au départ de la même taille que les tubes à vide, mais ils ont rapidement rétrécit. Ils prenaient encore beaucoup de place dans les 60-70, ce qui fait que les ordinateurs étaient assez gros. Concrètement, ils prenaient une pièce de bâtiment entière dans le meilleur des cas. C'était l'époque des gros ''mainframes'', reliés à des terminaux, peu puissants comparé aux standards actuels. Seules les grandes entreprises et les grands instituts de recherche pouvaient se payer les services de ce genre d'ordinateurs. Seuls les professionnels avaient accès à ce genre d'équipement.

===La troisième génération : le circuit intégré===

[[File:D8259AC-2.jpg|vignette|Exemple de circuit intégré.]]

La troisième génération est toujours fabriquée avec des transistors, mais dont la taille a été réduite. Avec l'évolution de la technologie, les transistors ont diminué en taille, de plus en plus. Ils sont devenus tellement petits qu'ils ont fini par être regroupés dans des '''circuits intégrés''', des circuits regroupent plusieurs transistors sur la même puce de silicium. Les circuits intégrés se présentent le plus souvent sous la forme de boitiers rectangulaires, comme illustré ci-contre. D'autres ont des boitiers de forme carrées, comme ceux que l'on peut trouver sur les barrettes de mémoire RAM, ou à l'intérieur des clés USB/ disques SSD.

Lors de cette génération, les processeurs étaient fournis en pièces détachées qu'il fallait relier entre elles. Le processeur était composé de plusieurs circuits intégrés séparés, impossible de mettre un processeur dans un seul boitier. Un exemple de processeur conçu en kit est la série des Intel 3000. Elle regroupe plusieurs circuits séparés aux noms à coucher dehors, mais dont vous comprendrez ce qu'ils veulent dire dans les chapitres adéquats : l'Intel 3001 est un séquenceur, l'Intel 3002 regroupe unité de calcul et registres, le 3003 est un circuit d'anticipation de retenue complémentaire du 3002, le 3212 est une mémoire tampon, le 3214 est une unité de gestion des interruptions, les 3216/3226 sont des interfaces de bus mémoire. On pourrait aussi citer la famille de circuits intégrés AMD Am2900.

Même si le processeur était en pièces détachées, utiliser une dizaine de circuits intégrés était nettement mieux que d'utiliser plusieurs milliers de transistors individuels. En conséquence, les ordinateurs ont vu leur taille grandement réduite, passant de pièces entières à une simple armoire, voire à quelques cartes intégrées superposées. De plus, le prix des circuits intégré était abordable, du moins comparé aux ordinateurs d'avant. Le prix des ordinateurs a alors grandement décru, permettant à des entreprises et administrations de taille modeste de s'équiper d'ordinateurs.

===La quatrième génération : le microprocesseur===

[[File:MOS6502.svg|vignette|Microprocesseur, ici un processeur MOS6502, de la quatrième génération.]]

Lors de la troisième génération, les circuits intégrés regroupaient plusieurs dizaines ou centaines de transistors, mais sont rapidement montés en gamme. De centaines de transistors, ils sont passés au millier de transistors, puis au million et maintenant au-delà du milliard. Les transistors étaient devenus tellement petits, tellement miniaturisés, qu'il était devenu possible de mettre un processeur entier dans un circuit intégré. C'est ainsi qu'est né le microprocesseur, à savoir un processeur qui tient tout entier dans un seul circuit imprimé. La quatrième génération d’ordinateur est celle des ordinateurs basés autour d'un microprocesseur.

Les tout premiers microprocesseurs étaient des processeurs à application militaire, comme le processeur du F-14 CADC ou celui de l'Air data computer. Le tout premier microprocesseur commercialisé au grand public est le 4004 d'Intel, sorti en 1971. L'intel 4004 comprenait environ 2300 transistors, avait une fréquence de 740 MHz, pouvait faire 46 opérations différentes, et manipulait des entiers de 4 bits. Il était au départ un processeur de commande, prévu pour être intégré dans la calculatrice Busicom calculator 141-P, mais il fut utilisé pour d'autres applications quelque temps plus tard. Immédiatement après le 4004, les premiers microprocesseurs 8 bits furent commercialisés. Le 4004 fut suivi par le 8008 et quelques autres processeurs 8 bits extrêmement connus, comme le 8080 d'Intel, le 68000 de Motorola, le 6502 ou le Z80.

Les microprocesseurs permirent encore uen fois de réduire la taille des ordinateurs, qui pouvaient tenir dans un boitier de PC, ou un boitier de console de jeu. Le prix des ordinateurs a aussi chuté en même temps que les transistors étaient miniaturisés. C'est cette invention qui permis l'invention des consoles de jeux et des mini-ordinateurs, à savoir les ordinateurs personnels. Sans miniaturisation, on n'aurait pas d'ordinateur personnel, pas de PC fixe ou portable.

==L'organisation du cours : les différents niveaux d'explication==

Le fonctionnement d'un ordinateur est assez complexe à expliquer car les explications peuvent se faire sur plusieurs niveaux. Par plusieurs niveaux, on veut dire qu'un ordinateur est composé de composants très simples, qui sont assemblés pour donner des composants eux-même plus complexes, qui sont eux-même regrouper, etc. Étudier tout cela demande de voir plusieurs niveaux, allant de transistors très petits à des processeurs multicœurs. Les niveaux les plus bas sont de l'électronique pur et dure, alors que ceux plus haut sont à mi-chemin entre électronique et informatique.

===Les niveaux d'abstraction en architecture des ordinateurs===

Les trois premiers niveaux sont de l'électronique pur et dure. Ils correspondent aux premiers chapitres du cours, qui porteront sur les circuits électroniques en général.
* Le premier niveau est celui des '''transistors''', des circuits intégrés, des ''wafer'' et autres circuits de très petite taille.
* Le second niveau est celui des '''portes logiques''', des circuits très basiques, très simples, à la base de tous les autres.
* Le troisième niveau est celui dit de la '''''Register Transfer Level''''', où un circuit électronique est construit à partir de circuits basiques, dont des registres et autres circuits dits combinatoires.
Les deux niveaux suivants sont de l'informatique proprement dit. C'est dans ces deux niveaux qu'on étudie les ordinateurs proprement dit, les circuits qu'il y a dedans et non l'électronique en général.
* Le quatrième niveau est celui de la '''microarchitecture''', qui étudie ce qu'il y a à l'intérieur d'un processeur, d'une mémoire, des périphériques et autres.
* Le cinquième niveau est celui de l''''architecture externe''', qui décrit l'interface du processeur, de la mémoire, d'un périphérique ou autre. Par décrire l'interface, on veut dire : comment un programmeur voit le processeur et la mémoire, comment il peut les manipuler. Une architecture externe unique peut avoir plusieurs microarchitecture, ce qui fait qu'on sépare les deux. Tout cela sera plus clair quand on passera aux chapitres sur le processeur et les mémoires.

Nous n'allons pas voir les 5 niveaux dans l'ordre, des transistors vers l'architecture externe. En réalité, nous allons procéder autrement. La première partie du cours portera sur les trois premiers niveaux, le reste sur les deux autres. Les 5 niveaux seront vus dans des chapitres séparés, du moins le plus possible. Au niveau pédagogique, tout est plus simple si on scinde les 5 niveaux. Bien sûr, il y a quelques explications qui demandent de voir plusieurs niveaux à la fois. Par exemple, dans le chapitre sur les mémoires caches, nous auront des explications portant sur la RTL, la microarchitecture du cache et son architecture externe. Mais le gros du cours tentera de séparer le plus possible les 5 niveaux.

===Les trois parties principales du cours===

Nous allons commencer par parler du binaire, avant de voir les portes logiques. Avec ces portes logiques, nous allons voir comment fabriquer des circuits basiques qui reviendront très souvent dans la suite du cours. Nous verrons les registres, les décodeurs, les additionneurs et plein d'autres circuits. Puis, nous reviendrons au niveau des transistors pour finir la première partie. La raison est que c'est plus simple de faire comme cela. Tout ce qui a trait aux transistors sert à expliquer comment fabriquer des portes logiques, et il faut expliquer les portes logiques pour voir le niveau de la RTL.

Une fois la première partie finie, nous allons voir les différents composants d'un ordinateur. Une première partie expliquera ce qu'il y a dans un ordinateur, quels sont ses composants. Nous y parlerons de l'architecture de base, de la hiérarchie mémoire, des tendances technologiques, et d'autres généralités qui serviront de base pour la suite. Puis, nous verrons dans l'ordre les bus électroniques, les mémoires RAM/ROM, le processeur, les périphériques, les mémoires de stockage (SSD et disques durs) et les mémoires caches. Pour chaque composant, nous allons voir leur architecture externe, avant de voir leur microarchitecture. La raison est que la microarchitecture ne peut se comprendre que quand on sait quelle architecture externe elle implémente.

Enfin, dans une troisième partie, nous allons voir les optimisations majeures présentes dans tous les ordinateurs modernes, avec une partie sur le pipeline et le parallélisme d'instruction, et une autre sur les architectures parallèles. Pour finir, les annexes de fin parlerons de sujets un peu à part.

&lt;noinclude&gt;
{{NavChapitre | book=Fonctionnement d'un ordinateur
           | next=L'encodage des données
           | nextText=L'encodage des données
}}
&lt;/noinclude&gt;</text>
      <sha1>mgot873unhnil3b2yrcrl19776ipzzy</sha1>
    </revision>
    <revision>
      <id>744171</id>
      <parentid>744170</parentid>
      <timestamp>2025-06-05T15:45:56Z</timestamp>
      <contributor>
        <username>Mewtow</username>
        <id>31375</id>
      </contributor>
      <minor />
      <comment>/* La première génération : les tubes à vide */</comment>
      <origin>744171</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="49701" sha1="18xq13z726xgxse2su8npqt6mkjtzx4" xml:space="preserve">Pour commencer, nous allons voir qu'il existe de nombreux types d'ordinateurs. Le plus connu est certainement le PC, l'ordinateur personnel, que vous avez sans doute dans votre salon. Les ordinateurs portables sont un deuxième type d'ordinateur assez intuitif, que vous avez peut-être. Mais il y a aussi d'autres types d'ordinateurs auxquels vous n'avez jamais été confrontés.

==Les différents types d'ordinateurs==

Dans cette section, nous allons décrire rapidement les ordinateurs les plus courant, mais surtout voir ce qu'il y a à l'intérieur d'un ordinateur.

===L'ordinateur de type PC fixe===

De l'extérieur, l'ordinateur est composé d'une unité centrale sur laquelle on branche des périphériques.

[[File:Typical computer architecture systems.jpg|vignette|upright=1.5|Exemples de périphériques, connectés à une unité centrale (ici appelée à tort ''operating system'').]]

Les '''périphériques''' regroupent l'écran, la souris, le clavier, l'imprimante, et bien d'autres choses. Ils permettent à l'utilisateur d'interagir avec l'ordinateur : un clavier permet de saisir du texte sous dans un fichier, une souris enregistre des déplacements de la main en déplacement du curseur, un écran affiche des données d’images/vidéos, un haut-parleur émet du son, etc. Tout ce qui est branché sur un ordinateur est, formellement un périphérique.

L''''unité centrale''' est là où se trouvent tous les composants importants d'un ordinateur, ceux qui font des calculs, qui exécutent des logiciels, qui mémorisent vos données, etc. Voici ce à quoi ressemble l'intérieur de l'unité centrale. Trois sections sont visibles : l'alimentation électrique en haut à gauche, la carte mère en bas à gauche et en jaune/orange, les disques et lecteurs à droite des câbles. Et on voit aussi beaucoup de câbles.

[[File:Asus P5K-SEIntel E6320.jpg|centre|vignette|upright=2|Exemple d'unité centrale.]]

Tout en haut à gauche, se trouve l''''alimentation électrique''', qui convertit le courant de la prise électrique en un courant plus faible, utilisable par les autres composants. Elle émet de nombreux câbles assez gros, qui sont reliés au reste. Les PC actuels utilisent des alimentations électriques standardisées, qui fournissent trois tensions au reste de l'ordinateur : une tension de 12 Volts, une de 5 Volts, une de 3,3 Volts.

À droite, caché par la partie &quot;métallique&quot; du boitier, se trouvent les lecteurs de CD/DVD, et les disques durs. Les lecteurs CD-ROM ou DVD-ROM permettaient de lire des CD ou des DVD. Je parle au passé, car ils ont aujourd'hui disparu des ordinateurs modernes. Les '''disques durs''' sont des mémoires de stockage, qui mémorisent vos données de manière permanente. De nos jours, ils sont remplacés par des SSD, qui sont des disques durs électroniques, là où les disques durs proprement dit sont des mémoires magnétiques. Nous verrons la différence dans deux chapitres dédiés, un sur les disques durs, l'autre sur les SSD.

En bas à droite, se trouve la '''carte mère''' un support plat, en plastique ou en céramique, sur laquelle sont soudés/connectés les autres composants. Sur celle-ci, de nombreux composants sont soudés, d'autres sont branchés dessus avec des câbles, d'autres sont connectés dessus avec des connecteurs. Ils sont reliés entre eux par des fils conducteurs, le plus souvent du cuivre ou de l’aluminium, ce qui leur permet de s’échanger des données. Sur les cartes simples, ces fils sont intégrés dans la carte électronique, dans des creux du plastique. Ils portent le nom de pistes.

Avant, les disques durs, SSD et lecteurs de CD/DVD sont branchés dessus via des connecteurs dédiés, appelés des connecteurs S-ATA. De nos jours, ils sont branchés sur un autre connecteur, grâce à l'interface NVME. Toujours est-il qu'ils sont reliés à la carte mère par des câbles, ce qui montre que ce sont des sortes de périphériques interne. Ils sont placés dans le boitier, mais on aurait tout aussi bien pu les mettre à l'extérieur, vu qu'ils communiquent avec l'ordinateur par l'intermédiaire d'un câble ou d'un connecteur dédié.

Mais deux autres composants très importants sont eux placés sur la carte mère, directement. Ils ont chacun un connecteur dédié, sur lequel ils sont branchés directement, sans passer par l'intermédiaire d'un câble, mais sans être soudés non plus. Il s'agit du processeur et de la mémoire RAM, deux composants centraux des PC modernes.

[[File:Pentium III SL4CB.jpg|thumb|Processeur Pentium III.]]

Le '''processeur''' traite les données, les modifie, les manipule. Pour faire simple, il s’agit d’une grosse calculatrice hyper-puissante. Il comprend à la fois un circuit qui fait des calculs, et un circuit de contrôle qui s'occupe de séquencer les calculs dans l'ordre demandé. Il est souvent caché sous un radiateur, lui-même surmonté par un ventilateur. En effet, un processeur chauffe beaucoup, ce qui demande d'évacuer cette chaleur. Un chapitre entier expliquera pourquoi les processeurs chauffent, ainsi que les techniques utilisées pour limiter leur production de chaleur et leur consommation électrique.

La '''mémoire vive''' conserve des informations/données temporairement, tant que le processeur en a besoin. Elle prend la forme de barrettes de RAM, comme montré ci-dessous.

[[File:2 gb ddr2 667.jpg|centre|vignette|upright=2|Barrette de RAM.]]

Outre ces composants dits principaux, un ordinateur peut comprendre plusieurs composants moins importants, surtout présents sur les ordinateurs personnels. Ils sont techniquement facultatifs, mais sont très présents dans les ordinateurs personnels. Cependant, certains ordinateurs spécialisés s'en passent. Il s'agit des diverses '''cartes d'extension''' sont branchées sur la carte mère. Elles permettent d’accélérer certains calculs ou certaines applications, afin de décharger le processeur. Par exemple, la carte graphique s'occupe des calculs graphiques, qu'il s'agisse de graphismes 3D de jeux vidéos ou de l'affichage en 2D du bureau. Dans un autre registre, la carte son prend en charge le microphone et les haut-parleurs.

[[Fichier:Personal computer, exploded 4.svg|thumb|upright=1.0|Éclaté d'un ordinateur de type PC :&lt;br /&gt;
1 : Écran ;&lt;br /&gt;
2 : Carte mère ;&lt;br /&gt;
3 : Processeur ;&lt;br /&gt;
4 : Câble Parallel ATA ;&lt;br /&gt;
5 : Mémoire vive (RAM) ;&lt;br /&gt;
6 : Carte d'extension ;&lt;br /&gt;
7 : Alimentation électrique ;&lt;br /&gt;
8 : Lecteur de disque optique ;&lt;br /&gt;
9 : Disque dur ;&lt;br /&gt;
10 : Clavier ;&lt;br /&gt;
11 : Souris.]]

Si on regarde une carte mère de face, on voit un grand nombre de connecteurs, mais aussi des circuits électroniques soudés à la carte mère.

[[File:Architecture matérielle d'une carte mère.png|centre|vignette|upright=2.0|Architecture matérielle d'une carte mère]]

Les '''connecteurs''' sont là où on branche les périphériques, la carte graphique, le processeur, la mémoire, etc. Dans l'ensemble, toute carte mère contient les connecteurs suivants :
* Le processeur vient s’enchâsser dans la carte mère sur un connecteur particulier : le '''socket'''. Celui-ci varie suivant la carte mère et le processeur, ce qui est source d'incompatibilités.
* Les barrettes de mémoire RAM s’enchâssent dans un autre type de connecteurs: les '''slots mémoire'''.
* Les mémoires de masse disposent de leurs propres connecteurs : connecteurs P-ATA pour les anciens disques durs, et S-ATA pour les récents.
* Les périphériques (clavier, souris, USB, Firewire, ...) sont connectés sur un ensemble de connecteurs dédiés, localisés à l'arrière du boitier de l'unité centrale. 
* Les autres périphériques sont placés dans l'unité centrale et sont connectés via des connecteurs spécialisés. Ces périphériques sont des cartes imprimées, d'où leur nom de '''cartes filles'''. On peut notamment citer les cartes réseau, les cartes son, ou les cartes vidéo.

===Les ordinateurs portables===

[[File:Samsung QX-511 (2).JPG|vignette|Ordinateur portable Samsung QX-511 (2), pour illustration.]]

Un ordinateur portable est identique à un ordinateur de type PC. Si vous ouvrez votre ordinateur portable (attention à la garantie), vous retrouverez les mêmes composants qu'un PC à l'intérieur. Un point important est la présence d'une batterie à l'intérieur du PC portable, absente des PC fixes.

[[File:LG gram 14Z90Q mainboard with battery.jpg|centre|vignette|upright=2|LG gram 14Z90Q avec sa batterie.]]

Une fois la batterie et les circuits associés retiré, la seule différence notable est que tous les composants sont soudés sur la carte mère, au lieu d'être branchés sur des connecteurs, à part éventuellement la RAM et le disque dur.

[[File:LG gram 14Z90Q mainboard without battery.jpg|centre|vignette|upright=2|LG gram 14Z90Q sans sa batterie.]]

La RAM est parfois soudée sur la carte mère, d'autres fois sous la forme de barrettes de mémoire vive semblables à celles des PC. Dans le dernier cas, elle est connectée à des connecteurs spécifiques, ce qui permet de les changer/upgrader. Les PC portables sont parfois construits de manière à pouvoir changer la RAM facilement, en ouvrant un cache spécial, concu pour.

[[File:Lenovo G555 состав - Донор.JPG|centre|vignette|upright=2|Lenovo G555.]]

La conception d'un ordinateur portable est légèrement différente de celle d'un PC, pour des raisons thermiques. Un PC fixe a plus de place pour évacuer sa chaleur. Les ventilateurs peuvent plus facilement déplacer l'air dans le boitier, même si le flux d'air dans le boitier est éventuellement gêné par la carte graphique. Mais l'évacuation de la chaleur est assez efficace. Sur les PC portables, leur finesse fait que le trajet de l'air est beaucoup plus contraint. Évacuer la chaleur produite par l'ordinateur est plus complexe, ce qui demande d'utiliser des systèmes de refroidissement et de ventilation spécifiques.

Là où les PC fixes se débrouillent avec des radiateurs et des ventilateurs posés sur le processeur, les PC portables font autrement. Ils ne peuvent pas forcément mettre le ventilateur sur le processeur. A la place, ils mettent le ventilateur à côté, mais le processeur est surmonté par un mécanisme de transmission de la chaleur, qui transfère la chaleur du processeur vers le ventilateur.

[[File:Diagram - How a laptop cooling system works.png|centre|vignette|upright=2|Comment fonctionne le système de ventilation d'un ordinateur portable, en anglais.]]

Les difficultés pour dissiper la chaleur font que les ordinateurs portables utilisent souvent des composants peu performants, mais qui chauffent peu. En effet, nous verrons que plus un composant est puissant, plus il chauffe. La relation n'est pas parfaite, mais les processeurs haute performance chauffent plus que les modèles d'entrée ou milieu de gamme moins puissants. En conséquence, les PC portables sont souvent moins puissants que les PC fixes, même pour les modèles dit ''gaming''.

===Les serveurs et ''mainframes''===

Les grandes entreprises utilisent des ordinateurs de grande taille, très puissants, appelés des ''mainframes''. Ils sont souvent confondus avec les serveurs par le grand public, il y a une différence entre les deux. Un serveur est une fonction logicielle/réseau, pas un type d'ordinateur. Mais laissons cette différence de côté, ce qui est dit pour les ''mainframes'' sert pour les gros serveurs haute performance.

[[File:IBM Z15 mainframe.jpg|vignette|Exemple de ''mainframe''' de type IBM Z15.]]

Les anciens ''mainframes'' des années 50-80 avaient une taille pouvant être impressionnante, au point de prendre une pièce complète d'un bâtiment. Mais de nos jours, les ''mainframes'' tiennent dans une grosse armoire un peu haute. Les ''mainframes'' doivent rester allumé en permanence et ne doivent pas être éteint, sauf éventuellement quelques jours par an pour des opérations de maintenance. Ils utilisent pour cela des techniques spécifiques, avec beaucoup de redondance interne.

[[File:ACONIT hall grandes machines.jpg|centre|vignette|upright=2|''Mainframe'' ACONIT.]]

Les ''mainframes'' sont aussi conçus pour mutualiser au maximum leur utilisation, ils peuvent être utilisés par plusieurs utilisateurs à la suite, voire en même temps. Pour cela, les anciens ''mainframes'' étaient capables de faire tourner plusieurs applications distinctes l'une à la suite de l'autre, avec des commutations fréquentes entre logiciels. De nos jours, ils sont capables d'exécuter un grand nombre de tâches en même temps, grâce à la présence de plusieurs processeurs. Les ''mainframes'' modernes sont même capables de faire tourner plusieurs systèmes d'exploitation en même temps si besoin.

Les anciens ''mainframes'' étaient des ordinateurs assez simples, avec un processeur, de la mémoire RAM, un ou plusieurs disques durs, pas plus. Le ''mainframe'' était tellement énorme et cher que les entreprises n'en avaient qu'un seul pour toute l'entreprise. Les employés avaient sur leur bureau des terminaux, qui permettaient d'accéder à l'ordinateur central, mais n'étaient pas des ordinateurs. Les terminaux étaient des composants électroniques simples, avec un écran, un clavier et une souris, mais sans processeur. Ils envoyaient des données au ''mainframe'', ils en recevaient de sa part, mais tout traitement était réalisé sur le ''mainframe''. L'arrivée sur le marché des ordinateurs personnels, de type PC fixe/portable, a entrainé l'abandon de ce genre de pratique, tous les employés ont maintenant un ordinateur rien que pour eux.

{|
|-
! colspan=&quot;2&quot; | Exemples de terminaux
|-
|[[File:Terminal-in2-sm9400.jpg|centre|vignette|upright=1.5|Exemple de terminal. Notez la présence d'un écran et d'un clavier, mais l'asbence d'une unité centrale.]]
|[[File:Chromatics CT4100.jpg|vignette|upright=1.5|Autre exemple de terminal. Le clavier est couplé à un stylo CRT, qui remplacait la souris et agissait sur l'écran comme s'il était tactile.]]
|-
! colspan=&quot;2&quot; | Intérieur d'un terminal
|-
|[[File:CT1024 Monitor.jpg|vignette|upright=1.5|Terminal CT1024, sans le boitier extérieur.]]
|[[File:CT1024 Terminal System.jpg|vignette|upright=1.5|Terminal CT1024, description des composants interne.]]
|}

De nos jours, les ''mainframes'' contiennent en réalité plusieurs ordinateurs simples interconnectés via un réseau local. Un ''mainframe'' qui tient dans une armoire contient facilement une dizaine ou centaine de processeurs, plein de RAM, des disques durs séparés dans une armoire distincte, etc. Vu qu'ils communiquent uniquement via le réseau, ils n'ont pas d'interface, pas d'écran, 'entrée via clavier/souris. Le tout est commandé avec une console de commande, typiquement un ordinateur portable ou un terminal assez simple séparé de l'armoire, qui permet à un administrateur de faire des opérations de surveillance, configuration et maintenance. Il peut y avoir une console de commande pour plusieurs armoires séparées, la console peut même être dans un autre bâtiment et accéder au ''mainframe'' par le réseau.

[[File:IBM System Z9 (type 2094 inside).jpg|centre|vignette|upright=2|''Mainframe'' de type IBM System Z9. L'ordinateur portable sert de console pour qu'un administrateur fasse des opérations de surveillance, configuration et maintenance.]]

Les processeurs et la RAM sont typiquement installés sur des cartes amovibles, qui sont connectées au fond de l'armoire lors de l'installation. Il est même possible de retirer ou d'ajouter des cartes en fonctionnement, afin d'ajouter/retirer des processeurs, des disques durs, etc. Ce qui est très utile si un composant est en panne et qu'il faut le remplacer. 

[[File:IBM TotalStorage Exp400.jpg|centre|vignette|upright=2|IBM TotalStorage Exp400]]

==Un peu d'abstraction : qu'est-ce qu'un ordinateur ?==

Un ordinateur comprend donc un processeur, plusieurs mémoires, des cartes d'extension et une carte mère pour connecter le tout. Mais il s'agit là d'une description assez terre-à-terre de ce qu'est un ordinateur. Une autre description, plus abstraite, se base sur le fait qu'un ordinateur est une énorme calculatrice programmable. Elle permet d'expliquer pourquoi il y a une distinction entre processeur et mémoire, entre unité centrale et périphériques. Tout ce qui va suivre pourra vous paraitre assez abstrait, mais rassurez-vous : les prochains chapitres rendront tout cela plus concrets.

===La séparation entre entrées-sorties et traitement===

L'unité centrale peut être vue comme une énorme calculatrice ultra-puissante, qui exécute des commandes/opérations. Mais à elle seule, elle ne servirait à rien, il faut interagir avec par l'intermédiaire de plusieurs périphériques. Il existe deux types de périphériques, qui sont conceptuellement différents. Les périphériques comme le clavier ou la souris permettent d'envoyer des informations à l'ordinateur, d'agir sur celui-ci. A l'inverse, les écrans transmettent des informations dans le sens inverse : de l'ordinateur vers l'utilisateur. Les premiers sont appelés des '''entrées''', les seconds des '''sorties'''.

Dans un ordinateur, les informations sont représentées sous la forme de nombres. Toute donnée dans un ordinateur est codée avec un ou plusieurs nombres regroupés dans une donnée, un fichier, ou autre. Et la transmissions avec les entrées et sorties se fait là-encore avec des nombres. Par exemple, quand vous appuyez sur votre clavier, le clavier envoie un numéro de touche à l'unité centrale, qui indique quelle touche a été appuyée. L'image à afficher à l'écran est codée sous la forme d'une suite de nombres (un par pixel). L'image est envoyée à l'écran, qui traduit la suite de nombre en image à afficher. Les entrées traduisent des actions utilisateurs en nombres, on dit que les entrées encodent les actions utilisateur. Les sorties font la traduction inverse, elles transforment des suites de nombres en une action physique. On dit qu'elles décodent des informations.

Pour résumer, toute appareil électronique est composé par :
* Des '''entrées''' sur lesquelles l'utilisateur agit sur l'ordinateur. Les entrées transforment les actions de l'utilisateur en nombres, qui sont interprétés par l'ordinateur.
* Une '''unité de traitement''', qui manipule des nombres et fait des calculs/opérations dessus. Les nombres proviennent des entrées, du disque dur, ou d'autres sources, peu importe.
* Des '''sorties''', qui va récupèrent le résultat calculé par l'unité de traitement pour en faire quelque chose : écrire sur une imprimante ou sur un moniteur, émettre du son,...

[[File:Ordinateur théorique Simple 1.png|centre|vignette|upright=2|Ordinateur théorique Simple 1]]

L'unité de traitement proprement dite, celle qui fait les calculs, est couplée à une mémoire qui mémorise les opérandes et résultats des calculs. La séparation entre processeur et mémoire est nécessaire pour qu'un appareil électronique soit qualifié d'ordinateur. De nombreux appareils n'ont pas de séparation entre unité de traitement et mémoire, comme certaines vielles radios AM/FM.

[[File:Schéma de principe d'un ordinateur.png|centre|vignette|upright=2|Schéma de principe d'un ordinateur]]

===Un ordinateur est un appareil programmable===

Les appareils simples sont non-programmables, ce qui veut dire qu’ils sont conçus pour une utilisation particulière et qu’ils ne peuvent pas faire autre chose. Par exemple, les circuits électroniques d’un lecteur de DVD ne peuvent pas être transformé en lecteur audio ou en console de jeux... Les circuits non-programmables sont câblés une bonne fois pour toute, et on ne peut pas les modifier. On peut parfois reconfigurer le circuit, pour faire varier certains paramètres, via des interrupteurs ou des boutons, mais cela s’arrête là. Et cela pose un problème : à chaque problème qu'on veut résoudre en utilisant un automate, on doit recréer un nouveau circuit.

À l'inverse, un ordinateur n’est pas conçu pour une utilisation particulière, contrairement aux autres objets techniques. Il est possible de modifier leur fonction du jour au lendemain, on peut lui faire faire ce qu’on veut. On dit qu'ils sont '''programmables'''. Pour cela, il suffit d’utiliser un logiciel, une application, un programme (ces termes sont synonymes), qui fait ce que l'on souhaite. La totalité des logiciels présents sur un ordinateur sont des programmes comme les autres, même le système d'exploitation (Windows, Linux, ...) ne fait pas exception.

Un programme est une suite de d''''instructions machines''', chaque instruction effectuant une action dans l'ordinateur. Sur les ordinateurs modernes, les instructions les plus communes effectuent une opération arithmétique : une addition, une multiplication, une soustraction, etc. Les ordinateurs modernes sont donc de grosses calculettes très puissantes, capables d'effectuer des millions d'opérations par secondes.

Et qui dit opération dit nombres : un ordinateur gère nativement des nombres, qui sont codés en binaire sur la quasi-totalité des ordinateurs modernes. Les ordinateurs modernes sont capables de faire des calculs sur des nombres entiers, mais aussi des nombres à virgule. Il existe plusieurs manières de représenter des nombres en binaire, certaines représentant des nombres entiers dits naturels (0 et plus), d'autres des nombres signés (positifs ou négatifs), d'autres des nombres à virgule. Un chapitre entier détaillera comment sont encodés ces nombres.

Une instruction est représentée dans un ordinateur par une série de nombres entiers : un nombre qui indique quelle opération/commande effectuer et des autres nombres pour coder les données (ou de quoi les retrouver dans l'ordinateur). L'ordinateur récupére les commandes une par une, les traduit en opération à effectuer, exécuter l'opération, et enregistre le résultat. Puis il recommence avec la commande suivante.

[[File:Ordinateur Théorique Complexe 1.png|centre|vignette|upright=3|Ordinateur Théorique Complexe. En jaune, le programme informatique, la liste de commande. Le rectangle gris est l'ordinateur proprement dit.]]

De nombreux appareils sont programmables, mais tous ne sont pas des ordinateurs. Par exemple, certains circuits programmables nommés FPGA n'en sont pas. Pour être qualifié d'ordinateur, un appareil programmable doit avoir un processeur séparé de la mémoire. De plus, il doit utiliser un '''codage numérique''', chose que nous allons aborder dans le chapitre suivant.

===Les ordinateurs à programme mémorisé ou programme externe===

[[File:Blue-punch-card-front.png|vignette|upright=0.5|Carte Perforée.]]

Au tout début de l'informatique, les programmes étaient enregistrés sur des cartes perforées, à savoir des cartes en papier/plastique percées par endroits. Un 1 est codé par un trou dans le papier et un 0 par une absence de trou. Les programmes étaient exécutés par l'ordinateur quand on insérait la carte perforée dans le lecteur et qu'on appuyait sur un bouton.

Par la suite, les premiers ordinateurs grand public, comme les Amstrad ou les Commodore, utilisaient des cassettes audio magnétiques pour stocker les programmes. Dans le même style, les consoles de jeu utilisaient autrefois des cartouches de jeu, qui contenaient le programme du jeu à exécuter. Pour résumer, les anciens ordinateurs mémorisaient les programmes sur un support externe, lu par un périphérique. De tels ordinateurs sont dits à '''programme externe'''.

: D’anciens ordinateurs personnels, comme l’Amstrad ou le Commodore, permettaient de taper les programmes à exécuter à la main, au clavier, avant d’appuyer une touche pour les exécuter. Nul besoin de vous dire que les cassettes audio étaient plus pratiques.

Mais de nos jours, les programmes sont enregistrés sur le disque dur de l'ordinateur ou dans une mémoire intégrée à l'ordinateur. On dit qu'ils sont installés, ce qui est un mot bien compliqué pour dire que le programme est enregistré sur le disque dur de l’ordinateur. A défaut de disque dur, le programme/logiciel est enregistré dans une mémoire spécialisée pour le stockage. Par exemple, sur les cartes électroniques grand public de marque Arduino, les programmes sont envoyés à la carte via le port USB, mais les programmes sont enregistrés dans la carte Arduino, dans une mémoire FLASH dédiée. Disque dur ou non, le programme est mémorisé dans la mémoire de l'ordinateur. Il est possible d'installer ou de désinstaller les programmes en modifiant le contenu de la mémoire. Le terme utilisé est alors celui de '''programme stocké en mémoire'''.

Les programmes à installer sont disponibles soit sur un périphérique, comme un DVD ou une clé USB, soit sont téléchargés depuis internet. Les premiers PC fournissaient les logiciels sur des disquettes, qui contenaient un programme d'installation pour enregistrer le programme sur le disque dur de l'ordinateur. Par la suite, le support des logiciels a migré vers les CD et DVD, les logiciels devenant de plus en plus gros. De nos jours, la majorité des applications sont téléchargées depuis le net, l'usage de périphériques est devenu obsolète, même les consoles de jeu abandonnent cette méthode de distribution.

==Les générations d'ordinateurs : un historique rapide==

L'informatique a beaucoup évolué dans le temps. Et une bonne partie de cette évolution tient à l'évolution de l’électronique sous-jacente. Les ordinateurs actuels sont fabriqués avec des transistors, des petits composants électroniques qui servent d'interrupteurs programmables, qu'on détaillera dans ce qui suit. Mais ça n'a pas toujours été le cas. Et cela permet de distinguer plusieurs '''générations d'ordinateurs'''.

===Les ordinateurs électro-mécaniques : les premiers ordinateurs===

Le tout premier ordinateur est le '''Z1''', un modèle unique inventé par Konrad Suze entre 1936 et 1938. Son processeur gérait non pas des nombres entiers, mais des nombres à virgule (des nombres dits flottants, pour être précis), encodés sur 22 bits. Le processeur du Z1 était capable de faire des additions et des soustractions, car il intégrait un circuit additionneur-soustracteur basique. Des circuits annexes permettaient de faire des multiplications et des divisions en enchainant des additions/soustractions successives. Il fonctionnait à une fréquence de 1 Hz, ce qui fait qu'il pouvait faire une addition/soustraction par seconde maximum.

Niveau mémoire, la RAM de l'ordinateur était très limitée : seulement 16 nombres de 22 bits chacun. S'il s'agissait d'une mémoire électronique, les programmes étaient mémorisés sur une mémoire mécanique et précisémment sur des cartes perforées, à savoir des cartes en papier/plastique dans lesquelles un 1 est codé par un trou dans le papier et un 0 par une absence de trou. Les programmes étaient exécutés par l'ordinateur quand on insérait la carte perforée dans le lecteur et qu'on appuyait sur un bouton.

[[File:German Museum of Technology, Berlin 2017 024.jpg|centre|vignette|upright=2|Réplique du Z1 au ''German Museum of Technology'' de Berlin, 2017.]]

Après sa destruction dans un bombardement, le Z1 a été reconstruit et amélioré, ce qui donné les deux ordinateurs Z2 et Z3. Quelques années plus tard, quelques laboratoires de recherche ont fabriqués des ordinateurs dans leur coin, comme le Harvard Mark I et le Colossus Mark 1 (UK) qui ont été mis en service en 1944. Ils ont servi pour les cryptanalystes pour casser les codes utilisés par les Allemands pour leurs transmissions, pendant la seconde guerre mondiale.

Les ordinateurs cités dans le précédent paragraphe étaient tous des ordinateurs dit '''électro-mécaniques''', car ils mélangeaient des composants électroniques et des composants mécaniques (tout ce qui a trait aux cartes perforées, notamment). Les composants électroniques étaient généralement des relais, à savoir des interrupteurs commandables électriquement, qui sont plus ou moins équivalents aux transistors modernes. La majeure partie des ordinateurs des années 40 étaient de ce type, mais leur nombre n'a pas dépassé 30. Il faut dire qu'ils ont rapidement laissé la place à des ordinateurs purement électroniques, que nous allons voir dans ce qui suit.

===La première génération : les tubes à vide===

Les ordinateurs qui ont suivi les ordinateurs électromécaniques sont regroupés dans la '''première génération d'ordinateur'''. Ils étaient conçus avec des tubes à vide, des espèces d'interrupteurs commandables, les ancêtres des transistors modernes. Les tubes à vide étaient assez encombrants, ils consommaient beaucoup de courant, ils chauffaient et étaient assez peu fiables. Ils tombaient en panne assez souvent. Et ils étaient assez simples à fabriquer, mais restaient malgré tout chers.

Les tubes à vide sont des ampoules à filament améliorées. Pour rappel, les ampoules à filament étaient des ampoules en verre dans lesquelles on plaçait un filament métallique. Le filament chauffait quand on envoyait du courant dedans et émettait de la lumière. De plus, un tube à vide contient en plus une électrode, une plaque en métal qui émet ou capte des électrons.

[[File:Diode vacuum tube.svg|vignette|Diode vacuum tube]]

Dans le cas le plus simple, le filament n'émet pas de lumière quand on le chauffe : il émet des électrons, de l'électricité. Il n'y a qu'une seule électrode, qui capte des électrons émis par le filament quand il chauffe. Vu qu'elle capte des électrons, on l'appelle l''''anode'''. Le résultat est un circuit qui laisse passer le courant, mais seulement dans un sens : du filament vers l'anode, l'autre sens n'est pas possible vu que l'anode ne peut pas émettre d'électrons. Un tel circuit est appelé une '''diode'''.

Une variante des tubes à vide précédent utilise un filament chauffant, qui n'émet pas d’électrons. A la place, le filament chauffe une seconde électrode, appelée la '''cathode''', qui émet les électrons quand elle est assez chaude. Le filament doit donc chauffer, ce qui réchauffe la cathode, qui elle-même émet des électrons en direction de l'anode.

{|
|[[File:Diode à vide.png|vignette|upright=1.5|Diode à vide, avec cathode.]]
|[[File:Diode à vide schéma de fonctionnement.png|vignette|upright=1.5|Diode à vide, schéma de fonctionnement. Le filament X chauffe la cathode (2), qui émet des électrons (3), vers l'anode (4).]]
|}

Les tubes à vide précédent peuvent être modifiés en ajoutant une grille métallique entre la cathode et l'anode. La grille est alimentée avec une tension électrique, ce qui la charge électriquement. Suivant sa charge, elle laisse plus ou moins passer les électrons de la cathode vers l'anode. Si elle n'est pas chargée, que la tension est de 0 Volts, elle ne fera pas obstacle aux électrons et le tube à vide fonctionnera comme une diode basique. Mais si la grille est chargée avec une tension négative, sa charge électrique va repousser les électrons et les empêcher de passer de la cathode vers l'anode.

Le tube à vide se comporte alors comme un interrupteur : fermé ou ouvert suivant ce qu'on met sur la grille. Un tel tube à vide est appelée une '''triode''', car c'est une diode à laquelle on a ajouté une entrée pour charger la grille. De tels interrupteurs commandables électriquement sont combinés pour fabriquer des circuits plus élaborés, comme les portes logiques qu'on verra d'ici quelques chapitres.

[[File:Triode.png|centre|vignette|upright=2.5|Triode, ancêtre du transistor]]

Les tubes à vides étaient utilisés pour le processeur et quelques circuits annexes, mais les mémoires utilisaient d'autres technologies. Les mémoires de l'époque n'étaient pas du tout des mémoires électroniques. Il existait déjà des ancêtres des disques durs, à savoir des mémoire magnétiques appelées tambours magnétiques, bandes magnétiques, mémoires à tore de ferrite, etc. Les mémoires RAM, quant à elles, utilisaient elles des technologies totalement abandonnées : les mémoires à lignes de délai étaient des mémoires acoustiques, les tubes Williams étaient des écrans CRT modifiés, etc. Un chapitre entier sera dédié aux technologies des mémoires de l'époque.

[[File:Elektronenroehren-auswahl.jpg|centre|vignette|upright=2|Tubes à vides.]]

L'usage de tubes à vide les place entre les premiers ordinateurs électro-mécaniques et les ordinateurs utilisant des transistors. Au vu de la taille des tubes à vide, les ordinateurs de l'époque étaient composés de plusieurs milliers de ces tubes, guère plus. Et malgré cela, un ordinateur prenait facilement un étage de bâtiment entier, ou au moins plusieurs pièces. La conséquence est que les ordinateurs de première génération étaient très simples, rudimentaires quand on les compare aux ordinateurs modernes. Ils ne géraient que quelques opérations simples : l'addition, la soustraction, pas grand-chose de plus. À quelques exceptions près, ils ne géraient pas la multiplication et encore moins la division, cela aurait demandé trop de tubes à vides.

Une des toutes premières machines construite avec des tubes à vide était l'Atanasoff–Berry. Ce n'était pas un ordinateur, car elle ne pouvait pas exécuter de programme sans intervention humaine pour séquencer des opérations, mais c'était la première machine de calcul purement électronique, sans aucune pièce mécanique. Elle utilisait une mémoire RAM construite avec des condensateurs, ceux-ci étant placés sur des cylindres tournants. Les circuits de calcul étaient construits avec des tubes à vide et faisaient leur travail un bit à la fois. Elle fonctionnait à une fréquence de 60 Hz et pouvait faire 30 additions/soustractions par seconde. Les nombres étaient encodés sur 50 bits. 

[[File:Atanasoff Berry Computer.gif|centre|vignette|upright=2.5|Atanasoff–Berry.]]

L'arrivée de l'ENIAC en 1945 a changé la donne. Cet ordinateur a introduit plusieurs innovations majeures. La première est assez technique, il s'agit de la turing-complétude, elle a trait aux programmes qui peuvent être écrit pour un ordinateur, nous ne la détaillerons pas ici.

[[File:BabyArchitecture.png|vignette|Architecture de la Manchester Baby.]]

En 1948, le ''Manchester Baby'' a introduit une innovation extrêmement importante : le programme n'était plus mémorisé sur des cartes perforées, mais dans une mémoire électronique à l’intérieur de l'ordinateur lui-même. En clair, le ''Manchester Baby'' était le premier '''ordinateur à programme stocké en mémoire''' en français. Au-delà de ça, le Manchester Baby restait quand même très simple, c'était limite un prototype.

Niveau interface, l'ordinateur avait une console avec 32 boutons, des interrupteurs et un écran de sortie sur lequel afficher les résultats. A l'intérieur, il y avait un processeur et une RAM de 32 nombres de 32 bits, fabriquées avec des tubes Williams (abordés dans une annexe à la fin du cours). Une instruction prenant autant de place qu'un nombre en RAM, ce qui limitait les programmes à 32 instructions maximum. Le processeur gérait 8 instructions en tout, mais la seule instruction de calcul qu'il gérait était la soustraction. L'addition n'était pas supportée. Il pouvait cependant émuler l'addition à partir d'une soustraction et inversant l'opérande soustrait.

Le Manchester Mark 1 était une amélioration du Manchester Baby. Il utilisait 4500 tubes à vide. L'ordinateur gérait des nombres de 40 bits, mais les instructions étaient codées sur 20 bits. La RAM avait la même taille, à savoir 32 nombres, leur taille était simplement augmentée. Par contre, la RAM était complémentée par l’ancêtre du disque dur magnétique, à savoir un tambour magnétique, l’ancêtre du disque dur magnétique. Il contenait 40 pages, chacune ayant la même taille que la RAM. Contrairement à la Manchester Baby, son processeur gérait l'addition. Les multiplications étaient réalisées par des additions successives, mais le processeur intégrait des registres pour mémoriser les opérandes à multiplier.

Par la suite, les ordinateurs commerciaux ont vu le jour. Les ordinateurs précédents provenaient de projets de recherches, souvent publics. Mais les entreprises privées se sont mises à fabriquer des ordinateurs elle-mêmes, pour les vendre à d'autres entreprises. On peut notamment citer les ordinateurs comme le UNIVAC I, le Bull Gamma 3 ou les premiers ordinateurs IBM. La performance de ces ordinateurs était nettement plus importante que leurs prédécesseurs, avec des fréquences de l'ordre de la centaine de kilo-hertz. Par exemple, le Bull Gamma 3 allait à 281 kHz, l'IBM 650 allait à 50 Khz.

===La seconde génération : le remplacement des tubes à vides par des transistors===

[[File:IBM 7070.jpg|vignette|Cartes imprimées de l'IBM 704, avec des transistors et résistances dessus.]]

La '''seconde génération''' est celle des ordinateurs fabriqués avec des '''transistors''' isolés, reliés entre avec des fils électriques. Les transistors en question possèdent trois broches, des pattes métalliques sur lesquelles on connecte des fils électriques. Le transistor s'utilise le plus souvent comme un interrupteur commandé par sa troisième broche. Le courant qui traverse les deux premières broches passe ou ne passe pas selon ce qu'on met sur la troisième.

[[File:Transistor basic flow.svg|centre|vignette|Un transistor est un morceau de conducteur, dont la conductivité est contrôlée par sa troisième broche/borne.]]

Les ordinateurs de seconde génération avaient entre 1000 et 500 000 transistors. Les capacités des ordinateurs étaient donc nettement supérieures à celles des ordinateurs de première génération. Une part non négligeable des ordinateurs de seconde génération supportait l'opération de multiplication, absente sur les ordinateurs de première génération. Néanmoins, cela variait beaucoup selon les ordinateurs.

Un exemple assez hors du commun est celui du premier modèle de l'IBM 1620. Le tout premier modèle n'avait aucun circuit de calcul, il n'était même pas capable de faire une addition ou une multiplication. A la place, il utilisait une table d'addition et une table de multiplication en mémoire RAM. Les deux tables devaient être initialisées par le logiciel lors du démarrage de la machine. La table d'addition faisait une centaine de chiffres, la table de multiplication faisait le double. Le processeur de l'ordinateur gérait des instructions pour faire des additions ou des multiplications, mais ces opérations lisaient le résultat dans la table d'addition. Les calculs étaient faits chiffre par chiffre, avec un encodage partiellement décimal, partiellement binaire (des chiffres décimaux étaient encodés en binaire, nous en reparlerons quand nous parlerons du BCD) !

[[File:KL CoreMemory.jpg|vignette|Mémoire à tore de ferrite.]]

Les transistors n'étaient utilisés que pour le processeur et les circuits annexes. La mémoire n'était pas faite en transistors, pas à cette époque. La mémoire était une mémoire aujourd'hui abandonnée, appelée une '''mémoire à tores de ferrite'''. Elle sera détaillée dans un chapitre ultérieur. Mais sachez pour le moment qu'il s'agit d'une mémoire au support magnétique, les données étant stockées sur un support magnétique.

Les transistors étaient au départ de la même taille que les tubes à vide, mais ils ont rapidement rétrécit. Ils prenaient encore beaucoup de place dans les 60-70, ce qui fait que les ordinateurs étaient assez gros. Concrètement, ils prenaient une pièce de bâtiment entière dans le meilleur des cas. C'était l'époque des gros ''mainframes'', reliés à des terminaux, peu puissants comparé aux standards actuels. Seules les grandes entreprises et les grands instituts de recherche pouvaient se payer les services de ce genre d'ordinateurs. Seuls les professionnels avaient accès à ce genre d'équipement.

===La troisième génération : le circuit intégré===

[[File:D8259AC-2.jpg|vignette|Exemple de circuit intégré.]]

La troisième génération est toujours fabriquée avec des transistors, mais dont la taille a été réduite. Avec l'évolution de la technologie, les transistors ont diminué en taille, de plus en plus. Ils sont devenus tellement petits qu'ils ont fini par être regroupés dans des '''circuits intégrés''', des circuits regroupent plusieurs transistors sur la même puce de silicium. Les circuits intégrés se présentent le plus souvent sous la forme de boitiers rectangulaires, comme illustré ci-contre. D'autres ont des boitiers de forme carrées, comme ceux que l'on peut trouver sur les barrettes de mémoire RAM, ou à l'intérieur des clés USB/ disques SSD.

Lors de cette génération, les processeurs étaient fournis en pièces détachées qu'il fallait relier entre elles. Le processeur était composé de plusieurs circuits intégrés séparés, impossible de mettre un processeur dans un seul boitier. Un exemple de processeur conçu en kit est la série des Intel 3000. Elle regroupe plusieurs circuits séparés aux noms à coucher dehors, mais dont vous comprendrez ce qu'ils veulent dire dans les chapitres adéquats : l'Intel 3001 est un séquenceur, l'Intel 3002 regroupe unité de calcul et registres, le 3003 est un circuit d'anticipation de retenue complémentaire du 3002, le 3212 est une mémoire tampon, le 3214 est une unité de gestion des interruptions, les 3216/3226 sont des interfaces de bus mémoire. On pourrait aussi citer la famille de circuits intégrés AMD Am2900.

Même si le processeur était en pièces détachées, utiliser une dizaine de circuits intégrés était nettement mieux que d'utiliser plusieurs milliers de transistors individuels. En conséquence, les ordinateurs ont vu leur taille grandement réduite, passant de pièces entières à une simple armoire, voire à quelques cartes intégrées superposées. De plus, le prix des circuits intégré était abordable, du moins comparé aux ordinateurs d'avant. Le prix des ordinateurs a alors grandement décru, permettant à des entreprises et administrations de taille modeste de s'équiper d'ordinateurs.

===La quatrième génération : le microprocesseur===

[[File:MOS6502.svg|vignette|Microprocesseur, ici un processeur MOS6502, de la quatrième génération.]]

Lors de la troisième génération, les circuits intégrés regroupaient plusieurs dizaines ou centaines de transistors, mais sont rapidement montés en gamme. De centaines de transistors, ils sont passés au millier de transistors, puis au million et maintenant au-delà du milliard. Les transistors étaient devenus tellement petits, tellement miniaturisés, qu'il était devenu possible de mettre un processeur entier dans un circuit intégré. C'est ainsi qu'est né le microprocesseur, à savoir un processeur qui tient tout entier dans un seul circuit imprimé. La quatrième génération d’ordinateur est celle des ordinateurs basés autour d'un microprocesseur.

Les tout premiers microprocesseurs étaient des processeurs à application militaire, comme le processeur du F-14 CADC ou celui de l'Air data computer. Le tout premier microprocesseur commercialisé au grand public est le 4004 d'Intel, sorti en 1971. L'intel 4004 comprenait environ 2300 transistors, avait une fréquence de 740 MHz, pouvait faire 46 opérations différentes, et manipulait des entiers de 4 bits. Il était au départ un processeur de commande, prévu pour être intégré dans la calculatrice Busicom calculator 141-P, mais il fut utilisé pour d'autres applications quelque temps plus tard. Immédiatement après le 4004, les premiers microprocesseurs 8 bits furent commercialisés. Le 4004 fut suivi par le 8008 et quelques autres processeurs 8 bits extrêmement connus, comme le 8080 d'Intel, le 68000 de Motorola, le 6502 ou le Z80.

Les microprocesseurs permirent encore uen fois de réduire la taille des ordinateurs, qui pouvaient tenir dans un boitier de PC, ou un boitier de console de jeu. Le prix des ordinateurs a aussi chuté en même temps que les transistors étaient miniaturisés. C'est cette invention qui permis l'invention des consoles de jeux et des mini-ordinateurs, à savoir les ordinateurs personnels. Sans miniaturisation, on n'aurait pas d'ordinateur personnel, pas de PC fixe ou portable.

==L'organisation du cours : les différents niveaux d'explication==

Le fonctionnement d'un ordinateur est assez complexe à expliquer car les explications peuvent se faire sur plusieurs niveaux. Par plusieurs niveaux, on veut dire qu'un ordinateur est composé de composants très simples, qui sont assemblés pour donner des composants eux-même plus complexes, qui sont eux-même regrouper, etc. Étudier tout cela demande de voir plusieurs niveaux, allant de transistors très petits à des processeurs multicœurs. Les niveaux les plus bas sont de l'électronique pur et dure, alors que ceux plus haut sont à mi-chemin entre électronique et informatique.

===Les niveaux d'abstraction en architecture des ordinateurs===

Les trois premiers niveaux sont de l'électronique pur et dure. Ils correspondent aux premiers chapitres du cours, qui porteront sur les circuits électroniques en général.
* Le premier niveau est celui des '''transistors''', des circuits intégrés, des ''wafer'' et autres circuits de très petite taille.
* Le second niveau est celui des '''portes logiques''', des circuits très basiques, très simples, à la base de tous les autres.
* Le troisième niveau est celui dit de la '''''Register Transfer Level''''', où un circuit électronique est construit à partir de circuits basiques, dont des registres et autres circuits dits combinatoires.
Les deux niveaux suivants sont de l'informatique proprement dit. C'est dans ces deux niveaux qu'on étudie les ordinateurs proprement dit, les circuits qu'il y a dedans et non l'électronique en général.
* Le quatrième niveau est celui de la '''microarchitecture''', qui étudie ce qu'il y a à l'intérieur d'un processeur, d'une mémoire, des périphériques et autres.
* Le cinquième niveau est celui de l''''architecture externe''', qui décrit l'interface du processeur, de la mémoire, d'un périphérique ou autre. Par décrire l'interface, on veut dire : comment un programmeur voit le processeur et la mémoire, comment il peut les manipuler. Une architecture externe unique peut avoir plusieurs microarchitecture, ce qui fait qu'on sépare les deux. Tout cela sera plus clair quand on passera aux chapitres sur le processeur et les mémoires.

Nous n'allons pas voir les 5 niveaux dans l'ordre, des transistors vers l'architecture externe. En réalité, nous allons procéder autrement. La première partie du cours portera sur les trois premiers niveaux, le reste sur les deux autres. Les 5 niveaux seront vus dans des chapitres séparés, du moins le plus possible. Au niveau pédagogique, tout est plus simple si on scinde les 5 niveaux. Bien sûr, il y a quelques explications qui demandent de voir plusieurs niveaux à la fois. Par exemple, dans le chapitre sur les mémoires caches, nous auront des explications portant sur la RTL, la microarchitecture du cache et son architecture externe. Mais le gros du cours tentera de séparer le plus possible les 5 niveaux.

===Les trois parties principales du cours===

Nous allons commencer par parler du binaire, avant de voir les portes logiques. Avec ces portes logiques, nous allons voir comment fabriquer des circuits basiques qui reviendront très souvent dans la suite du cours. Nous verrons les registres, les décodeurs, les additionneurs et plein d'autres circuits. Puis, nous reviendrons au niveau des transistors pour finir la première partie. La raison est que c'est plus simple de faire comme cela. Tout ce qui a trait aux transistors sert à expliquer comment fabriquer des portes logiques, et il faut expliquer les portes logiques pour voir le niveau de la RTL.

Une fois la première partie finie, nous allons voir les différents composants d'un ordinateur. Une première partie expliquera ce qu'il y a dans un ordinateur, quels sont ses composants. Nous y parlerons de l'architecture de base, de la hiérarchie mémoire, des tendances technologiques, et d'autres généralités qui serviront de base pour la suite. Puis, nous verrons dans l'ordre les bus électroniques, les mémoires RAM/ROM, le processeur, les périphériques, les mémoires de stockage (SSD et disques durs) et les mémoires caches. Pour chaque composant, nous allons voir leur architecture externe, avant de voir leur microarchitecture. La raison est que la microarchitecture ne peut se comprendre que quand on sait quelle architecture externe elle implémente.

Enfin, dans une troisième partie, nous allons voir les optimisations majeures présentes dans tous les ordinateurs modernes, avec une partie sur le pipeline et le parallélisme d'instruction, et une autre sur les architectures parallèles. Pour finir, les annexes de fin parlerons de sujets un peu à part.

&lt;noinclude&gt;
{{NavChapitre | book=Fonctionnement d'un ordinateur
           | next=L'encodage des données
           | nextText=L'encodage des données
}}
&lt;/noinclude&gt;</text>
      <sha1>18xq13z726xgxse2su8npqt6mkjtzx4</sha1>
    </revision>
    <revision>
      <id>744172</id>
      <parentid>744171</parentid>
      <timestamp>2025-06-05T15:47:28Z</timestamp>
      <contributor>
        <username>Mewtow</username>
        <id>31375</id>
      </contributor>
      <minor />
      <comment>/* La première génération : les tubes à vide */</comment>
      <origin>744172</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="49755" sha1="2d8saqtpblv31xaulgklrwfsbxvprj4" xml:space="preserve">Pour commencer, nous allons voir qu'il existe de nombreux types d'ordinateurs. Le plus connu est certainement le PC, l'ordinateur personnel, que vous avez sans doute dans votre salon. Les ordinateurs portables sont un deuxième type d'ordinateur assez intuitif, que vous avez peut-être. Mais il y a aussi d'autres types d'ordinateurs auxquels vous n'avez jamais été confrontés.

==Les différents types d'ordinateurs==

Dans cette section, nous allons décrire rapidement les ordinateurs les plus courant, mais surtout voir ce qu'il y a à l'intérieur d'un ordinateur.

===L'ordinateur de type PC fixe===

De l'extérieur, l'ordinateur est composé d'une unité centrale sur laquelle on branche des périphériques.

[[File:Typical computer architecture systems.jpg|vignette|upright=1.5|Exemples de périphériques, connectés à une unité centrale (ici appelée à tort ''operating system'').]]

Les '''périphériques''' regroupent l'écran, la souris, le clavier, l'imprimante, et bien d'autres choses. Ils permettent à l'utilisateur d'interagir avec l'ordinateur : un clavier permet de saisir du texte sous dans un fichier, une souris enregistre des déplacements de la main en déplacement du curseur, un écran affiche des données d’images/vidéos, un haut-parleur émet du son, etc. Tout ce qui est branché sur un ordinateur est, formellement un périphérique.

L''''unité centrale''' est là où se trouvent tous les composants importants d'un ordinateur, ceux qui font des calculs, qui exécutent des logiciels, qui mémorisent vos données, etc. Voici ce à quoi ressemble l'intérieur de l'unité centrale. Trois sections sont visibles : l'alimentation électrique en haut à gauche, la carte mère en bas à gauche et en jaune/orange, les disques et lecteurs à droite des câbles. Et on voit aussi beaucoup de câbles.

[[File:Asus P5K-SEIntel E6320.jpg|centre|vignette|upright=2|Exemple d'unité centrale.]]

Tout en haut à gauche, se trouve l''''alimentation électrique''', qui convertit le courant de la prise électrique en un courant plus faible, utilisable par les autres composants. Elle émet de nombreux câbles assez gros, qui sont reliés au reste. Les PC actuels utilisent des alimentations électriques standardisées, qui fournissent trois tensions au reste de l'ordinateur : une tension de 12 Volts, une de 5 Volts, une de 3,3 Volts.

À droite, caché par la partie &quot;métallique&quot; du boitier, se trouvent les lecteurs de CD/DVD, et les disques durs. Les lecteurs CD-ROM ou DVD-ROM permettaient de lire des CD ou des DVD. Je parle au passé, car ils ont aujourd'hui disparu des ordinateurs modernes. Les '''disques durs''' sont des mémoires de stockage, qui mémorisent vos données de manière permanente. De nos jours, ils sont remplacés par des SSD, qui sont des disques durs électroniques, là où les disques durs proprement dit sont des mémoires magnétiques. Nous verrons la différence dans deux chapitres dédiés, un sur les disques durs, l'autre sur les SSD.

En bas à droite, se trouve la '''carte mère''' un support plat, en plastique ou en céramique, sur laquelle sont soudés/connectés les autres composants. Sur celle-ci, de nombreux composants sont soudés, d'autres sont branchés dessus avec des câbles, d'autres sont connectés dessus avec des connecteurs. Ils sont reliés entre eux par des fils conducteurs, le plus souvent du cuivre ou de l’aluminium, ce qui leur permet de s’échanger des données. Sur les cartes simples, ces fils sont intégrés dans la carte électronique, dans des creux du plastique. Ils portent le nom de pistes.

Avant, les disques durs, SSD et lecteurs de CD/DVD sont branchés dessus via des connecteurs dédiés, appelés des connecteurs S-ATA. De nos jours, ils sont branchés sur un autre connecteur, grâce à l'interface NVME. Toujours est-il qu'ils sont reliés à la carte mère par des câbles, ce qui montre que ce sont des sortes de périphériques interne. Ils sont placés dans le boitier, mais on aurait tout aussi bien pu les mettre à l'extérieur, vu qu'ils communiquent avec l'ordinateur par l'intermédiaire d'un câble ou d'un connecteur dédié.

Mais deux autres composants très importants sont eux placés sur la carte mère, directement. Ils ont chacun un connecteur dédié, sur lequel ils sont branchés directement, sans passer par l'intermédiaire d'un câble, mais sans être soudés non plus. Il s'agit du processeur et de la mémoire RAM, deux composants centraux des PC modernes.

[[File:Pentium III SL4CB.jpg|thumb|Processeur Pentium III.]]

Le '''processeur''' traite les données, les modifie, les manipule. Pour faire simple, il s’agit d’une grosse calculatrice hyper-puissante. Il comprend à la fois un circuit qui fait des calculs, et un circuit de contrôle qui s'occupe de séquencer les calculs dans l'ordre demandé. Il est souvent caché sous un radiateur, lui-même surmonté par un ventilateur. En effet, un processeur chauffe beaucoup, ce qui demande d'évacuer cette chaleur. Un chapitre entier expliquera pourquoi les processeurs chauffent, ainsi que les techniques utilisées pour limiter leur production de chaleur et leur consommation électrique.

La '''mémoire vive''' conserve des informations/données temporairement, tant que le processeur en a besoin. Elle prend la forme de barrettes de RAM, comme montré ci-dessous.

[[File:2 gb ddr2 667.jpg|centre|vignette|upright=2|Barrette de RAM.]]

Outre ces composants dits principaux, un ordinateur peut comprendre plusieurs composants moins importants, surtout présents sur les ordinateurs personnels. Ils sont techniquement facultatifs, mais sont très présents dans les ordinateurs personnels. Cependant, certains ordinateurs spécialisés s'en passent. Il s'agit des diverses '''cartes d'extension''' sont branchées sur la carte mère. Elles permettent d’accélérer certains calculs ou certaines applications, afin de décharger le processeur. Par exemple, la carte graphique s'occupe des calculs graphiques, qu'il s'agisse de graphismes 3D de jeux vidéos ou de l'affichage en 2D du bureau. Dans un autre registre, la carte son prend en charge le microphone et les haut-parleurs.

[[Fichier:Personal computer, exploded 4.svg|thumb|upright=1.0|Éclaté d'un ordinateur de type PC :&lt;br /&gt;
1 : Écran ;&lt;br /&gt;
2 : Carte mère ;&lt;br /&gt;
3 : Processeur ;&lt;br /&gt;
4 : Câble Parallel ATA ;&lt;br /&gt;
5 : Mémoire vive (RAM) ;&lt;br /&gt;
6 : Carte d'extension ;&lt;br /&gt;
7 : Alimentation électrique ;&lt;br /&gt;
8 : Lecteur de disque optique ;&lt;br /&gt;
9 : Disque dur ;&lt;br /&gt;
10 : Clavier ;&lt;br /&gt;
11 : Souris.]]

Si on regarde une carte mère de face, on voit un grand nombre de connecteurs, mais aussi des circuits électroniques soudés à la carte mère.

[[File:Architecture matérielle d'une carte mère.png|centre|vignette|upright=2.0|Architecture matérielle d'une carte mère]]

Les '''connecteurs''' sont là où on branche les périphériques, la carte graphique, le processeur, la mémoire, etc. Dans l'ensemble, toute carte mère contient les connecteurs suivants :
* Le processeur vient s’enchâsser dans la carte mère sur un connecteur particulier : le '''socket'''. Celui-ci varie suivant la carte mère et le processeur, ce qui est source d'incompatibilités.
* Les barrettes de mémoire RAM s’enchâssent dans un autre type de connecteurs: les '''slots mémoire'''.
* Les mémoires de masse disposent de leurs propres connecteurs : connecteurs P-ATA pour les anciens disques durs, et S-ATA pour les récents.
* Les périphériques (clavier, souris, USB, Firewire, ...) sont connectés sur un ensemble de connecteurs dédiés, localisés à l'arrière du boitier de l'unité centrale. 
* Les autres périphériques sont placés dans l'unité centrale et sont connectés via des connecteurs spécialisés. Ces périphériques sont des cartes imprimées, d'où leur nom de '''cartes filles'''. On peut notamment citer les cartes réseau, les cartes son, ou les cartes vidéo.

===Les ordinateurs portables===

[[File:Samsung QX-511 (2).JPG|vignette|Ordinateur portable Samsung QX-511 (2), pour illustration.]]

Un ordinateur portable est identique à un ordinateur de type PC. Si vous ouvrez votre ordinateur portable (attention à la garantie), vous retrouverez les mêmes composants qu'un PC à l'intérieur. Un point important est la présence d'une batterie à l'intérieur du PC portable, absente des PC fixes.

[[File:LG gram 14Z90Q mainboard with battery.jpg|centre|vignette|upright=2|LG gram 14Z90Q avec sa batterie.]]

Une fois la batterie et les circuits associés retiré, la seule différence notable est que tous les composants sont soudés sur la carte mère, au lieu d'être branchés sur des connecteurs, à part éventuellement la RAM et le disque dur.

[[File:LG gram 14Z90Q mainboard without battery.jpg|centre|vignette|upright=2|LG gram 14Z90Q sans sa batterie.]]

La RAM est parfois soudée sur la carte mère, d'autres fois sous la forme de barrettes de mémoire vive semblables à celles des PC. Dans le dernier cas, elle est connectée à des connecteurs spécifiques, ce qui permet de les changer/upgrader. Les PC portables sont parfois construits de manière à pouvoir changer la RAM facilement, en ouvrant un cache spécial, concu pour.

[[File:Lenovo G555 состав - Донор.JPG|centre|vignette|upright=2|Lenovo G555.]]

La conception d'un ordinateur portable est légèrement différente de celle d'un PC, pour des raisons thermiques. Un PC fixe a plus de place pour évacuer sa chaleur. Les ventilateurs peuvent plus facilement déplacer l'air dans le boitier, même si le flux d'air dans le boitier est éventuellement gêné par la carte graphique. Mais l'évacuation de la chaleur est assez efficace. Sur les PC portables, leur finesse fait que le trajet de l'air est beaucoup plus contraint. Évacuer la chaleur produite par l'ordinateur est plus complexe, ce qui demande d'utiliser des systèmes de refroidissement et de ventilation spécifiques.

Là où les PC fixes se débrouillent avec des radiateurs et des ventilateurs posés sur le processeur, les PC portables font autrement. Ils ne peuvent pas forcément mettre le ventilateur sur le processeur. A la place, ils mettent le ventilateur à côté, mais le processeur est surmonté par un mécanisme de transmission de la chaleur, qui transfère la chaleur du processeur vers le ventilateur.

[[File:Diagram - How a laptop cooling system works.png|centre|vignette|upright=2|Comment fonctionne le système de ventilation d'un ordinateur portable, en anglais.]]

Les difficultés pour dissiper la chaleur font que les ordinateurs portables utilisent souvent des composants peu performants, mais qui chauffent peu. En effet, nous verrons que plus un composant est puissant, plus il chauffe. La relation n'est pas parfaite, mais les processeurs haute performance chauffent plus que les modèles d'entrée ou milieu de gamme moins puissants. En conséquence, les PC portables sont souvent moins puissants que les PC fixes, même pour les modèles dit ''gaming''.

===Les serveurs et ''mainframes''===

Les grandes entreprises utilisent des ordinateurs de grande taille, très puissants, appelés des ''mainframes''. Ils sont souvent confondus avec les serveurs par le grand public, il y a une différence entre les deux. Un serveur est une fonction logicielle/réseau, pas un type d'ordinateur. Mais laissons cette différence de côté, ce qui est dit pour les ''mainframes'' sert pour les gros serveurs haute performance.

[[File:IBM Z15 mainframe.jpg|vignette|Exemple de ''mainframe''' de type IBM Z15.]]

Les anciens ''mainframes'' des années 50-80 avaient une taille pouvant être impressionnante, au point de prendre une pièce complète d'un bâtiment. Mais de nos jours, les ''mainframes'' tiennent dans une grosse armoire un peu haute. Les ''mainframes'' doivent rester allumé en permanence et ne doivent pas être éteint, sauf éventuellement quelques jours par an pour des opérations de maintenance. Ils utilisent pour cela des techniques spécifiques, avec beaucoup de redondance interne.

[[File:ACONIT hall grandes machines.jpg|centre|vignette|upright=2|''Mainframe'' ACONIT.]]

Les ''mainframes'' sont aussi conçus pour mutualiser au maximum leur utilisation, ils peuvent être utilisés par plusieurs utilisateurs à la suite, voire en même temps. Pour cela, les anciens ''mainframes'' étaient capables de faire tourner plusieurs applications distinctes l'une à la suite de l'autre, avec des commutations fréquentes entre logiciels. De nos jours, ils sont capables d'exécuter un grand nombre de tâches en même temps, grâce à la présence de plusieurs processeurs. Les ''mainframes'' modernes sont même capables de faire tourner plusieurs systèmes d'exploitation en même temps si besoin.

Les anciens ''mainframes'' étaient des ordinateurs assez simples, avec un processeur, de la mémoire RAM, un ou plusieurs disques durs, pas plus. Le ''mainframe'' était tellement énorme et cher que les entreprises n'en avaient qu'un seul pour toute l'entreprise. Les employés avaient sur leur bureau des terminaux, qui permettaient d'accéder à l'ordinateur central, mais n'étaient pas des ordinateurs. Les terminaux étaient des composants électroniques simples, avec un écran, un clavier et une souris, mais sans processeur. Ils envoyaient des données au ''mainframe'', ils en recevaient de sa part, mais tout traitement était réalisé sur le ''mainframe''. L'arrivée sur le marché des ordinateurs personnels, de type PC fixe/portable, a entrainé l'abandon de ce genre de pratique, tous les employés ont maintenant un ordinateur rien que pour eux.

{|
|-
! colspan=&quot;2&quot; | Exemples de terminaux
|-
|[[File:Terminal-in2-sm9400.jpg|centre|vignette|upright=1.5|Exemple de terminal. Notez la présence d'un écran et d'un clavier, mais l'asbence d'une unité centrale.]]
|[[File:Chromatics CT4100.jpg|vignette|upright=1.5|Autre exemple de terminal. Le clavier est couplé à un stylo CRT, qui remplacait la souris et agissait sur l'écran comme s'il était tactile.]]
|-
! colspan=&quot;2&quot; | Intérieur d'un terminal
|-
|[[File:CT1024 Monitor.jpg|vignette|upright=1.5|Terminal CT1024, sans le boitier extérieur.]]
|[[File:CT1024 Terminal System.jpg|vignette|upright=1.5|Terminal CT1024, description des composants interne.]]
|}

De nos jours, les ''mainframes'' contiennent en réalité plusieurs ordinateurs simples interconnectés via un réseau local. Un ''mainframe'' qui tient dans une armoire contient facilement une dizaine ou centaine de processeurs, plein de RAM, des disques durs séparés dans une armoire distincte, etc. Vu qu'ils communiquent uniquement via le réseau, ils n'ont pas d'interface, pas d'écran, 'entrée via clavier/souris. Le tout est commandé avec une console de commande, typiquement un ordinateur portable ou un terminal assez simple séparé de l'armoire, qui permet à un administrateur de faire des opérations de surveillance, configuration et maintenance. Il peut y avoir une console de commande pour plusieurs armoires séparées, la console peut même être dans un autre bâtiment et accéder au ''mainframe'' par le réseau.

[[File:IBM System Z9 (type 2094 inside).jpg|centre|vignette|upright=2|''Mainframe'' de type IBM System Z9. L'ordinateur portable sert de console pour qu'un administrateur fasse des opérations de surveillance, configuration et maintenance.]]

Les processeurs et la RAM sont typiquement installés sur des cartes amovibles, qui sont connectées au fond de l'armoire lors de l'installation. Il est même possible de retirer ou d'ajouter des cartes en fonctionnement, afin d'ajouter/retirer des processeurs, des disques durs, etc. Ce qui est très utile si un composant est en panne et qu'il faut le remplacer. 

[[File:IBM TotalStorage Exp400.jpg|centre|vignette|upright=2|IBM TotalStorage Exp400]]

==Un peu d'abstraction : qu'est-ce qu'un ordinateur ?==

Un ordinateur comprend donc un processeur, plusieurs mémoires, des cartes d'extension et une carte mère pour connecter le tout. Mais il s'agit là d'une description assez terre-à-terre de ce qu'est un ordinateur. Une autre description, plus abstraite, se base sur le fait qu'un ordinateur est une énorme calculatrice programmable. Elle permet d'expliquer pourquoi il y a une distinction entre processeur et mémoire, entre unité centrale et périphériques. Tout ce qui va suivre pourra vous paraitre assez abstrait, mais rassurez-vous : les prochains chapitres rendront tout cela plus concrets.

===La séparation entre entrées-sorties et traitement===

L'unité centrale peut être vue comme une énorme calculatrice ultra-puissante, qui exécute des commandes/opérations. Mais à elle seule, elle ne servirait à rien, il faut interagir avec par l'intermédiaire de plusieurs périphériques. Il existe deux types de périphériques, qui sont conceptuellement différents. Les périphériques comme le clavier ou la souris permettent d'envoyer des informations à l'ordinateur, d'agir sur celui-ci. A l'inverse, les écrans transmettent des informations dans le sens inverse : de l'ordinateur vers l'utilisateur. Les premiers sont appelés des '''entrées''', les seconds des '''sorties'''.

Dans un ordinateur, les informations sont représentées sous la forme de nombres. Toute donnée dans un ordinateur est codée avec un ou plusieurs nombres regroupés dans une donnée, un fichier, ou autre. Et la transmissions avec les entrées et sorties se fait là-encore avec des nombres. Par exemple, quand vous appuyez sur votre clavier, le clavier envoie un numéro de touche à l'unité centrale, qui indique quelle touche a été appuyée. L'image à afficher à l'écran est codée sous la forme d'une suite de nombres (un par pixel). L'image est envoyée à l'écran, qui traduit la suite de nombre en image à afficher. Les entrées traduisent des actions utilisateurs en nombres, on dit que les entrées encodent les actions utilisateur. Les sorties font la traduction inverse, elles transforment des suites de nombres en une action physique. On dit qu'elles décodent des informations.

Pour résumer, toute appareil électronique est composé par :
* Des '''entrées''' sur lesquelles l'utilisateur agit sur l'ordinateur. Les entrées transforment les actions de l'utilisateur en nombres, qui sont interprétés par l'ordinateur.
* Une '''unité de traitement''', qui manipule des nombres et fait des calculs/opérations dessus. Les nombres proviennent des entrées, du disque dur, ou d'autres sources, peu importe.
* Des '''sorties''', qui va récupèrent le résultat calculé par l'unité de traitement pour en faire quelque chose : écrire sur une imprimante ou sur un moniteur, émettre du son,...

[[File:Ordinateur théorique Simple 1.png|centre|vignette|upright=2|Ordinateur théorique Simple 1]]

L'unité de traitement proprement dite, celle qui fait les calculs, est couplée à une mémoire qui mémorise les opérandes et résultats des calculs. La séparation entre processeur et mémoire est nécessaire pour qu'un appareil électronique soit qualifié d'ordinateur. De nombreux appareils n'ont pas de séparation entre unité de traitement et mémoire, comme certaines vielles radios AM/FM.

[[File:Schéma de principe d'un ordinateur.png|centre|vignette|upright=2|Schéma de principe d'un ordinateur]]

===Un ordinateur est un appareil programmable===

Les appareils simples sont non-programmables, ce qui veut dire qu’ils sont conçus pour une utilisation particulière et qu’ils ne peuvent pas faire autre chose. Par exemple, les circuits électroniques d’un lecteur de DVD ne peuvent pas être transformé en lecteur audio ou en console de jeux... Les circuits non-programmables sont câblés une bonne fois pour toute, et on ne peut pas les modifier. On peut parfois reconfigurer le circuit, pour faire varier certains paramètres, via des interrupteurs ou des boutons, mais cela s’arrête là. Et cela pose un problème : à chaque problème qu'on veut résoudre en utilisant un automate, on doit recréer un nouveau circuit.

À l'inverse, un ordinateur n’est pas conçu pour une utilisation particulière, contrairement aux autres objets techniques. Il est possible de modifier leur fonction du jour au lendemain, on peut lui faire faire ce qu’on veut. On dit qu'ils sont '''programmables'''. Pour cela, il suffit d’utiliser un logiciel, une application, un programme (ces termes sont synonymes), qui fait ce que l'on souhaite. La totalité des logiciels présents sur un ordinateur sont des programmes comme les autres, même le système d'exploitation (Windows, Linux, ...) ne fait pas exception.

Un programme est une suite de d''''instructions machines''', chaque instruction effectuant une action dans l'ordinateur. Sur les ordinateurs modernes, les instructions les plus communes effectuent une opération arithmétique : une addition, une multiplication, une soustraction, etc. Les ordinateurs modernes sont donc de grosses calculettes très puissantes, capables d'effectuer des millions d'opérations par secondes.

Et qui dit opération dit nombres : un ordinateur gère nativement des nombres, qui sont codés en binaire sur la quasi-totalité des ordinateurs modernes. Les ordinateurs modernes sont capables de faire des calculs sur des nombres entiers, mais aussi des nombres à virgule. Il existe plusieurs manières de représenter des nombres en binaire, certaines représentant des nombres entiers dits naturels (0 et plus), d'autres des nombres signés (positifs ou négatifs), d'autres des nombres à virgule. Un chapitre entier détaillera comment sont encodés ces nombres.

Une instruction est représentée dans un ordinateur par une série de nombres entiers : un nombre qui indique quelle opération/commande effectuer et des autres nombres pour coder les données (ou de quoi les retrouver dans l'ordinateur). L'ordinateur récupére les commandes une par une, les traduit en opération à effectuer, exécuter l'opération, et enregistre le résultat. Puis il recommence avec la commande suivante.

[[File:Ordinateur Théorique Complexe 1.png|centre|vignette|upright=3|Ordinateur Théorique Complexe. En jaune, le programme informatique, la liste de commande. Le rectangle gris est l'ordinateur proprement dit.]]

De nombreux appareils sont programmables, mais tous ne sont pas des ordinateurs. Par exemple, certains circuits programmables nommés FPGA n'en sont pas. Pour être qualifié d'ordinateur, un appareil programmable doit avoir un processeur séparé de la mémoire. De plus, il doit utiliser un '''codage numérique''', chose que nous allons aborder dans le chapitre suivant.

===Les ordinateurs à programme mémorisé ou programme externe===

[[File:Blue-punch-card-front.png|vignette|upright=0.5|Carte Perforée.]]

Au tout début de l'informatique, les programmes étaient enregistrés sur des cartes perforées, à savoir des cartes en papier/plastique percées par endroits. Un 1 est codé par un trou dans le papier et un 0 par une absence de trou. Les programmes étaient exécutés par l'ordinateur quand on insérait la carte perforée dans le lecteur et qu'on appuyait sur un bouton.

Par la suite, les premiers ordinateurs grand public, comme les Amstrad ou les Commodore, utilisaient des cassettes audio magnétiques pour stocker les programmes. Dans le même style, les consoles de jeu utilisaient autrefois des cartouches de jeu, qui contenaient le programme du jeu à exécuter. Pour résumer, les anciens ordinateurs mémorisaient les programmes sur un support externe, lu par un périphérique. De tels ordinateurs sont dits à '''programme externe'''.

: D’anciens ordinateurs personnels, comme l’Amstrad ou le Commodore, permettaient de taper les programmes à exécuter à la main, au clavier, avant d’appuyer une touche pour les exécuter. Nul besoin de vous dire que les cassettes audio étaient plus pratiques.

Mais de nos jours, les programmes sont enregistrés sur le disque dur de l'ordinateur ou dans une mémoire intégrée à l'ordinateur. On dit qu'ils sont installés, ce qui est un mot bien compliqué pour dire que le programme est enregistré sur le disque dur de l’ordinateur. A défaut de disque dur, le programme/logiciel est enregistré dans une mémoire spécialisée pour le stockage. Par exemple, sur les cartes électroniques grand public de marque Arduino, les programmes sont envoyés à la carte via le port USB, mais les programmes sont enregistrés dans la carte Arduino, dans une mémoire FLASH dédiée. Disque dur ou non, le programme est mémorisé dans la mémoire de l'ordinateur. Il est possible d'installer ou de désinstaller les programmes en modifiant le contenu de la mémoire. Le terme utilisé est alors celui de '''programme stocké en mémoire'''.

Les programmes à installer sont disponibles soit sur un périphérique, comme un DVD ou une clé USB, soit sont téléchargés depuis internet. Les premiers PC fournissaient les logiciels sur des disquettes, qui contenaient un programme d'installation pour enregistrer le programme sur le disque dur de l'ordinateur. Par la suite, le support des logiciels a migré vers les CD et DVD, les logiciels devenant de plus en plus gros. De nos jours, la majorité des applications sont téléchargées depuis le net, l'usage de périphériques est devenu obsolète, même les consoles de jeu abandonnent cette méthode de distribution.

==Les générations d'ordinateurs : un historique rapide==

L'informatique a beaucoup évolué dans le temps. Et une bonne partie de cette évolution tient à l'évolution de l’électronique sous-jacente. Les ordinateurs actuels sont fabriqués avec des transistors, des petits composants électroniques qui servent d'interrupteurs programmables, qu'on détaillera dans ce qui suit. Mais ça n'a pas toujours été le cas. Et cela permet de distinguer plusieurs '''générations d'ordinateurs'''.

===Les ordinateurs électro-mécaniques : les premiers ordinateurs===

Le tout premier ordinateur est le '''Z1''', un modèle unique inventé par Konrad Suze entre 1936 et 1938. Son processeur gérait non pas des nombres entiers, mais des nombres à virgule (des nombres dits flottants, pour être précis), encodés sur 22 bits. Le processeur du Z1 était capable de faire des additions et des soustractions, car il intégrait un circuit additionneur-soustracteur basique. Des circuits annexes permettaient de faire des multiplications et des divisions en enchainant des additions/soustractions successives. Il fonctionnait à une fréquence de 1 Hz, ce qui fait qu'il pouvait faire une addition/soustraction par seconde maximum.

Niveau mémoire, la RAM de l'ordinateur était très limitée : seulement 16 nombres de 22 bits chacun. S'il s'agissait d'une mémoire électronique, les programmes étaient mémorisés sur une mémoire mécanique et précisémment sur des cartes perforées, à savoir des cartes en papier/plastique dans lesquelles un 1 est codé par un trou dans le papier et un 0 par une absence de trou. Les programmes étaient exécutés par l'ordinateur quand on insérait la carte perforée dans le lecteur et qu'on appuyait sur un bouton.

[[File:German Museum of Technology, Berlin 2017 024.jpg|centre|vignette|upright=2|Réplique du Z1 au ''German Museum of Technology'' de Berlin, 2017.]]

Après sa destruction dans un bombardement, le Z1 a été reconstruit et amélioré, ce qui donné les deux ordinateurs Z2 et Z3. Quelques années plus tard, quelques laboratoires de recherche ont fabriqués des ordinateurs dans leur coin, comme le Harvard Mark I et le Colossus Mark 1 (UK) qui ont été mis en service en 1944. Ils ont servi pour les cryptanalystes pour casser les codes utilisés par les Allemands pour leurs transmissions, pendant la seconde guerre mondiale.

Les ordinateurs cités dans le précédent paragraphe étaient tous des ordinateurs dit '''électro-mécaniques''', car ils mélangeaient des composants électroniques et des composants mécaniques (tout ce qui a trait aux cartes perforées, notamment). Les composants électroniques étaient généralement des relais, à savoir des interrupteurs commandables électriquement, qui sont plus ou moins équivalents aux transistors modernes. La majeure partie des ordinateurs des années 40 étaient de ce type, mais leur nombre n'a pas dépassé 30. Il faut dire qu'ils ont rapidement laissé la place à des ordinateurs purement électroniques, que nous allons voir dans ce qui suit.

===La première génération : les tubes à vide===

Les ordinateurs qui ont suivi les ordinateurs électromécaniques sont regroupés dans la '''première génération d'ordinateur'''. Ils étaient conçus avec des tubes à vide, des espèces d'interrupteurs commandables, les ancêtres des transistors modernes. Les tubes à vide étaient assez encombrants, ils consommaient beaucoup de courant, ils chauffaient et étaient assez peu fiables. Ils tombaient en panne assez souvent. Et ils étaient assez simples à fabriquer, mais restaient malgré tout chers.

Les tubes à vide sont des ampoules à filament améliorées. Pour rappel, les ampoules à filament étaient des ampoules en verre dans lesquelles on plaçait un filament métallique. Le filament chauffait quand on envoyait du courant dedans et émettait de la lumière. De plus, un tube à vide contient en plus une électrode, une plaque en métal qui émet ou capte des électrons.

[[File:Diode vacuum tube.svg|vignette|Diode vacuum tube]]

Dans le cas le plus simple, le filament n'émet pas de lumière quand on le chauffe : il émet des électrons, de l'électricité. Il n'y a qu'une seule électrode, qui capte des électrons émis par le filament quand il chauffe. Vu qu'elle capte des électrons, on l'appelle l''''anode'''. Le résultat est un circuit qui laisse passer le courant, mais seulement dans un sens : du filament vers l'anode, l'autre sens n'est pas possible vu que l'anode ne peut pas émettre d'électrons. Un tel circuit est appelé une '''diode'''.

Une variante des tubes à vide précédent utilise un filament chauffant, qui n'émet pas d’électrons. A la place, le filament chauffe une seconde électrode, appelée la '''cathode''', qui émet les électrons quand elle est assez chaude. Le filament doit donc chauffer, ce qui réchauffe la cathode, qui elle-même émet des électrons en direction de l'anode.

{|
|[[File:Diode à vide.png|vignette|upright=1.5|Diode à vide, avec cathode.]]
|[[File:Diode à vide schéma de fonctionnement.png|vignette|upright=1.5|Diode à vide, schéma de fonctionnement. Le filament X chauffe la cathode (2), qui émet des électrons (3), vers l'anode (4).]]
|}

[[File:Triode vacuum tube FR.png|vignette|Triode.]]

Les tubes à vide précédents peuvent être modifiés en ajoutant une grille métallique entre la cathode et l'anode. La grille est alimentée avec une tension électrique, ce qui la charge électriquement. Suivant sa charge, elle laisse plus ou moins passer les électrons de la cathode vers l'anode. Si elle n'est pas chargée, que la tension est de 0 Volts, elle ne fera pas obstacle aux électrons et le tube à vide fonctionnera comme une diode basique. Mais si la grille est chargée avec une tension négative, sa charge électrique va repousser les électrons et les empêcher de passer de la cathode vers l'anode.

Le tube à vide se comporte alors comme un interrupteur : fermé ou ouvert suivant ce qu'on met sur la grille. Un tel tube à vide est appelée une '''triode''', car c'est une diode à laquelle on a ajouté une entrée pour charger la grille. De tels interrupteurs commandables électriquement sont combinés pour fabriquer des circuits plus élaborés, comme les portes logiques qu'on verra d'ici quelques chapitres.

[[File:Triode.png|centre|vignette|upright=2.5|Triode, ancêtre du transistor]]

Les tubes à vides étaient utilisés pour le processeur et quelques circuits annexes, mais les mémoires utilisaient d'autres technologies. Les mémoires de l'époque n'étaient pas du tout des mémoires électroniques. Il existait déjà des ancêtres des disques durs, à savoir des mémoire magnétiques appelées tambours magnétiques, bandes magnétiques, mémoires à tore de ferrite, etc. Les mémoires RAM, quant à elles, utilisaient elles des technologies totalement abandonnées : les mémoires à lignes de délai étaient des mémoires acoustiques, les tubes Williams étaient des écrans CRT modifiés, etc. Un chapitre entier sera dédié aux technologies des mémoires de l'époque.

[[File:Elektronenroehren-auswahl.jpg|centre|vignette|upright=2|Tubes à vides.]]

L'usage de tubes à vide les place entre les premiers ordinateurs électro-mécaniques et les ordinateurs utilisant des transistors. Au vu de la taille des tubes à vide, les ordinateurs de l'époque étaient composés de plusieurs milliers de ces tubes, guère plus. Et malgré cela, un ordinateur prenait facilement un étage de bâtiment entier, ou au moins plusieurs pièces. La conséquence est que les ordinateurs de première génération étaient très simples, rudimentaires quand on les compare aux ordinateurs modernes. Ils ne géraient que quelques opérations simples : l'addition, la soustraction, pas grand-chose de plus. À quelques exceptions près, ils ne géraient pas la multiplication et encore moins la division, cela aurait demandé trop de tubes à vides.

Une des toutes premières machines construite avec des tubes à vide était l'Atanasoff–Berry. Ce n'était pas un ordinateur, car elle ne pouvait pas exécuter de programme sans intervention humaine pour séquencer des opérations, mais c'était la première machine de calcul purement électronique, sans aucune pièce mécanique. Elle utilisait une mémoire RAM construite avec des condensateurs, ceux-ci étant placés sur des cylindres tournants. Les circuits de calcul étaient construits avec des tubes à vide et faisaient leur travail un bit à la fois. Elle fonctionnait à une fréquence de 60 Hz et pouvait faire 30 additions/soustractions par seconde. Les nombres étaient encodés sur 50 bits. 

[[File:Atanasoff Berry Computer.gif|centre|vignette|upright=2.5|Atanasoff–Berry.]]

L'arrivée de l'ENIAC en 1945 a changé la donne. Cet ordinateur a introduit plusieurs innovations majeures. La première est assez technique, il s'agit de la turing-complétude, elle a trait aux programmes qui peuvent être écrit pour un ordinateur, nous ne la détaillerons pas ici.

[[File:BabyArchitecture.png|vignette|Architecture de la Manchester Baby.]]

En 1948, le ''Manchester Baby'' a introduit une innovation extrêmement importante : le programme n'était plus mémorisé sur des cartes perforées, mais dans une mémoire électronique à l’intérieur de l'ordinateur lui-même. En clair, le ''Manchester Baby'' était le premier '''ordinateur à programme stocké en mémoire''' en français. Au-delà de ça, le Manchester Baby restait quand même très simple, c'était limite un prototype.

Niveau interface, l'ordinateur avait une console avec 32 boutons, des interrupteurs et un écran de sortie sur lequel afficher les résultats. A l'intérieur, il y avait un processeur et une RAM de 32 nombres de 32 bits, fabriquées avec des tubes Williams (abordés dans une annexe à la fin du cours). Une instruction prenant autant de place qu'un nombre en RAM, ce qui limitait les programmes à 32 instructions maximum. Le processeur gérait 8 instructions en tout, mais la seule instruction de calcul qu'il gérait était la soustraction. L'addition n'était pas supportée. Il pouvait cependant émuler l'addition à partir d'une soustraction et inversant l'opérande soustrait.

Le Manchester Mark 1 était une amélioration du Manchester Baby. Il utilisait 4500 tubes à vide. L'ordinateur gérait des nombres de 40 bits, mais les instructions étaient codées sur 20 bits. La RAM avait la même taille, à savoir 32 nombres, leur taille était simplement augmentée. Par contre, la RAM était complémentée par l’ancêtre du disque dur magnétique, à savoir un tambour magnétique, l’ancêtre du disque dur magnétique. Il contenait 40 pages, chacune ayant la même taille que la RAM. Contrairement à la Manchester Baby, son processeur gérait l'addition. Les multiplications étaient réalisées par des additions successives, mais le processeur intégrait des registres pour mémoriser les opérandes à multiplier.

Par la suite, les ordinateurs commerciaux ont vu le jour. Les ordinateurs précédents provenaient de projets de recherches, souvent publics. Mais les entreprises privées se sont mises à fabriquer des ordinateurs elle-mêmes, pour les vendre à d'autres entreprises. On peut notamment citer les ordinateurs comme le UNIVAC I, le Bull Gamma 3 ou les premiers ordinateurs IBM. La performance de ces ordinateurs était nettement plus importante que leurs prédécesseurs, avec des fréquences de l'ordre de la centaine de kilo-hertz. Par exemple, le Bull Gamma 3 allait à 281 kHz, l'IBM 650 allait à 50 Khz.

===La seconde génération : le remplacement des tubes à vides par des transistors===

[[File:IBM 7070.jpg|vignette|Cartes imprimées de l'IBM 704, avec des transistors et résistances dessus.]]

La '''seconde génération''' est celle des ordinateurs fabriqués avec des '''transistors''' isolés, reliés entre avec des fils électriques. Les transistors en question possèdent trois broches, des pattes métalliques sur lesquelles on connecte des fils électriques. Le transistor s'utilise le plus souvent comme un interrupteur commandé par sa troisième broche. Le courant qui traverse les deux premières broches passe ou ne passe pas selon ce qu'on met sur la troisième.

[[File:Transistor basic flow.svg|centre|vignette|Un transistor est un morceau de conducteur, dont la conductivité est contrôlée par sa troisième broche/borne.]]

Les ordinateurs de seconde génération avaient entre 1000 et 500 000 transistors. Les capacités des ordinateurs étaient donc nettement supérieures à celles des ordinateurs de première génération. Une part non négligeable des ordinateurs de seconde génération supportait l'opération de multiplication, absente sur les ordinateurs de première génération. Néanmoins, cela variait beaucoup selon les ordinateurs.

Un exemple assez hors du commun est celui du premier modèle de l'IBM 1620. Le tout premier modèle n'avait aucun circuit de calcul, il n'était même pas capable de faire une addition ou une multiplication. A la place, il utilisait une table d'addition et une table de multiplication en mémoire RAM. Les deux tables devaient être initialisées par le logiciel lors du démarrage de la machine. La table d'addition faisait une centaine de chiffres, la table de multiplication faisait le double. Le processeur de l'ordinateur gérait des instructions pour faire des additions ou des multiplications, mais ces opérations lisaient le résultat dans la table d'addition. Les calculs étaient faits chiffre par chiffre, avec un encodage partiellement décimal, partiellement binaire (des chiffres décimaux étaient encodés en binaire, nous en reparlerons quand nous parlerons du BCD) !

[[File:KL CoreMemory.jpg|vignette|Mémoire à tore de ferrite.]]

Les transistors n'étaient utilisés que pour le processeur et les circuits annexes. La mémoire n'était pas faite en transistors, pas à cette époque. La mémoire était une mémoire aujourd'hui abandonnée, appelée une '''mémoire à tores de ferrite'''. Elle sera détaillée dans un chapitre ultérieur. Mais sachez pour le moment qu'il s'agit d'une mémoire au support magnétique, les données étant stockées sur un support magnétique.

Les transistors étaient au départ de la même taille que les tubes à vide, mais ils ont rapidement rétrécit. Ils prenaient encore beaucoup de place dans les 60-70, ce qui fait que les ordinateurs étaient assez gros. Concrètement, ils prenaient une pièce de bâtiment entière dans le meilleur des cas. C'était l'époque des gros ''mainframes'', reliés à des terminaux, peu puissants comparé aux standards actuels. Seules les grandes entreprises et les grands instituts de recherche pouvaient se payer les services de ce genre d'ordinateurs. Seuls les professionnels avaient accès à ce genre d'équipement.

===La troisième génération : le circuit intégré===

[[File:D8259AC-2.jpg|vignette|Exemple de circuit intégré.]]

La troisième génération est toujours fabriquée avec des transistors, mais dont la taille a été réduite. Avec l'évolution de la technologie, les transistors ont diminué en taille, de plus en plus. Ils sont devenus tellement petits qu'ils ont fini par être regroupés dans des '''circuits intégrés''', des circuits regroupent plusieurs transistors sur la même puce de silicium. Les circuits intégrés se présentent le plus souvent sous la forme de boitiers rectangulaires, comme illustré ci-contre. D'autres ont des boitiers de forme carrées, comme ceux que l'on peut trouver sur les barrettes de mémoire RAM, ou à l'intérieur des clés USB/ disques SSD.

Lors de cette génération, les processeurs étaient fournis en pièces détachées qu'il fallait relier entre elles. Le processeur était composé de plusieurs circuits intégrés séparés, impossible de mettre un processeur dans un seul boitier. Un exemple de processeur conçu en kit est la série des Intel 3000. Elle regroupe plusieurs circuits séparés aux noms à coucher dehors, mais dont vous comprendrez ce qu'ils veulent dire dans les chapitres adéquats : l'Intel 3001 est un séquenceur, l'Intel 3002 regroupe unité de calcul et registres, le 3003 est un circuit d'anticipation de retenue complémentaire du 3002, le 3212 est une mémoire tampon, le 3214 est une unité de gestion des interruptions, les 3216/3226 sont des interfaces de bus mémoire. On pourrait aussi citer la famille de circuits intégrés AMD Am2900.

Même si le processeur était en pièces détachées, utiliser une dizaine de circuits intégrés était nettement mieux que d'utiliser plusieurs milliers de transistors individuels. En conséquence, les ordinateurs ont vu leur taille grandement réduite, passant de pièces entières à une simple armoire, voire à quelques cartes intégrées superposées. De plus, le prix des circuits intégré était abordable, du moins comparé aux ordinateurs d'avant. Le prix des ordinateurs a alors grandement décru, permettant à des entreprises et administrations de taille modeste de s'équiper d'ordinateurs.

===La quatrième génération : le microprocesseur===

[[File:MOS6502.svg|vignette|Microprocesseur, ici un processeur MOS6502, de la quatrième génération.]]

Lors de la troisième génération, les circuits intégrés regroupaient plusieurs dizaines ou centaines de transistors, mais sont rapidement montés en gamme. De centaines de transistors, ils sont passés au millier de transistors, puis au million et maintenant au-delà du milliard. Les transistors étaient devenus tellement petits, tellement miniaturisés, qu'il était devenu possible de mettre un processeur entier dans un circuit intégré. C'est ainsi qu'est né le microprocesseur, à savoir un processeur qui tient tout entier dans un seul circuit imprimé. La quatrième génération d’ordinateur est celle des ordinateurs basés autour d'un microprocesseur.

Les tout premiers microprocesseurs étaient des processeurs à application militaire, comme le processeur du F-14 CADC ou celui de l'Air data computer. Le tout premier microprocesseur commercialisé au grand public est le 4004 d'Intel, sorti en 1971. L'intel 4004 comprenait environ 2300 transistors, avait une fréquence de 740 MHz, pouvait faire 46 opérations différentes, et manipulait des entiers de 4 bits. Il était au départ un processeur de commande, prévu pour être intégré dans la calculatrice Busicom calculator 141-P, mais il fut utilisé pour d'autres applications quelque temps plus tard. Immédiatement après le 4004, les premiers microprocesseurs 8 bits furent commercialisés. Le 4004 fut suivi par le 8008 et quelques autres processeurs 8 bits extrêmement connus, comme le 8080 d'Intel, le 68000 de Motorola, le 6502 ou le Z80.

Les microprocesseurs permirent encore uen fois de réduire la taille des ordinateurs, qui pouvaient tenir dans un boitier de PC, ou un boitier de console de jeu. Le prix des ordinateurs a aussi chuté en même temps que les transistors étaient miniaturisés. C'est cette invention qui permis l'invention des consoles de jeux et des mini-ordinateurs, à savoir les ordinateurs personnels. Sans miniaturisation, on n'aurait pas d'ordinateur personnel, pas de PC fixe ou portable.

==L'organisation du cours : les différents niveaux d'explication==

Le fonctionnement d'un ordinateur est assez complexe à expliquer car les explications peuvent se faire sur plusieurs niveaux. Par plusieurs niveaux, on veut dire qu'un ordinateur est composé de composants très simples, qui sont assemblés pour donner des composants eux-même plus complexes, qui sont eux-même regrouper, etc. Étudier tout cela demande de voir plusieurs niveaux, allant de transistors très petits à des processeurs multicœurs. Les niveaux les plus bas sont de l'électronique pur et dure, alors que ceux plus haut sont à mi-chemin entre électronique et informatique.

===Les niveaux d'abstraction en architecture des ordinateurs===

Les trois premiers niveaux sont de l'électronique pur et dure. Ils correspondent aux premiers chapitres du cours, qui porteront sur les circuits électroniques en général.
* Le premier niveau est celui des '''transistors''', des circuits intégrés, des ''wafer'' et autres circuits de très petite taille.
* Le second niveau est celui des '''portes logiques''', des circuits très basiques, très simples, à la base de tous les autres.
* Le troisième niveau est celui dit de la '''''Register Transfer Level''''', où un circuit électronique est construit à partir de circuits basiques, dont des registres et autres circuits dits combinatoires.
Les deux niveaux suivants sont de l'informatique proprement dit. C'est dans ces deux niveaux qu'on étudie les ordinateurs proprement dit, les circuits qu'il y a dedans et non l'électronique en général.
* Le quatrième niveau est celui de la '''microarchitecture''', qui étudie ce qu'il y a à l'intérieur d'un processeur, d'une mémoire, des périphériques et autres.
* Le cinquième niveau est celui de l''''architecture externe''', qui décrit l'interface du processeur, de la mémoire, d'un périphérique ou autre. Par décrire l'interface, on veut dire : comment un programmeur voit le processeur et la mémoire, comment il peut les manipuler. Une architecture externe unique peut avoir plusieurs microarchitecture, ce qui fait qu'on sépare les deux. Tout cela sera plus clair quand on passera aux chapitres sur le processeur et les mémoires.

Nous n'allons pas voir les 5 niveaux dans l'ordre, des transistors vers l'architecture externe. En réalité, nous allons procéder autrement. La première partie du cours portera sur les trois premiers niveaux, le reste sur les deux autres. Les 5 niveaux seront vus dans des chapitres séparés, du moins le plus possible. Au niveau pédagogique, tout est plus simple si on scinde les 5 niveaux. Bien sûr, il y a quelques explications qui demandent de voir plusieurs niveaux à la fois. Par exemple, dans le chapitre sur les mémoires caches, nous auront des explications portant sur la RTL, la microarchitecture du cache et son architecture externe. Mais le gros du cours tentera de séparer le plus possible les 5 niveaux.

===Les trois parties principales du cours===

Nous allons commencer par parler du binaire, avant de voir les portes logiques. Avec ces portes logiques, nous allons voir comment fabriquer des circuits basiques qui reviendront très souvent dans la suite du cours. Nous verrons les registres, les décodeurs, les additionneurs et plein d'autres circuits. Puis, nous reviendrons au niveau des transistors pour finir la première partie. La raison est que c'est plus simple de faire comme cela. Tout ce qui a trait aux transistors sert à expliquer comment fabriquer des portes logiques, et il faut expliquer les portes logiques pour voir le niveau de la RTL.

Une fois la première partie finie, nous allons voir les différents composants d'un ordinateur. Une première partie expliquera ce qu'il y a dans un ordinateur, quels sont ses composants. Nous y parlerons de l'architecture de base, de la hiérarchie mémoire, des tendances technologiques, et d'autres généralités qui serviront de base pour la suite. Puis, nous verrons dans l'ordre les bus électroniques, les mémoires RAM/ROM, le processeur, les périphériques, les mémoires de stockage (SSD et disques durs) et les mémoires caches. Pour chaque composant, nous allons voir leur architecture externe, avant de voir leur microarchitecture. La raison est que la microarchitecture ne peut se comprendre que quand on sait quelle architecture externe elle implémente.

Enfin, dans une troisième partie, nous allons voir les optimisations majeures présentes dans tous les ordinateurs modernes, avec une partie sur le pipeline et le parallélisme d'instruction, et une autre sur les architectures parallèles. Pour finir, les annexes de fin parlerons de sujets un peu à part.

&lt;noinclude&gt;
{{NavChapitre | book=Fonctionnement d'un ordinateur
           | next=L'encodage des données
           | nextText=L'encodage des données
}}
&lt;/noinclude&gt;</text>
      <sha1>2d8saqtpblv31xaulgklrwfsbxvprj4</sha1>
    </revision>
    <revision>
      <id>744173</id>
      <parentid>744172</parentid>
      <timestamp>2025-06-05T15:50:16Z</timestamp>
      <contributor>
        <username>Mewtow</username>
        <id>31375</id>
      </contributor>
      <minor />
      <comment>/* La première génération : les tubes à vide */</comment>
      <origin>744173</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="48851" sha1="rq245v6wjk3g5tbqg4hkhptw8llkce3" xml:space="preserve">Pour commencer, nous allons voir qu'il existe de nombreux types d'ordinateurs. Le plus connu est certainement le PC, l'ordinateur personnel, que vous avez sans doute dans votre salon. Les ordinateurs portables sont un deuxième type d'ordinateur assez intuitif, que vous avez peut-être. Mais il y a aussi d'autres types d'ordinateurs auxquels vous n'avez jamais été confrontés.

==Les différents types d'ordinateurs==

Dans cette section, nous allons décrire rapidement les ordinateurs les plus courant, mais surtout voir ce qu'il y a à l'intérieur d'un ordinateur.

===L'ordinateur de type PC fixe===

De l'extérieur, l'ordinateur est composé d'une unité centrale sur laquelle on branche des périphériques.

[[File:Typical computer architecture systems.jpg|vignette|upright=1.5|Exemples de périphériques, connectés à une unité centrale (ici appelée à tort ''operating system'').]]

Les '''périphériques''' regroupent l'écran, la souris, le clavier, l'imprimante, et bien d'autres choses. Ils permettent à l'utilisateur d'interagir avec l'ordinateur : un clavier permet de saisir du texte sous dans un fichier, une souris enregistre des déplacements de la main en déplacement du curseur, un écran affiche des données d’images/vidéos, un haut-parleur émet du son, etc. Tout ce qui est branché sur un ordinateur est, formellement un périphérique.

L''''unité centrale''' est là où se trouvent tous les composants importants d'un ordinateur, ceux qui font des calculs, qui exécutent des logiciels, qui mémorisent vos données, etc. Voici ce à quoi ressemble l'intérieur de l'unité centrale. Trois sections sont visibles : l'alimentation électrique en haut à gauche, la carte mère en bas à gauche et en jaune/orange, les disques et lecteurs à droite des câbles. Et on voit aussi beaucoup de câbles.

[[File:Asus P5K-SEIntel E6320.jpg|centre|vignette|upright=2|Exemple d'unité centrale.]]

Tout en haut à gauche, se trouve l''''alimentation électrique''', qui convertit le courant de la prise électrique en un courant plus faible, utilisable par les autres composants. Elle émet de nombreux câbles assez gros, qui sont reliés au reste. Les PC actuels utilisent des alimentations électriques standardisées, qui fournissent trois tensions au reste de l'ordinateur : une tension de 12 Volts, une de 5 Volts, une de 3,3 Volts.

À droite, caché par la partie &quot;métallique&quot; du boitier, se trouvent les lecteurs de CD/DVD, et les disques durs. Les lecteurs CD-ROM ou DVD-ROM permettaient de lire des CD ou des DVD. Je parle au passé, car ils ont aujourd'hui disparu des ordinateurs modernes. Les '''disques durs''' sont des mémoires de stockage, qui mémorisent vos données de manière permanente. De nos jours, ils sont remplacés par des SSD, qui sont des disques durs électroniques, là où les disques durs proprement dit sont des mémoires magnétiques. Nous verrons la différence dans deux chapitres dédiés, un sur les disques durs, l'autre sur les SSD.

En bas à droite, se trouve la '''carte mère''' un support plat, en plastique ou en céramique, sur laquelle sont soudés/connectés les autres composants. Sur celle-ci, de nombreux composants sont soudés, d'autres sont branchés dessus avec des câbles, d'autres sont connectés dessus avec des connecteurs. Ils sont reliés entre eux par des fils conducteurs, le plus souvent du cuivre ou de l’aluminium, ce qui leur permet de s’échanger des données. Sur les cartes simples, ces fils sont intégrés dans la carte électronique, dans des creux du plastique. Ils portent le nom de pistes.

Avant, les disques durs, SSD et lecteurs de CD/DVD sont branchés dessus via des connecteurs dédiés, appelés des connecteurs S-ATA. De nos jours, ils sont branchés sur un autre connecteur, grâce à l'interface NVME. Toujours est-il qu'ils sont reliés à la carte mère par des câbles, ce qui montre que ce sont des sortes de périphériques interne. Ils sont placés dans le boitier, mais on aurait tout aussi bien pu les mettre à l'extérieur, vu qu'ils communiquent avec l'ordinateur par l'intermédiaire d'un câble ou d'un connecteur dédié.

Mais deux autres composants très importants sont eux placés sur la carte mère, directement. Ils ont chacun un connecteur dédié, sur lequel ils sont branchés directement, sans passer par l'intermédiaire d'un câble, mais sans être soudés non plus. Il s'agit du processeur et de la mémoire RAM, deux composants centraux des PC modernes.

[[File:Pentium III SL4CB.jpg|thumb|Processeur Pentium III.]]

Le '''processeur''' traite les données, les modifie, les manipule. Pour faire simple, il s’agit d’une grosse calculatrice hyper-puissante. Il comprend à la fois un circuit qui fait des calculs, et un circuit de contrôle qui s'occupe de séquencer les calculs dans l'ordre demandé. Il est souvent caché sous un radiateur, lui-même surmonté par un ventilateur. En effet, un processeur chauffe beaucoup, ce qui demande d'évacuer cette chaleur. Un chapitre entier expliquera pourquoi les processeurs chauffent, ainsi que les techniques utilisées pour limiter leur production de chaleur et leur consommation électrique.

La '''mémoire vive''' conserve des informations/données temporairement, tant que le processeur en a besoin. Elle prend la forme de barrettes de RAM, comme montré ci-dessous.

[[File:2 gb ddr2 667.jpg|centre|vignette|upright=2|Barrette de RAM.]]

Outre ces composants dits principaux, un ordinateur peut comprendre plusieurs composants moins importants, surtout présents sur les ordinateurs personnels. Ils sont techniquement facultatifs, mais sont très présents dans les ordinateurs personnels. Cependant, certains ordinateurs spécialisés s'en passent. Il s'agit des diverses '''cartes d'extension''' sont branchées sur la carte mère. Elles permettent d’accélérer certains calculs ou certaines applications, afin de décharger le processeur. Par exemple, la carte graphique s'occupe des calculs graphiques, qu'il s'agisse de graphismes 3D de jeux vidéos ou de l'affichage en 2D du bureau. Dans un autre registre, la carte son prend en charge le microphone et les haut-parleurs.

[[Fichier:Personal computer, exploded 4.svg|thumb|upright=1.0|Éclaté d'un ordinateur de type PC :&lt;br /&gt;
1 : Écran ;&lt;br /&gt;
2 : Carte mère ;&lt;br /&gt;
3 : Processeur ;&lt;br /&gt;
4 : Câble Parallel ATA ;&lt;br /&gt;
5 : Mémoire vive (RAM) ;&lt;br /&gt;
6 : Carte d'extension ;&lt;br /&gt;
7 : Alimentation électrique ;&lt;br /&gt;
8 : Lecteur de disque optique ;&lt;br /&gt;
9 : Disque dur ;&lt;br /&gt;
10 : Clavier ;&lt;br /&gt;
11 : Souris.]]

Si on regarde une carte mère de face, on voit un grand nombre de connecteurs, mais aussi des circuits électroniques soudés à la carte mère.

[[File:Architecture matérielle d'une carte mère.png|centre|vignette|upright=2.0|Architecture matérielle d'une carte mère]]

Les '''connecteurs''' sont là où on branche les périphériques, la carte graphique, le processeur, la mémoire, etc. Dans l'ensemble, toute carte mère contient les connecteurs suivants :
* Le processeur vient s’enchâsser dans la carte mère sur un connecteur particulier : le '''socket'''. Celui-ci varie suivant la carte mère et le processeur, ce qui est source d'incompatibilités.
* Les barrettes de mémoire RAM s’enchâssent dans un autre type de connecteurs: les '''slots mémoire'''.
* Les mémoires de masse disposent de leurs propres connecteurs : connecteurs P-ATA pour les anciens disques durs, et S-ATA pour les récents.
* Les périphériques (clavier, souris, USB, Firewire, ...) sont connectés sur un ensemble de connecteurs dédiés, localisés à l'arrière du boitier de l'unité centrale. 
* Les autres périphériques sont placés dans l'unité centrale et sont connectés via des connecteurs spécialisés. Ces périphériques sont des cartes imprimées, d'où leur nom de '''cartes filles'''. On peut notamment citer les cartes réseau, les cartes son, ou les cartes vidéo.

===Les ordinateurs portables===

[[File:Samsung QX-511 (2).JPG|vignette|Ordinateur portable Samsung QX-511 (2), pour illustration.]]

Un ordinateur portable est identique à un ordinateur de type PC. Si vous ouvrez votre ordinateur portable (attention à la garantie), vous retrouverez les mêmes composants qu'un PC à l'intérieur. Un point important est la présence d'une batterie à l'intérieur du PC portable, absente des PC fixes.

[[File:LG gram 14Z90Q mainboard with battery.jpg|centre|vignette|upright=2|LG gram 14Z90Q avec sa batterie.]]

Une fois la batterie et les circuits associés retiré, la seule différence notable est que tous les composants sont soudés sur la carte mère, au lieu d'être branchés sur des connecteurs, à part éventuellement la RAM et le disque dur.

[[File:LG gram 14Z90Q mainboard without battery.jpg|centre|vignette|upright=2|LG gram 14Z90Q sans sa batterie.]]

La RAM est parfois soudée sur la carte mère, d'autres fois sous la forme de barrettes de mémoire vive semblables à celles des PC. Dans le dernier cas, elle est connectée à des connecteurs spécifiques, ce qui permet de les changer/upgrader. Les PC portables sont parfois construits de manière à pouvoir changer la RAM facilement, en ouvrant un cache spécial, concu pour.

[[File:Lenovo G555 состав - Донор.JPG|centre|vignette|upright=2|Lenovo G555.]]

La conception d'un ordinateur portable est légèrement différente de celle d'un PC, pour des raisons thermiques. Un PC fixe a plus de place pour évacuer sa chaleur. Les ventilateurs peuvent plus facilement déplacer l'air dans le boitier, même si le flux d'air dans le boitier est éventuellement gêné par la carte graphique. Mais l'évacuation de la chaleur est assez efficace. Sur les PC portables, leur finesse fait que le trajet de l'air est beaucoup plus contraint. Évacuer la chaleur produite par l'ordinateur est plus complexe, ce qui demande d'utiliser des systèmes de refroidissement et de ventilation spécifiques.

Là où les PC fixes se débrouillent avec des radiateurs et des ventilateurs posés sur le processeur, les PC portables font autrement. Ils ne peuvent pas forcément mettre le ventilateur sur le processeur. A la place, ils mettent le ventilateur à côté, mais le processeur est surmonté par un mécanisme de transmission de la chaleur, qui transfère la chaleur du processeur vers le ventilateur.

[[File:Diagram - How a laptop cooling system works.png|centre|vignette|upright=2|Comment fonctionne le système de ventilation d'un ordinateur portable, en anglais.]]

Les difficultés pour dissiper la chaleur font que les ordinateurs portables utilisent souvent des composants peu performants, mais qui chauffent peu. En effet, nous verrons que plus un composant est puissant, plus il chauffe. La relation n'est pas parfaite, mais les processeurs haute performance chauffent plus que les modèles d'entrée ou milieu de gamme moins puissants. En conséquence, les PC portables sont souvent moins puissants que les PC fixes, même pour les modèles dit ''gaming''.

===Les serveurs et ''mainframes''===

Les grandes entreprises utilisent des ordinateurs de grande taille, très puissants, appelés des ''mainframes''. Ils sont souvent confondus avec les serveurs par le grand public, il y a une différence entre les deux. Un serveur est une fonction logicielle/réseau, pas un type d'ordinateur. Mais laissons cette différence de côté, ce qui est dit pour les ''mainframes'' sert pour les gros serveurs haute performance.

[[File:IBM Z15 mainframe.jpg|vignette|Exemple de ''mainframe''' de type IBM Z15.]]

Les anciens ''mainframes'' des années 50-80 avaient une taille pouvant être impressionnante, au point de prendre une pièce complète d'un bâtiment. Mais de nos jours, les ''mainframes'' tiennent dans une grosse armoire un peu haute. Les ''mainframes'' doivent rester allumé en permanence et ne doivent pas être éteint, sauf éventuellement quelques jours par an pour des opérations de maintenance. Ils utilisent pour cela des techniques spécifiques, avec beaucoup de redondance interne.

[[File:ACONIT hall grandes machines.jpg|centre|vignette|upright=2|''Mainframe'' ACONIT.]]

Les ''mainframes'' sont aussi conçus pour mutualiser au maximum leur utilisation, ils peuvent être utilisés par plusieurs utilisateurs à la suite, voire en même temps. Pour cela, les anciens ''mainframes'' étaient capables de faire tourner plusieurs applications distinctes l'une à la suite de l'autre, avec des commutations fréquentes entre logiciels. De nos jours, ils sont capables d'exécuter un grand nombre de tâches en même temps, grâce à la présence de plusieurs processeurs. Les ''mainframes'' modernes sont même capables de faire tourner plusieurs systèmes d'exploitation en même temps si besoin.

Les anciens ''mainframes'' étaient des ordinateurs assez simples, avec un processeur, de la mémoire RAM, un ou plusieurs disques durs, pas plus. Le ''mainframe'' était tellement énorme et cher que les entreprises n'en avaient qu'un seul pour toute l'entreprise. Les employés avaient sur leur bureau des terminaux, qui permettaient d'accéder à l'ordinateur central, mais n'étaient pas des ordinateurs. Les terminaux étaient des composants électroniques simples, avec un écran, un clavier et une souris, mais sans processeur. Ils envoyaient des données au ''mainframe'', ils en recevaient de sa part, mais tout traitement était réalisé sur le ''mainframe''. L'arrivée sur le marché des ordinateurs personnels, de type PC fixe/portable, a entrainé l'abandon de ce genre de pratique, tous les employés ont maintenant un ordinateur rien que pour eux.

{|
|-
! colspan=&quot;2&quot; | Exemples de terminaux
|-
|[[File:Terminal-in2-sm9400.jpg|centre|vignette|upright=1.5|Exemple de terminal. Notez la présence d'un écran et d'un clavier, mais l'asbence d'une unité centrale.]]
|[[File:Chromatics CT4100.jpg|vignette|upright=1.5|Autre exemple de terminal. Le clavier est couplé à un stylo CRT, qui remplacait la souris et agissait sur l'écran comme s'il était tactile.]]
|-
! colspan=&quot;2&quot; | Intérieur d'un terminal
|-
|[[File:CT1024 Monitor.jpg|vignette|upright=1.5|Terminal CT1024, sans le boitier extérieur.]]
|[[File:CT1024 Terminal System.jpg|vignette|upright=1.5|Terminal CT1024, description des composants interne.]]
|}

De nos jours, les ''mainframes'' contiennent en réalité plusieurs ordinateurs simples interconnectés via un réseau local. Un ''mainframe'' qui tient dans une armoire contient facilement une dizaine ou centaine de processeurs, plein de RAM, des disques durs séparés dans une armoire distincte, etc. Vu qu'ils communiquent uniquement via le réseau, ils n'ont pas d'interface, pas d'écran, 'entrée via clavier/souris. Le tout est commandé avec une console de commande, typiquement un ordinateur portable ou un terminal assez simple séparé de l'armoire, qui permet à un administrateur de faire des opérations de surveillance, configuration et maintenance. Il peut y avoir une console de commande pour plusieurs armoires séparées, la console peut même être dans un autre bâtiment et accéder au ''mainframe'' par le réseau.

[[File:IBM System Z9 (type 2094 inside).jpg|centre|vignette|upright=2|''Mainframe'' de type IBM System Z9. L'ordinateur portable sert de console pour qu'un administrateur fasse des opérations de surveillance, configuration et maintenance.]]

Les processeurs et la RAM sont typiquement installés sur des cartes amovibles, qui sont connectées au fond de l'armoire lors de l'installation. Il est même possible de retirer ou d'ajouter des cartes en fonctionnement, afin d'ajouter/retirer des processeurs, des disques durs, etc. Ce qui est très utile si un composant est en panne et qu'il faut le remplacer. 

[[File:IBM TotalStorage Exp400.jpg|centre|vignette|upright=2|IBM TotalStorage Exp400]]

==Un peu d'abstraction : qu'est-ce qu'un ordinateur ?==

Un ordinateur comprend donc un processeur, plusieurs mémoires, des cartes d'extension et une carte mère pour connecter le tout. Mais il s'agit là d'une description assez terre-à-terre de ce qu'est un ordinateur. Une autre description, plus abstraite, se base sur le fait qu'un ordinateur est une énorme calculatrice programmable. Elle permet d'expliquer pourquoi il y a une distinction entre processeur et mémoire, entre unité centrale et périphériques. Tout ce qui va suivre pourra vous paraitre assez abstrait, mais rassurez-vous : les prochains chapitres rendront tout cela plus concrets.

===La séparation entre entrées-sorties et traitement===

L'unité centrale peut être vue comme une énorme calculatrice ultra-puissante, qui exécute des commandes/opérations. Mais à elle seule, elle ne servirait à rien, il faut interagir avec par l'intermédiaire de plusieurs périphériques. Il existe deux types de périphériques, qui sont conceptuellement différents. Les périphériques comme le clavier ou la souris permettent d'envoyer des informations à l'ordinateur, d'agir sur celui-ci. A l'inverse, les écrans transmettent des informations dans le sens inverse : de l'ordinateur vers l'utilisateur. Les premiers sont appelés des '''entrées''', les seconds des '''sorties'''.

Dans un ordinateur, les informations sont représentées sous la forme de nombres. Toute donnée dans un ordinateur est codée avec un ou plusieurs nombres regroupés dans une donnée, un fichier, ou autre. Et la transmissions avec les entrées et sorties se fait là-encore avec des nombres. Par exemple, quand vous appuyez sur votre clavier, le clavier envoie un numéro de touche à l'unité centrale, qui indique quelle touche a été appuyée. L'image à afficher à l'écran est codée sous la forme d'une suite de nombres (un par pixel). L'image est envoyée à l'écran, qui traduit la suite de nombre en image à afficher. Les entrées traduisent des actions utilisateurs en nombres, on dit que les entrées encodent les actions utilisateur. Les sorties font la traduction inverse, elles transforment des suites de nombres en une action physique. On dit qu'elles décodent des informations.

Pour résumer, toute appareil électronique est composé par :
* Des '''entrées''' sur lesquelles l'utilisateur agit sur l'ordinateur. Les entrées transforment les actions de l'utilisateur en nombres, qui sont interprétés par l'ordinateur.
* Une '''unité de traitement''', qui manipule des nombres et fait des calculs/opérations dessus. Les nombres proviennent des entrées, du disque dur, ou d'autres sources, peu importe.
* Des '''sorties''', qui va récupèrent le résultat calculé par l'unité de traitement pour en faire quelque chose : écrire sur une imprimante ou sur un moniteur, émettre du son,...

[[File:Ordinateur théorique Simple 1.png|centre|vignette|upright=2|Ordinateur théorique Simple 1]]

L'unité de traitement proprement dite, celle qui fait les calculs, est couplée à une mémoire qui mémorise les opérandes et résultats des calculs. La séparation entre processeur et mémoire est nécessaire pour qu'un appareil électronique soit qualifié d'ordinateur. De nombreux appareils n'ont pas de séparation entre unité de traitement et mémoire, comme certaines vielles radios AM/FM.

[[File:Schéma de principe d'un ordinateur.png|centre|vignette|upright=2|Schéma de principe d'un ordinateur]]

===Un ordinateur est un appareil programmable===

Les appareils simples sont non-programmables, ce qui veut dire qu’ils sont conçus pour une utilisation particulière et qu’ils ne peuvent pas faire autre chose. Par exemple, les circuits électroniques d’un lecteur de DVD ne peuvent pas être transformé en lecteur audio ou en console de jeux... Les circuits non-programmables sont câblés une bonne fois pour toute, et on ne peut pas les modifier. On peut parfois reconfigurer le circuit, pour faire varier certains paramètres, via des interrupteurs ou des boutons, mais cela s’arrête là. Et cela pose un problème : à chaque problème qu'on veut résoudre en utilisant un automate, on doit recréer un nouveau circuit.

À l'inverse, un ordinateur n’est pas conçu pour une utilisation particulière, contrairement aux autres objets techniques. Il est possible de modifier leur fonction du jour au lendemain, on peut lui faire faire ce qu’on veut. On dit qu'ils sont '''programmables'''. Pour cela, il suffit d’utiliser un logiciel, une application, un programme (ces termes sont synonymes), qui fait ce que l'on souhaite. La totalité des logiciels présents sur un ordinateur sont des programmes comme les autres, même le système d'exploitation (Windows, Linux, ...) ne fait pas exception.

Un programme est une suite de d''''instructions machines''', chaque instruction effectuant une action dans l'ordinateur. Sur les ordinateurs modernes, les instructions les plus communes effectuent une opération arithmétique : une addition, une multiplication, une soustraction, etc. Les ordinateurs modernes sont donc de grosses calculettes très puissantes, capables d'effectuer des millions d'opérations par secondes.

Et qui dit opération dit nombres : un ordinateur gère nativement des nombres, qui sont codés en binaire sur la quasi-totalité des ordinateurs modernes. Les ordinateurs modernes sont capables de faire des calculs sur des nombres entiers, mais aussi des nombres à virgule. Il existe plusieurs manières de représenter des nombres en binaire, certaines représentant des nombres entiers dits naturels (0 et plus), d'autres des nombres signés (positifs ou négatifs), d'autres des nombres à virgule. Un chapitre entier détaillera comment sont encodés ces nombres.

Une instruction est représentée dans un ordinateur par une série de nombres entiers : un nombre qui indique quelle opération/commande effectuer et des autres nombres pour coder les données (ou de quoi les retrouver dans l'ordinateur). L'ordinateur récupére les commandes une par une, les traduit en opération à effectuer, exécuter l'opération, et enregistre le résultat. Puis il recommence avec la commande suivante.

[[File:Ordinateur Théorique Complexe 1.png|centre|vignette|upright=3|Ordinateur Théorique Complexe. En jaune, le programme informatique, la liste de commande. Le rectangle gris est l'ordinateur proprement dit.]]

De nombreux appareils sont programmables, mais tous ne sont pas des ordinateurs. Par exemple, certains circuits programmables nommés FPGA n'en sont pas. Pour être qualifié d'ordinateur, un appareil programmable doit avoir un processeur séparé de la mémoire. De plus, il doit utiliser un '''codage numérique''', chose que nous allons aborder dans le chapitre suivant.

===Les ordinateurs à programme mémorisé ou programme externe===

[[File:Blue-punch-card-front.png|vignette|upright=0.5|Carte Perforée.]]

Au tout début de l'informatique, les programmes étaient enregistrés sur des cartes perforées, à savoir des cartes en papier/plastique percées par endroits. Un 1 est codé par un trou dans le papier et un 0 par une absence de trou. Les programmes étaient exécutés par l'ordinateur quand on insérait la carte perforée dans le lecteur et qu'on appuyait sur un bouton.

Par la suite, les premiers ordinateurs grand public, comme les Amstrad ou les Commodore, utilisaient des cassettes audio magnétiques pour stocker les programmes. Dans le même style, les consoles de jeu utilisaient autrefois des cartouches de jeu, qui contenaient le programme du jeu à exécuter. Pour résumer, les anciens ordinateurs mémorisaient les programmes sur un support externe, lu par un périphérique. De tels ordinateurs sont dits à '''programme externe'''.

: D’anciens ordinateurs personnels, comme l’Amstrad ou le Commodore, permettaient de taper les programmes à exécuter à la main, au clavier, avant d’appuyer une touche pour les exécuter. Nul besoin de vous dire que les cassettes audio étaient plus pratiques.

Mais de nos jours, les programmes sont enregistrés sur le disque dur de l'ordinateur ou dans une mémoire intégrée à l'ordinateur. On dit qu'ils sont installés, ce qui est un mot bien compliqué pour dire que le programme est enregistré sur le disque dur de l’ordinateur. A défaut de disque dur, le programme/logiciel est enregistré dans une mémoire spécialisée pour le stockage. Par exemple, sur les cartes électroniques grand public de marque Arduino, les programmes sont envoyés à la carte via le port USB, mais les programmes sont enregistrés dans la carte Arduino, dans une mémoire FLASH dédiée. Disque dur ou non, le programme est mémorisé dans la mémoire de l'ordinateur. Il est possible d'installer ou de désinstaller les programmes en modifiant le contenu de la mémoire. Le terme utilisé est alors celui de '''programme stocké en mémoire'''.

Les programmes à installer sont disponibles soit sur un périphérique, comme un DVD ou une clé USB, soit sont téléchargés depuis internet. Les premiers PC fournissaient les logiciels sur des disquettes, qui contenaient un programme d'installation pour enregistrer le programme sur le disque dur de l'ordinateur. Par la suite, le support des logiciels a migré vers les CD et DVD, les logiciels devenant de plus en plus gros. De nos jours, la majorité des applications sont téléchargées depuis le net, l'usage de périphériques est devenu obsolète, même les consoles de jeu abandonnent cette méthode de distribution.

==Les générations d'ordinateurs : un historique rapide==

L'informatique a beaucoup évolué dans le temps. Et une bonne partie de cette évolution tient à l'évolution de l’électronique sous-jacente. Les ordinateurs actuels sont fabriqués avec des transistors, des petits composants électroniques qui servent d'interrupteurs programmables, qu'on détaillera dans ce qui suit. Mais ça n'a pas toujours été le cas. Et cela permet de distinguer plusieurs '''générations d'ordinateurs'''.

===Les ordinateurs électro-mécaniques : les premiers ordinateurs===

Le tout premier ordinateur est le '''Z1''', un modèle unique inventé par Konrad Suze entre 1936 et 1938. Son processeur gérait non pas des nombres entiers, mais des nombres à virgule (des nombres dits flottants, pour être précis), encodés sur 22 bits. Le processeur du Z1 était capable de faire des additions et des soustractions, car il intégrait un circuit additionneur-soustracteur basique. Des circuits annexes permettaient de faire des multiplications et des divisions en enchainant des additions/soustractions successives. Il fonctionnait à une fréquence de 1 Hz, ce qui fait qu'il pouvait faire une addition/soustraction par seconde maximum.

Niveau mémoire, la RAM de l'ordinateur était très limitée : seulement 16 nombres de 22 bits chacun. S'il s'agissait d'une mémoire électronique, les programmes étaient mémorisés sur une mémoire mécanique et précisémment sur des cartes perforées, à savoir des cartes en papier/plastique dans lesquelles un 1 est codé par un trou dans le papier et un 0 par une absence de trou. Les programmes étaient exécutés par l'ordinateur quand on insérait la carte perforée dans le lecteur et qu'on appuyait sur un bouton.

[[File:German Museum of Technology, Berlin 2017 024.jpg|centre|vignette|upright=2|Réplique du Z1 au ''German Museum of Technology'' de Berlin, 2017.]]

Après sa destruction dans un bombardement, le Z1 a été reconstruit et amélioré, ce qui donné les deux ordinateurs Z2 et Z3. Quelques années plus tard, quelques laboratoires de recherche ont fabriqués des ordinateurs dans leur coin, comme le Harvard Mark I et le Colossus Mark 1 (UK) qui ont été mis en service en 1944. Ils ont servi pour les cryptanalystes pour casser les codes utilisés par les Allemands pour leurs transmissions, pendant la seconde guerre mondiale.

Les ordinateurs cités dans le précédent paragraphe étaient tous des ordinateurs dit '''électro-mécaniques''', car ils mélangeaient des composants électroniques et des composants mécaniques (tout ce qui a trait aux cartes perforées, notamment). Les composants électroniques étaient généralement des relais, à savoir des interrupteurs commandables électriquement, qui sont plus ou moins équivalents aux transistors modernes. La majeure partie des ordinateurs des années 40 étaient de ce type, mais leur nombre n'a pas dépassé 30. Il faut dire qu'ils ont rapidement laissé la place à des ordinateurs purement électroniques, que nous allons voir dans ce qui suit.

===La première génération : les tubes à vide===

Les ordinateurs qui ont suivi les ordinateurs électromécaniques sont regroupés dans la '''première génération d'ordinateur'''. Ils étaient conçus avec des tubes à vide, des espèces d'interrupteurs commandables, les ancêtres des transistors modernes. Les tubes à vide étaient assez encombrants, ils consommaient beaucoup de courant, ils chauffaient et étaient assez peu fiables. Ils tombaient en panne assez souvent. Et ils étaient assez simples à fabriquer, mais restaient malgré tout chers.

[[File:Diode vacuum tube.svg|vignette|Diode vacuum tube]]

Les tubes à vide sont des ampoules à filament améliorées. Pour rappel, les ampoules à filament étaient des ampoules en verre dans lesquelles on plaçait un filament métallique. Le filament chauffait quand on envoyait du courant dedans et émettait de la lumière. Dans les tubes à vides, le filament n'émet pas de lumière quand on le chauffe : il émet des électrons, de l'électricité. De plus, on ajoute une plaque métalliques appelée l'anode, qui capte des électrons émis par le filament. Le résultat est un circuit qui laisse passer le courant, mais seulement dans un sens : du filament vers l'anode, l'autre sens n'est pas possible vu que l'anode ne peut pas émettre d'électrons. Un tel circuit est appelé une '''diode'''.

[[File:Triode vacuum tube FR.png|vignette|Triode.]]

Les tubes à vide précédents peuvent être modifiés en ajoutant une grille métallique entre la cathode et l'anode. La grille est alimentée avec une tension électrique, ce qui la charge électriquement. Suivant sa charge, elle laisse plus ou moins passer les électrons de la cathode vers l'anode. Si elle n'est pas chargée, que la tension est de 0 Volts, elle ne fera pas obstacle aux électrons et le tube à vide fonctionnera comme une diode basique. Mais si la grille est chargée avec une tension négative, sa charge électrique va repousser les électrons et les empêcher de passer de la cathode vers l'anode.

Le tube à vide se comporte alors comme un interrupteur : fermé ou ouvert suivant ce qu'on met sur la grille. Un tel tube à vide est appelée une '''triode''', car c'est une diode à laquelle on a ajouté une entrée pour charger la grille. De tels interrupteurs commandables électriquement sont combinés pour fabriquer des circuits plus élaborés, comme les portes logiques qu'on verra d'ici quelques chapitres.

Les tubes à vides étaient utilisés pour le processeur et quelques circuits annexes, mais les mémoires utilisaient d'autres technologies. Les mémoires de l'époque n'étaient pas du tout des mémoires électroniques. Il existait déjà des ancêtres des disques durs, à savoir des mémoire magnétiques appelées tambours magnétiques, bandes magnétiques, mémoires à tore de ferrite, etc. Les mémoires RAM, quant à elles, utilisaient elles des technologies totalement abandonnées : les mémoires à lignes de délai étaient des mémoires acoustiques, les tubes Williams étaient des écrans CRT modifiés, etc. Un chapitre entier sera dédié aux technologies des mémoires de l'époque.

[[File:Elektronenroehren-auswahl.jpg|centre|vignette|upright=2|Tubes à vides.]]

L'usage de tubes à vide les place entre les premiers ordinateurs électro-mécaniques et les ordinateurs utilisant des transistors. Au vu de la taille des tubes à vide, les ordinateurs de l'époque étaient composés de plusieurs milliers de ces tubes, guère plus. Et malgré cela, un ordinateur prenait facilement un étage de bâtiment entier, ou au moins plusieurs pièces. La conséquence est que les ordinateurs de première génération étaient très simples, rudimentaires quand on les compare aux ordinateurs modernes. Ils ne géraient que quelques opérations simples : l'addition, la soustraction, pas grand-chose de plus. À quelques exceptions près, ils ne géraient pas la multiplication et encore moins la division, cela aurait demandé trop de tubes à vides.

Une des toutes premières machines construite avec des tubes à vide était l'Atanasoff–Berry. Ce n'était pas un ordinateur, car elle ne pouvait pas exécuter de programme sans intervention humaine pour séquencer des opérations, mais c'était la première machine de calcul purement électronique, sans aucune pièce mécanique. Elle utilisait une mémoire RAM construite avec des condensateurs, ceux-ci étant placés sur des cylindres tournants. Les circuits de calcul étaient construits avec des tubes à vide et faisaient leur travail un bit à la fois. Elle fonctionnait à une fréquence de 60 Hz et pouvait faire 30 additions/soustractions par seconde. Les nombres étaient encodés sur 50 bits. 

[[File:Atanasoff Berry Computer.gif|centre|vignette|upright=2.5|Atanasoff–Berry.]]

L'arrivée de l'ENIAC en 1945 a changé la donne. Cet ordinateur a introduit plusieurs innovations majeures. La première est assez technique, il s'agit de la turing-complétude, elle a trait aux programmes qui peuvent être écrit pour un ordinateur, nous ne la détaillerons pas ici.

[[File:BabyArchitecture.png|vignette|Architecture de la Manchester Baby.]]

En 1948, le ''Manchester Baby'' a introduit une innovation extrêmement importante : le programme n'était plus mémorisé sur des cartes perforées, mais dans une mémoire électronique à l’intérieur de l'ordinateur lui-même. En clair, le ''Manchester Baby'' était le premier '''ordinateur à programme stocké en mémoire''' en français. Au-delà de ça, le Manchester Baby restait quand même très simple, c'était limite un prototype.

Niveau interface, l'ordinateur avait une console avec 32 boutons, des interrupteurs et un écran de sortie sur lequel afficher les résultats. A l'intérieur, il y avait un processeur et une RAM de 32 nombres de 32 bits, fabriquées avec des tubes Williams (abordés dans une annexe à la fin du cours). Une instruction prenant autant de place qu'un nombre en RAM, ce qui limitait les programmes à 32 instructions maximum. Le processeur gérait 8 instructions en tout, mais la seule instruction de calcul qu'il gérait était la soustraction. L'addition n'était pas supportée. Il pouvait cependant émuler l'addition à partir d'une soustraction et inversant l'opérande soustrait.

Le Manchester Mark 1 était une amélioration du Manchester Baby. Il utilisait 4500 tubes à vide. L'ordinateur gérait des nombres de 40 bits, mais les instructions étaient codées sur 20 bits. La RAM avait la même taille, à savoir 32 nombres, leur taille était simplement augmentée. Par contre, la RAM était complémentée par l’ancêtre du disque dur magnétique, à savoir un tambour magnétique, l’ancêtre du disque dur magnétique. Il contenait 40 pages, chacune ayant la même taille que la RAM. Contrairement à la Manchester Baby, son processeur gérait l'addition. Les multiplications étaient réalisées par des additions successives, mais le processeur intégrait des registres pour mémoriser les opérandes à multiplier.

Par la suite, les ordinateurs commerciaux ont vu le jour. Les ordinateurs précédents provenaient de projets de recherches, souvent publics. Mais les entreprises privées se sont mises à fabriquer des ordinateurs elle-mêmes, pour les vendre à d'autres entreprises. On peut notamment citer les ordinateurs comme le UNIVAC I, le Bull Gamma 3 ou les premiers ordinateurs IBM. La performance de ces ordinateurs était nettement plus importante que leurs prédécesseurs, avec des fréquences de l'ordre de la centaine de kilo-hertz. Par exemple, le Bull Gamma 3 allait à 281 kHz, l'IBM 650 allait à 50 Khz.

===La seconde génération : le remplacement des tubes à vides par des transistors===

[[File:IBM 7070.jpg|vignette|Cartes imprimées de l'IBM 704, avec des transistors et résistances dessus.]]

La '''seconde génération''' est celle des ordinateurs fabriqués avec des '''transistors''' isolés, reliés entre avec des fils électriques. Les transistors en question possèdent trois broches, des pattes métalliques sur lesquelles on connecte des fils électriques. Le transistor s'utilise le plus souvent comme un interrupteur commandé par sa troisième broche. Le courant qui traverse les deux premières broches passe ou ne passe pas selon ce qu'on met sur la troisième.

[[File:Transistor basic flow.svg|centre|vignette|Un transistor est un morceau de conducteur, dont la conductivité est contrôlée par sa troisième broche/borne.]]

Les ordinateurs de seconde génération avaient entre 1000 et 500 000 transistors. Les capacités des ordinateurs étaient donc nettement supérieures à celles des ordinateurs de première génération. Une part non négligeable des ordinateurs de seconde génération supportait l'opération de multiplication, absente sur les ordinateurs de première génération. Néanmoins, cela variait beaucoup selon les ordinateurs.

Un exemple assez hors du commun est celui du premier modèle de l'IBM 1620. Le tout premier modèle n'avait aucun circuit de calcul, il n'était même pas capable de faire une addition ou une multiplication. A la place, il utilisait une table d'addition et une table de multiplication en mémoire RAM. Les deux tables devaient être initialisées par le logiciel lors du démarrage de la machine. La table d'addition faisait une centaine de chiffres, la table de multiplication faisait le double. Le processeur de l'ordinateur gérait des instructions pour faire des additions ou des multiplications, mais ces opérations lisaient le résultat dans la table d'addition. Les calculs étaient faits chiffre par chiffre, avec un encodage partiellement décimal, partiellement binaire (des chiffres décimaux étaient encodés en binaire, nous en reparlerons quand nous parlerons du BCD) !

[[File:KL CoreMemory.jpg|vignette|Mémoire à tore de ferrite.]]

Les transistors n'étaient utilisés que pour le processeur et les circuits annexes. La mémoire n'était pas faite en transistors, pas à cette époque. La mémoire était une mémoire aujourd'hui abandonnée, appelée une '''mémoire à tores de ferrite'''. Elle sera détaillée dans un chapitre ultérieur. Mais sachez pour le moment qu'il s'agit d'une mémoire au support magnétique, les données étant stockées sur un support magnétique.

Les transistors étaient au départ de la même taille que les tubes à vide, mais ils ont rapidement rétrécit. Ils prenaient encore beaucoup de place dans les 60-70, ce qui fait que les ordinateurs étaient assez gros. Concrètement, ils prenaient une pièce de bâtiment entière dans le meilleur des cas. C'était l'époque des gros ''mainframes'', reliés à des terminaux, peu puissants comparé aux standards actuels. Seules les grandes entreprises et les grands instituts de recherche pouvaient se payer les services de ce genre d'ordinateurs. Seuls les professionnels avaient accès à ce genre d'équipement.

===La troisième génération : le circuit intégré===

[[File:D8259AC-2.jpg|vignette|Exemple de circuit intégré.]]

La troisième génération est toujours fabriquée avec des transistors, mais dont la taille a été réduite. Avec l'évolution de la technologie, les transistors ont diminué en taille, de plus en plus. Ils sont devenus tellement petits qu'ils ont fini par être regroupés dans des '''circuits intégrés''', des circuits regroupent plusieurs transistors sur la même puce de silicium. Les circuits intégrés se présentent le plus souvent sous la forme de boitiers rectangulaires, comme illustré ci-contre. D'autres ont des boitiers de forme carrées, comme ceux que l'on peut trouver sur les barrettes de mémoire RAM, ou à l'intérieur des clés USB/ disques SSD.

Lors de cette génération, les processeurs étaient fournis en pièces détachées qu'il fallait relier entre elles. Le processeur était composé de plusieurs circuits intégrés séparés, impossible de mettre un processeur dans un seul boitier. Un exemple de processeur conçu en kit est la série des Intel 3000. Elle regroupe plusieurs circuits séparés aux noms à coucher dehors, mais dont vous comprendrez ce qu'ils veulent dire dans les chapitres adéquats : l'Intel 3001 est un séquenceur, l'Intel 3002 regroupe unité de calcul et registres, le 3003 est un circuit d'anticipation de retenue complémentaire du 3002, le 3212 est une mémoire tampon, le 3214 est une unité de gestion des interruptions, les 3216/3226 sont des interfaces de bus mémoire. On pourrait aussi citer la famille de circuits intégrés AMD Am2900.

Même si le processeur était en pièces détachées, utiliser une dizaine de circuits intégrés était nettement mieux que d'utiliser plusieurs milliers de transistors individuels. En conséquence, les ordinateurs ont vu leur taille grandement réduite, passant de pièces entières à une simple armoire, voire à quelques cartes intégrées superposées. De plus, le prix des circuits intégré était abordable, du moins comparé aux ordinateurs d'avant. Le prix des ordinateurs a alors grandement décru, permettant à des entreprises et administrations de taille modeste de s'équiper d'ordinateurs.

===La quatrième génération : le microprocesseur===

[[File:MOS6502.svg|vignette|Microprocesseur, ici un processeur MOS6502, de la quatrième génération.]]

Lors de la troisième génération, les circuits intégrés regroupaient plusieurs dizaines ou centaines de transistors, mais sont rapidement montés en gamme. De centaines de transistors, ils sont passés au millier de transistors, puis au million et maintenant au-delà du milliard. Les transistors étaient devenus tellement petits, tellement miniaturisés, qu'il était devenu possible de mettre un processeur entier dans un circuit intégré. C'est ainsi qu'est né le microprocesseur, à savoir un processeur qui tient tout entier dans un seul circuit imprimé. La quatrième génération d’ordinateur est celle des ordinateurs basés autour d'un microprocesseur.

Les tout premiers microprocesseurs étaient des processeurs à application militaire, comme le processeur du F-14 CADC ou celui de l'Air data computer. Le tout premier microprocesseur commercialisé au grand public est le 4004 d'Intel, sorti en 1971. L'intel 4004 comprenait environ 2300 transistors, avait une fréquence de 740 MHz, pouvait faire 46 opérations différentes, et manipulait des entiers de 4 bits. Il était au départ un processeur de commande, prévu pour être intégré dans la calculatrice Busicom calculator 141-P, mais il fut utilisé pour d'autres applications quelque temps plus tard. Immédiatement après le 4004, les premiers microprocesseurs 8 bits furent commercialisés. Le 4004 fut suivi par le 8008 et quelques autres processeurs 8 bits extrêmement connus, comme le 8080 d'Intel, le 68000 de Motorola, le 6502 ou le Z80.

Les microprocesseurs permirent encore uen fois de réduire la taille des ordinateurs, qui pouvaient tenir dans un boitier de PC, ou un boitier de console de jeu. Le prix des ordinateurs a aussi chuté en même temps que les transistors étaient miniaturisés. C'est cette invention qui permis l'invention des consoles de jeux et des mini-ordinateurs, à savoir les ordinateurs personnels. Sans miniaturisation, on n'aurait pas d'ordinateur personnel, pas de PC fixe ou portable.

==L'organisation du cours : les différents niveaux d'explication==

Le fonctionnement d'un ordinateur est assez complexe à expliquer car les explications peuvent se faire sur plusieurs niveaux. Par plusieurs niveaux, on veut dire qu'un ordinateur est composé de composants très simples, qui sont assemblés pour donner des composants eux-même plus complexes, qui sont eux-même regrouper, etc. Étudier tout cela demande de voir plusieurs niveaux, allant de transistors très petits à des processeurs multicœurs. Les niveaux les plus bas sont de l'électronique pur et dure, alors que ceux plus haut sont à mi-chemin entre électronique et informatique.

===Les niveaux d'abstraction en architecture des ordinateurs===

Les trois premiers niveaux sont de l'électronique pur et dure. Ils correspondent aux premiers chapitres du cours, qui porteront sur les circuits électroniques en général.
* Le premier niveau est celui des '''transistors''', des circuits intégrés, des ''wafer'' et autres circuits de très petite taille.
* Le second niveau est celui des '''portes logiques''', des circuits très basiques, très simples, à la base de tous les autres.
* Le troisième niveau est celui dit de la '''''Register Transfer Level''''', où un circuit électronique est construit à partir de circuits basiques, dont des registres et autres circuits dits combinatoires.
Les deux niveaux suivants sont de l'informatique proprement dit. C'est dans ces deux niveaux qu'on étudie les ordinateurs proprement dit, les circuits qu'il y a dedans et non l'électronique en général.
* Le quatrième niveau est celui de la '''microarchitecture''', qui étudie ce qu'il y a à l'intérieur d'un processeur, d'une mémoire, des périphériques et autres.
* Le cinquième niveau est celui de l''''architecture externe''', qui décrit l'interface du processeur, de la mémoire, d'un périphérique ou autre. Par décrire l'interface, on veut dire : comment un programmeur voit le processeur et la mémoire, comment il peut les manipuler. Une architecture externe unique peut avoir plusieurs microarchitecture, ce qui fait qu'on sépare les deux. Tout cela sera plus clair quand on passera aux chapitres sur le processeur et les mémoires.

Nous n'allons pas voir les 5 niveaux dans l'ordre, des transistors vers l'architecture externe. En réalité, nous allons procéder autrement. La première partie du cours portera sur les trois premiers niveaux, le reste sur les deux autres. Les 5 niveaux seront vus dans des chapitres séparés, du moins le plus possible. Au niveau pédagogique, tout est plus simple si on scinde les 5 niveaux. Bien sûr, il y a quelques explications qui demandent de voir plusieurs niveaux à la fois. Par exemple, dans le chapitre sur les mémoires caches, nous auront des explications portant sur la RTL, la microarchitecture du cache et son architecture externe. Mais le gros du cours tentera de séparer le plus possible les 5 niveaux.

===Les trois parties principales du cours===

Nous allons commencer par parler du binaire, avant de voir les portes logiques. Avec ces portes logiques, nous allons voir comment fabriquer des circuits basiques qui reviendront très souvent dans la suite du cours. Nous verrons les registres, les décodeurs, les additionneurs et plein d'autres circuits. Puis, nous reviendrons au niveau des transistors pour finir la première partie. La raison est que c'est plus simple de faire comme cela. Tout ce qui a trait aux transistors sert à expliquer comment fabriquer des portes logiques, et il faut expliquer les portes logiques pour voir le niveau de la RTL.

Une fois la première partie finie, nous allons voir les différents composants d'un ordinateur. Une première partie expliquera ce qu'il y a dans un ordinateur, quels sont ses composants. Nous y parlerons de l'architecture de base, de la hiérarchie mémoire, des tendances technologiques, et d'autres généralités qui serviront de base pour la suite. Puis, nous verrons dans l'ordre les bus électroniques, les mémoires RAM/ROM, le processeur, les périphériques, les mémoires de stockage (SSD et disques durs) et les mémoires caches. Pour chaque composant, nous allons voir leur architecture externe, avant de voir leur microarchitecture. La raison est que la microarchitecture ne peut se comprendre que quand on sait quelle architecture externe elle implémente.

Enfin, dans une troisième partie, nous allons voir les optimisations majeures présentes dans tous les ordinateurs modernes, avec une partie sur le pipeline et le parallélisme d'instruction, et une autre sur les architectures parallèles. Pour finir, les annexes de fin parlerons de sujets un peu à part.

&lt;noinclude&gt;
{{NavChapitre | book=Fonctionnement d'un ordinateur
           | next=L'encodage des données
           | nextText=L'encodage des données
}}
&lt;/noinclude&gt;</text>
      <sha1>rq245v6wjk3g5tbqg4hkhptw8llkce3</sha1>
    </revision>
    <revision>
      <id>744174</id>
      <parentid>744173</parentid>
      <timestamp>2025-06-05T15:53:48Z</timestamp>
      <contributor>
        <username>Mewtow</username>
        <id>31375</id>
      </contributor>
      <minor />
      <comment>/* La première génération : les tubes à vide */</comment>
      <origin>744174</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="49216" sha1="9116h9lujccv7m3f5sla0tuwmhxgsgi" xml:space="preserve">Pour commencer, nous allons voir qu'il existe de nombreux types d'ordinateurs. Le plus connu est certainement le PC, l'ordinateur personnel, que vous avez sans doute dans votre salon. Les ordinateurs portables sont un deuxième type d'ordinateur assez intuitif, que vous avez peut-être. Mais il y a aussi d'autres types d'ordinateurs auxquels vous n'avez jamais été confrontés.

==Les différents types d'ordinateurs==

Dans cette section, nous allons décrire rapidement les ordinateurs les plus courant, mais surtout voir ce qu'il y a à l'intérieur d'un ordinateur.

===L'ordinateur de type PC fixe===

De l'extérieur, l'ordinateur est composé d'une unité centrale sur laquelle on branche des périphériques.

[[File:Typical computer architecture systems.jpg|vignette|upright=1.5|Exemples de périphériques, connectés à une unité centrale (ici appelée à tort ''operating system'').]]

Les '''périphériques''' regroupent l'écran, la souris, le clavier, l'imprimante, et bien d'autres choses. Ils permettent à l'utilisateur d'interagir avec l'ordinateur : un clavier permet de saisir du texte sous dans un fichier, une souris enregistre des déplacements de la main en déplacement du curseur, un écran affiche des données d’images/vidéos, un haut-parleur émet du son, etc. Tout ce qui est branché sur un ordinateur est, formellement un périphérique.

L''''unité centrale''' est là où se trouvent tous les composants importants d'un ordinateur, ceux qui font des calculs, qui exécutent des logiciels, qui mémorisent vos données, etc. Voici ce à quoi ressemble l'intérieur de l'unité centrale. Trois sections sont visibles : l'alimentation électrique en haut à gauche, la carte mère en bas à gauche et en jaune/orange, les disques et lecteurs à droite des câbles. Et on voit aussi beaucoup de câbles.

[[File:Asus P5K-SEIntel E6320.jpg|centre|vignette|upright=2|Exemple d'unité centrale.]]

Tout en haut à gauche, se trouve l''''alimentation électrique''', qui convertit le courant de la prise électrique en un courant plus faible, utilisable par les autres composants. Elle émet de nombreux câbles assez gros, qui sont reliés au reste. Les PC actuels utilisent des alimentations électriques standardisées, qui fournissent trois tensions au reste de l'ordinateur : une tension de 12 Volts, une de 5 Volts, une de 3,3 Volts.

À droite, caché par la partie &quot;métallique&quot; du boitier, se trouvent les lecteurs de CD/DVD, et les disques durs. Les lecteurs CD-ROM ou DVD-ROM permettaient de lire des CD ou des DVD. Je parle au passé, car ils ont aujourd'hui disparu des ordinateurs modernes. Les '''disques durs''' sont des mémoires de stockage, qui mémorisent vos données de manière permanente. De nos jours, ils sont remplacés par des SSD, qui sont des disques durs électroniques, là où les disques durs proprement dit sont des mémoires magnétiques. Nous verrons la différence dans deux chapitres dédiés, un sur les disques durs, l'autre sur les SSD.

En bas à droite, se trouve la '''carte mère''' un support plat, en plastique ou en céramique, sur laquelle sont soudés/connectés les autres composants. Sur celle-ci, de nombreux composants sont soudés, d'autres sont branchés dessus avec des câbles, d'autres sont connectés dessus avec des connecteurs. Ils sont reliés entre eux par des fils conducteurs, le plus souvent du cuivre ou de l’aluminium, ce qui leur permet de s’échanger des données. Sur les cartes simples, ces fils sont intégrés dans la carte électronique, dans des creux du plastique. Ils portent le nom de pistes.

Avant, les disques durs, SSD et lecteurs de CD/DVD sont branchés dessus via des connecteurs dédiés, appelés des connecteurs S-ATA. De nos jours, ils sont branchés sur un autre connecteur, grâce à l'interface NVME. Toujours est-il qu'ils sont reliés à la carte mère par des câbles, ce qui montre que ce sont des sortes de périphériques interne. Ils sont placés dans le boitier, mais on aurait tout aussi bien pu les mettre à l'extérieur, vu qu'ils communiquent avec l'ordinateur par l'intermédiaire d'un câble ou d'un connecteur dédié.

Mais deux autres composants très importants sont eux placés sur la carte mère, directement. Ils ont chacun un connecteur dédié, sur lequel ils sont branchés directement, sans passer par l'intermédiaire d'un câble, mais sans être soudés non plus. Il s'agit du processeur et de la mémoire RAM, deux composants centraux des PC modernes.

[[File:Pentium III SL4CB.jpg|thumb|Processeur Pentium III.]]

Le '''processeur''' traite les données, les modifie, les manipule. Pour faire simple, il s’agit d’une grosse calculatrice hyper-puissante. Il comprend à la fois un circuit qui fait des calculs, et un circuit de contrôle qui s'occupe de séquencer les calculs dans l'ordre demandé. Il est souvent caché sous un radiateur, lui-même surmonté par un ventilateur. En effet, un processeur chauffe beaucoup, ce qui demande d'évacuer cette chaleur. Un chapitre entier expliquera pourquoi les processeurs chauffent, ainsi que les techniques utilisées pour limiter leur production de chaleur et leur consommation électrique.

La '''mémoire vive''' conserve des informations/données temporairement, tant que le processeur en a besoin. Elle prend la forme de barrettes de RAM, comme montré ci-dessous.

[[File:2 gb ddr2 667.jpg|centre|vignette|upright=2|Barrette de RAM.]]

Outre ces composants dits principaux, un ordinateur peut comprendre plusieurs composants moins importants, surtout présents sur les ordinateurs personnels. Ils sont techniquement facultatifs, mais sont très présents dans les ordinateurs personnels. Cependant, certains ordinateurs spécialisés s'en passent. Il s'agit des diverses '''cartes d'extension''' sont branchées sur la carte mère. Elles permettent d’accélérer certains calculs ou certaines applications, afin de décharger le processeur. Par exemple, la carte graphique s'occupe des calculs graphiques, qu'il s'agisse de graphismes 3D de jeux vidéos ou de l'affichage en 2D du bureau. Dans un autre registre, la carte son prend en charge le microphone et les haut-parleurs.

[[Fichier:Personal computer, exploded 4.svg|thumb|upright=1.0|Éclaté d'un ordinateur de type PC :&lt;br /&gt;
1 : Écran ;&lt;br /&gt;
2 : Carte mère ;&lt;br /&gt;
3 : Processeur ;&lt;br /&gt;
4 : Câble Parallel ATA ;&lt;br /&gt;
5 : Mémoire vive (RAM) ;&lt;br /&gt;
6 : Carte d'extension ;&lt;br /&gt;
7 : Alimentation électrique ;&lt;br /&gt;
8 : Lecteur de disque optique ;&lt;br /&gt;
9 : Disque dur ;&lt;br /&gt;
10 : Clavier ;&lt;br /&gt;
11 : Souris.]]

Si on regarde une carte mère de face, on voit un grand nombre de connecteurs, mais aussi des circuits électroniques soudés à la carte mère.

[[File:Architecture matérielle d'une carte mère.png|centre|vignette|upright=2.0|Architecture matérielle d'une carte mère]]

Les '''connecteurs''' sont là où on branche les périphériques, la carte graphique, le processeur, la mémoire, etc. Dans l'ensemble, toute carte mère contient les connecteurs suivants :
* Le processeur vient s’enchâsser dans la carte mère sur un connecteur particulier : le '''socket'''. Celui-ci varie suivant la carte mère et le processeur, ce qui est source d'incompatibilités.
* Les barrettes de mémoire RAM s’enchâssent dans un autre type de connecteurs: les '''slots mémoire'''.
* Les mémoires de masse disposent de leurs propres connecteurs : connecteurs P-ATA pour les anciens disques durs, et S-ATA pour les récents.
* Les périphériques (clavier, souris, USB, Firewire, ...) sont connectés sur un ensemble de connecteurs dédiés, localisés à l'arrière du boitier de l'unité centrale. 
* Les autres périphériques sont placés dans l'unité centrale et sont connectés via des connecteurs spécialisés. Ces périphériques sont des cartes imprimées, d'où leur nom de '''cartes filles'''. On peut notamment citer les cartes réseau, les cartes son, ou les cartes vidéo.

===Les ordinateurs portables===

[[File:Samsung QX-511 (2).JPG|vignette|Ordinateur portable Samsung QX-511 (2), pour illustration.]]

Un ordinateur portable est identique à un ordinateur de type PC. Si vous ouvrez votre ordinateur portable (attention à la garantie), vous retrouverez les mêmes composants qu'un PC à l'intérieur. Un point important est la présence d'une batterie à l'intérieur du PC portable, absente des PC fixes.

[[File:LG gram 14Z90Q mainboard with battery.jpg|centre|vignette|upright=2|LG gram 14Z90Q avec sa batterie.]]

Une fois la batterie et les circuits associés retiré, la seule différence notable est que tous les composants sont soudés sur la carte mère, au lieu d'être branchés sur des connecteurs, à part éventuellement la RAM et le disque dur.

[[File:LG gram 14Z90Q mainboard without battery.jpg|centre|vignette|upright=2|LG gram 14Z90Q sans sa batterie.]]

La RAM est parfois soudée sur la carte mère, d'autres fois sous la forme de barrettes de mémoire vive semblables à celles des PC. Dans le dernier cas, elle est connectée à des connecteurs spécifiques, ce qui permet de les changer/upgrader. Les PC portables sont parfois construits de manière à pouvoir changer la RAM facilement, en ouvrant un cache spécial, concu pour.

[[File:Lenovo G555 состав - Донор.JPG|centre|vignette|upright=2|Lenovo G555.]]

La conception d'un ordinateur portable est légèrement différente de celle d'un PC, pour des raisons thermiques. Un PC fixe a plus de place pour évacuer sa chaleur. Les ventilateurs peuvent plus facilement déplacer l'air dans le boitier, même si le flux d'air dans le boitier est éventuellement gêné par la carte graphique. Mais l'évacuation de la chaleur est assez efficace. Sur les PC portables, leur finesse fait que le trajet de l'air est beaucoup plus contraint. Évacuer la chaleur produite par l'ordinateur est plus complexe, ce qui demande d'utiliser des systèmes de refroidissement et de ventilation spécifiques.

Là où les PC fixes se débrouillent avec des radiateurs et des ventilateurs posés sur le processeur, les PC portables font autrement. Ils ne peuvent pas forcément mettre le ventilateur sur le processeur. A la place, ils mettent le ventilateur à côté, mais le processeur est surmonté par un mécanisme de transmission de la chaleur, qui transfère la chaleur du processeur vers le ventilateur.

[[File:Diagram - How a laptop cooling system works.png|centre|vignette|upright=2|Comment fonctionne le système de ventilation d'un ordinateur portable, en anglais.]]

Les difficultés pour dissiper la chaleur font que les ordinateurs portables utilisent souvent des composants peu performants, mais qui chauffent peu. En effet, nous verrons que plus un composant est puissant, plus il chauffe. La relation n'est pas parfaite, mais les processeurs haute performance chauffent plus que les modèles d'entrée ou milieu de gamme moins puissants. En conséquence, les PC portables sont souvent moins puissants que les PC fixes, même pour les modèles dit ''gaming''.

===Les serveurs et ''mainframes''===

Les grandes entreprises utilisent des ordinateurs de grande taille, très puissants, appelés des ''mainframes''. Ils sont souvent confondus avec les serveurs par le grand public, il y a une différence entre les deux. Un serveur est une fonction logicielle/réseau, pas un type d'ordinateur. Mais laissons cette différence de côté, ce qui est dit pour les ''mainframes'' sert pour les gros serveurs haute performance.

[[File:IBM Z15 mainframe.jpg|vignette|Exemple de ''mainframe''' de type IBM Z15.]]

Les anciens ''mainframes'' des années 50-80 avaient une taille pouvant être impressionnante, au point de prendre une pièce complète d'un bâtiment. Mais de nos jours, les ''mainframes'' tiennent dans une grosse armoire un peu haute. Les ''mainframes'' doivent rester allumé en permanence et ne doivent pas être éteint, sauf éventuellement quelques jours par an pour des opérations de maintenance. Ils utilisent pour cela des techniques spécifiques, avec beaucoup de redondance interne.

[[File:ACONIT hall grandes machines.jpg|centre|vignette|upright=2|''Mainframe'' ACONIT.]]

Les ''mainframes'' sont aussi conçus pour mutualiser au maximum leur utilisation, ils peuvent être utilisés par plusieurs utilisateurs à la suite, voire en même temps. Pour cela, les anciens ''mainframes'' étaient capables de faire tourner plusieurs applications distinctes l'une à la suite de l'autre, avec des commutations fréquentes entre logiciels. De nos jours, ils sont capables d'exécuter un grand nombre de tâches en même temps, grâce à la présence de plusieurs processeurs. Les ''mainframes'' modernes sont même capables de faire tourner plusieurs systèmes d'exploitation en même temps si besoin.

Les anciens ''mainframes'' étaient des ordinateurs assez simples, avec un processeur, de la mémoire RAM, un ou plusieurs disques durs, pas plus. Le ''mainframe'' était tellement énorme et cher que les entreprises n'en avaient qu'un seul pour toute l'entreprise. Les employés avaient sur leur bureau des terminaux, qui permettaient d'accéder à l'ordinateur central, mais n'étaient pas des ordinateurs. Les terminaux étaient des composants électroniques simples, avec un écran, un clavier et une souris, mais sans processeur. Ils envoyaient des données au ''mainframe'', ils en recevaient de sa part, mais tout traitement était réalisé sur le ''mainframe''. L'arrivée sur le marché des ordinateurs personnels, de type PC fixe/portable, a entrainé l'abandon de ce genre de pratique, tous les employés ont maintenant un ordinateur rien que pour eux.

{|
|-
! colspan=&quot;2&quot; | Exemples de terminaux
|-
|[[File:Terminal-in2-sm9400.jpg|centre|vignette|upright=1.5|Exemple de terminal. Notez la présence d'un écran et d'un clavier, mais l'asbence d'une unité centrale.]]
|[[File:Chromatics CT4100.jpg|vignette|upright=1.5|Autre exemple de terminal. Le clavier est couplé à un stylo CRT, qui remplacait la souris et agissait sur l'écran comme s'il était tactile.]]
|-
! colspan=&quot;2&quot; | Intérieur d'un terminal
|-
|[[File:CT1024 Monitor.jpg|vignette|upright=1.5|Terminal CT1024, sans le boitier extérieur.]]
|[[File:CT1024 Terminal System.jpg|vignette|upright=1.5|Terminal CT1024, description des composants interne.]]
|}

De nos jours, les ''mainframes'' contiennent en réalité plusieurs ordinateurs simples interconnectés via un réseau local. Un ''mainframe'' qui tient dans une armoire contient facilement une dizaine ou centaine de processeurs, plein de RAM, des disques durs séparés dans une armoire distincte, etc. Vu qu'ils communiquent uniquement via le réseau, ils n'ont pas d'interface, pas d'écran, 'entrée via clavier/souris. Le tout est commandé avec une console de commande, typiquement un ordinateur portable ou un terminal assez simple séparé de l'armoire, qui permet à un administrateur de faire des opérations de surveillance, configuration et maintenance. Il peut y avoir une console de commande pour plusieurs armoires séparées, la console peut même être dans un autre bâtiment et accéder au ''mainframe'' par le réseau.

[[File:IBM System Z9 (type 2094 inside).jpg|centre|vignette|upright=2|''Mainframe'' de type IBM System Z9. L'ordinateur portable sert de console pour qu'un administrateur fasse des opérations de surveillance, configuration et maintenance.]]

Les processeurs et la RAM sont typiquement installés sur des cartes amovibles, qui sont connectées au fond de l'armoire lors de l'installation. Il est même possible de retirer ou d'ajouter des cartes en fonctionnement, afin d'ajouter/retirer des processeurs, des disques durs, etc. Ce qui est très utile si un composant est en panne et qu'il faut le remplacer. 

[[File:IBM TotalStorage Exp400.jpg|centre|vignette|upright=2|IBM TotalStorage Exp400]]

==Un peu d'abstraction : qu'est-ce qu'un ordinateur ?==

Un ordinateur comprend donc un processeur, plusieurs mémoires, des cartes d'extension et une carte mère pour connecter le tout. Mais il s'agit là d'une description assez terre-à-terre de ce qu'est un ordinateur. Une autre description, plus abstraite, se base sur le fait qu'un ordinateur est une énorme calculatrice programmable. Elle permet d'expliquer pourquoi il y a une distinction entre processeur et mémoire, entre unité centrale et périphériques. Tout ce qui va suivre pourra vous paraitre assez abstrait, mais rassurez-vous : les prochains chapitres rendront tout cela plus concrets.

===La séparation entre entrées-sorties et traitement===

L'unité centrale peut être vue comme une énorme calculatrice ultra-puissante, qui exécute des commandes/opérations. Mais à elle seule, elle ne servirait à rien, il faut interagir avec par l'intermédiaire de plusieurs périphériques. Il existe deux types de périphériques, qui sont conceptuellement différents. Les périphériques comme le clavier ou la souris permettent d'envoyer des informations à l'ordinateur, d'agir sur celui-ci. A l'inverse, les écrans transmettent des informations dans le sens inverse : de l'ordinateur vers l'utilisateur. Les premiers sont appelés des '''entrées''', les seconds des '''sorties'''.

Dans un ordinateur, les informations sont représentées sous la forme de nombres. Toute donnée dans un ordinateur est codée avec un ou plusieurs nombres regroupés dans une donnée, un fichier, ou autre. Et la transmissions avec les entrées et sorties se fait là-encore avec des nombres. Par exemple, quand vous appuyez sur votre clavier, le clavier envoie un numéro de touche à l'unité centrale, qui indique quelle touche a été appuyée. L'image à afficher à l'écran est codée sous la forme d'une suite de nombres (un par pixel). L'image est envoyée à l'écran, qui traduit la suite de nombre en image à afficher. Les entrées traduisent des actions utilisateurs en nombres, on dit que les entrées encodent les actions utilisateur. Les sorties font la traduction inverse, elles transforment des suites de nombres en une action physique. On dit qu'elles décodent des informations.

Pour résumer, toute appareil électronique est composé par :
* Des '''entrées''' sur lesquelles l'utilisateur agit sur l'ordinateur. Les entrées transforment les actions de l'utilisateur en nombres, qui sont interprétés par l'ordinateur.
* Une '''unité de traitement''', qui manipule des nombres et fait des calculs/opérations dessus. Les nombres proviennent des entrées, du disque dur, ou d'autres sources, peu importe.
* Des '''sorties''', qui va récupèrent le résultat calculé par l'unité de traitement pour en faire quelque chose : écrire sur une imprimante ou sur un moniteur, émettre du son,...

[[File:Ordinateur théorique Simple 1.png|centre|vignette|upright=2|Ordinateur théorique Simple 1]]

L'unité de traitement proprement dite, celle qui fait les calculs, est couplée à une mémoire qui mémorise les opérandes et résultats des calculs. La séparation entre processeur et mémoire est nécessaire pour qu'un appareil électronique soit qualifié d'ordinateur. De nombreux appareils n'ont pas de séparation entre unité de traitement et mémoire, comme certaines vielles radios AM/FM.

[[File:Schéma de principe d'un ordinateur.png|centre|vignette|upright=2|Schéma de principe d'un ordinateur]]

===Un ordinateur est un appareil programmable===

Les appareils simples sont non-programmables, ce qui veut dire qu’ils sont conçus pour une utilisation particulière et qu’ils ne peuvent pas faire autre chose. Par exemple, les circuits électroniques d’un lecteur de DVD ne peuvent pas être transformé en lecteur audio ou en console de jeux... Les circuits non-programmables sont câblés une bonne fois pour toute, et on ne peut pas les modifier. On peut parfois reconfigurer le circuit, pour faire varier certains paramètres, via des interrupteurs ou des boutons, mais cela s’arrête là. Et cela pose un problème : à chaque problème qu'on veut résoudre en utilisant un automate, on doit recréer un nouveau circuit.

À l'inverse, un ordinateur n’est pas conçu pour une utilisation particulière, contrairement aux autres objets techniques. Il est possible de modifier leur fonction du jour au lendemain, on peut lui faire faire ce qu’on veut. On dit qu'ils sont '''programmables'''. Pour cela, il suffit d’utiliser un logiciel, une application, un programme (ces termes sont synonymes), qui fait ce que l'on souhaite. La totalité des logiciels présents sur un ordinateur sont des programmes comme les autres, même le système d'exploitation (Windows, Linux, ...) ne fait pas exception.

Un programme est une suite de d''''instructions machines''', chaque instruction effectuant une action dans l'ordinateur. Sur les ordinateurs modernes, les instructions les plus communes effectuent une opération arithmétique : une addition, une multiplication, une soustraction, etc. Les ordinateurs modernes sont donc de grosses calculettes très puissantes, capables d'effectuer des millions d'opérations par secondes.

Et qui dit opération dit nombres : un ordinateur gère nativement des nombres, qui sont codés en binaire sur la quasi-totalité des ordinateurs modernes. Les ordinateurs modernes sont capables de faire des calculs sur des nombres entiers, mais aussi des nombres à virgule. Il existe plusieurs manières de représenter des nombres en binaire, certaines représentant des nombres entiers dits naturels (0 et plus), d'autres des nombres signés (positifs ou négatifs), d'autres des nombres à virgule. Un chapitre entier détaillera comment sont encodés ces nombres.

Une instruction est représentée dans un ordinateur par une série de nombres entiers : un nombre qui indique quelle opération/commande effectuer et des autres nombres pour coder les données (ou de quoi les retrouver dans l'ordinateur). L'ordinateur récupére les commandes une par une, les traduit en opération à effectuer, exécuter l'opération, et enregistre le résultat. Puis il recommence avec la commande suivante.

[[File:Ordinateur Théorique Complexe 1.png|centre|vignette|upright=3|Ordinateur Théorique Complexe. En jaune, le programme informatique, la liste de commande. Le rectangle gris est l'ordinateur proprement dit.]]

De nombreux appareils sont programmables, mais tous ne sont pas des ordinateurs. Par exemple, certains circuits programmables nommés FPGA n'en sont pas. Pour être qualifié d'ordinateur, un appareil programmable doit avoir un processeur séparé de la mémoire. De plus, il doit utiliser un '''codage numérique''', chose que nous allons aborder dans le chapitre suivant.

===Les ordinateurs à programme mémorisé ou programme externe===

[[File:Blue-punch-card-front.png|vignette|upright=0.5|Carte Perforée.]]

Au tout début de l'informatique, les programmes étaient enregistrés sur des cartes perforées, à savoir des cartes en papier/plastique percées par endroits. Un 1 est codé par un trou dans le papier et un 0 par une absence de trou. Les programmes étaient exécutés par l'ordinateur quand on insérait la carte perforée dans le lecteur et qu'on appuyait sur un bouton.

Par la suite, les premiers ordinateurs grand public, comme les Amstrad ou les Commodore, utilisaient des cassettes audio magnétiques pour stocker les programmes. Dans le même style, les consoles de jeu utilisaient autrefois des cartouches de jeu, qui contenaient le programme du jeu à exécuter. Pour résumer, les anciens ordinateurs mémorisaient les programmes sur un support externe, lu par un périphérique. De tels ordinateurs sont dits à '''programme externe'''.

: D’anciens ordinateurs personnels, comme l’Amstrad ou le Commodore, permettaient de taper les programmes à exécuter à la main, au clavier, avant d’appuyer une touche pour les exécuter. Nul besoin de vous dire que les cassettes audio étaient plus pratiques.

Mais de nos jours, les programmes sont enregistrés sur le disque dur de l'ordinateur ou dans une mémoire intégrée à l'ordinateur. On dit qu'ils sont installés, ce qui est un mot bien compliqué pour dire que le programme est enregistré sur le disque dur de l’ordinateur. A défaut de disque dur, le programme/logiciel est enregistré dans une mémoire spécialisée pour le stockage. Par exemple, sur les cartes électroniques grand public de marque Arduino, les programmes sont envoyés à la carte via le port USB, mais les programmes sont enregistrés dans la carte Arduino, dans une mémoire FLASH dédiée. Disque dur ou non, le programme est mémorisé dans la mémoire de l'ordinateur. Il est possible d'installer ou de désinstaller les programmes en modifiant le contenu de la mémoire. Le terme utilisé est alors celui de '''programme stocké en mémoire'''.

Les programmes à installer sont disponibles soit sur un périphérique, comme un DVD ou une clé USB, soit sont téléchargés depuis internet. Les premiers PC fournissaient les logiciels sur des disquettes, qui contenaient un programme d'installation pour enregistrer le programme sur le disque dur de l'ordinateur. Par la suite, le support des logiciels a migré vers les CD et DVD, les logiciels devenant de plus en plus gros. De nos jours, la majorité des applications sont téléchargées depuis le net, l'usage de périphériques est devenu obsolète, même les consoles de jeu abandonnent cette méthode de distribution.

==Les générations d'ordinateurs : un historique rapide==

L'informatique a beaucoup évolué dans le temps. Et une bonne partie de cette évolution tient à l'évolution de l’électronique sous-jacente. Les ordinateurs actuels sont fabriqués avec des transistors, des petits composants électroniques qui servent d'interrupteurs programmables, qu'on détaillera dans ce qui suit. Mais ça n'a pas toujours été le cas. Et cela permet de distinguer plusieurs '''générations d'ordinateurs'''.

===Les ordinateurs électro-mécaniques : les premiers ordinateurs===

Le tout premier ordinateur est le '''Z1''', un modèle unique inventé par Konrad Suze entre 1936 et 1938. Son processeur gérait non pas des nombres entiers, mais des nombres à virgule (des nombres dits flottants, pour être précis), encodés sur 22 bits. Le processeur du Z1 était capable de faire des additions et des soustractions, car il intégrait un circuit additionneur-soustracteur basique. Des circuits annexes permettaient de faire des multiplications et des divisions en enchainant des additions/soustractions successives. Il fonctionnait à une fréquence de 1 Hz, ce qui fait qu'il pouvait faire une addition/soustraction par seconde maximum.

Niveau mémoire, la RAM de l'ordinateur était très limitée : seulement 16 nombres de 22 bits chacun. S'il s'agissait d'une mémoire électronique, les programmes étaient mémorisés sur une mémoire mécanique et précisémment sur des cartes perforées, à savoir des cartes en papier/plastique dans lesquelles un 1 est codé par un trou dans le papier et un 0 par une absence de trou. Les programmes étaient exécutés par l'ordinateur quand on insérait la carte perforée dans le lecteur et qu'on appuyait sur un bouton.

[[File:German Museum of Technology, Berlin 2017 024.jpg|centre|vignette|upright=2|Réplique du Z1 au ''German Museum of Technology'' de Berlin, 2017.]]

Après sa destruction dans un bombardement, le Z1 a été reconstruit et amélioré, ce qui donné les deux ordinateurs Z2 et Z3. Quelques années plus tard, quelques laboratoires de recherche ont fabriqués des ordinateurs dans leur coin, comme le Harvard Mark I et le Colossus Mark 1 (UK) qui ont été mis en service en 1944. Ils ont servi pour les cryptanalystes pour casser les codes utilisés par les Allemands pour leurs transmissions, pendant la seconde guerre mondiale.

Les ordinateurs cités dans le précédent paragraphe étaient tous des ordinateurs dit '''électro-mécaniques''', car ils mélangeaient des composants électroniques et des composants mécaniques (tout ce qui a trait aux cartes perforées, notamment). Les composants électroniques étaient généralement des relais, à savoir des interrupteurs commandables électriquement, qui sont plus ou moins équivalents aux transistors modernes. La majeure partie des ordinateurs des années 40 étaient de ce type, mais leur nombre n'a pas dépassé 30. Il faut dire qu'ils ont rapidement laissé la place à des ordinateurs purement électroniques, que nous allons voir dans ce qui suit.

===La première génération : les tubes à vide===

[[File:Diode vacuum tube.svg|vignette|Diode vacuum tube]]

Les ordinateurs qui ont suivi les ordinateurs électromécaniques sont regroupés dans la '''première génération d'ordinateur'''. Ils étaient conçus avec des tubes à vide. Les tubes à vide sont des ampoules à filament améliorées. Pour rappel, les ampoules à filament étaient des ampoules en verre dans lesquelles on plaçait un filament métallique. Le filament chauffait quand on envoyait du courant dedans et émettait de la lumière.

Dans les tubes à vides, le filament n'émet pas de lumière quand on le chauffe : il émet des électrons, de l'électricité. De plus, on ajoute une plaque métalliques appelée l'anode, qui capte des électrons émis par le filament. Le résultat est un circuit qui laisse passer le courant, mais seulement dans un sens : du filament vers l'anode, l'autre sens n'est pas possible vu que l'anode ne peut pas émettre d'électrons. Un tel circuit est appelé une '''diode'''.

[[File:Triode vacuum tube FR.png|vignette|Triode.]]

Les tubes à vide précédents peuvent être modifiés en ajoutant une grille métallique entre la cathode et l'anode. La grille est alimentée avec une tension électrique, ce qui la charge électriquement. Suivant sa charge, elle laisse plus ou moins passer les électrons de la cathode vers l'anode. Si elle n'est pas chargée, que la tension est de 0 Volts, elle ne fera pas obstacle aux électrons et le tube à vide fonctionnera comme une diode basique. Mais si la grille est chargée avec une tension négative, sa charge électrique va repousser les électrons et les empêcher de passer de la cathode vers l'anode.

Le tube à vide se comporte alors comme un interrupteur : fermé ou ouvert suivant ce qu'on met sur la grille. Un tel tube à vide est appelée une '''triode''', car c'est une diode à laquelle on a ajouté une entrée pour charger la grille. De tels interrupteurs commandables électriquement sont combinés pour fabriquer des circuits plus élaborés, comme les portes logiques qu'on verra d'ici quelques chapitres.

Au vu de ce qu'on vient de dire, on peut facilement deviner que les tubes à vide avaient beaucoup de défauts. Ils étaient assez encombrants, dans le sens où une ampoule prend beaucoup de place. Et il est difficile de miniaturiser une ampoule, personne n'imagine une ampoule de quelques microns de côté, alors que les transistors actuels sont plus petits que ça. De plus, ils consommaient beaucoup de courant et chauffaient. Faire chauffer un filament demande un courant important et une bonne partie de ce courant part en chaleur. De plus, ils étaient assez peu fiables et tombaient en panne assez souvent. Et s'ils étaient assez simples à fabriquer, ils restaient malgré tout chers.

Les tubes à vides étaient utilisés pour le processeur et quelques circuits annexes, mais les mémoires utilisaient d'autres technologies. Les mémoires de l'époque n'étaient pas du tout des mémoires électroniques. Il existait déjà des ancêtres des disques durs, à savoir des mémoire magnétiques appelées tambours magnétiques, bandes magnétiques, mémoires à tore de ferrite, etc. Les mémoires RAM, quant à elles, utilisaient elles des technologies totalement abandonnées : les mémoires à lignes de délai étaient des mémoires acoustiques, les tubes Williams étaient des écrans CRT modifiés, etc. Un chapitre entier sera dédié aux technologies des mémoires de l'époque.

[[File:Elektronenroehren-auswahl.jpg|centre|vignette|upright=2|Tubes à vides.]]

L'usage de tubes à vide les place entre les premiers ordinateurs électro-mécaniques et les ordinateurs utilisant des transistors. Au vu de la taille des tubes à vide, les ordinateurs de l'époque étaient composés de plusieurs milliers de ces tubes, guère plus. Et malgré cela, un ordinateur prenait facilement un étage de bâtiment entier, ou au moins plusieurs pièces. La conséquence est que les ordinateurs de première génération étaient très simples, rudimentaires quand on les compare aux ordinateurs modernes. Ils ne géraient que quelques opérations simples : l'addition, la soustraction, pas grand-chose de plus. À quelques exceptions près, ils ne géraient pas la multiplication et encore moins la division, cela aurait demandé trop de tubes à vides.

Une des toutes premières machines construite avec des tubes à vide était l'Atanasoff–Berry. Ce n'était pas un ordinateur, car elle ne pouvait pas exécuter de programme sans intervention humaine pour séquencer des opérations, mais c'était la première machine de calcul purement électronique, sans aucune pièce mécanique. Elle utilisait une mémoire RAM construite avec des condensateurs, ceux-ci étant placés sur des cylindres tournants. Les circuits de calcul étaient construits avec des tubes à vide et faisaient leur travail un bit à la fois. Elle fonctionnait à une fréquence de 60 Hz et pouvait faire 30 additions/soustractions par seconde. Les nombres étaient encodés sur 50 bits. 

[[File:Atanasoff Berry Computer.gif|centre|vignette|upright=2.5|Atanasoff–Berry.]]

L'arrivée de l'ENIAC en 1945 a changé la donne. Cet ordinateur a introduit plusieurs innovations majeures. La première est assez technique, il s'agit de la turing-complétude, elle a trait aux programmes qui peuvent être écrit pour un ordinateur, nous ne la détaillerons pas ici.

[[File:BabyArchitecture.png|vignette|Architecture de la Manchester Baby.]]

En 1948, le ''Manchester Baby'' a introduit une innovation extrêmement importante : le programme n'était plus mémorisé sur des cartes perforées, mais dans une mémoire électronique à l’intérieur de l'ordinateur lui-même. En clair, le ''Manchester Baby'' était le premier '''ordinateur à programme stocké en mémoire''' en français. Au-delà de ça, le Manchester Baby restait quand même très simple, c'était limite un prototype.

Niveau interface, l'ordinateur avait une console avec 32 boutons, des interrupteurs et un écran de sortie sur lequel afficher les résultats. A l'intérieur, il y avait un processeur et une RAM de 32 nombres de 32 bits, fabriquées avec des tubes Williams (abordés dans une annexe à la fin du cours). Une instruction prenant autant de place qu'un nombre en RAM, ce qui limitait les programmes à 32 instructions maximum. Le processeur gérait 8 instructions en tout, mais la seule instruction de calcul qu'il gérait était la soustraction. L'addition n'était pas supportée. Il pouvait cependant émuler l'addition à partir d'une soustraction et inversant l'opérande soustrait.

Le Manchester Mark 1 était une amélioration du Manchester Baby. Il utilisait 4500 tubes à vide. L'ordinateur gérait des nombres de 40 bits, mais les instructions étaient codées sur 20 bits. La RAM avait la même taille, à savoir 32 nombres, leur taille était simplement augmentée. Par contre, la RAM était complémentée par l’ancêtre du disque dur magnétique, à savoir un tambour magnétique, l’ancêtre du disque dur magnétique. Il contenait 40 pages, chacune ayant la même taille que la RAM. Contrairement à la Manchester Baby, son processeur gérait l'addition. Les multiplications étaient réalisées par des additions successives, mais le processeur intégrait des registres pour mémoriser les opérandes à multiplier.

Par la suite, les ordinateurs commerciaux ont vu le jour. Les ordinateurs précédents provenaient de projets de recherches, souvent publics. Mais les entreprises privées se sont mises à fabriquer des ordinateurs elle-mêmes, pour les vendre à d'autres entreprises. On peut notamment citer les ordinateurs comme le UNIVAC I, le Bull Gamma 3 ou les premiers ordinateurs IBM. La performance de ces ordinateurs était nettement plus importante que leurs prédécesseurs, avec des fréquences de l'ordre de la centaine de kilo-hertz. Par exemple, le Bull Gamma 3 allait à 281 kHz, l'IBM 650 allait à 50 Khz.

===La seconde génération : le remplacement des tubes à vides par des transistors===

[[File:IBM 7070.jpg|vignette|Cartes imprimées de l'IBM 704, avec des transistors et résistances dessus.]]

La '''seconde génération''' est celle des ordinateurs fabriqués avec des '''transistors''' isolés, reliés entre avec des fils électriques. Les transistors en question possèdent trois broches, des pattes métalliques sur lesquelles on connecte des fils électriques. Le transistor s'utilise le plus souvent comme un interrupteur commandé par sa troisième broche. Le courant qui traverse les deux premières broches passe ou ne passe pas selon ce qu'on met sur la troisième.

[[File:Transistor basic flow.svg|centre|vignette|Un transistor est un morceau de conducteur, dont la conductivité est contrôlée par sa troisième broche/borne.]]

Les ordinateurs de seconde génération avaient entre 1000 et 500 000 transistors. Les capacités des ordinateurs étaient donc nettement supérieures à celles des ordinateurs de première génération. Une part non négligeable des ordinateurs de seconde génération supportait l'opération de multiplication, absente sur les ordinateurs de première génération. Néanmoins, cela variait beaucoup selon les ordinateurs.

Un exemple assez hors du commun est celui du premier modèle de l'IBM 1620. Le tout premier modèle n'avait aucun circuit de calcul, il n'était même pas capable de faire une addition ou une multiplication. A la place, il utilisait une table d'addition et une table de multiplication en mémoire RAM. Les deux tables devaient être initialisées par le logiciel lors du démarrage de la machine. La table d'addition faisait une centaine de chiffres, la table de multiplication faisait le double. Le processeur de l'ordinateur gérait des instructions pour faire des additions ou des multiplications, mais ces opérations lisaient le résultat dans la table d'addition. Les calculs étaient faits chiffre par chiffre, avec un encodage partiellement décimal, partiellement binaire (des chiffres décimaux étaient encodés en binaire, nous en reparlerons quand nous parlerons du BCD) !

[[File:KL CoreMemory.jpg|vignette|Mémoire à tore de ferrite.]]

Les transistors n'étaient utilisés que pour le processeur et les circuits annexes. La mémoire n'était pas faite en transistors, pas à cette époque. La mémoire était une mémoire aujourd'hui abandonnée, appelée une '''mémoire à tores de ferrite'''. Elle sera détaillée dans un chapitre ultérieur. Mais sachez pour le moment qu'il s'agit d'une mémoire au support magnétique, les données étant stockées sur un support magnétique.

Les transistors étaient au départ de la même taille que les tubes à vide, mais ils ont rapidement rétrécit. Ils prenaient encore beaucoup de place dans les 60-70, ce qui fait que les ordinateurs étaient assez gros. Concrètement, ils prenaient une pièce de bâtiment entière dans le meilleur des cas. C'était l'époque des gros ''mainframes'', reliés à des terminaux, peu puissants comparé aux standards actuels. Seules les grandes entreprises et les grands instituts de recherche pouvaient se payer les services de ce genre d'ordinateurs. Seuls les professionnels avaient accès à ce genre d'équipement.

===La troisième génération : le circuit intégré===

[[File:D8259AC-2.jpg|vignette|Exemple de circuit intégré.]]

La troisième génération est toujours fabriquée avec des transistors, mais dont la taille a été réduite. Avec l'évolution de la technologie, les transistors ont diminué en taille, de plus en plus. Ils sont devenus tellement petits qu'ils ont fini par être regroupés dans des '''circuits intégrés''', des circuits regroupent plusieurs transistors sur la même puce de silicium. Les circuits intégrés se présentent le plus souvent sous la forme de boitiers rectangulaires, comme illustré ci-contre. D'autres ont des boitiers de forme carrées, comme ceux que l'on peut trouver sur les barrettes de mémoire RAM, ou à l'intérieur des clés USB/ disques SSD.

Lors de cette génération, les processeurs étaient fournis en pièces détachées qu'il fallait relier entre elles. Le processeur était composé de plusieurs circuits intégrés séparés, impossible de mettre un processeur dans un seul boitier. Un exemple de processeur conçu en kit est la série des Intel 3000. Elle regroupe plusieurs circuits séparés aux noms à coucher dehors, mais dont vous comprendrez ce qu'ils veulent dire dans les chapitres adéquats : l'Intel 3001 est un séquenceur, l'Intel 3002 regroupe unité de calcul et registres, le 3003 est un circuit d'anticipation de retenue complémentaire du 3002, le 3212 est une mémoire tampon, le 3214 est une unité de gestion des interruptions, les 3216/3226 sont des interfaces de bus mémoire. On pourrait aussi citer la famille de circuits intégrés AMD Am2900.

Même si le processeur était en pièces détachées, utiliser une dizaine de circuits intégrés était nettement mieux que d'utiliser plusieurs milliers de transistors individuels. En conséquence, les ordinateurs ont vu leur taille grandement réduite, passant de pièces entières à une simple armoire, voire à quelques cartes intégrées superposées. De plus, le prix des circuits intégré était abordable, du moins comparé aux ordinateurs d'avant. Le prix des ordinateurs a alors grandement décru, permettant à des entreprises et administrations de taille modeste de s'équiper d'ordinateurs.

===La quatrième génération : le microprocesseur===

[[File:MOS6502.svg|vignette|Microprocesseur, ici un processeur MOS6502, de la quatrième génération.]]

Lors de la troisième génération, les circuits intégrés regroupaient plusieurs dizaines ou centaines de transistors, mais sont rapidement montés en gamme. De centaines de transistors, ils sont passés au millier de transistors, puis au million et maintenant au-delà du milliard. Les transistors étaient devenus tellement petits, tellement miniaturisés, qu'il était devenu possible de mettre un processeur entier dans un circuit intégré. C'est ainsi qu'est né le microprocesseur, à savoir un processeur qui tient tout entier dans un seul circuit imprimé. La quatrième génération d’ordinateur est celle des ordinateurs basés autour d'un microprocesseur.

Les tout premiers microprocesseurs étaient des processeurs à application militaire, comme le processeur du F-14 CADC ou celui de l'Air data computer. Le tout premier microprocesseur commercialisé au grand public est le 4004 d'Intel, sorti en 1971. L'intel 4004 comprenait environ 2300 transistors, avait une fréquence de 740 MHz, pouvait faire 46 opérations différentes, et manipulait des entiers de 4 bits. Il était au départ un processeur de commande, prévu pour être intégré dans la calculatrice Busicom calculator 141-P, mais il fut utilisé pour d'autres applications quelque temps plus tard. Immédiatement après le 4004, les premiers microprocesseurs 8 bits furent commercialisés. Le 4004 fut suivi par le 8008 et quelques autres processeurs 8 bits extrêmement connus, comme le 8080 d'Intel, le 68000 de Motorola, le 6502 ou le Z80.

Les microprocesseurs permirent encore uen fois de réduire la taille des ordinateurs, qui pouvaient tenir dans un boitier de PC, ou un boitier de console de jeu. Le prix des ordinateurs a aussi chuté en même temps que les transistors étaient miniaturisés. C'est cette invention qui permis l'invention des consoles de jeux et des mini-ordinateurs, à savoir les ordinateurs personnels. Sans miniaturisation, on n'aurait pas d'ordinateur personnel, pas de PC fixe ou portable.

==L'organisation du cours : les différents niveaux d'explication==

Le fonctionnement d'un ordinateur est assez complexe à expliquer car les explications peuvent se faire sur plusieurs niveaux. Par plusieurs niveaux, on veut dire qu'un ordinateur est composé de composants très simples, qui sont assemblés pour donner des composants eux-même plus complexes, qui sont eux-même regrouper, etc. Étudier tout cela demande de voir plusieurs niveaux, allant de transistors très petits à des processeurs multicœurs. Les niveaux les plus bas sont de l'électronique pur et dure, alors que ceux plus haut sont à mi-chemin entre électronique et informatique.

===Les niveaux d'abstraction en architecture des ordinateurs===

Les trois premiers niveaux sont de l'électronique pur et dure. Ils correspondent aux premiers chapitres du cours, qui porteront sur les circuits électroniques en général.
* Le premier niveau est celui des '''transistors''', des circuits intégrés, des ''wafer'' et autres circuits de très petite taille.
* Le second niveau est celui des '''portes logiques''', des circuits très basiques, très simples, à la base de tous les autres.
* Le troisième niveau est celui dit de la '''''Register Transfer Level''''', où un circuit électronique est construit à partir de circuits basiques, dont des registres et autres circuits dits combinatoires.
Les deux niveaux suivants sont de l'informatique proprement dit. C'est dans ces deux niveaux qu'on étudie les ordinateurs proprement dit, les circuits qu'il y a dedans et non l'électronique en général.
* Le quatrième niveau est celui de la '''microarchitecture''', qui étudie ce qu'il y a à l'intérieur d'un processeur, d'une mémoire, des périphériques et autres.
* Le cinquième niveau est celui de l''''architecture externe''', qui décrit l'interface du processeur, de la mémoire, d'un périphérique ou autre. Par décrire l'interface, on veut dire : comment un programmeur voit le processeur et la mémoire, comment il peut les manipuler. Une architecture externe unique peut avoir plusieurs microarchitecture, ce qui fait qu'on sépare les deux. Tout cela sera plus clair quand on passera aux chapitres sur le processeur et les mémoires.

Nous n'allons pas voir les 5 niveaux dans l'ordre, des transistors vers l'architecture externe. En réalité, nous allons procéder autrement. La première partie du cours portera sur les trois premiers niveaux, le reste sur les deux autres. Les 5 niveaux seront vus dans des chapitres séparés, du moins le plus possible. Au niveau pédagogique, tout est plus simple si on scinde les 5 niveaux. Bien sûr, il y a quelques explications qui demandent de voir plusieurs niveaux à la fois. Par exemple, dans le chapitre sur les mémoires caches, nous auront des explications portant sur la RTL, la microarchitecture du cache et son architecture externe. Mais le gros du cours tentera de séparer le plus possible les 5 niveaux.

===Les trois parties principales du cours===

Nous allons commencer par parler du binaire, avant de voir les portes logiques. Avec ces portes logiques, nous allons voir comment fabriquer des circuits basiques qui reviendront très souvent dans la suite du cours. Nous verrons les registres, les décodeurs, les additionneurs et plein d'autres circuits. Puis, nous reviendrons au niveau des transistors pour finir la première partie. La raison est que c'est plus simple de faire comme cela. Tout ce qui a trait aux transistors sert à expliquer comment fabriquer des portes logiques, et il faut expliquer les portes logiques pour voir le niveau de la RTL.

Une fois la première partie finie, nous allons voir les différents composants d'un ordinateur. Une première partie expliquera ce qu'il y a dans un ordinateur, quels sont ses composants. Nous y parlerons de l'architecture de base, de la hiérarchie mémoire, des tendances technologiques, et d'autres généralités qui serviront de base pour la suite. Puis, nous verrons dans l'ordre les bus électroniques, les mémoires RAM/ROM, le processeur, les périphériques, les mémoires de stockage (SSD et disques durs) et les mémoires caches. Pour chaque composant, nous allons voir leur architecture externe, avant de voir leur microarchitecture. La raison est que la microarchitecture ne peut se comprendre que quand on sait quelle architecture externe elle implémente.

Enfin, dans une troisième partie, nous allons voir les optimisations majeures présentes dans tous les ordinateurs modernes, avec une partie sur le pipeline et le parallélisme d'instruction, et une autre sur les architectures parallèles. Pour finir, les annexes de fin parlerons de sujets un peu à part.

&lt;noinclude&gt;
{{NavChapitre | book=Fonctionnement d'un ordinateur
           | next=L'encodage des données
           | nextText=L'encodage des données
}}
&lt;/noinclude&gt;</text>
      <sha1>9116h9lujccv7m3f5sla0tuwmhxgsgi</sha1>
    </revision>
    <revision>
      <id>744175</id>
      <parentid>744174</parentid>
      <timestamp>2025-06-05T16:56:40Z</timestamp>
      <contributor>
        <username>Mewtow</username>
        <id>31375</id>
      </contributor>
      <minor />
      <comment>/* La première génération : les tubes à vide */</comment>
      <origin>744175</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="49213" sha1="grvzr6ea0195vj8tsrxjgbe2zt19vp1" xml:space="preserve">Pour commencer, nous allons voir qu'il existe de nombreux types d'ordinateurs. Le plus connu est certainement le PC, l'ordinateur personnel, que vous avez sans doute dans votre salon. Les ordinateurs portables sont un deuxième type d'ordinateur assez intuitif, que vous avez peut-être. Mais il y a aussi d'autres types d'ordinateurs auxquels vous n'avez jamais été confrontés.

==Les différents types d'ordinateurs==

Dans cette section, nous allons décrire rapidement les ordinateurs les plus courant, mais surtout voir ce qu'il y a à l'intérieur d'un ordinateur.

===L'ordinateur de type PC fixe===

De l'extérieur, l'ordinateur est composé d'une unité centrale sur laquelle on branche des périphériques.

[[File:Typical computer architecture systems.jpg|vignette|upright=1.5|Exemples de périphériques, connectés à une unité centrale (ici appelée à tort ''operating system'').]]

Les '''périphériques''' regroupent l'écran, la souris, le clavier, l'imprimante, et bien d'autres choses. Ils permettent à l'utilisateur d'interagir avec l'ordinateur : un clavier permet de saisir du texte sous dans un fichier, une souris enregistre des déplacements de la main en déplacement du curseur, un écran affiche des données d’images/vidéos, un haut-parleur émet du son, etc. Tout ce qui est branché sur un ordinateur est, formellement un périphérique.

L''''unité centrale''' est là où se trouvent tous les composants importants d'un ordinateur, ceux qui font des calculs, qui exécutent des logiciels, qui mémorisent vos données, etc. Voici ce à quoi ressemble l'intérieur de l'unité centrale. Trois sections sont visibles : l'alimentation électrique en haut à gauche, la carte mère en bas à gauche et en jaune/orange, les disques et lecteurs à droite des câbles. Et on voit aussi beaucoup de câbles.

[[File:Asus P5K-SEIntel E6320.jpg|centre|vignette|upright=2|Exemple d'unité centrale.]]

Tout en haut à gauche, se trouve l''''alimentation électrique''', qui convertit le courant de la prise électrique en un courant plus faible, utilisable par les autres composants. Elle émet de nombreux câbles assez gros, qui sont reliés au reste. Les PC actuels utilisent des alimentations électriques standardisées, qui fournissent trois tensions au reste de l'ordinateur : une tension de 12 Volts, une de 5 Volts, une de 3,3 Volts.

À droite, caché par la partie &quot;métallique&quot; du boitier, se trouvent les lecteurs de CD/DVD, et les disques durs. Les lecteurs CD-ROM ou DVD-ROM permettaient de lire des CD ou des DVD. Je parle au passé, car ils ont aujourd'hui disparu des ordinateurs modernes. Les '''disques durs''' sont des mémoires de stockage, qui mémorisent vos données de manière permanente. De nos jours, ils sont remplacés par des SSD, qui sont des disques durs électroniques, là où les disques durs proprement dit sont des mémoires magnétiques. Nous verrons la différence dans deux chapitres dédiés, un sur les disques durs, l'autre sur les SSD.

En bas à droite, se trouve la '''carte mère''' un support plat, en plastique ou en céramique, sur laquelle sont soudés/connectés les autres composants. Sur celle-ci, de nombreux composants sont soudés, d'autres sont branchés dessus avec des câbles, d'autres sont connectés dessus avec des connecteurs. Ils sont reliés entre eux par des fils conducteurs, le plus souvent du cuivre ou de l’aluminium, ce qui leur permet de s’échanger des données. Sur les cartes simples, ces fils sont intégrés dans la carte électronique, dans des creux du plastique. Ils portent le nom de pistes.

Avant, les disques durs, SSD et lecteurs de CD/DVD sont branchés dessus via des connecteurs dédiés, appelés des connecteurs S-ATA. De nos jours, ils sont branchés sur un autre connecteur, grâce à l'interface NVME. Toujours est-il qu'ils sont reliés à la carte mère par des câbles, ce qui montre que ce sont des sortes de périphériques interne. Ils sont placés dans le boitier, mais on aurait tout aussi bien pu les mettre à l'extérieur, vu qu'ils communiquent avec l'ordinateur par l'intermédiaire d'un câble ou d'un connecteur dédié.

Mais deux autres composants très importants sont eux placés sur la carte mère, directement. Ils ont chacun un connecteur dédié, sur lequel ils sont branchés directement, sans passer par l'intermédiaire d'un câble, mais sans être soudés non plus. Il s'agit du processeur et de la mémoire RAM, deux composants centraux des PC modernes.

[[File:Pentium III SL4CB.jpg|thumb|Processeur Pentium III.]]

Le '''processeur''' traite les données, les modifie, les manipule. Pour faire simple, il s’agit d’une grosse calculatrice hyper-puissante. Il comprend à la fois un circuit qui fait des calculs, et un circuit de contrôle qui s'occupe de séquencer les calculs dans l'ordre demandé. Il est souvent caché sous un radiateur, lui-même surmonté par un ventilateur. En effet, un processeur chauffe beaucoup, ce qui demande d'évacuer cette chaleur. Un chapitre entier expliquera pourquoi les processeurs chauffent, ainsi que les techniques utilisées pour limiter leur production de chaleur et leur consommation électrique.

La '''mémoire vive''' conserve des informations/données temporairement, tant que le processeur en a besoin. Elle prend la forme de barrettes de RAM, comme montré ci-dessous.

[[File:2 gb ddr2 667.jpg|centre|vignette|upright=2|Barrette de RAM.]]

Outre ces composants dits principaux, un ordinateur peut comprendre plusieurs composants moins importants, surtout présents sur les ordinateurs personnels. Ils sont techniquement facultatifs, mais sont très présents dans les ordinateurs personnels. Cependant, certains ordinateurs spécialisés s'en passent. Il s'agit des diverses '''cartes d'extension''' sont branchées sur la carte mère. Elles permettent d’accélérer certains calculs ou certaines applications, afin de décharger le processeur. Par exemple, la carte graphique s'occupe des calculs graphiques, qu'il s'agisse de graphismes 3D de jeux vidéos ou de l'affichage en 2D du bureau. Dans un autre registre, la carte son prend en charge le microphone et les haut-parleurs.

[[Fichier:Personal computer, exploded 4.svg|thumb|upright=1.0|Éclaté d'un ordinateur de type PC :&lt;br /&gt;
1 : Écran ;&lt;br /&gt;
2 : Carte mère ;&lt;br /&gt;
3 : Processeur ;&lt;br /&gt;
4 : Câble Parallel ATA ;&lt;br /&gt;
5 : Mémoire vive (RAM) ;&lt;br /&gt;
6 : Carte d'extension ;&lt;br /&gt;
7 : Alimentation électrique ;&lt;br /&gt;
8 : Lecteur de disque optique ;&lt;br /&gt;
9 : Disque dur ;&lt;br /&gt;
10 : Clavier ;&lt;br /&gt;
11 : Souris.]]

Si on regarde une carte mère de face, on voit un grand nombre de connecteurs, mais aussi des circuits électroniques soudés à la carte mère.

[[File:Architecture matérielle d'une carte mère.png|centre|vignette|upright=2.0|Architecture matérielle d'une carte mère]]

Les '''connecteurs''' sont là où on branche les périphériques, la carte graphique, le processeur, la mémoire, etc. Dans l'ensemble, toute carte mère contient les connecteurs suivants :
* Le processeur vient s’enchâsser dans la carte mère sur un connecteur particulier : le '''socket'''. Celui-ci varie suivant la carte mère et le processeur, ce qui est source d'incompatibilités.
* Les barrettes de mémoire RAM s’enchâssent dans un autre type de connecteurs: les '''slots mémoire'''.
* Les mémoires de masse disposent de leurs propres connecteurs : connecteurs P-ATA pour les anciens disques durs, et S-ATA pour les récents.
* Les périphériques (clavier, souris, USB, Firewire, ...) sont connectés sur un ensemble de connecteurs dédiés, localisés à l'arrière du boitier de l'unité centrale. 
* Les autres périphériques sont placés dans l'unité centrale et sont connectés via des connecteurs spécialisés. Ces périphériques sont des cartes imprimées, d'où leur nom de '''cartes filles'''. On peut notamment citer les cartes réseau, les cartes son, ou les cartes vidéo.

===Les ordinateurs portables===

[[File:Samsung QX-511 (2).JPG|vignette|Ordinateur portable Samsung QX-511 (2), pour illustration.]]

Un ordinateur portable est identique à un ordinateur de type PC. Si vous ouvrez votre ordinateur portable (attention à la garantie), vous retrouverez les mêmes composants qu'un PC à l'intérieur. Un point important est la présence d'une batterie à l'intérieur du PC portable, absente des PC fixes.

[[File:LG gram 14Z90Q mainboard with battery.jpg|centre|vignette|upright=2|LG gram 14Z90Q avec sa batterie.]]

Une fois la batterie et les circuits associés retiré, la seule différence notable est que tous les composants sont soudés sur la carte mère, au lieu d'être branchés sur des connecteurs, à part éventuellement la RAM et le disque dur.

[[File:LG gram 14Z90Q mainboard without battery.jpg|centre|vignette|upright=2|LG gram 14Z90Q sans sa batterie.]]

La RAM est parfois soudée sur la carte mère, d'autres fois sous la forme de barrettes de mémoire vive semblables à celles des PC. Dans le dernier cas, elle est connectée à des connecteurs spécifiques, ce qui permet de les changer/upgrader. Les PC portables sont parfois construits de manière à pouvoir changer la RAM facilement, en ouvrant un cache spécial, concu pour.

[[File:Lenovo G555 состав - Донор.JPG|centre|vignette|upright=2|Lenovo G555.]]

La conception d'un ordinateur portable est légèrement différente de celle d'un PC, pour des raisons thermiques. Un PC fixe a plus de place pour évacuer sa chaleur. Les ventilateurs peuvent plus facilement déplacer l'air dans le boitier, même si le flux d'air dans le boitier est éventuellement gêné par la carte graphique. Mais l'évacuation de la chaleur est assez efficace. Sur les PC portables, leur finesse fait que le trajet de l'air est beaucoup plus contraint. Évacuer la chaleur produite par l'ordinateur est plus complexe, ce qui demande d'utiliser des systèmes de refroidissement et de ventilation spécifiques.

Là où les PC fixes se débrouillent avec des radiateurs et des ventilateurs posés sur le processeur, les PC portables font autrement. Ils ne peuvent pas forcément mettre le ventilateur sur le processeur. A la place, ils mettent le ventilateur à côté, mais le processeur est surmonté par un mécanisme de transmission de la chaleur, qui transfère la chaleur du processeur vers le ventilateur.

[[File:Diagram - How a laptop cooling system works.png|centre|vignette|upright=2|Comment fonctionne le système de ventilation d'un ordinateur portable, en anglais.]]

Les difficultés pour dissiper la chaleur font que les ordinateurs portables utilisent souvent des composants peu performants, mais qui chauffent peu. En effet, nous verrons que plus un composant est puissant, plus il chauffe. La relation n'est pas parfaite, mais les processeurs haute performance chauffent plus que les modèles d'entrée ou milieu de gamme moins puissants. En conséquence, les PC portables sont souvent moins puissants que les PC fixes, même pour les modèles dit ''gaming''.

===Les serveurs et ''mainframes''===

Les grandes entreprises utilisent des ordinateurs de grande taille, très puissants, appelés des ''mainframes''. Ils sont souvent confondus avec les serveurs par le grand public, il y a une différence entre les deux. Un serveur est une fonction logicielle/réseau, pas un type d'ordinateur. Mais laissons cette différence de côté, ce qui est dit pour les ''mainframes'' sert pour les gros serveurs haute performance.

[[File:IBM Z15 mainframe.jpg|vignette|Exemple de ''mainframe''' de type IBM Z15.]]

Les anciens ''mainframes'' des années 50-80 avaient une taille pouvant être impressionnante, au point de prendre une pièce complète d'un bâtiment. Mais de nos jours, les ''mainframes'' tiennent dans une grosse armoire un peu haute. Les ''mainframes'' doivent rester allumé en permanence et ne doivent pas être éteint, sauf éventuellement quelques jours par an pour des opérations de maintenance. Ils utilisent pour cela des techniques spécifiques, avec beaucoup de redondance interne.

[[File:ACONIT hall grandes machines.jpg|centre|vignette|upright=2|''Mainframe'' ACONIT.]]

Les ''mainframes'' sont aussi conçus pour mutualiser au maximum leur utilisation, ils peuvent être utilisés par plusieurs utilisateurs à la suite, voire en même temps. Pour cela, les anciens ''mainframes'' étaient capables de faire tourner plusieurs applications distinctes l'une à la suite de l'autre, avec des commutations fréquentes entre logiciels. De nos jours, ils sont capables d'exécuter un grand nombre de tâches en même temps, grâce à la présence de plusieurs processeurs. Les ''mainframes'' modernes sont même capables de faire tourner plusieurs systèmes d'exploitation en même temps si besoin.

Les anciens ''mainframes'' étaient des ordinateurs assez simples, avec un processeur, de la mémoire RAM, un ou plusieurs disques durs, pas plus. Le ''mainframe'' était tellement énorme et cher que les entreprises n'en avaient qu'un seul pour toute l'entreprise. Les employés avaient sur leur bureau des terminaux, qui permettaient d'accéder à l'ordinateur central, mais n'étaient pas des ordinateurs. Les terminaux étaient des composants électroniques simples, avec un écran, un clavier et une souris, mais sans processeur. Ils envoyaient des données au ''mainframe'', ils en recevaient de sa part, mais tout traitement était réalisé sur le ''mainframe''. L'arrivée sur le marché des ordinateurs personnels, de type PC fixe/portable, a entrainé l'abandon de ce genre de pratique, tous les employés ont maintenant un ordinateur rien que pour eux.

{|
|-
! colspan=&quot;2&quot; | Exemples de terminaux
|-
|[[File:Terminal-in2-sm9400.jpg|centre|vignette|upright=1.5|Exemple de terminal. Notez la présence d'un écran et d'un clavier, mais l'asbence d'une unité centrale.]]
|[[File:Chromatics CT4100.jpg|vignette|upright=1.5|Autre exemple de terminal. Le clavier est couplé à un stylo CRT, qui remplacait la souris et agissait sur l'écran comme s'il était tactile.]]
|-
! colspan=&quot;2&quot; | Intérieur d'un terminal
|-
|[[File:CT1024 Monitor.jpg|vignette|upright=1.5|Terminal CT1024, sans le boitier extérieur.]]
|[[File:CT1024 Terminal System.jpg|vignette|upright=1.5|Terminal CT1024, description des composants interne.]]
|}

De nos jours, les ''mainframes'' contiennent en réalité plusieurs ordinateurs simples interconnectés via un réseau local. Un ''mainframe'' qui tient dans une armoire contient facilement une dizaine ou centaine de processeurs, plein de RAM, des disques durs séparés dans une armoire distincte, etc. Vu qu'ils communiquent uniquement via le réseau, ils n'ont pas d'interface, pas d'écran, 'entrée via clavier/souris. Le tout est commandé avec une console de commande, typiquement un ordinateur portable ou un terminal assez simple séparé de l'armoire, qui permet à un administrateur de faire des opérations de surveillance, configuration et maintenance. Il peut y avoir une console de commande pour plusieurs armoires séparées, la console peut même être dans un autre bâtiment et accéder au ''mainframe'' par le réseau.

[[File:IBM System Z9 (type 2094 inside).jpg|centre|vignette|upright=2|''Mainframe'' de type IBM System Z9. L'ordinateur portable sert de console pour qu'un administrateur fasse des opérations de surveillance, configuration et maintenance.]]

Les processeurs et la RAM sont typiquement installés sur des cartes amovibles, qui sont connectées au fond de l'armoire lors de l'installation. Il est même possible de retirer ou d'ajouter des cartes en fonctionnement, afin d'ajouter/retirer des processeurs, des disques durs, etc. Ce qui est très utile si un composant est en panne et qu'il faut le remplacer. 

[[File:IBM TotalStorage Exp400.jpg|centre|vignette|upright=2|IBM TotalStorage Exp400]]

==Un peu d'abstraction : qu'est-ce qu'un ordinateur ?==

Un ordinateur comprend donc un processeur, plusieurs mémoires, des cartes d'extension et une carte mère pour connecter le tout. Mais il s'agit là d'une description assez terre-à-terre de ce qu'est un ordinateur. Une autre description, plus abstraite, se base sur le fait qu'un ordinateur est une énorme calculatrice programmable. Elle permet d'expliquer pourquoi il y a une distinction entre processeur et mémoire, entre unité centrale et périphériques. Tout ce qui va suivre pourra vous paraitre assez abstrait, mais rassurez-vous : les prochains chapitres rendront tout cela plus concrets.

===La séparation entre entrées-sorties et traitement===

L'unité centrale peut être vue comme une énorme calculatrice ultra-puissante, qui exécute des commandes/opérations. Mais à elle seule, elle ne servirait à rien, il faut interagir avec par l'intermédiaire de plusieurs périphériques. Il existe deux types de périphériques, qui sont conceptuellement différents. Les périphériques comme le clavier ou la souris permettent d'envoyer des informations à l'ordinateur, d'agir sur celui-ci. A l'inverse, les écrans transmettent des informations dans le sens inverse : de l'ordinateur vers l'utilisateur. Les premiers sont appelés des '''entrées''', les seconds des '''sorties'''.

Dans un ordinateur, les informations sont représentées sous la forme de nombres. Toute donnée dans un ordinateur est codée avec un ou plusieurs nombres regroupés dans une donnée, un fichier, ou autre. Et la transmissions avec les entrées et sorties se fait là-encore avec des nombres. Par exemple, quand vous appuyez sur votre clavier, le clavier envoie un numéro de touche à l'unité centrale, qui indique quelle touche a été appuyée. L'image à afficher à l'écran est codée sous la forme d'une suite de nombres (un par pixel). L'image est envoyée à l'écran, qui traduit la suite de nombre en image à afficher. Les entrées traduisent des actions utilisateurs en nombres, on dit que les entrées encodent les actions utilisateur. Les sorties font la traduction inverse, elles transforment des suites de nombres en une action physique. On dit qu'elles décodent des informations.

Pour résumer, toute appareil électronique est composé par :
* Des '''entrées''' sur lesquelles l'utilisateur agit sur l'ordinateur. Les entrées transforment les actions de l'utilisateur en nombres, qui sont interprétés par l'ordinateur.
* Une '''unité de traitement''', qui manipule des nombres et fait des calculs/opérations dessus. Les nombres proviennent des entrées, du disque dur, ou d'autres sources, peu importe.
* Des '''sorties''', qui va récupèrent le résultat calculé par l'unité de traitement pour en faire quelque chose : écrire sur une imprimante ou sur un moniteur, émettre du son,...

[[File:Ordinateur théorique Simple 1.png|centre|vignette|upright=2|Ordinateur théorique Simple 1]]

L'unité de traitement proprement dite, celle qui fait les calculs, est couplée à une mémoire qui mémorise les opérandes et résultats des calculs. La séparation entre processeur et mémoire est nécessaire pour qu'un appareil électronique soit qualifié d'ordinateur. De nombreux appareils n'ont pas de séparation entre unité de traitement et mémoire, comme certaines vielles radios AM/FM.

[[File:Schéma de principe d'un ordinateur.png|centre|vignette|upright=2|Schéma de principe d'un ordinateur]]

===Un ordinateur est un appareil programmable===

Les appareils simples sont non-programmables, ce qui veut dire qu’ils sont conçus pour une utilisation particulière et qu’ils ne peuvent pas faire autre chose. Par exemple, les circuits électroniques d’un lecteur de DVD ne peuvent pas être transformé en lecteur audio ou en console de jeux... Les circuits non-programmables sont câblés une bonne fois pour toute, et on ne peut pas les modifier. On peut parfois reconfigurer le circuit, pour faire varier certains paramètres, via des interrupteurs ou des boutons, mais cela s’arrête là. Et cela pose un problème : à chaque problème qu'on veut résoudre en utilisant un automate, on doit recréer un nouveau circuit.

À l'inverse, un ordinateur n’est pas conçu pour une utilisation particulière, contrairement aux autres objets techniques. Il est possible de modifier leur fonction du jour au lendemain, on peut lui faire faire ce qu’on veut. On dit qu'ils sont '''programmables'''. Pour cela, il suffit d’utiliser un logiciel, une application, un programme (ces termes sont synonymes), qui fait ce que l'on souhaite. La totalité des logiciels présents sur un ordinateur sont des programmes comme les autres, même le système d'exploitation (Windows, Linux, ...) ne fait pas exception.

Un programme est une suite de d''''instructions machines''', chaque instruction effectuant une action dans l'ordinateur. Sur les ordinateurs modernes, les instructions les plus communes effectuent une opération arithmétique : une addition, une multiplication, une soustraction, etc. Les ordinateurs modernes sont donc de grosses calculettes très puissantes, capables d'effectuer des millions d'opérations par secondes.

Et qui dit opération dit nombres : un ordinateur gère nativement des nombres, qui sont codés en binaire sur la quasi-totalité des ordinateurs modernes. Les ordinateurs modernes sont capables de faire des calculs sur des nombres entiers, mais aussi des nombres à virgule. Il existe plusieurs manières de représenter des nombres en binaire, certaines représentant des nombres entiers dits naturels (0 et plus), d'autres des nombres signés (positifs ou négatifs), d'autres des nombres à virgule. Un chapitre entier détaillera comment sont encodés ces nombres.

Une instruction est représentée dans un ordinateur par une série de nombres entiers : un nombre qui indique quelle opération/commande effectuer et des autres nombres pour coder les données (ou de quoi les retrouver dans l'ordinateur). L'ordinateur récupére les commandes une par une, les traduit en opération à effectuer, exécuter l'opération, et enregistre le résultat. Puis il recommence avec la commande suivante.

[[File:Ordinateur Théorique Complexe 1.png|centre|vignette|upright=3|Ordinateur Théorique Complexe. En jaune, le programme informatique, la liste de commande. Le rectangle gris est l'ordinateur proprement dit.]]

De nombreux appareils sont programmables, mais tous ne sont pas des ordinateurs. Par exemple, certains circuits programmables nommés FPGA n'en sont pas. Pour être qualifié d'ordinateur, un appareil programmable doit avoir un processeur séparé de la mémoire. De plus, il doit utiliser un '''codage numérique''', chose que nous allons aborder dans le chapitre suivant.

===Les ordinateurs à programme mémorisé ou programme externe===

[[File:Blue-punch-card-front.png|vignette|upright=0.5|Carte Perforée.]]

Au tout début de l'informatique, les programmes étaient enregistrés sur des cartes perforées, à savoir des cartes en papier/plastique percées par endroits. Un 1 est codé par un trou dans le papier et un 0 par une absence de trou. Les programmes étaient exécutés par l'ordinateur quand on insérait la carte perforée dans le lecteur et qu'on appuyait sur un bouton.

Par la suite, les premiers ordinateurs grand public, comme les Amstrad ou les Commodore, utilisaient des cassettes audio magnétiques pour stocker les programmes. Dans le même style, les consoles de jeu utilisaient autrefois des cartouches de jeu, qui contenaient le programme du jeu à exécuter. Pour résumer, les anciens ordinateurs mémorisaient les programmes sur un support externe, lu par un périphérique. De tels ordinateurs sont dits à '''programme externe'''.

: D’anciens ordinateurs personnels, comme l’Amstrad ou le Commodore, permettaient de taper les programmes à exécuter à la main, au clavier, avant d’appuyer une touche pour les exécuter. Nul besoin de vous dire que les cassettes audio étaient plus pratiques.

Mais de nos jours, les programmes sont enregistrés sur le disque dur de l'ordinateur ou dans une mémoire intégrée à l'ordinateur. On dit qu'ils sont installés, ce qui est un mot bien compliqué pour dire que le programme est enregistré sur le disque dur de l’ordinateur. A défaut de disque dur, le programme/logiciel est enregistré dans une mémoire spécialisée pour le stockage. Par exemple, sur les cartes électroniques grand public de marque Arduino, les programmes sont envoyés à la carte via le port USB, mais les programmes sont enregistrés dans la carte Arduino, dans une mémoire FLASH dédiée. Disque dur ou non, le programme est mémorisé dans la mémoire de l'ordinateur. Il est possible d'installer ou de désinstaller les programmes en modifiant le contenu de la mémoire. Le terme utilisé est alors celui de '''programme stocké en mémoire'''.

Les programmes à installer sont disponibles soit sur un périphérique, comme un DVD ou une clé USB, soit sont téléchargés depuis internet. Les premiers PC fournissaient les logiciels sur des disquettes, qui contenaient un programme d'installation pour enregistrer le programme sur le disque dur de l'ordinateur. Par la suite, le support des logiciels a migré vers les CD et DVD, les logiciels devenant de plus en plus gros. De nos jours, la majorité des applications sont téléchargées depuis le net, l'usage de périphériques est devenu obsolète, même les consoles de jeu abandonnent cette méthode de distribution.

==Les générations d'ordinateurs : un historique rapide==

L'informatique a beaucoup évolué dans le temps. Et une bonne partie de cette évolution tient à l'évolution de l’électronique sous-jacente. Les ordinateurs actuels sont fabriqués avec des transistors, des petits composants électroniques qui servent d'interrupteurs programmables, qu'on détaillera dans ce qui suit. Mais ça n'a pas toujours été le cas. Et cela permet de distinguer plusieurs '''générations d'ordinateurs'''.

===Les ordinateurs électro-mécaniques : les premiers ordinateurs===

Le tout premier ordinateur est le '''Z1''', un modèle unique inventé par Konrad Suze entre 1936 et 1938. Son processeur gérait non pas des nombres entiers, mais des nombres à virgule (des nombres dits flottants, pour être précis), encodés sur 22 bits. Le processeur du Z1 était capable de faire des additions et des soustractions, car il intégrait un circuit additionneur-soustracteur basique. Des circuits annexes permettaient de faire des multiplications et des divisions en enchainant des additions/soustractions successives. Il fonctionnait à une fréquence de 1 Hz, ce qui fait qu'il pouvait faire une addition/soustraction par seconde maximum.

Niveau mémoire, la RAM de l'ordinateur était très limitée : seulement 16 nombres de 22 bits chacun. S'il s'agissait d'une mémoire électronique, les programmes étaient mémorisés sur une mémoire mécanique et précisémment sur des cartes perforées, à savoir des cartes en papier/plastique dans lesquelles un 1 est codé par un trou dans le papier et un 0 par une absence de trou. Les programmes étaient exécutés par l'ordinateur quand on insérait la carte perforée dans le lecteur et qu'on appuyait sur un bouton.

[[File:German Museum of Technology, Berlin 2017 024.jpg|centre|vignette|upright=2|Réplique du Z1 au ''German Museum of Technology'' de Berlin, 2017.]]

Après sa destruction dans un bombardement, le Z1 a été reconstruit et amélioré, ce qui donné les deux ordinateurs Z2 et Z3. Quelques années plus tard, quelques laboratoires de recherche ont fabriqués des ordinateurs dans leur coin, comme le Harvard Mark I et le Colossus Mark 1 (UK) qui ont été mis en service en 1944. Ils ont servi pour les cryptanalystes pour casser les codes utilisés par les Allemands pour leurs transmissions, pendant la seconde guerre mondiale.

Les ordinateurs cités dans le précédent paragraphe étaient tous des ordinateurs dit '''électro-mécaniques''', car ils mélangeaient des composants électroniques et des composants mécaniques (tout ce qui a trait aux cartes perforées, notamment). Les composants électroniques étaient généralement des relais, à savoir des interrupteurs commandables électriquement, qui sont plus ou moins équivalents aux transistors modernes. La majeure partie des ordinateurs des années 40 étaient de ce type, mais leur nombre n'a pas dépassé 30. Il faut dire qu'ils ont rapidement laissé la place à des ordinateurs purement électroniques, que nous allons voir dans ce qui suit.

===La première génération : les tubes à vide===

[[File:Diode vacuum tube.svg|vignette|Diode vacuum tube]]

Les ordinateurs qui ont suivi les ordinateurs électromécaniques sont regroupés dans la '''première génération d'ordinateur'''. Ils étaient conçus avec des tubes à vide. Les tubes à vide sont des ampoules à filament améliorées. Pour rappel, les ampoules à filament étaient des ampoules en verre dans lesquelles on plaçait un filament métallique. Le filament chauffait quand on envoyait du courant dedans et émettait de la lumière.

Dans les tubes à vides, le filament n'émet pas de lumière quand on le chauffe : il émet des électrons, de l'électricité. De plus, on ajoute une plaque métalliques appelée l'anode, qui capte des électrons émis par le filament. Le résultat est un circuit qui laisse passer le courant, mais seulement dans un sens : du filament vers l'anode, l'autre sens n'est pas possible vu que l'anode ne peut pas émettre d'électrons. Un tel circuit est appelé une '''diode'''.

[[File:Triode vacuum tube FR.png|vignette|Triode.]]

Les tubes à vide précédents peuvent être modifiés en ajoutant une grille métallique entre la cathode et l'anode. La grille est alimentée avec une tension électrique, ce qui la charge électriquement. Suivant sa charge, elle laisse plus ou moins passer les électrons de la cathode vers l'anode. Si elle n'est pas chargée, que la tension est de 0 volt, elle ne fera pas obstacle aux électrons et le tube à vide fonctionnera comme une diode basique. Mais si la grille est chargée avec une tension négative, sa charge électrique va repousser les électrons et les empêcher de passer de la cathode vers l'anode.

Le tube à vide se comporte alors comme un interrupteur : fermé ou ouvert suivant ce qu'on met sur la grille. Un tel tube à vide est appelée une '''triode''', car c'est une diode à laquelle on a ajouté une entrée pour charger la grille. De tels interrupteurs commandables électriquement sont combinés pour fabriquer des circuits plus élaborés, comme les portes logiques qu'on verra d'ici quelques chapitres.

Au vu de ce qu'on vient de dire, on peut facilement deviner que les tubes à vide avaient beaucoup de défauts. Ils étaient assez encombrants, dans le sens où une ampoule prend beaucoup de place. Et il est difficile de miniaturiser une ampoule, personne n'imagine une ampoule de quelques microns de côté, alors que les transistors actuels sont plus petits que ça. De plus, ils consommaient beaucoup de courant et chauffaient. Faire chauffer un filament demande un courant important et une bonne partie de ce courant part en chaleur. De plus, ils étaient assez peu fiables et tombaient en panne assez souvent. Et s'ils étaient assez simples à fabriquer, ils restaient malgré tout chers.

Les tubes à vides étaient utilisés pour le processeur et quelques circuits annexes, mais les mémoires utilisaient d'autres technologies. Les mémoires de l'époque n'étaient pas du tout des mémoires électroniques. Il existait déjà des ancêtres des disques durs, à savoir des mémoires magnétiques appelées tambours magnétiques, bandes magnétiques, mémoires à tore de ferrite, etc. Les mémoires RAM, quant à elles, utilisaient des technologies totalement abandonnées : les mémoires à lignes de délai étaient des mémoires acoustiques, les tubes Williams étaient des écrans CRT modifiés, etc. Un chapitre entier sera dédié aux technologies des mémoires de l'époque.

[[File:Elektronenroehren-auswahl.jpg|centre|vignette|upright=2|Tubes à vides.]]

L'usage de tubes à vide les place entre les premiers ordinateurs électro-mécaniques et les ordinateurs utilisant des transistors. Au vu de la taille des tubes à vide, les ordinateurs de l'époque étaient composés de plusieurs milliers de ces tubes, guère plus. Et malgré cela, un ordinateur prenait facilement un étage de bâtiment entier, ou au moins plusieurs pièces. La conséquence est que les ordinateurs de première génération étaient très simples, rudimentaires quand on les compare aux ordinateurs modernes. Ils ne géraient que quelques opérations simples : l'addition, la soustraction, pas grand-chose de plus. À quelques exceptions près, ils ne géraient pas la multiplication et encore moins la division, cela aurait demandé trop de tubes à vides.

Une des toutes premières machines construite avec des tubes à vide était l'Atanasoff–Berry. Ce n'était pas un ordinateur, car elle ne pouvait pas exécuter de programme sans intervention humaine pour séquencer des opérations, mais c'était la première machine de calcul purement électronique, sans aucune pièce mécanique. Elle utilisait une mémoire RAM construite avec des condensateurs, ceux-ci étant placés sur des cylindres tournants. Les circuits de calcul étaient construits avec des tubes à vide et faisaient leur travail un bit à la fois. Elle fonctionnait à une fréquence de 60 Hz et pouvait faire 30 additions/soustractions par seconde. Les nombres étaient encodés sur 50 bits. 

[[File:Atanasoff Berry Computer.gif|centre|vignette|upright=2.5|Atanasoff–Berry.]]

L'arrivée de l'ENIAC en 1945 a changé la donne. Cet ordinateur a introduit plusieurs innovations majeures. La première est assez technique, il s'agit de la turing-complétude, elle a trait aux programmes qui peuvent être écrits pour un ordinateur, nous ne la détaillerons pas ici.

[[File:BabyArchitecture.png|vignette|Architecture de la Manchester Baby.]]

En 1948, le ''Manchester Baby'' a introduit une innovation extrêmement importante : le programme n'était plus mémorisé sur des cartes perforées, mais dans une mémoire électronique à l’intérieur de l'ordinateur lui-même. En clair, le ''Manchester Baby'' était le premier '''ordinateur à programme stocké en mémoire''' en français. Au-delà de ça, le Manchester Baby restait quand même très simple, c'était limite un prototype.

Niveau interface, l'ordinateur avait une console avec 32 boutons, des interrupteurs et un écran de sortie sur lequel afficher les résultats. À l'intérieur, il y avait un processeur et une RAM de 32 nombres de 32 bits, fabriquées avec des tubes Williams (abordés dans une annexe à la fin du cours). Une instruction prenant autant de place qu'un nombre en RAM, ce qui limitait les programmes à 32 instructions maximum. Le processeur gérait 8 instructions en tout, mais la seule instruction de calcul qu'il gérait était la soustraction. L'addition n'était pas supportée. Il pouvait cependant émuler l'addition à partir d'une soustraction et inversant l'opérande soustrait.

Le Manchester Mark 1 était une amélioration du Manchester Baby. Il utilisait 4500 tubes à vide. L'ordinateur gérait des nombres de 40 bits, mais les instructions étaient codées sur 20 bits. La RAM avait la même taille, à savoir 32 nombres, leur taille était simplement augmentée. Par contre, la RAM était complémentée par l’ancêtre du disque dur magnétique, à savoir un tambour magnétique, l’ancêtre du disque dur magnétique. Il contenait 40 pages, chacune ayant la même taille que la RAM. Contrairement à la Manchester Baby, son processeur gérait l'addition. Les multiplications étaient réalisées par des additions successives, mais le processeur intégrait des registres pour mémoriser les opérandes à multiplier.

Par la suite, les ordinateurs commerciaux ont vu le jour. Les ordinateurs précédents provenaient de projets de recherches, souvent publics. Mais les entreprises privées se sont mises à fabriquer des ordinateurs elle-mêmes, pour les vendre à d'autres entreprises. On peut notamment citer les ordinateurs comme le UNIVAC I, le Bull Gamma 3 ou les premiers ordinateurs IBM. La performance de ces ordinateurs était nettement plus importante que leurs prédécesseurs, avec des fréquences de l'ordre de la centaine de kilo-hertz. Par exemple, le Bull Gamma 3 allait à 281 kHz, l'IBM 650 allait à 50 Khz.

===La seconde génération : le remplacement des tubes à vides par des transistors===

[[File:IBM 7070.jpg|vignette|Cartes imprimées de l'IBM 704, avec des transistors et résistances dessus.]]

La '''seconde génération''' est celle des ordinateurs fabriqués avec des '''transistors''' isolés, reliés entre avec des fils électriques. Les transistors en question possèdent trois broches, des pattes métalliques sur lesquelles on connecte des fils électriques. Le transistor s'utilise le plus souvent comme un interrupteur commandé par sa troisième broche. Le courant qui traverse les deux premières broches passe ou ne passe pas selon ce qu'on met sur la troisième.

[[File:Transistor basic flow.svg|centre|vignette|Un transistor est un morceau de conducteur, dont la conductivité est contrôlée par sa troisième broche/borne.]]

Les ordinateurs de seconde génération avaient entre 1000 et 500 000 transistors. Les capacités des ordinateurs étaient donc nettement supérieures à celles des ordinateurs de première génération. Une part non négligeable des ordinateurs de seconde génération supportait l'opération de multiplication, absente sur les ordinateurs de première génération. Néanmoins, cela variait beaucoup selon les ordinateurs.

Un exemple assez hors du commun est celui du premier modèle de l'IBM 1620. Le tout premier modèle n'avait aucun circuit de calcul, il n'était même pas capable de faire une addition ou une multiplication. A la place, il utilisait une table d'addition et une table de multiplication en mémoire RAM. Les deux tables devaient être initialisées par le logiciel lors du démarrage de la machine. La table d'addition faisait une centaine de chiffres, la table de multiplication faisait le double. Le processeur de l'ordinateur gérait des instructions pour faire des additions ou des multiplications, mais ces opérations lisaient le résultat dans la table d'addition. Les calculs étaient faits chiffre par chiffre, avec un encodage partiellement décimal, partiellement binaire (des chiffres décimaux étaient encodés en binaire, nous en reparlerons quand nous parlerons du BCD) !

[[File:KL CoreMemory.jpg|vignette|Mémoire à tore de ferrite.]]

Les transistors n'étaient utilisés que pour le processeur et les circuits annexes. La mémoire n'était pas faite en transistors, pas à cette époque. La mémoire était une mémoire aujourd'hui abandonnée, appelée une '''mémoire à tores de ferrite'''. Elle sera détaillée dans un chapitre ultérieur. Mais sachez pour le moment qu'il s'agit d'une mémoire au support magnétique, les données étant stockées sur un support magnétique.

Les transistors étaient au départ de la même taille que les tubes à vide, mais ils ont rapidement rétrécit. Ils prenaient encore beaucoup de place dans les 60-70, ce qui fait que les ordinateurs étaient assez gros. Concrètement, ils prenaient une pièce de bâtiment entière dans le meilleur des cas. C'était l'époque des gros ''mainframes'', reliés à des terminaux, peu puissants comparé aux standards actuels. Seules les grandes entreprises et les grands instituts de recherche pouvaient se payer les services de ce genre d'ordinateurs. Seuls les professionnels avaient accès à ce genre d'équipement.

===La troisième génération : le circuit intégré===

[[File:D8259AC-2.jpg|vignette|Exemple de circuit intégré.]]

La troisième génération est toujours fabriquée avec des transistors, mais dont la taille a été réduite. Avec l'évolution de la technologie, les transistors ont diminué en taille, de plus en plus. Ils sont devenus tellement petits qu'ils ont fini par être regroupés dans des '''circuits intégrés''', des circuits regroupent plusieurs transistors sur la même puce de silicium. Les circuits intégrés se présentent le plus souvent sous la forme de boitiers rectangulaires, comme illustré ci-contre. D'autres ont des boitiers de forme carrées, comme ceux que l'on peut trouver sur les barrettes de mémoire RAM, ou à l'intérieur des clés USB/ disques SSD.

Lors de cette génération, les processeurs étaient fournis en pièces détachées qu'il fallait relier entre elles. Le processeur était composé de plusieurs circuits intégrés séparés, impossible de mettre un processeur dans un seul boitier. Un exemple de processeur conçu en kit est la série des Intel 3000. Elle regroupe plusieurs circuits séparés aux noms à coucher dehors, mais dont vous comprendrez ce qu'ils veulent dire dans les chapitres adéquats : l'Intel 3001 est un séquenceur, l'Intel 3002 regroupe unité de calcul et registres, le 3003 est un circuit d'anticipation de retenue complémentaire du 3002, le 3212 est une mémoire tampon, le 3214 est une unité de gestion des interruptions, les 3216/3226 sont des interfaces de bus mémoire. On pourrait aussi citer la famille de circuits intégrés AMD Am2900.

Même si le processeur était en pièces détachées, utiliser une dizaine de circuits intégrés était nettement mieux que d'utiliser plusieurs milliers de transistors individuels. En conséquence, les ordinateurs ont vu leur taille grandement réduite, passant de pièces entières à une simple armoire, voire à quelques cartes intégrées superposées. De plus, le prix des circuits intégré était abordable, du moins comparé aux ordinateurs d'avant. Le prix des ordinateurs a alors grandement décru, permettant à des entreprises et administrations de taille modeste de s'équiper d'ordinateurs.

===La quatrième génération : le microprocesseur===

[[File:MOS6502.svg|vignette|Microprocesseur, ici un processeur MOS6502, de la quatrième génération.]]

Lors de la troisième génération, les circuits intégrés regroupaient plusieurs dizaines ou centaines de transistors, mais sont rapidement montés en gamme. De centaines de transistors, ils sont passés au millier de transistors, puis au million et maintenant au-delà du milliard. Les transistors étaient devenus tellement petits, tellement miniaturisés, qu'il était devenu possible de mettre un processeur entier dans un circuit intégré. C'est ainsi qu'est né le microprocesseur, à savoir un processeur qui tient tout entier dans un seul circuit imprimé. La quatrième génération d’ordinateur est celle des ordinateurs basés autour d'un microprocesseur.

Les tout premiers microprocesseurs étaient des processeurs à application militaire, comme le processeur du F-14 CADC ou celui de l'Air data computer. Le tout premier microprocesseur commercialisé au grand public est le 4004 d'Intel, sorti en 1971. L'intel 4004 comprenait environ 2300 transistors, avait une fréquence de 740 MHz, pouvait faire 46 opérations différentes, et manipulait des entiers de 4 bits. Il était au départ un processeur de commande, prévu pour être intégré dans la calculatrice Busicom calculator 141-P, mais il fut utilisé pour d'autres applications quelque temps plus tard. Immédiatement après le 4004, les premiers microprocesseurs 8 bits furent commercialisés. Le 4004 fut suivi par le 8008 et quelques autres processeurs 8 bits extrêmement connus, comme le 8080 d'Intel, le 68000 de Motorola, le 6502 ou le Z80.

Les microprocesseurs permirent encore uen fois de réduire la taille des ordinateurs, qui pouvaient tenir dans un boitier de PC, ou un boitier de console de jeu. Le prix des ordinateurs a aussi chuté en même temps que les transistors étaient miniaturisés. C'est cette invention qui permis l'invention des consoles de jeux et des mini-ordinateurs, à savoir les ordinateurs personnels. Sans miniaturisation, on n'aurait pas d'ordinateur personnel, pas de PC fixe ou portable.

==L'organisation du cours : les différents niveaux d'explication==

Le fonctionnement d'un ordinateur est assez complexe à expliquer car les explications peuvent se faire sur plusieurs niveaux. Par plusieurs niveaux, on veut dire qu'un ordinateur est composé de composants très simples, qui sont assemblés pour donner des composants eux-même plus complexes, qui sont eux-même regrouper, etc. Étudier tout cela demande de voir plusieurs niveaux, allant de transistors très petits à des processeurs multicœurs. Les niveaux les plus bas sont de l'électronique pur et dure, alors que ceux plus haut sont à mi-chemin entre électronique et informatique.

===Les niveaux d'abstraction en architecture des ordinateurs===

Les trois premiers niveaux sont de l'électronique pur et dure. Ils correspondent aux premiers chapitres du cours, qui porteront sur les circuits électroniques en général.
* Le premier niveau est celui des '''transistors''', des circuits intégrés, des ''wafer'' et autres circuits de très petite taille.
* Le second niveau est celui des '''portes logiques''', des circuits très basiques, très simples, à la base de tous les autres.
* Le troisième niveau est celui dit de la '''''Register Transfer Level''''', où un circuit électronique est construit à partir de circuits basiques, dont des registres et autres circuits dits combinatoires.
Les deux niveaux suivants sont de l'informatique proprement dit. C'est dans ces deux niveaux qu'on étudie les ordinateurs proprement dit, les circuits qu'il y a dedans et non l'électronique en général.
* Le quatrième niveau est celui de la '''microarchitecture''', qui étudie ce qu'il y a à l'intérieur d'un processeur, d'une mémoire, des périphériques et autres.
* Le cinquième niveau est celui de l''''architecture externe''', qui décrit l'interface du processeur, de la mémoire, d'un périphérique ou autre. Par décrire l'interface, on veut dire : comment un programmeur voit le processeur et la mémoire, comment il peut les manipuler. Une architecture externe unique peut avoir plusieurs microarchitecture, ce qui fait qu'on sépare les deux. Tout cela sera plus clair quand on passera aux chapitres sur le processeur et les mémoires.

Nous n'allons pas voir les 5 niveaux dans l'ordre, des transistors vers l'architecture externe. En réalité, nous allons procéder autrement. La première partie du cours portera sur les trois premiers niveaux, le reste sur les deux autres. Les 5 niveaux seront vus dans des chapitres séparés, du moins le plus possible. Au niveau pédagogique, tout est plus simple si on scinde les 5 niveaux. Bien sûr, il y a quelques explications qui demandent de voir plusieurs niveaux à la fois. Par exemple, dans le chapitre sur les mémoires caches, nous auront des explications portant sur la RTL, la microarchitecture du cache et son architecture externe. Mais le gros du cours tentera de séparer le plus possible les 5 niveaux.

===Les trois parties principales du cours===

Nous allons commencer par parler du binaire, avant de voir les portes logiques. Avec ces portes logiques, nous allons voir comment fabriquer des circuits basiques qui reviendront très souvent dans la suite du cours. Nous verrons les registres, les décodeurs, les additionneurs et plein d'autres circuits. Puis, nous reviendrons au niveau des transistors pour finir la première partie. La raison est que c'est plus simple de faire comme cela. Tout ce qui a trait aux transistors sert à expliquer comment fabriquer des portes logiques, et il faut expliquer les portes logiques pour voir le niveau de la RTL.

Une fois la première partie finie, nous allons voir les différents composants d'un ordinateur. Une première partie expliquera ce qu'il y a dans un ordinateur, quels sont ses composants. Nous y parlerons de l'architecture de base, de la hiérarchie mémoire, des tendances technologiques, et d'autres généralités qui serviront de base pour la suite. Puis, nous verrons dans l'ordre les bus électroniques, les mémoires RAM/ROM, le processeur, les périphériques, les mémoires de stockage (SSD et disques durs) et les mémoires caches. Pour chaque composant, nous allons voir leur architecture externe, avant de voir leur microarchitecture. La raison est que la microarchitecture ne peut se comprendre que quand on sait quelle architecture externe elle implémente.

Enfin, dans une troisième partie, nous allons voir les optimisations majeures présentes dans tous les ordinateurs modernes, avec une partie sur le pipeline et le parallélisme d'instruction, et une autre sur les architectures parallèles. Pour finir, les annexes de fin parlerons de sujets un peu à part.

&lt;noinclude&gt;
{{NavChapitre | book=Fonctionnement d'un ordinateur
           | next=L'encodage des données
           | nextText=L'encodage des données
}}
&lt;/noinclude&gt;</text>
      <sha1>grvzr6ea0195vj8tsrxjgbe2zt19vp1</sha1>
    </revision>
  </page>
  <page>
    <title>Programmation PHP/Problèmes connus</title>
    <ns>0</ns>
    <id>72289</id>
    <revision>
      <id>744164</id>
      <parentid>743681</parentid>
      <timestamp>2025-06-05T15:27:25Z</timestamp>
      <contributor>
        <username>JackPotte</username>
        <id>5426</id>
      </contributor>
      <comment>/* The referenced column name 'xxx' has to be a primary key column on the target entity class */</comment>
      <origin>744164</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="61824" sha1="sgixck30nu9ydnqjxw61m468tdixx83" xml:space="preserve">&lt;noinclude&gt;{{PHP}}&lt;/noinclude&gt;

Le processus de débogage est relativement le même d'un bug à l'autre :
* En cas d'erreur 400, regarder d'abord les logs les plus spécifiques (ex : le var/log de l'application), puis les logs des serveurs Web (ex : /var/log/nginx), puis ceux du système (/var/log).
* En cas d'erreur 500 ou de non réponse, passer directement aux logs des serveurs.
* En cas d'absence de log, localiser le problème avec :
** [[../Exceptions#Logs|Des ajouts de logs supplémentaires]].
** [[../Xdebug/]].

La liste suivante doit permettre de gagner du temps pour solutionner les erreurs que l'on peut trouver dans les logs.

== Erreurs sans message PHP ==
=== IIS tourne dans le vide après la mise à jour de PHP ===
Vérifier que les dépendances sont bien installées (ex : Visual C++)&lt;ref&gt;http://windows.php.net/download/&lt;/ref&gt;.

=== Les modifications du fichier php.ini ne sont pas prises en compte dans phpinfo ===
Sur Wamp, redémarrer PHP et Apache ne suffit pas car Apache contient une copie du fichier &lt;code&gt;php.ini&lt;/code&gt; dans &lt;u&gt;C:\wamp64\bin\apache\apache2.4.54.2\bin&lt;/u&gt;, créée lors de la sélection de la version de PHP (au clic sur PHP/Version).

=== La connexion a été réinitialisée ===
Erreur sous Firefox provenant d'un &lt;code&gt;mysql_close()&lt;/code&gt; ou d'une directive Apache.

=== La page n'est pas redirigée correctement ===
Un &lt;code&gt;header&lt;/code&gt; revient en boucle après une suite de conditions. S'il est local, le remplacer par &lt;code&gt;chdir()&lt;/code&gt;.

=== Le code PHP n'est pas interprété (et est affiché) ===
Si &lt;code&gt;a2enmod php7.4&lt;/code&gt; indique que le module est déjà installé, c'est peut-être lié à &lt;code&gt;a2enmod userdir&lt;/code&gt;. Cela peut se régler avec :
&lt;syntaxhighlight lang=bash&gt;
vim /etc/apache2/mods-enabled/php7.4.conf
&lt;/syntaxhighlight&gt;
Commenter les lignes :
&lt;syntaxhighlight lang=apache&gt;
&lt;IfModule mod_userdir.c&gt;
...
&lt;/IfModule&gt;
&lt;/syntaxhighlight&gt;
Et relancer Apache.

Sinon c'est peut-être le vhost utilisé qui n'est pas le bon (voir /var/log/apache2) ou qu'il ne contient pas :
&lt;syntaxhighlight lang=apache&gt;
    	ScriptAlias /cgi-bin/ /usr/lib/cgi-bin/
    	&lt;Directory &quot;/usr/lib/cgi-bin&quot;&gt;
        	Require all granted
        	AllowOverride None
        	Options +ExecCGI -MultiViews +SymLinksIfOwnerMatch
        	Allow from all
    	&lt;/Directory&gt;
&lt;/syntaxhighlight&gt;

=== Les dernières lignes d'un POST sont ignorées ===
Il faut soit augmenter la variable PHP max_input_vars (ce qui ne peut pas être fait avec &lt;code&gt;ini_set()&lt;/code&gt;&lt;ref&gt;https://stackoverflow.com/questions/9973555/setting-max-input-vars-php-ini-directive-using-ini-set&lt;/ref&gt;), soit il faut fragmenter en plusieurs requêtes, par exemple toutes les 300 lignes.

=== Une expression régulière (''regex'') marche sur https://regex101.com/ mais pas en local ===
Si la machine est Windows, tenir compte de la différence de retour chariot : &lt;code&gt;\r\n&lt;/code&gt; au lieu de &lt;code&gt;\n&lt;/code&gt;.

=== Une addition ou soustraction de dates ajoute ou retire un jour ===
Cela survient quand on part d'un mois à 31 jours pour arriver à un mois qui en a moins.

Par exemple :
&lt;pre&gt;
 var_dump((new DateTime('2024-12-31'))-&gt;add(new DateInterval(&quot;P6M&quot;))); // 2025-07-01 00:00:00
 var_dump((new DateTime('2024-12-31'))-&gt;add(new DateInterval(&quot;P12M&quot;))); // 2025-12-31 00:00:00
&lt;/pre&gt;

Pour avoir un calcul juste, on peut ajuster le jour du résultat ainsi :
&lt;pre&gt;
            $startDate = new DateTime('2024-12-31');
            $originalDay = $startDate-&gt;format('d');
            $startDate-&gt;add(new DateInterval('P6M'));
            if ($startDate-&gt;format('d') !== $originalDay) {
                // Ajuster au dernier jour du mois précédent
                $startDate-&gt;modify('last day of previous month');
            }

            var_dump($startDate); // 2025-06-30 00:00:00
&lt;/pre&gt;

=== Une addition ou soustraction de dates ajoute ou retire une heure ===
C'est à cause des changements d'heure d'hiver et heure été.

Par exemple :
&lt;pre&gt;
 var_dump((new DateTime('2024-12-31'))-&gt;add(new DateInterval(&quot;PT4320H&quot;))); // 2025-06-29 01:00:00
 var_dump((new DateTime('2024-12-31'))-&gt;add(new DateInterval(&quot;PT8640H&quot;))); // 2025-12-26 00:00:00
&lt;/pre&gt;

Pour avoir un calcul juste, on peut changer de fuseau horaire le temps du calcul, vers un qui n'est pas soumis aux changements d'heures&lt;ref&gt;https://stackoverflow.com/questions/804571/how-to-subtract-two-dates-ignoring-daylight-savings-time-in-php&lt;/ref&gt; :

&lt;pre&gt;
 var_dump((new DateTime('2024-12-31 UTC'))-&gt;add(new DateInterval(&quot;PT4320H&quot;))); // 2025-06-29 00:00:00
 var_dump((new DateTime('2024-12-31 UTC'))-&gt;add(new DateInterval(&quot;PT8640H&quot;))); // 2025-12-26 00:00:00
&lt;/pre&gt;
ou à l'échelle du serveur :
&lt;pre&gt;
$timeZone = date_default_timezone_get();
date_default_timezone_set('UTC');
// calcul
date_default_timezone_set($timeZone);
&lt;/pre&gt;

== PHP natif ==
=== Connect Error, 2002: Aucune connexion n'a pu être établie car l'ordinateur cible l'a expressément refusée. ===
Relancer le serveur de base de données.

=== Connect Error, 2002: Une tentative de connexion a échoué car le parti connecté n'a pas répondu convenablement au-delà d'une certaine durée ou une connexion établie a échoué car l'hôte de connexion n'a pas répondu. ===
Ouvrir les pare-feux.

=== Invalid body indentation level (expecting an indentation level of at least 8) ===
En PHP7.3, la syntaxe heredoc impose de supprimer l'indentation de la balise fermante : elle soit suivre &quot;\n&quot;.

=== json_decode renvoie NULL (aléatoirement) ===
Ajouter le paramètre 4 : JSON_THROW_ON_ERROR.

=== json_decode throw &quot;Control character error, possibly incorrectly encoded&quot; ===
La string à décoder est trop longue.

=== Malformed UTF-8 characters, possibly incorrectly encoded ===
Changer l'encodage de la chaine avant son encodage en JSON, avec&lt;ref&gt;https://stackoverflow.com/questions/31115982/malformed-utf-8-characters-possibly-incorrectly-encoded-in-laravel&lt;/ref&gt; :
 $chaine = mb_convert_encoding($chaine, 'UTF-8', 'auto');

=== MySQL server has gone away ===
La limite des 61 jointures a peut-être été atteinte dans une requête. Sinon vérifier les limites des ressources (du .ini) : par défaut default_socket_timeout égal 60 s.

=== This extension requires the Microsoft ODBC Driver 11 for SQL Server ===
Installer le pilote depuis https://www.microsoft.com/en-us/download/details.aspx?id=36434.

=== Unable to initialize module. Module compiled with module API=x. PHP compiled with module API=y. These options need to match ===
Se procurer une autre DLL à renseigner dans le fichier &lt;code&gt;php.ini&lt;/code&gt;.

=== You can only iterate a generator by-reference if it declared that it yields by-reference ===
Se produit quand on itère sur la référence d'un générateur PHP :
&lt;syntaxhighlight lang=&quot;php&quot;&gt;
foreach ($generator as &amp;$item) {
    ...
}
&lt;/syntaxhighlight&gt;

Il faut donc retirer l'opérateur de référence (&amp;) de l'itération...

=== Cannot traverse an already closed generator ===
Un &lt;code&gt;iterator_to_array($generator)&lt;/code&gt; le ferme en le convertissant en tableau.

=== child exited on signal 7 (SIGBUS) ===
Modifier le fichier &lt;code&gt;php.ini&lt;/code&gt;&lt;ref&gt;https://whynhow.info/17522/How-to-get-rid-of-SIGBUS-when-running-php-fpm?&lt;/ref&gt; :
&lt;syntaxhighlight lang=&quot;ini&quot;&gt;
pm.max_children = 80
pm.max_spare_servers = 20
pm.max_requests = 200
apc.stat = 0
&lt;/syntaxhighlight&gt;

&lt;code&gt;max_children&lt;/code&gt; est calculé en divisant la RAM par la taille des processus&lt;ref&gt;https://www.kinamo.fr/fr/support/faq/determiner-le-nombre-de-processes-valide-pour-php-fpm-sur-nginx&lt;/ref&gt;.

=== Invalid resource type: unknown type ===
Le paramètre n°2 de &lt;code&gt;fopen()&lt;/code&gt; ne permet pas la lecture&lt;ref&gt;https://www.php.net/manual/fr/function.fopen.php&lt;/ref&gt;.

=== Each stream must be readable ===
On essaie de lire un fichier fermé : déplacer le &lt;code&gt;fclose()&lt;/code&gt; après s'il y en a un avant.

=== fclose(): supplied resource is not a valid stream resource ===
On essaie de fermer un fichier fermé : utiliser &lt;code&gt;if (is_resource($f))&lt;/code&gt; avant.

=== SSL peer certificate or SSH remote key was not OK ===
Lors d'un &lt;code&gt;curl_exec&lt;/code&gt;, ajouter :
&lt;syntaxhighlight lang=&quot;php&quot;&gt;
curl_setopt($ch, CURLOPT_SSL_VERIFYHOST, 0);
curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, 0);
&lt;/syntaxhighlight&gt;
ou :
&lt;syntaxhighlight lang=&quot;php&quot;&gt;
        $options['verify_host'] = false;
        $options['verify_peer'] = false;
&lt;/syntaxhighlight&gt;

=== Fatal error ===
==== {{rouge|[] operator not supported for strings}} ====
&lt;syntaxhighlight lang=&quot;php&quot;&gt;
// On récupère une variable dont on ne connait pas le type pour en faire un tableau
if (!isset($tableau1)) {
  $tableau1 = array();
} elseif (is_string($tableau1)) {
  $tableau1 = array($tableau1);
}
$tableau1[] = 'paramètre suivant';
&lt;/syntaxhighlight&gt;

==== {{rouge|Allowed memory size of x bytes exhausted}} ====
Modifier le fichier &lt;code&gt;php.ini&lt;/code&gt; ou bien ajouter une autre limite dans le programme :
&lt;syntaxhighlight lang=&quot;php&quot;&gt;
 ini_set('memory_limit', '100M');
&lt;/syntaxhighlight&gt;
Pour faire sauter la limitation :
&lt;syntaxhighlight lang=&quot;php&quot;&gt;
 ini_set('memory_limit', '-1');
&lt;/syntaxhighlight&gt;

Si c'est dans une commande :
 php -d memory_limit=-1 ma_commande

Si c'est Composer :
 COMPOSER_MEMORY_LIMIT=-1 ./composer.phar update

Sinon, utiliser Xdebug en mode pas à pas pour visualiser les variables à supprimer (avec &lt;code&gt;unset()&lt;/code&gt;).

==== {{rouge|Call to a member function ... on a non-object}} ====
La méthode est invoquée sur une variable qui n'est pas une classe.


==== {{rouge|Call to undefined function}} ====
Si une fonction est définie mais qu'on ne peut pas l'invoquer dans une méthode de classe, il faut préalablement l'importer en tenant compte du [[../Programmation_orientée_objet#Polymorphisme|polymorphisme]].


===== {{rouge|Call to undefined function sqlsrv_connect()}} =====
Installer le pilote correspondant à la version de PHP du serveur Web :
# Télécharger sur https://www.microsoft.com/en-us/download/details.aspx?id=20098.
# Copier dans le dossier PHP (ex : &lt;u&gt;C:\Program Files (x86)\EasyPHP\binaries\php\php_runningversion\ext&lt;/u&gt;).
# Ajouter au fichier &lt;code&gt;php.ini&lt;/code&gt;.
# Redémarrer le serveur Web.

==== {{rouge|Call to undefined method}} ====
La méthode est invoquée sur une classe qui ne l'a pas.

Si elle est censée l'avoir c'est qu'elle n'est pas récupérée, ce qui peut arriver avec les jointures entre entités d'ORM.

==== {{rouge|Cannot access empty property}} ====
Une variable non définie ne peut pas fournir de propriété. Si elle était définie ailleurs c'est qu'elle est inaccessible, et donc qu'il faut la récupérer (ex : avec &lt;code&gt;global&lt;/code&gt;).


==== {{rouge|Error connecting to the ODBC database: [Microsoft][SQL Server Native Client 10.0][SQL Server]échec de l'ouverture de session de l'utilisateur}} ====
La précédente connexion n'a pas dû être fermée proprement avant une tentative de reconnexion. Essayer au choix :
&lt;syntaxhighlight lang=&quot;php&quot;&gt;
mysql_close($conn); // MySQL
sqlsrv_close($conn); // MS-SQL
odbc_close($conn); // ODBC
&lt;/syntaxhighlight&gt;


==== {{rouge|Out of memory}} ====
Éditer le fichier &lt;code&gt;php.ini&lt;/code&gt; pour augmenter la limite mémoire :
 memory_limit = 256M
Si cela ne suffit pas, vérifier la taille des structures et tableaux alloués, probablement par une boucle avec trop d'itérations ou une boucle infinie, ou le chargement d'une ressource trop volumineuse en mémoire.

==== {{rouge|pdo_sqlsrv_db_handle_factory: Unknown exception caught}} ====
Installer et configurer le paquet suivant :
&lt;syntaxhighlight lang=&quot;bash&quot;&gt;
apt-get install -y locales
echo &quot;en_US.UTF-8 UTF-8&quot; &gt; /etc/locale.gen &amp;&amp; locale-gen
&lt;/syntaxhighlight&gt;

==== {{rouge|Uncaught exception 'com_exception' with message 'Failed to create COM object `xxx.application': Accès refusé.}} ====
Sur le serveur Web Windows, dans ''démarrer'', exécuter ''dcomcnfg'' (sinon y aller dans ''Outils d'administration'', ''Service de composants''), puis ''Ordinateurs'', ''Poste de travail'', ''Configuration DCOM'', aller dans les propriétés de l'application mentionnée, puis dans l'onglet ''Sécurité'', définir la première permission (''Autorisations d'exécution et d'activation'' à ''Personnaliser'' et ajouter le compte du serveur ou site qui exécute le script (ex pour ISS : IIS_IUSRS ou IUSR).

Par exemple pour Word l'application se prénomme &quot;Document Microsoft Office Word&quot;, et Excel &quot;Microsoft Excel Application&quot;.


==== {{rouge|Uncaught exception 'com_exception' with message 'Source: Microsoft Office Excel Description: Mémoire insuffisante.}} ====
Il faut certainement rerégler la Configuration DCOM voire le serveur Web.


==== {{rouge|Uncaught exception 'PDOException' with message}} ====
===== {{rouge|could not find driver}} =====
Se référer à la liste des pilotes connus dans [[../PDO#Installation]].

===== {{rouge|SQLSTATE[HY000]: General error}} =====
PDO ne gère pas le code SQL &quot;set @ma_variable&quot; ou &quot;if&quot;. Donc il faut plutôt faire ces calculs en PHP.

===== {{rouge|SQLSTATE[28000] [1045] Access denied for user}} =====
Si l'utilisateur existe avec les privilèges nécessaires, y compris depuis toute localisation (@%), il faut quand-même créer un deuxième compte homonyme pour l'emplacement distant (ex : 'username'@'example.com'). Par exemple dans phpMyAdmin, remplir la provenance mentionnée en erreur ('example.com') dans le champ &quot;Client&quot;.

===== {{rouge|SQLSTATE[28000] SQLConnect: 18456 [Microsoft][ODBC SQL Server Driver][SQL Server] Échec de l'ouverture de session de l'utilisateur}} =====
Se référer à [[../PDO#Accès à la base de données avec PDO]] : la source de données ODBC doit être suivie du compte pour y accéder.

===== {{rouge|SQLSTATE[IM002] SQLConnect: 0 [Microsoft][Gestionnaire de pilotes ODBC] Source de données introuvable et nom de pilote non spécifié}} =====
Se référer à [[../PDO#Accès à la base de données avec PDO]] : la source de données ODBC doit être créée dans &lt;u&gt;C:\Windows\SysWOW64\odbcad32.exe&lt;/u&gt;.

===== {{rouge|SQLSTATE[IMSSP]: An invalid keyword 'host' was specified in the DSN string}} =====
Se référer à [[../PDO#Accès à la base de données avec PDO]] : le paramètre 'host' est valide pour MySQL mais pas pour MS-SQL.

===== {{rouge|SQLSTATE[IMSSP]: The DSN string ended unexpectedly}} =====
Se référer à [[../PDO#Accès à la base de données avec PDO]] : les virgules et points-virgules changent d'un pilote à l'autre.

===== {{rouge|SQLSTATE[IMSSP]: This extension requires the Microsoft SQL Server 2012 Native Client ODBC Driver to communicate with SQL Server}} =====
Se référer à [[../PDO#Accès à la base de données avec PDO]] : utiliser la syntaxe ODBC.

=== Notice ===
==== {{rouge|Undefined property}} ====
La propriété de la variable n'est pas déclarée.


==== {{rouge|Undefined index: SERVER_NAME in ...php}} ====
Certaines versions de PHP utilisent &lt;code&gt;$_SERVER['HTTP_HOST']&lt;/code&gt; au lieu de &lt;code&gt;$_SERVER['SERVER_NAME']&lt;/code&gt;.

==== {{rouge|Undefined variable}} ====
La variable n'est pas déclarée.

==== {{rouge|Use of undefined constant}} ====
La constante n'est pas déclarée.

=== Parse error ===
==== {{rouge|syntax error, unexpected '(', expecting variable (T_VARIABLE) or '$' in...}} ====
Séparer le $ dans la chaine (ex : &lt;code&gt;{$&lt;/code&gt; -&gt; &lt;code&gt;{ $&lt;/code&gt;).


==== {{rouge|syntax error, unexpected &lt;nowiki&gt;''&lt;/nowiki&gt; (T_ENCAPSED_AND_WHITESPACE), expecting identifier (T_STRING) or variable (T_VARIABLE) or number (T_NUM_STRING)}} ====
Remplacer les variables incluses dans des chaines. Ex :
&lt;syntaxhighlight lang=&quot;php&quot;&gt;
$query=&quot;select $contact['member']&quot;; // pas bien
$query=&quot;select &quot;.$contact['member']; // bien
&lt;/syntaxhighlight&gt;

==== {{rouge|syntax error, unexpected '$Variable' (T_VARIABLE), expecting function (T_FUNCTION)}} ====
Dans une classe en dehors des méthodes, il faut déclarer les variables avec leur portée :
&lt;syntaxhighlight lang=&quot;php&quot;&gt;
private $Variable;
&lt;/syntaxhighlight&gt;

=== Strict Standards ===
==== {{rouge|Declaration of extFunctions::logs() should be compatible with functions::logs($chaine)}} ====
La fonction (&lt;code&gt;logs()&lt;/code&gt; dans l'exemple) existe déjà, peut-être avec des majuscules (peu importe les arguments).

==== {{rouge|Only variables should be passed by reference}} ====
Il faut appliquer la fonction &lt;code&gt;end()&lt;/code&gt; sur une variable au lieu du résultat d'une opération&lt;ref&gt;http://stackoverflow.com/questions/4636166/only-variables-should-be-passed-by-reference&lt;/ref&gt;. Ex :
&lt;syntaxhighlight lang=&quot;php&quot;&gt;
// $extension = end(explode('.', $fichier));
$ext = explode('.', $fichier);
$extension = end($ext);
&lt;/syntaxhighlight&gt;

=== Warning ===
==== {{rouge|Cannot use a scalar value as an array}} ====
Un tableau de valeurs ne peut pas être redéfini en tableau de tableaux si elles existent. Remplacer les cas ainsi :
&lt;syntaxhighlight lang=&quot;php&quot;&gt;
$tab['1'] = 1;
//$tab['1']['un'] = 'un';
$tab['un']['un'] = 'un';
&lt;/syntaxhighlight&gt;

==== {{rouge|Creating default object from empty value}} ====
Se produit quand on appelle l'attribut d'un objet NULL.

==== {{rouge|date_diff() expects parameter 1 to be DateTimeInterface}} ====
La classe native &lt;code&gt;DateTime()&lt;/code&gt; est plus pratique que la fonction &lt;code&gt;date_diff()&lt;/code&gt; :
&lt;syntaxhighlight lang=&quot;php&quot;&gt;
$Avant = new DateTime('20140101');
$Apres = new DateTime();
print $Avant-&gt;diff($Apres)-&gt;format(&quot;%d&quot;);
&lt;/syntaxhighlight&gt;


==== {{rouge|Illegal string offset}} ====
On invoque une entrée inexistante dans un tableau associatif. Lever l'exception avec &lt;code&gt;Try&lt;/code&gt; ou &lt;code&gt;if (!isset(&lt;/code&gt;.


==== {{rouge|mkdir(): File exists}} ====
Sous Docker Desktop pour Windows, mkdir() appelle file_exists(), et ce dernier renvoie ''true'' si le dossier a existé.

==== {{rouge|PHP Startup: Unable to load dynamic library 'memcached.so'}} ====
 sudo pecl install memcached

Si cela persiste :
 sudo apt-get install php-igbinary
 sudo apt-get install php-msgpack
 sudo service php7.2-fpm reload

==== {{rouge|PHP Startup: Unable to load dynamic library 'redis.so'}} ====
 sudo pecl install redis

== Erreurs SMTP ==
=== ''La connexion a échoué'' ===
Vérifier le serveur HTTP qui interprète le fichier &lt;code&gt;.php&lt;/code&gt;.

=== ''SMTP Error: Could not connect to SMTP host'' ===
Changer de SMTP, ex : http://www.commentcamarche.net/faq/893-parametres-de-serveurs-pop-imap-et-smtp-des-principaux-fai

=== Si les mails partent sans arriver ===
* Vérifier que l'IP de l'expéditeur n'est pas blacklistée : http://whatismyipaddress.com/blacklist-check
* Définir un reverse DNS si absent
* Veiller à ce que le mail ne soit pas présumé spam, en évitant les sujets vides par exemple, ou les pièces jointes exécutables non compressées (.exe, .cmd, .vbs...).


== Composer ==

=== 1 package has known vulnerabilities ===
Exemple avec un &lt;code&gt;guzzlehttp/guzzle (7.4.3)&lt;/code&gt; absent du composer.json :
 composer depends guzzlehttp/guzzle
puis &lt;code&gt;composer update&lt;/code&gt; du résultat.

Si cela ne suffit pas, installer Guzzle puis le désinstaller pour mettre à jour sa dépendance indirecte :
 composer require guzzlehttp/guzzle &amp;&amp; composer remove guzzlehttp/guzzle

=== &quot;./composer.json&quot; does not contain valid JSON ===
Lors d'un ''composer install'', si ce message survient à tort, c'est qu'un autre fichier .json du projet contient le problème.

Si cela persiste malgré la correction, il se peut qu'il faille redémarrer Docker Desktop sur Windows.

=== Conclusion: don't install xxx ===
Lors d'un ''composer require'', spécifier une version inférieure du paquet requis.

=== No driver found to handle VCS repository ===
VCS fonctionne en protocole git, vérifier que l'URL est bien au format &quot;git@repo:bundle.git&quot;.

Sinon il y a deux alternatives :
* Pour HTTPS, remplacer la dépendance de type &quot;vcs&quot; par une de type &quot;package&quot;&lt;ref&gt;https://stackoverflow.com/questions/24443318/getting-error-no-driver-found-to-handle-vcs-repository-on-composer-and-svn?answertab=votes#tab-top&lt;/ref&gt;.
* Pour décompresser un .zip, utiliser le type &quot;artifact&quot;.

=== no matching package found ===
Ajouter le paramètre suivant :
 composer require mon_paquet --update-with-all-dependencies

=== Permission denied (public key) ===
Si le dépôt privé se clone bien sans passer par &quot;composer&quot; : voir la page [[Programmation PHP/Composer]].

=== You must be using the interactive console to authenticate ===
Pour installer cette bibliothèque, il faut que Composer puisse se loguer. Pour ce faire, il utilise auth.json qui peut se trouver dans&lt;ref&gt;https://getcomposer.org/doc/articles/http-basic-authentication.md&lt;/ref&gt; :
# &lt;code&gt;$HOME/.composer/auth.json&lt;/code&gt;
# ou à côté du &lt;code&gt;composer.json&lt;/code&gt;

Exemple de auth.json&lt;ref&gt;https://github.com/magento/magento2/issues/2523#issuecomment-159884152&lt;/ref&gt; :
&lt;syntaxhighlight lang=&quot;json&quot;&gt;
{
    &quot;github-oauth&quot;: {
        &quot;github.com&quot;: &quot;&lt;snip&gt;&quot;
    },
    &quot;http-basic&quot;: {
        &quot;repo.magento.com&quot;: {
            &quot;username&quot;: &quot;&lt;snip&gt;&quot;,
            &quot;password&quot;: &quot;&lt;snip&gt;&quot;
        }
    }
}
&lt;/syntaxhighlight&gt;

=== Your Composer dependencies require a PHP version &quot;&gt;= 8.0.0&quot;. ===
Ajouter au paragraphe &quot;config&quot; :
&lt;syntaxhighlight lang=&quot;json&quot;&gt;
&quot;platform-check&quot;: false
&lt;/syntaxhighlight&gt;
Puis relancer &lt;code&gt;composer install&lt;/code&gt; pour que cela soit pris en compte.

=== Your requirements could not be resolved to an installable set of packages ===
Si deux dépendances s'empêchent mutuellement de se mettre à jour, les demander dans la même commande :
&lt;syntaxhighlight lang=&quot;bash&quot;&gt;
 composer require mon-bundle ^1.0 symfony/http-client 5.3.* -W
&lt;/syntaxhighlight&gt;

=== Timeout sur composer install ===
Désactiver Xdebug et relancer.

== PHPUnit ==
=== Les tests ne se lancent pas ===
Si phpunit.xml.dist utiliser un bootstrap.php, y ajouter &lt;code&gt;error_reporting(E_ALL);&lt;/code&gt;.

Sinon, si un var_dump() fonctionne dans le setUp() du test unitaire mais pas dans ses méthodes de test, c'est peut-être une exception qui se lance dans un trait ou dans le vendor PHPUnit. Pour la trouver, lancer l'application et regarder les logs (par exemple depuis un contrôleur).

Sinon, si ça fonctionne en commentant le &quot;extends&quot;, tester la classe mère pour y trouver l'exception.

Sinon, dans Symfony, &lt;code&gt;tail var/log/test/mon_log.log&lt;/code&gt;.

Sinon, lancer Xdebug pour comprendre.

=== et echo() ou var_dump() dans les tests n'affiche rien ===
Lancer le test en mode le plus verbeux :
* Avec le paramètre : -vvv
* Modifier phpunit.xml.dist avec :
** &lt;nowiki&gt;&lt;server name=&quot;SHELL_VERBOSITY&quot; value=&quot;3&quot; /&gt;&lt;/nowiki&gt;&lt;ref&gt;https://symfony.com/doc/current/console/verbosity.html&lt;/ref&gt;
** &lt;nowiki&gt;&lt;ini name=&quot;error_reporting&quot; value=&quot;true&quot; /&gt;&lt;/nowiki&gt;

=== Les tests fonctionnels renvoient toujours 404 ===
Sur Symfony, &lt;code&gt;self::createClient()&lt;/code&gt; appelle directement l'API sans serveur HTTP. Si on utilise phpunit dans symfony/phpunit-bridge, il va chercher sur example.com.

Sinon il manque peut-être un trailing slash dans la route appelée.

=== Les tests se lancent mais s'arrêtent sans explication, en renvoyant &quot;killed&quot; ===
Un var_dump() sature la mémoire.

=== Did you forget a &quot;use&quot; statement for MaClasse ''ou''  Class 'MaClasse' not found ===
Si des classes existent mais que PHPUnit n'arrive pas à les charger :
* Vérifier les namespaces racines définis dans composer.json par ''autoload'' et ''autoload-dev''.
* Retirer ''suffix=&quot;.php&quot;'' du phpunit.xml utilisé.

=== The .git directory is missing from... ===
Supprimer vendor/ et relancer composer.

=== THE ERROR HANDLER HAS CHANGED! ===
Plusieurs solutions possibles :
* phpunit --self-update
* Dans Symfony, changer phpunit.xml.dist avec SYMFONY_DEPRECATIONS_HELPER = weak_vendors
* set_error_handler(array(&amp;$this, 'handleGeoError'));
* Si le projet Symfony a Sentry, on peut le retirer des tests dans bundles.php.

=== Trying to configure method &quot;get&quot; which cannot be configured because it does not exist, has not been specified, is final, or is static ===
Un mock ne récupère aucune méthode de sa classe car elle n'a pas pu être instanciée.
* La casse du nom de la classe ou du namespace de son &lt;code&gt;use&lt;/code&gt; n'est probablement pas exacte.
* Sinon c'est la portée de la méthode mockée qui n'a pas publique. Si un dump du mock montre les attributs mais pas les méthodes, remplacer &lt;code&gt;-&gt;getMockForAbstractClass()&lt;/code&gt; par &lt;code&gt;-&gt;getMock()&lt;/code&gt;.
* S'il s'agit d'une méthode finale, il faut la définir lors de l'instanciation du mock. Ex :
&lt;syntaxhighlight lang=&quot;php&quot;&gt;
        $this-&gt;serializerMock = $this
            -&gt;getMockBuilder(SerializerInterface::class)
            -&gt;setMethods(['serialize', 'deserialize', 'decode'])
            -&gt;getMock()
        ;

        $this-&gt;serializerMock
            -&gt;method('decode')
            -&gt;willReturn('')
        ;
&lt;/syntaxhighlight&gt;

=== Trying to @cover or @use not existing method ===
Si la méthode existe bien, c'est que la classe testée n'a pas été définie en annotation (avec son namespace) :
&lt;syntaxhighlight lang=&quot;php&quot;&gt;
/**
 * @coversDefaultClass App\Service\MyService
 */
class MyServiceTest extends TestCase
{
    ...
}
&lt;/syntaxhighlight&gt;

=== TypeError: Argument 1 passed to PHPUnit\Framework\TestCase::registerMockObjectsFromTestArguments() must be of the type array, null given ===
Si cela survient dans tous les tests qui invoquent un trait, retirer le constructeur de ce trait.

=== Warning No tests found in class &quot;Xxx&quot;. ===
Si les méthodes de tests contiennent des assertions invisibles de PHPUnit, leur ajouter &lt;code&gt;/** @test */&lt;/code&gt; pour afficher pourquoi ils ne se lancent pas. Par exemple, il peut s'agir d'un mock qui demande un constructeur.

Si c'est normal de ne pas lancer de test dans une classe mère, la rendre abstraite ou statique.

== Symfony ==
[[Image:Symfony 2.8 - Profiler.png|vignette|Profiler sous Symfony 2.8.|upright=2]]
En cas d'erreur, un composant de débogage appelé &quot;Profiler&quot;, est accessible en bas à gauche de la page d'erreur, avec des logs et mesures de performances. Installation :
&lt;pre&gt;
composer require --dev symfony/profiler-pack
&lt;/pre&gt;

On peut par exemple accéder au phpinfo() via l'URL &lt;u&gt;.../_profiler/phpinfo&lt;/u&gt;.

{{attention|Le profiler fonctionne pour les contrôleurs mais pas pour les commandes.|clear=left}}

=== La première soumission d'un formulaire ne marche pas, mais les suivantes oui ===
Retirer le :
&lt;pre&gt;
$uow = $em-&gt;getUnitOfWork();
$uow-&gt;computeChangeSets();
&lt;/pre&gt;

=== Le contrôle de formulaire avec name=‘xxx’ ne peut recevoir le focus. ===
Il s'agit généralement d'un champ caché : le passer en required=false ou faire en sorte qu'il soit toujours rempli même caché.

=== Un champ de formulaire ChoiceType n'affiche pas sa valeur par défaut, qui est pourtant dans la liste ===
La liste contient une clé d'un type different. Exemple de solution : &lt;pre&gt;'data' =&gt; (string) $myInteger,&lt;/pre&gt;

=== Une route de contrôleur fonctionne dans un client HTTP mais pas dans un autre ===
Si $request est vide avec certains clients HTTP :
* Utiliser HTTPS au lieu de HTTP.
* Vérifier les paramètres d'en-tête HTTP (Accept: 'application/json' et  Content-Type: 'application/json').
* Utiliser $request-&gt;getContent() ou ou $request-&gt;toArray() au lieu de $request-&gt;request&lt;ref&gt;https://silex.symfony.com/doc/2.0/cookbook/json_request_body.html&lt;/ref&gt; (ça ne marche pas à la place de $request-&gt;query).

=== Une route de contrôleur fonctionne dans un client HTTP mais pas en PhpUnit, ex : No matching accepted Response format could be determined (406 Not Acceptable) ===
&lt;syntaxhighlight lang=&quot;bash&quot;&gt;
composer remove friendsofsymfony/rest-bundle
&lt;/syntaxhighlight&gt;

=== Attempted to load class &quot;WebProfilerBundle&quot; from namespace &quot;Symfony\Bundle\WebProfilerBundle&quot; ===
Si cela fonctionne avec &quot;composer install&quot; mais pas avec &quot; composer install --no-dev&quot;, il faut définir &lt;code&gt;APP_ENV=prod&lt;/code&gt; dans le .env.

=== Attribute &quot;autowire&quot; on service &quot;xxx&quot; cannot be inherited from &quot;_defaults&quot; when a &quot;parent&quot; is set. Move your child definitions to a separate file or define this attribute explicitly. ===
Lors d'utilisation de service abstrait, on ne peut pas utiliser l'autowiring. On peut alors {{w|lang=en|Composition over inheritance|transformer ce service abstrait en dépendance à injecter plutôt qu'à hériter}}.

=== Cannot autowire service... alors qu'il existe ===
Peut se produire :
* quand le dossier de la classe est dans &quot;App\.exclude&quot; du services.yaml.
* quand il n'est pas exclus et qu'on le déclare dans un .yaml importé dans services.yaml (donc en doublon de l'autowiring). Il faut alors soit le désactiver, soit exclure les namespaces concernés, soit déplacer ces déclarations dans services.yaml.
* dans un bundle, si &lt;code&gt;$loader-&gt;load('services.yaml');&lt;/code&gt; est bien effectué&lt;ref&gt;https://symfony.com/doc/current/bundles/configuration.html&lt;/ref&gt;, alors le déclarer dans le services.yaml du bundle. Sinon, vérifier qu'il n'y a pas un chemin erroné dans l'extension prepend().
* Depuis Symfony 6.1 on peut utiliser l'attribut &lt;code&gt;#[Autowire]&lt;/code&gt;&lt;ref&gt;https://symfony.com/doc/current/service_container/autowiring.html&lt;/ref&gt;.

&lt;syntaxhighlight lang=php&gt;
#[AsEventListener(event: KernelEvents::CONTROLLER)]
class MyListener
{
    public function __construct(
        private readonly Security $security,  // exemple
        private readonly ControllerResolverInterface $controllerResolver
    ) {
    }
}
&lt;/syntaxhighlight&gt;

L'erreur est :

&lt;blockquote&gt;Cannot autowire service &quot;App\EventListener\MyListener&quot;: argument &quot;$controllerResolver&quot; of method &quot;__construct()&quot; references interface &quot;Symfony\Component\HttpKernel\Controller\ControllerResolverInterface&quot; but no such service exists. You should maybe alias this interface to one of these existing services: &quot;debug.controller_resolver&quot;, &quot;debug.controller_resolver.inner&quot;.&lt;/blockquote&gt;

La solution est d'écrire :

&lt;syntaxhighlight lang=php&gt;
#[AsEventListener(event: KernelEvents::CONTROLLER)]
class MyListener
{
    public function __construct(
        private readonly Security $security,  // exemple
        #[Autowire(service: 'controller_resolver')] private readonly ControllerResolverInterface $controllerResolver
    ) {
    }
}
&lt;/syntaxhighlight&gt;

=== Cannot load resource &quot;../../src/Controller/&quot;. Make sure to use PHP 8+ or that annotations are installed and enabled. ===
&lt;syntaxhighlight lang=&quot;bash&quot;&gt;
 composer require sensio/framework-extra-bundle
&lt;/syntaxhighlight&gt;

=== Circular reference detected ===
L'autoloader se heurte à un argument du constructeur d'une classe : il faut le sortir de la méthode &lt;code&gt;__construct()&lt;/code&gt; pour le définir dans une méthode portant son nom. Exemple de déclaration en YAML :
&lt;syntaxhighlight lang=&quot;yaml&quot;&gt;
    app.ma_classe:
        class: App\MaClasse
        arguments:
            - '@service.sans.probleme'
        calls:
            -   method: setServiceAvecProbleme
            arguments:
                - '@service.avec.probleme'
        tags:
            - { name: doctrine.event_subscriber }
&lt;/syntaxhighlight&gt;

==== A circular reference has been detected when serializing the object ====
Idem en &lt;code&gt;fetch=&quot;EXTRA_LAZY&quot;&lt;/code&gt; dans l'entité.

Pour résoudre cela sans changer de relation entre les entités, il y a plusieurs solutions :
* Dans l'entité, &lt;code&gt;use Symfony\Component\Serializer\Annotation\Ignore;&lt;/code&gt; et annotation &lt;code&gt;/** @Ignore() */&lt;/code&gt; au dessus de l'attribut en erreur.
* Dans le contrôleur, éviter de renvoyer la réponse brute, mais filtrer les attributs avec &lt;code&gt;use Symfony\Component\Serializer\SerializerInterface;&lt;/code&gt; et &lt;code&gt;$this-&gt;serializer-&gt;serialize($data, 'json', $context)&lt;/code&gt;.

=== curl error 6 while downloading https://flex.symfony.com/versions.json: Could not resolve host: flex.symfony.com ===
&lt;syntaxhighlight lang=bash&gt;
composer update symfony/flex --no-plugins --no-scripts
&lt;/syntaxhighlight&gt;

=== CURLPIPE_HTTP1 is no longer supported ===
Si cela se produit sur un projet Symfony avec composer, il faut juste :
&lt;syntaxhighlight lang=&quot;bash&quot;&gt;
composer global require symfony/flex ^1.5
rm -Rf vendor/symfony/flex
&lt;/syntaxhighlight&gt;

=== Environment variables &quot;xxx&quot; are never used. Please, check your container's configuration. ===
Pazsser par des variables intermédiaires dans services.yaml :
&lt;syntaxhighlight lang=&quot;yaml&quot;&gt;
yyy: '%env(xxx)%'
&lt;/syntaxhighlight&gt;

=== Error 400 Bad Request ''Your browser sent a request that this server could not understand.'' ===
Les règles de réécriture d'URL Apache sont erronées (voir ci-dessous).

=== Error 404 Not Found ''The requested URL /xxx was not found on this server.'' ===
Si la page d'accueil fonctionne mais pas les sous-pages (alors qu'un nom de domaine est déjà dédié au site dans le vhost), les règles de réécriture d'URL de la configuration Apache sont manquantes ou erronées. Il faut donc créer &lt;code&gt;public/.htaccess&lt;/code&gt; :
&lt;syntaxhighlight lang=&quot;apache&quot;&gt;
&lt;IfModule mod_rewrite.c&gt;
        RewriteEngine On
        RewriteCond %{REQUEST_FILENAME} !-f
        RewriteRule ^(.*)$ index.php [QSA,L]
&lt;/IfModule&gt;
&lt;/syntaxhighlight&gt;

=== Invalid header: CR/LF/NUL found ===
Un JSON envoyé en POST dans symfony/http-client contient des retours chariots inattendus : les retirer. Ex : 
&lt;syntaxhighlight lang=&quot;php&quot;&gt;
$json = preg_replace(&quot;(\r?\n)&quot;, '', $json);
&lt;/syntaxhighlight&gt;

=== manifest.json does not exist ===
 yarn install &amp;&amp; yarn add --dev @symfony/webpack-encore &amp;&amp; yarn build

=== Maximum function nesting level of '6000' reached ===
Si cela se produit par exemple en vidant le cache, c'est que deux services se renvoient la balle (même indirectement) depuis leurs constructeurs.

=== NetworkError when attempting to fetch resource (Firefox) / Failed to fetch (Chrome) ===
Dans l'API avec Swagger UI : violation du CQRS empêchant l'affichage du résultat de l'API dans /api/doc, à causes des domaines. Sur un domaine local, cela peut être résolu en changeant l'URL avant /api/doc pour qu'elle soit valide (ex : passer de wikibooks/api/doc à wikibooks.org/api/doc).

Sinon réessayer en HTTP au lieu de HTTPS.

Sinon c'est la clé renseignée (du .env) qui est différente de celle en BDD.

Si le serveur Web est Nginx, retirer du vhost &quot;add_header Access-Control-Allow-Origin *;&quot; et &quot;limit_exept&quot;.

=== request-&gt;request et request-&gt;query sont vides à tort ===
Utiliser $request-&gt;getContent() ou $request-&gt;toArray() à la place&lt;ref&gt;https://symfony.com/doc/5.4/components/http_foundation.html&lt;/ref&gt;.

=== SQLSTATE[HY000] [2002] php_network_getaddresses: getaddrinfo failed: Name or service not known ===
Un service inexistant ou avec des paramètres en erreur est appelé. Cela peut être provoqué par une variable d'environnement d'URL manquante ou erronée (ex : retirer le protocole, ou ajouter la version du SGBD).

=== SSL certificate problem: unable to get local issuer certificate ===
Utiliser l'installation avec &quot;Composer.phar&quot; plutôt que &quot;Symfony.phar&quot;.

=== InvalidArgumentException Invalid env(bool:xxx) name: only &quot;word&quot; characters are allowed ===
Soit retirer la résolution &quot;bool:&quot; sur la variable d'environnement concernée, soit la renommer si elle contient des symboles autres que des lettres, des nombres ou underscore (ex : &quot;=&quot;, &quot;%&quot;, &quot;:&quot;, etc.).

=== The autoloader expected class &quot;App\MaClasse&quot; to be defined in file &quot;/var/www/.../MaClasse.php&quot;. The file was found but the class was not in it, the class name or namespace probably has a typo. ===
Revérifier que :
* le fichier a bien l'extension .php
* la balise ouvrante &lt;code&gt;&lt;?php&lt;/code&gt;
* comporte bien la classe du même nom à la majuscule prêt
* avec le bon namespace et qui correspond aux dossiers (vérifiable dans la déclaration avec CTRL + clic dans PhpStorm).

=== Uncaught ReflectionException ===
Si c'est lors du passage de PHP 7 à 8, essayer de lancer le script sans Symfony pour avoir le détail (ex : utiliser PhpUnit directement au lieu de PhpUnit bridge). Cela peut par exemple provenir de return type différents entre une interface (ex : ArrayAccess) et son implémentation.

=== You have requested a non-existent parameter &quot;kernel.secret&quot;. Did you mean this: &quot;kernel.charset&quot;? ===
À l'installation d'une dépendance, si les champs sont renseignés dans config/packages, alors c'est qu'ils ne sont pas chargé dans le bundle par Kernel.php.

Peut se traduire aussi par des erreurs de chargement de bundle du type : ''The child config &quot;x&quot; under &quot;y&quot; must be configured.''

=== &quot;The controller for URI \&quot;/api/ma_route/123\&quot; is not callable: Controller \&quot;MonController\&quot; does neither exist a service nor as class.&quot; ===
Si &lt;code&gt;bin/console debug:autowiring --all&lt;/code&gt; montre le service et &lt;code&gt;bin/console debug:route&lt;/code&gt; la route, renseigner routes.yaml et vider le cache. Ex :
&lt;syntaxhighlight lang=&quot;yaml&quot;&gt;
index:
    methods: DELETE
    path: /api/ma_route/{id}
    controller: App\Controller\MonController::__invoke
&lt;/syntaxhighlight&gt;
Si ça ne fonctionne pas, passer par un évènement sur la méthode générique.

=== Doctrine ===

==== Le champ ne se sauvegarde pas en base ====
* Est-ce qu'il y a le flush après la modification du champ ?
* Le cache Doctrine a-t-il bien été vidé depuis l'ajout du champ ?
* Est-il bien dans la variable, sinon est-il mappé dans un formulaire ?
* Est-il en annotation PHP alors que Symfony est configuré pour les attributs ?
* Est-il qu'il y a eu un clear() avant le flush(), ce qui aurait détaché l'entité à sauvegarder ?

==== Le champ sauvegardé en base est toujours 0 ====
Se produit quand on utilise l'annotation &lt;code&gt;@ORM\GeneratedValue(strategy=&quot;IDENTITY&quot;)&lt;/code&gt; sur un champ qui n'est pas ''AUTOINCREMENT'' en base de données.

==== A new entity was found through the relationship 'X' that was not configured to cascade persist operations for entity: X. To solve this issue: Either explicitly call EntityManager#persist() on this unknown entity or configure cascade persist  this association in the mapping for example @ManyToOne(..,cascade={&quot;persist&quot;}) ====
* Dans le cas d'un Doctrine\ORM\ORMInvalidArgumentException:
** Si on est en train de suppriemr une entité, il manque son retrait d'une collection au préalable (ex : &lt;code&gt;$entityToKeep-&gt;removeEntityToDelete($entityToDelete)&lt;/code&gt;);
** Un service a un tag et un argument constructeur incompatible. Ce service en argument fait un $em-&gt;clear() au lieu de clear(object), ou persist(object) au lieu de merge(object).
* Dans le cas &quot;Multiple non-persisted new entities were found through the given association graph&quot;
** Ajouter un persist dans l'entité ou avant le flush.
** Sinon, on tente de flusher une entité récupérée, ou dont une de ses entités liées a été récupérée, par l’entityManager d'un replica SQL (potentiellement non répliqué). Utiliser la base de données maitresee à la place.
** Sinon c'est que le même flush est réalisé plusieurs fois : ajouter du cache d'instance pour ne pas ré-exécuter ce code.


==== Binding an entity with a composite primary key to a query is not supported ====
Se produit quand on utilise la méthode magique find() d'un repository sur une entité qui a une clé composite (au moins deux attributs avec &lt;code&gt;@ORM\Id&lt;/code&gt;). Il faut alors utiliser &lt;code&gt;findBy(['id' =&gt; xxx])&lt;/code&gt;.

==== Call to undefined function Closure at EventDispatcher.php:299 ====
Ajouter dans composer.json :
&lt;syntaxhighlight lang=&quot;json&quot;&gt;
    &quot;conflict&quot;: {
        &quot;symfony/symfony&quot;: &quot;*&quot;,
        &quot;doctrine/common&quot;: &quot;&gt;=3.0&quot;,
        &quot;doctrine/persistence&quot;: &quot;&lt;1.3&quot;
    },
&lt;/syntaxhighlight&gt;

Puis lancer &quot;composer update&quot;.

==== Cannot autowire service &quot;App\Components\CRM\Repository\MonRepository&quot;: argument &quot;$class&quot; of method &quot;Doctrine\ORM\EntityRepository::__construct()&quot; references class &quot;Doctrine\ORM\Mapping\ClassMetadata&quot; but no such service exists. ====
Se produit avec l'autowiring, quand on ajoute l'annotation vers un repo dans une entité. Ex :
 @ORM\Entity(repositoryClass=&quot;App\MonRepository&quot;)

En fait depuis Doctrine 1.8&lt;ref&gt;https://www.it-swarm.dev/fr/php/service-autowire-impossible-largument-fait-reference-la-classe-mais-ce-service-nexiste-pas/836794307/&lt;/ref&gt;, le repository doit étendre &quot;ServiceEntityRepository&quot; au lieu de &quot;EntityRepository&quot;, et avoir un constructeur. Par exemple :
&lt;syntaxhighlight lang=&quot;php&quot;&gt;
use App\Entity\MonEntite;
use Doctrine\Bundle\DoctrineBundle\Repository\ServiceEntityRepository;
use Symfony\Bridge\Doctrine\ManagerRegistry; // anciennement Doctrine\Persistence\ManagerRegistry;

class MonEntiteRepository extends ServiceEntityRepository
{
    public function __construct(ManagerRegistry $registry)
    {
        parent::__construct($registry, MonEntite::class);
    }
&lt;/syntaxhighlight&gt;

==== Cannot select entity through identification variables without choosing at least one root entity alias ====
Retirer les &lt;code&gt;-&gt;addSelect()&lt;/code&gt; du queryBuilder, ou utiliser &lt;code&gt;-&gt;from()&lt;/code&gt;.

==== Class &quot;App\Entity\X&quot; seems not to be a managed Doctrine entity. Did you forget to map it? ====
On fait appel à une classe PHP comme si c'était une entité Doctrine : il faut simplement ajouter les annotations Doctrine à la classe, ou bien recréer la table à partir du code PHP.

==== Column not found: 1054 Unknown column 't0.xxx_id' in 'field list' ====
Il faut juse ajouter la colonne de jointure sous l'annotation *To*. Ex :

&lt;code&gt;@ORM\JoinColumn(name=&quot;id&quot;, referencedColumnName=&quot;id_personne&quot;)&lt;/code&gt;

==== Could not find the entity manager for class '...' ====
Dans doctrine.yaml, retirer &lt;code&gt;type: annotation&lt;/code&gt;.

==== Entity has to be managed or scheduled for removal for single computation ====
* Si remove : retirer le ON CASCADE DELETE de l’entité supprimée.
* Si update : faire le add avant.

==== Entity of type 'App\\MonEntite' for IDs id(1) was not found ====
S'il s'agit de l'ID d'une entité jointe, le rendre nullable (&lt;code&gt;@ORM\JoinColumn(nullable=true)&lt;/code&gt;)&lt;ref&gt;https://cilefen.github.io/symfony/2016/12/29/doctrine-orm-nulls.html&lt;/ref&gt;.

S'il s'agit d'une entité dont la clé primaire est une clé étrangère, lui ajouter :
&lt;pre&gt;
 @ORM\GeneratedValue(strategy=&quot;NONE&quot;)
&lt;/pre&gt;

==== Entity of type App\\MonEntite is missing an assigned ID for field  'id'. ====
Une entité n'arrive pas à être sauvegardée avec un ID null (non auto-incrémenté). Il faut donc le générer (par exemple avec un &lt;code&gt;new UuidV4()&lt;/code&gt;).

Sinon vérifier que l'erreur ne vient pas d'un listener en sur &lt;code&gt;Doctrine\ORM\Events::prePersist&lt;/code&gt; qui tente de persister l'entité récupérée via &lt;code&gt;$eventArgs-&gt;getEntity()&lt;/code&gt;.

==== Invalid PathExpression. Must be a StateFieldPathExpression ====
Cela peut arriver quand on ajoute une clé étrangère dans un select sans sa jointure :
 $this-&gt;createQueryBuilder('user')
     -&gt;select(['user.id', 'user.company'])

On peut donc le remplacer par :
 $this-&gt;createQueryBuilder('user')
     -&gt;select('user.id')
     -&gt;leftJoin('user.company', 'u')

Par contre, si on ne veut pas la jointure, utiliser &quot;identity&quot; :
 $this-&gt;createQueryBuilder('user')
     -&gt;select(['user.id', 'identity(user.company) company'])

==== No alias was set before invoking getRootAlias() ====
Se produit soit :

* Lors d'un &lt;code&gt;$qb = $this-&gt;entityManager-&gt;getEntityManager()-&gt;createQueryBuilder();&lt;/code&gt; (sans alias comme dans : &lt;code&gt;$this-&gt;createQueryBuilder('me')&lt;/code&gt; hérité de &lt;code&gt;EntityRepository&lt;/code&gt;).

Il faut alors rajouter un alias pour l'entité courante ainsi :
&lt;pre&gt;
$em-&gt;createQueryBuilder()
    -&gt;select('me')
    -&gt;from(MonEntite::class, 'me')
&lt;/pre&gt;


* Ou pour un update où on répète à tort l'alias ('me') dans &lt;code&gt;update()&lt;/code&gt; (ce qui peut aussi donner &lt;code&gt;Error: Class 'pn' is not defined&lt;/code&gt; quand il n'y a pas de jointure) :
&lt;pre&gt;
$this-&gt;createQueryBuilder('me')
    -&gt;update()
    -&gt;set('me.isDeleted', 1)
&lt;/pre&gt;

==== Property \&quot;metadata\&quot; on resource \&quot;App\\MonEntite\&quot; is declared as a subresource, but its type could not be determined in  ====
Survient quand une entité étend une autre sans discriminator&lt;ref&gt;https://www.doctrine-project.org/projects/doctrine-orm/en/2.7/reference/inheritance-mapping.html&lt;/ref&gt;.

==== The association mon_entité1#entité2 refers to the owning side field mon_entité2#id which does not exist ====
Si l'entité 2 ne fait pas référence à l'entité 1, supprimer dans l'entité 1, champ entité2, le &lt;code&gt;mappedBy=&lt;/code&gt;.

==== The class 'Doctrine\Common\Collections\ArrayCollection' was not found in the chain configured namespaces App\Entity ====
Il peut y avoir une entité avec une relation ManyToMany dans laquelle on met un ArrayCollection au lieu de l'entité demandée&lt;ref&gt;https://openclassrooms.com/forum/sujet/symfony2-collection-erreur-de-namespace&lt;/ref&gt;.

Sinon vérifier qu'on attend pas un PersistentCollection au lieu d'un ArrayCollection (ou vice-versa avec -&gt;unwrap()).

==== The EntityManager is closed ====

Cela survient quand l'EntityManager rencontre une exception. On peut&lt;ref&gt;https://www.kerstner.at/2014/09/doctrine-2-exception-entitymanager-closed/&lt;/ref&gt; :
* la lever avec :
&lt;syntaxhighlight lang=&quot;php&quot;&gt;
if ($this-&gt;em-&gt;isOpen()) {
    $this-&gt;em-&gt;persist($entity);
    $this-&gt;em-&gt;flush($entity);
}
&lt;/syntaxhighlight&gt;

* recréer l'entityManager :
&lt;syntaxhighlight lang=&quot;php&quot;&gt;
        if (!$this-&gt;em-&gt;isOpen()) {
            $this-&gt;em = $this-&gt;em-&gt;create(
                $this-&gt;em-&gt;getConnection(),
                $this-&gt;em-&gt;getConfiguration()
            );
        }
&lt;/syntaxhighlight&gt;

==== The field xxx has the property type 'bool' that differs from the metadata field type 'int' returned by the 'integer' DBAL type ====
Se produit avec :
&lt;pre&gt;
 bin/console doctrine:schema:validate
&lt;/pre&gt;
Quand il trouve par exemple une option par défaut manquante. Ex :
&lt;pre&gt;
    #[ORM\Column(type: 'boolean', nullable: true, options: ['default' =&gt; null])]
&lt;/pre&gt;

==== The identifier id is missing for a query ====
Se produit lors d'un repository-&gt;find(null).

==== The metadata storage is not up to date, please run the sync-metadata-storage command to fix this issue ====
Si le paramètre &quot;server_version&quot; est présent dans le {{wt|DSN}} &quot;DATABASE_URL&quot;, l'ajouter, sinon le retirer.

==== The referenced column name 'xxx' has to be a primary key column on the target entity class ====
S'il n'est pas possible d'utiliser la clé étrangère comme clé primaire, retirer simplement la ligne :
&lt;pre&gt;
 #[ORM\JoinColumn(name: 'my_id', referencedColumnName: 'my_id')]
&lt;/pre&gt;

Mais ça peut provoquer un problème N+1...

==== The table with name 'xxx' already exists ====
Si cela survient lors du &lt;code&gt;bin/console doctrine:schema:validate&lt;/code&gt;, create ou update sur une base vide, et qu'il n'y a pas de doublon dans le dossier &quot;Entity&quot;&lt;ref&gt;https://openclassrooms.com/forum/sujet/doctrine-schema-update-impossible&lt;/ref&gt; :
* Chercher les doublons dans d'autres namespaces.
* Retirer les appels directs à la table de l'entité mal placés (&lt;code&gt;#[ORM\JoinTable(name: xxx&lt;/code&gt;)).
* Forcer la version du SGBD dans &lt;code&gt;DATABASE_URL&lt;/code&gt;, en l'ajoutant dans &lt;code&gt;?serverVersion=&lt;/code&gt;.
* Dans le cas du validate, on peut ajouter &lt;code&gt;--skip-sync&lt;/code&gt; pour bypasser cette partie du test.

==== Transaction commit failed because the transaction has been marked for rollback only ====
Se produit quand un flush() rencontre une erreur SQLSTATE (ex : colonne manquante, même d'une autre table, ou locks à cause d'UPDATE du même champ qui se répètent).
* Le commenter pour la voir apparaitre.
* Si elle n'apparait pas (ex : timeout), regarder directement [[MySQL/Parcourir_les_bases_de_données|dans les logs de la base de données]].

Cela peut être dû à la présence de deux attributs dans une entité, pointant vers la même colonne de sa table (ex : un ID de clé étrangère et son objet correspondant).

==== Uncaught PHP Exception Doctrine\Common\Proxy\Exception\UnexpectedValueException: &quot;Your proxy directory &quot;var/cache/prod/doctrine/orm/Proxies&quot; must be writable&quot; ====
Si cela se produit avec &lt;code&gt;APP_ENV=prod&lt;/code&gt; et pas &lt;code&gt;dev&lt;/code&gt; dans le .env :
 rm -Rf var/cache/ var/log

==== Uncaught Symfony\Component\Debug\Exception\UndefinedFunctionException: Attempted to call function &quot;apc_fetch&quot; ====
&lt;syntaxhighlight lang=&quot;bash&quot;&gt;
 sudo pecl install apcu
 sudo pecl install apcu_bc
 sudo apt-get install -y php7.2-apcu php7.2-apcu-bc
&lt;/syntaxhighlight&gt;

==== Unexpected non-iterable value for to-many relation ====
Modifier la déclaration du champ en erreur avec un itérable. Ex :
&lt;syntaxhighlight lang=&quot;php&quot;&gt;
public $mesObjets = new ArrayCollection();
&lt;/syntaxhighlight&gt;

S'il n'y a pas de champ en erreur, il faut le retrouver avec &lt;code&gt;dd($type)&lt;/code&gt; dans AbstractItemNormalizer.

==== Unknown database ====
Lancer ''doctrine:database:create'' :
&lt;syntaxhighlight lang=&quot;bash&quot;&gt;
bin/console d:d:c
&lt;/syntaxhighlight&gt;
Puis rajouter les éventuelles tables :
&lt;syntaxhighlight lang=&quot;bash&quot;&gt;
bin/console doctrine:schema:update --force
&lt;/syntaxhighlight&gt;

==== Unrecognized field (ORMException) ====
Se produit quand un findBy de repository ne trouve pas un champ de son entité. Cela peut être résolu avec :
* &lt;code&gt;bin/console cache:clear&lt;/code&gt;
* Vérifier si on ne recherche pas à tort une valeur sans sa clé (si ''Unrecognized field: 0'').
* Passer par un QueryBuilder plutôt que par un find.
* Ne pas faire hériter le repo de ServiceEntityRepository.

==== WARNING   [cache] Failed to save key... &quot;cache-adapter&quot; =&gt; &quot;Symfony\Component\Cache\Adapter\ApcuAdapter&quot; ====
Ajouter &lt;code&gt;apc.enable_cli=1&lt;/code&gt; dans le fichier &lt;code&gt;php.ini&lt;/code&gt;.

==== DoctrineMigrations ====
===== S'il n'exécute pas tout (sans logs même en -vvv) =====
Séparer en plusieurs migrations, notamment les créations de tables et de fonctions.

===== The schema provider is not available =====
Remplacer &quot;connection&quot; par &quot;em&quot; dans doctrine_migrations.yaml :
&lt;syntaxhighlight lang=&quot;yaml&quot;&gt;
doctrine_migrations:
    em: default
&lt;/syntaxhighlight&gt;

===== Syntax error or access violation =====
Il faut probablement échapper des caractères, par exemple avec la syntaxe heredoc ou $this-&gt;connection-&gt;quote().

=== API Platform ===

==== Invalid IRI ====
Ajouter le getId() dans l'entité récupérée par IRI.

==== InvalidArgumentException: &quot;No item route associated with the type xxx ====
Se produit quand on a pas une route POST sans route GET&lt;ref&gt;https://github.com/api-platform/core/issues/3501&lt;/ref&gt;, ou si le GET n'a pas d'ID pour créer des URI. Il faut donc en créer une, mais pas forcément besoin de créer un contrôleur :
&lt;syntaxhighlight lang=&quot;php&quot;&gt;
 * @ApiResource(
 *     itemOperations={
 *         &quot;get&quot;={
 *             &quot;method&quot;=&quot;GET&quot;,
 *             &quot;controller&quot;=NotFoundAction::class,
 *             &quot;read&quot;=false,
 *             &quot;output&quot;=false,
 *         },
 *     },
 * )
&lt;/syntaxhighlight&gt;

==== No identifiers defined for resource of type ====
&lt;syntaxhighlight lang=&quot;php&quot;&gt;
 /**
  * @ApiProperty(identifier=true)
 */
 private $id;
&lt;/syntaxhighlight&gt;

Si aucun ID n'est possible, en renvoyer &quot;1&quot; par exemple.

==== Unable to generate an IRI for ====
En général, rajouter un getId() dans l'entité.

==== The total number of joined relations has exceeded the specified maximum. Raise the limit if necessary with the \&quot;api_platform.eager_loading.max_joins\&quot; configuration key, or limit the maximum serialization depth using the \&quot;enable_max_depth\&quot; option of the Symfony serializer ====
Sur MySQL (ou MariaDB) il existe un maximum de 64 jointures. Donc s'il n'est pas possible d'augmenter max_joins, il faut limiter les jointures par les deux annotations suivantes :
&lt;syntaxhighlight lang=&quot;php&quot;&gt;
 * @API\ApiSubresource(maxDepth=1)
 * @ORM\OneToMany(targetEntity=&quot;MonEntité&quot;, mappedBy=&quot;monChamp&quot;, fetch=&quot;EXTRA_LAZY&quot;)
&lt;/syntaxhighlight&gt;

=== Twig ===

==== Un template Twig ne se rafraichit pas dans la navigateur ====
En local, dans .env, passer de &lt;code&gt;APP_ENV=prod&lt;/code&gt; à &lt;code&gt;APP_ENV=dev&lt;/code&gt;.

Sinon vider le cache Symfony.

==== A hash key must be followed by a colon (:) ====
Il faut probablement mettre des parenthèses autour des variables dans un merge de tableau. Ex :
 myArray|merge([{(myKey): (myValue)}])

==== Array to string conversion ====
Plusieurs solutions sont possibles pour afficher un tableau dans un template JSON.
* Pour avoir un tableau, ajouter (et retirer les guillemets autour de la valeur si besoin) :
&lt;syntaxhighlight lang=twig&gt;
&quot;my_key&quot;: {{ my_value |json_encode(constant('JSON_PRETTY_PRINT'))|raw }},
&lt;/syntaxhighlight&gt;
voire :
&lt;syntaxhighlight lang=twig&gt;
&quot;my_key&quot;: {{ my_value |join(', ') }},
&lt;/syntaxhighlight&gt;
* Pour avoir un objet en chaine de caractères, faire le json_encode en amont puis laisser les guillemets :
&lt;syntaxhighlight lang=twig&gt;
&quot;my_key&quot;: &quot;{{ my_value }}&quot;,
&lt;/syntaxhighlight&gt;

==== double quoted property ====
Une virgule de trop après une clé.

==== key \&quot;id\&quot; for array with keys \&quot;0\&quot; does not exist. ====
Appel d'une clé absente d'un tableau.

==== The CSRF token is invalid. Please try to resubmit the form ====
Dans le formulaire concerné, ajouter la ligne :
&lt;syntaxhighlight lang=php&gt;
    public function configureOptions(OptionsResolver $resolver)
    {
        $resolver-&gt;setDefaults([
            ...
            'csrf_protection' =&gt; false,
        ]);
    }
&lt;/syntaxhighlight&gt;

==== unexpected token &quot;punctuation&quot; of value &quot;{&quot; ====
Au choix :
* Ajouter les apostrophes aux clés du tableau concerné.
* Ajouter des parenthèses à ses expressions.
* Remplacer les accolades par des crochets pour le premier niveau.

==== xmlParseEntityRef: no name ====
Un &quot;&amp;&quot; n'est pas échappé en XML. Il faut ajouter un filtre &quot;| escape&quot; en Twig pour le faire.

== PhpStorm ==

Les logs sont accessibles par :
 tail -f ~/.PhpStorm2019.2/system/log/idea.log

=== Certains dossiers sont rouges (exclus) dans la navigation et l'indexation, alors qu'ils ne sont pas censés l'être ===
Fermer le projet, supprimer le .idea, et le rouvrir.

=== Impossible de CTRL + clic dans un .twig (chemin introuvable) ===
Vérifier que le plugin Symfony de PhpStorm est bien installé et activé.

Si cela persiste, dans ''File\Settings\PHP\Symfony\Twig \ Template'', ajouter le chemin vers les .twig importés du bundle concerné.

=== L'historique Git d'un dossier est tronqué ===
Si &lt;code&gt;git log .&lt;/code&gt; montre plus de commits que le clic droit / Git / Show history, alors cliquer sur Files / Invalidate Caches, et tout cocher.

Si cela ne fonctionne pas après redémarrage, et que le projet fait partie d'un groupe de projets ouverts, le fermer (clic droit dessus et &quot;Remove from project view&quot;), puis le rouvrir.

=== Dans l'onglet Git, on ne voit pas la liste des fichiers modifiés ===
Dans Settings, Version Control, Commit, décocher &quot;Use non-modal commit interface&quot;.

=== Un fichier a disparu des onglets, a un icône de point d'interrogation, et ne peut être rouvert ===
Il n'est pas ou plus associé à un type de fichier, aller dans ''File\Associate with File Type''.

=== incoming connection from xdebug ===
Lors d'une erreur au remplissage de cette pop-up, on peut la corriger dans .idea/workspace.xml.

=== No differences files that files have differences only in line separators ===
Les scripts lancés depuis PhpStorm sous Windows modifient les retours à la ligne (CLRF to LF).

Changer l'option dans ''Settings/Preferences | Editor | Code Style | Line separator''&lt;ref&gt;https://stackoverflow.com/questions/40470895/phpstorm-saving-with-linux-line-ending-on-windows&lt;/ref&gt; vers &quot;System dependent&quot;.

Sinon, configurer git :
 git config --global core.autocrlf true

=== Undefined class xxx ===
Une classe existe mais PhpStorm ne la voit pas : ajouter son dossier dans File\Settings\Directories, retirer l'exclusion (rouge) du dossier concerné.

== Xdebug ==
Des logs Xdebug sont ajoutables dans le fichier &lt;code&gt;php.ini&lt;/code&gt; :
&lt;syntaxhighlight lang=&quot;ini&quot;&gt;
xdebug.remote_log = /var/www/xdebug.log
xdebug.show_error_trace = 1
; Profiling (enable via cookie or GET/POST variable: XDEBUG_PROFILE=1).
xdebug.profiler_enable = 1
xdebug.profiler_enable_trigger = 0
xdebug.profiler_output_dir = /tmp/
; var_dump() settings.
xdebug.overload_var_dump = 1
xdebug.cli_color = 1
&lt;/syntaxhighlight&gt;

=== En CLI, la console s'ouvre sur default_prepend.php et on ne voit pas l'exécution de la commande ===
Cela se produit quand plusieurs projets sont ouverts dans PhpStorm et que la commande n'appartient pas au principal.

=== Le navigateur déclenche bien le débogage pas à pas, mais on ne voit pas le fichier PHP dans l'IDE ===
Il manque le mapping (par exemple avec les routes du conteneur). Par exemple dans PhpStorm, Servers, cocher &quot;Use path mappings&quot; et le renseigner.

=== Messages d'erreur ===
==== Cannot find file '/usr/local/php/php/auto_prepends/default_prepend.php' locally ====
Sous PhpStorm avec Docker, cliquer sous l'erreur pour modifier le ''path mapping''.

==== Code coverage needs to be enabled in php.ini by setting 'xdebug.mode' to 'coverage' ====
Pour éviter d'éditer le .ini, on peut remplacer :
 bin/phpunit --coverage-text
par :
 php -dxdebug.mode=coverage bin/phpunit --coverage-text

==== Could not connect to client ====
Le serveur est introuvable, changer :
* En V2, xdebug.remote_host ou remote_port.
* En V3, xdebug.client_host ou xdebug.client_port.

==== Gateway Timeout ====
Cette erreur du navigateur généralement due au serveur Web.
* Sur Apache, dans httpd.conf augmenter le nombre de secondes par défaut dans &lt;code&gt;Timeout 60&lt;/code&gt;&lt;ref&gt;https://www.h3xed.com/web-development/php-and-apache-504-gateway-timeout-troubleshooting-and-solutions&lt;/ref&gt;.
* Sur Nginx, augmenter &lt;code&gt;fastcgi_read_timeout 60s;&lt;/code&gt;&lt;ref&gt;http://nginx.org/en/docs/http/ngx_http_fastcgi_module.html#fastcgi_read_timeout&lt;/ref&gt;.
*Sur IIS, étendre la valeur du paramètre ''Activity Timeout'' des ''FastCGI Settings''&lt;ref&gt;https://www.leighton.com/blog/php-debugging-in-phpstorm-6-0-with-xdebug/&lt;/ref&gt;.
* Cela peut aussi provenir d'un load balancer en amont du serveur HTTP.

De plus, on peut aussi revoir les variables du fichier &lt;code&gt;php.ini&lt;/code&gt;. Ex :
&lt;syntaxhighlight lang=&quot;ini&quot;&gt;
max_execution_time=30  # 30 s par défaut
max_input_time=-1      # Utilisera &quot;max_execution_time&quot; si -1, sinon la valeur indiquée
&lt;/syntaxhighlight&gt;

==== Failed to read FastCGI header ====
Si le log Apache affiche cela lors d'un ''Gateway Timeout'', il faut ajouter à httpd.conf&lt;ref&gt;https://support.plesk.com/hc/en-us/articles/115000064929-Website-is-not-accessible-The-timeout-specified-has-expired-Error-dispatching-request-to&lt;/ref&gt; :
&lt;syntaxhighlight lang=&quot;apache&quot;&gt;
    ProxyTimeout 6000
    &lt;IfModule mod_fcgi.c&gt;
        FcgidProcessLifeTime 6000
        FcgidBusyTimeout 6000
        FcgidConnectTimeout 6000
        FcgidIdleTimeout 6000
        FcgidInitialEnv 6000
        FcgidIOTimeout 6000
        IdleTimeout 6000
        IPCConnectTimeout 6000
        IPCCommTimeout 6000
        IdleScanInterval 6000
    &lt;/IfModule&gt;
&lt;/syntaxhighlight&gt;

Parfois il convient aussi de modifier le fichier &lt;code&gt;php.ini&lt;/code&gt;&lt;ref&gt;https://www.reddit.com/r/drupal/comments/ase67i/for_issue_reference_service_unavailable_error/&lt;/ref&gt; :
&lt;syntaxhighlight lang=&quot;ini&quot;&gt;
opcache.optimization_level=0xFFFFFBFF
xdebug.remote_cookie_expire_time=6000
&lt;/syntaxhighlight&gt;

Enfin, sur PhpStorm on rencontre cela dans le cas de sous-requêtes qui dépassent la valeur du paramètre &quot;Max. simultaneous connections&quot;.

==== No code coverage driver is available ====
Installer ou activer [[../Xdebug|Xdebug]]. Il doit apparaitre ensuite dans &lt;code&gt;php -v&lt;/code&gt;.

==== Remote file path 'default_prepend.php' is not mapped to any file path in project ====
Sous PhpStorm il faut décocher dans les ''settings'', ''debug'', les deux cases ''Force break...'', puis de redémarrer l'IDE&lt;ref&gt;https://www.jetbrains.com/help/phpstorm/troubleshooting-php-debugging.html&lt;/ref&gt;.

==== Time-out connecting to client ====
Changer xdebug.remote_host ou xdebug.remote_port car le serveur existe mais n'écoute pas le port spécifié.

Si le navigateur ne déclenche plus le débogage sur l'IDE, alors que ce dernier écoute et que la clé du navigateur est bien définie, c'est peut-être le pare-feu qui bloque. Exemple de reset sur Linux avec [[Le système d'exploitation GNU-Linux/Protection avec iptables|iptables]]&lt;ref&gt;https://ubuntuforums.org/showthread.php?t=1381516&lt;/ref&gt; :
&lt;syntaxhighlight lang=&quot;bash&quot;&gt;
   iptables --policy INPUT   ACCEPT;
   iptables --policy OUTPUT  ACCEPT;
   iptables --policy FORWARD ACCEPT;
   iptables -Z; # zero counters
   iptables -F; # flush rules
   iptables -X; # delete all extra chains
&lt;/syntaxhighlight&gt;

==== Waiting for incoming connection with ide key 'xxx' ====
Xdebug peut marcher pour certains sites, sauf un qui ne déclenche rien dans l'IDE. Ce message apparait alors dans PhpStorm si on clique sur &quot;Debug&quot;.

* Vérifier le serveur et son port) associé à l'URL&lt;ref&gt;https://stackoverflow.com/questions/17715128/xdebug-phpstorm-waiting-for-incoming-connection-with-ide-key&lt;/ref&gt;.
* Voir la page [[Programmation PHP/Xdebug]].

== GraphQL ==
=== Fields &quot;maRoute&quot; conflict because they have differing arguments. Use different aliases on the fields to fetch both if this was intentional. ===
Si on appelle plusieurs fois la même route dans la même requête, il faut définir des alias. Ex :
&lt;syntaxhighlight lang=&quot;cypher&quot;&gt;
mutation {
    maRoute(...)
    aliasMaRoute: maRoute(...)
}
&lt;/syntaxhighlight&gt;
Le résultat de la requête sera donc un tableau avec ['data' =&gt; [[maRoute =&gt; ...], [aliasMaRoute =&gt; ...]].

== Windows ==
=== imagecreatefromstring(): gd-png: libpng warning: Interlace handling should be turned on when using png_read_image ===
Remplacer le php_gd2.dll du PHP 7.4.33 par celui du 7.4.2 téléchargé depuis https://www.pconlife.com/viewfileinfo/php-gd2-dll/.

Exemple du chemin par défaut :
 C:\wamp64\bin\php\php7.4.33\ext\

== Références ==
{{Références}}

&lt;noinclude&gt;[[Catégorie:Messages d'erreur]]&lt;/noinclude&gt;</text>
      <sha1>sgixck30nu9ydnqjxw61m468tdixx83</sha1>
    </revision>
  </page>
  <page>
    <title>Auto-éditer un wikilivre/Auto-référencer</title>
    <ns>0</ns>
    <id>74478</id>
    <revision>
      <id>744187</id>
      <parentid>710411</parentid>
      <timestamp>2025-06-06T04:32:12Z</timestamp>
      <contributor>
        <ip>2A01:CB18:1150:4600:C5FF:3372:4F9:EE19</ip>
      </contributor>
      <comment>/* Les lignes qui méritent notre attention */Correction d'une faute d'orthographe</comment>
      <origin>744187</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="69630" sha1="h5fn6q4aimq41c8cdlv0pw6cf8sx83w" xml:space="preserve">&lt;!--{{En cours}}--&gt;
&lt;div class=&quot;noprint&quot;&gt;
&lt;div style=&quot;background: #EAF5FB; font-size: 120%; margin: 1em auto; padding: 0.3em; text-align: center; width: 70%;&quot;&gt;
&lt;div style=&quot;background: #EAF5FB; border: 2px solid #fff; padding: 0.3em;&quot;&gt;
&lt;span style=&quot;font-size: 125%;&quot;&gt;'''Programmation bash (exercices, tests et documentation.)'''&lt;/span&gt;&lt;br /&gt;
''Un livre appartenant à la série [[Programmation]] de [[Accueil|Wikilivres]]''.
&lt;/div&gt;
&lt;/div&gt;

&lt;strong&gt;self-referencing&lt;/strong&gt;
&lt;/div&gt;
__TOC__
&lt;div style=&quot;width: 270px; float: right;&quot;&gt;
{{Moteur}}
{{version imprimable}}
&lt;!--{{étiquette progression|en cours}}--&gt;&lt;!--{{étiquette progression|ébauche}}encours, avancé, complet --&gt;
&lt;!--{{étiquette progression|avancé}}--&gt;
{{niveau|12|img=douze}}
&lt;/div&gt;
{{Nouvelle page imprimée}}
== Codes shell pour créer la page « Annexe » d'un wikilivre ==
{{:Auto-éditer_un_wikilivre/Auto-référencer/Description du projet}}
&lt;small&gt;&lt;small&gt;[[Auto-éditer_un_wikilivre/Auto-référencer/Description du projet|modifier cette description du projet]]&lt;/small&gt;&lt;/small&gt;

{{Nouvelle page imprimée}}
=== Entête des modules ===
; (header)
; Documentation :
 Le fichier de commandes header.sh doit être inclus dans tous les modules
   de test du programme principal. Il initialise le répertoire des commandes,
   le répertoire de travail du projet; le projet est le nom du livre, de
   l'article ou de la page. Si ils n'existent pas ils seront créés
 Ce projet éducatif et de tests est destiné à être utilisé sous wikilivres
   en langue française et en caractères UTF8. 
   Les variables Site et SitePrefix se rapportent à &quot;fr.wikibooks.org&quot;.
 Le programme est prévu pour fonctionner à l'initiative du contributeur qui
   qui doit copier la page &quot;Contenus&quot; ou la page de la compilation dans le
   répertoire de travail &quot;~/Annexe/&lt;nom du livre&gt;&quot;
 Les modules en tests sont indépendants, cependant ils doivent être exécutés
   dans l'ordre ./header.sh &lt;livre&gt;, ./lister &lt;livre&gt;, ./télécharger &lt;livre&gt;
   ./ajouter_sclt &lt;livre&gt;, ./ajouter_sclic, ./ajouter_sclip &lt;livre&gt;
 La liste des pages à analyser est indispensable dans tous les modules en
   tests. L'absence de la liste des pages à analyser est signalée à chaque
   lancement des modules du programme principal &quot;Annexer&quot;

 AVERTISSEMENT : Ce programme avec ses modules doit être utilisé par des
   wikipédiens, à titre personnel. La structure du résultat est voisine de
   l'impression par PediaPress. Pour cette raison ce programme n'est pas
   commercialisable.
; Organigramme :
&lt;pre&gt;
2:#P Nom du fichier de commandes : header ou header.sh
3:#P Syntaxe : &quot;.header.sh &lt;nom du livre&gt;&quot;
4:#P Exemple : &quot;./header.sh LivreTest&quot; à la console pour les essais.
5:#P Ce fichier d'entête est commun aux fichiers de commandes annexer, lister,
6:#P   télécharger, ajouter_sclt, ajouter_sclip dans lesquels ils sont inclus.
7:#P Date de création : 24 mars 2020
8:#P Modifié le : 14 mai 2020 par GC ajout des &quot;données_de_conversions&quot; url-&gt;utf8
9:#P Modifié le : 16 mai 2020 par GC maj de la nouvelle syntaxe de la commande.
10:#P Version sur WikiLivres le : 17 mai 2020
11:#P
34:#P Note : L'extraction de la documentation peut se faire par la commande :
35:#P   Documentation :
36:#P     mkd -Stw D header.sh &lt;livre&gt;_doc/header.sh.D.doc
37:#P     grep -e '#D' header.sh | sed s/#D//g  &gt; &lt;livre&gt;_doc/header.sh.HPw.doc
38:#P   Organigrammes :
39:#P     grep -e -n '#H' -e '#P' -e '#w' header.sh
40:#P     ou : grep -E &quot;#H|#P|#w&quot; header.sh &gt; &lt;livre&gt;_doc/header.sh.HPw.doc
41:#P   Exemples :
42:#P     mkd -Stw D header.sh LivreTest_doc/header.sh.D.doc
43:#P     grep -e '#D' header.sh | sed s/#D//g  &gt; LivreTest_doc/header.sh.D.doc
44:#P     grep -n -E &quot;#H|#P|#w&quot; header.sh &gt; LivreTest_doc/header.sh.HPw.doc 
45:#P
47:#H vider (nettoyer) l'écran.
54:#H tester la présence du répertoire racine des commandes, si il n'existe pas,
55:#H   le créer.
65:#H initialiser la variable Conversion avec le lien vers le fichier
66:#H   données_de_conversion
69:#H si le programme de test de header.sh est actif, alors supprimer le fichier
70:#H   'données_de_conversions'
77:#H tester la présence du fichier des 'données_de_conversion', si il n'existe
78:#H   pas; le créer.
121:#H créer la fonction header_syntax.
126:       #w seulement avec la commande 'Annexer'
127:       #w echo &quot;ou $0 &lt;livre&gt; [-v] [-pb||-pc]&quot;
128:       #w echo &quot;options -v:mode bavard, -pb ou -pc:versions personnalisées Wikibooks ou Commons.&quot;
132:#H tester la présence du premier paramètre de la ligne de commandes
146:      exit 0 #P exit 0 : Fin d'affichage de la syntaxe
150:#H initialiser la variable &quot;Projet&quot; = répertoire de projet.
156:#H tester la présence du répertoire du projet, si il n'existe pas, le créer.
165:#H initialiser les variables 'Site' (nom du serveur) et 'SitePrefix'.
169:#H nettoyer l'écran, afficher les variables globales et le contenu du répertoire de projet.
198:#H entrer dans la répertoire de travail.
&lt;/pre&gt;
{{Boîte déroulante début|titre=Code header.sh|styleFrame=width:100%;|fondtitre=#F0F0F0&lt;!--|styleTitre=color:white;|style=headerbleu--&gt;}}
;Référence de l'article pour cette section : [https://fr.wikibooks.org/w/index.php?title=Auto-%C3%A9diter_un_wikilivre/Auto-r%C3%A9f%C3%A9rencer/header.inc.sh&amp;oldid=641583 Version du 25 mai 2020]

; Version actualisée :
{{:Auto-éditer_un_wikilivre/Auto-référencer/header.inc.sh|Version actualisée}}

{{Boîte déroulante fin}}
{{Nouvelle page imprimée}}

=== Annexer (main) ===
; (Appendix)
'''Annexer''' ou '''annexer.sh''' est la page principale qui permet de produire la page « Annexe », elle utilise les commandes shell &quot;header.sh, &quot;lister&quot;, &quot;télécharger&quot;, &quot;ajouter_sclt&quot;,  &quot;ajouter_sclic&quot; et &quot;ajouter_sclip&quot;.
; Documentation : '''''mkd -Stw D annexer Bash_doc/annexer.D.doc''''', qui respecte les tabulations, ou :&lt;br /&gt;'''''mkd -sStw D annexer &gt; Bash_doc/annexer.D.doc''''', avec une présentation comme ci-dessous.
   la commande &quot;annexer&quot; est le programme principal de tests pour créer la
     page &quot;Annexe&quot; des livres de wikilivres.
   annexer (module de tests) analyse la ligne de commandes et initialise la
     variable $Verbose ou affiche la syntaxe à la demande interrogative '?'
     en premier paramètre.
   ce programme supprime tous les fichiers obsolètes du répertoire de travail
      &quot;~/Annexe/&lt;nom du livre&gt;&quot; et de ses sous répertoires, avec l'accord de
      l'utilisateur.
   les modules lister, télécharger, ajouter_sclt, ajouter_scli* sont exécutés
     dans l'ordre, puis pour finir, le fichier &quot;Annexe&quot; du livre est assemblé.
   à la fin de l'exécution de chaque module il est possible d'interrompre le
     programme par la validation de la ligne (retour chariot après #T) :
     #T exit -&gt; sur deux lignes comme ci-après :
     #T
     exit
  
   l'extraction de la documentation peut se faire par la commande :
     mkd -Stw DOP annexer (D=Docu, O=organigramme, P=pour programmeurs)
  
; Organigramme : '''''mkd -nStw O annexer Bash_doc/annexer.O.doc'''''
   47    analyse de la ligne de commandes :
   48      si le premier paramètre est le caractère ?
   50      alors :
   52        afficher la syntaxe et quitter.
   63      fin si
   66    inclure le fichier d'entête header.sh
   69   ## annexer ################
   71    initialiser les variables $Verbose et $Personal à 'false'
   80    si ne nombre de paramètres est supérieur à 1
   82    alors :
   84      si le deuxième paramètre est '-v'
   86      alors initialiser la variable $Verbose à 'true' (vrai).
   89      fin si
   91      si le deuxième paramètre est '-pb'
   93      alors initialiser la variable $Personalwb à 'true' (vrai).
   96      fin si
   98            si le deuxième paramètre est '-pc'
  100      alors initialiser la variable $Personalco à 'true' (vrai).
  103      fin s
  105    fin si
  108    si le nombre de paramètres est égal à 3
  110    alors :
  112      si le troisième paramètre est '-v'
  114      alors initialiser la variable $Verbose à 'true' (vrai).
  117      fin si
  119      si le troisième paramètre est '-pb'
  121      alors, si la variable $Personalco n'est pas à validée, initialiser la variable $Personalwb à 'true' (vrai).
  123      fin si
  126      si le troisième paramètre est '-pc'
  128      alors, si la variable $Personalwb n'est pas à validée, initialiser la variable $Personalco à 'true' (vrai).
  130      fin si
  132    fin si
  135    si le nombre de paramètres est supérieur à 3
  137    alors : signaler l'erreur et quitter.
  142    fin si
  156    afficher : 'effacer tous les fichiers obsolètes ? :'
  157      '*.html *.str *.img *.lnk tmp temp *.tmp *.temp *.list ?'
  161    attendre 'un' (un seul) caractère de réponse.
  165    si la réponse au clavier est 'o' (oui !),
  167    alors effacer les fichiers du répertoire de projet (nom du livre).
  173    sinon, continuer.
  175    fin si
  181    se placer dans le répertoire des commandes(~/Annexer/.)
  184    créer le fichier contenant la liste des articles à analyser. (./lister $1)
  185      si la variable $Verbose et validée (à 'true'),
  187      alors : exécuter la commande 'lister' en mode bavard.
  190      sinon : exécuter 'lister' en mode silencieux, les observation seront dans
  191        le fichier lister-cmd.txt 
  194      fin si
  199    si le code de retour est supérieur à 0
  201    alors afficher le nom du module de commande en erreur et quitter 'annexer'
  202      avec retour à 1
  206    fin si
  212    se placer dans le répertoire des commandes
  216      si le mode bavard est activé,
  218      alors: exécuter la commande 'télécharger' en mode bavard.
  221      sinon: exécuter la commande 'télécharger' en mode silencieux..
  224      fin si
  229    si le code de retour est supérieur à 0
  231    alors afficher le nom du module de commande en erreur et quitter 'annexer'
  232      avec retour à 1
  236    fin si
  242    se placer dans le répertoire des commandes
  245    créer la &quot;page Annexe&quot; et ajouter les sources, contributeurs, droits de
  246      copie du texte des articles.
  247      sclt signifie : s=source, c=contributeurs, l=licence, t=texte des articles
  248    si le mode bavard est activé,
  250      alors : exécuter la commande 'ajouter_sclt' en mode bavard.
  253      sinon : exécuter la commande 'ajouter_sclt' en mode silencieux.
  256      fin si
  261    si le code de retour est supérieur à 0
  263    alors afficher le nom du module de commande en erreur et quitter 'annexer'
  264      avec retour à 1
  268    fin si
  274    se placer dans le répertoire des commandes
  277    si la variable $Personal est invalide 'false' 
  279    alors:
  281      exécuter ajouter_sclic 
  282        (ajouter les sources, licence, contributeurs des images avec la commande
  283        globale conventionnelle ajouter_sclic
  284      si le mode bavard est validé,
  286      alors : ajouter_sclic en mode bavard
  289      sinon : ajouter_sclic et copier les observations dans ajouter-sclic-cmd.txt
  292      fin si
  295    fin si
  300    si le code de retour est supérieur '0'
  302    alors afficher le nom du module de commande en erreur et quitter 'annexer'
  303      avec retour à 1
  307    fin si
  313    se placer dans le répertoire des commandes
  315    si l'option annexe' personnalisée est validée ($Personal=true)
  317    alors:
  319      exécuter ajouter_sclip 
  320        (ajouter les sources, licence, contributeurs des images avec la commande
  321        globale conventionnelle ajouter_sclic
  327      fin si
  330    fin si
  334    si le code de retour est différent de '0'
  336    alors afficher le nom du module de commande en erreur et quitter 'annexer'
  337      avec retour à 1
  341    fin si
  350    se placer dans le répertoire des commandes.
  352    si l'option de la commande annexe '-pc' (personalco) est activée à 'vrai'
  354      alors exécuter sclipco.inc
  358    fin si
  360    si le code de retour est différent de '0',
  362    alors afficher le nom du module de commande en erreur et quitter 'annexer'
  363      avec retour à 1
  367    fin si
  374    se placer dans le répertoire des commandes.
  376    si l'option de la commande annexe '-pb' (personalwb) est activée à 'vrai'
  378      alors exécuter sclipwb.inc
  382    fin si
  384    si le code de retour est différent de '0',
  386    alors afficher le nom du module de commande en erreur et quitter 'annexer'
  387      avec retour à 1
  391    fin si
  397    assembler la page 'Annexe' du livre.
  400      copier sclt dans la page 'Annexe' du livre.
  403    si la variable Personal est activée à 'true'
  405    alors : ajouter le contenu du fichier $1.sclip au fichier $1.annexe
  407    sinon :
  409      ajouter $1.sclic à l'annexe
  411    fin si
  414      ajouter la licence (fr) à la page 'Annexe'
 
{{Boîte déroulante début|titre=Code du programme maître ''annexer''|styleFrame=width:100%;|fondtitre=#F0F0F0&lt;!--|styleTitre=color:white;&lt;!|style=headerbleu--&gt;}}
;Version de référence pour cet article du 20 mai 2020 :[https://fr.wikibooks.org/w/index.php?title=Auto-%C3%A9diter_un_wikilivre/Auto-r%C3%A9f%C3%A9rencer/annexer.sh&amp;oldid=641588 Annexer.sh]
; Version actualisée :
{{:Auto-éditer_un_wikilivre/Auto-référencer/annexer.sh}}
{{Boîte déroulante fin}}

==== Tests unitaires du fichier de commandes ''annexer'' ====
''&lt;u&gt;Faire un brouillon avec le micro-ordinateur sous linux&lt;/u&gt; (ou autre système acceptant les shells bash).''
# Avec un micro-ordinateur doté d'un système d'exploitation unix ou linux.
# Copier le code du fichier [[Auto-éditer_un_wikilivre/Auto-référencer#Annexer|annexer]] dans un éditeur de texte comme Notepadqq, Gedit, ou Bluefish.
# Créer le répertoire ''Annexer'' avec l'éditeur, ou, sous console : '''mkdir ~/Annexer'''
# Enregistrer le texte avec pour nom '''annexer''' dans le répertoire '''Annexer'''.
# &lt;u&gt;Sous console&lt;/u&gt;, entrer dans le répertoire Annexer : '''cd ~/Annexer'''
# Copier le code de la commande '''header.sh''' dans '''~/Annexer/.'''
# Rendre les commandes ''annexer'' et ''header.sh'' exécutables : '''chmod 777 annexer header.sh'''
# Pour tester, lancer la commande '''./annexer LivreTest'''.
# Observer le répertoire ''LivreTest'' : '''ls -l ~/Annexer/LivreTest''' qui doit être vide.
# Copier et coller tous les codes des modules : header.sh, lister, télécharger, ajouter-sclt, ajouter_sclic, ajouter_sclip, &lt;u&gt;dans le répertoire des commandes ''Annexer''&lt;/u&gt;. &lt;br :&gt;exemple : code ''header.sh'' dans le fichier ~/Annexer/hearder.sh, etc.
# tous les fichiers shell doivent être exécutables &lt;br /&gt;'''chmod 777 lister télécharger ajouter_sclt ajouter_sclic ajouter_sclip'''
# Éditer et copier le contenu de la page '''''Contenus''''' de la version imprimable, dans le répertoire de travail du projet, '''''~/Annexer/&lt;nom du livre&gt;/.''''' avec pour nom '''''&lt;nom du livre&gt;.contenu''''' ou le contenu d'une page de '''''compilation''''', avec pour nom '''''&lt;nom du livre&gt;.compilé'''''.&lt;br /&gt;'''ls -l ~/Annexer/&lt;nom du livre&gt;''' doit maintenant afficher un de ces deux fichiers.

'''Note : '''Si, par exemple, vous lancez la commande '''''./annexer LivreTest''''' ou '''''./header.sh LivreTest''''' de n'importe répertoire, les répertoires '''''~/Annexer''''' et '''''~/annexer/LivreTest''''' seront automatiquement créés au bon endroit par l'entête ''header.sh''. Il suffira de copier le fichier de commandes ''annexer'' ou ''annexer.sh'' dans le répertoire de fichiers de commandes : &lt;br /&gt;&quot;'''mv ./annexer ~/Annexer/annexer'''&quot; ou shell bash sous windows, &quot;'''mv ./annexer.sh ~/Annexer/annexer.sh'''&quot;

==== Annexe obtenue ====
&lt;pre&gt;
= Annexe =

== Références ==
&lt;references /&gt;
 
{{Nouvelle page imprimée}}
== Contenus ==
&lt;small&gt;
https://fr.wikibooks.org/wiki/Utilisateur:Goelette_Cardabela/Sandbox/LivreTest

https://fr.wikibooks.org/wiki/Utilisateur:Goelette_Cardabela/Sandbox/LivreTest/ArticleUn

https://fr.wikibooks.org/wiki/Utilisateur:Goelette_Cardabela/Sandbox/LivreTest/ArticleDeux

https://fr.wikibooks.org/wiki/Utilisateur:Goelette_Cardabela/Sandbox/LivreTest/ArticleTrois

&lt;/small&gt;
=== Source de cette édition ===
&lt;small&gt;
https://fr.wikibooks.org/wiki/Utilisateur:Goelette_Cardabela/Sandbox/LivreTest
&lt;/small&gt;
 
{{Nouvelle page imprimée}}
== Sources licences et contributeurs des articles ==
&lt;small&gt;Les ''sources'' listées pour chaque article fournissent des informations de licence plus détaillées, y compris le statut des droits d'auteurs, les détenteurs de ces droits et les conditions de licence.&lt;/small&gt;
 
&lt;small&gt;&lt;small&gt;

'''ArticleUn'''
, ''source : ''https://fr.wikibooks.org/w/index.php?oldid=632571
, ''licence : ''https://creativecommons.org/licenses/by-sa/3.0/
, ''auteur(s) : ''Goelette Cardabela

'''ArticleDeux'''
, ''source : ''https://fr.wikibooks.org/w/index.php?oldid=632572
, ''licence : ''https://creativecommons.org/licenses/by-sa/3.0/
, ''auteur(s) : ''Goelette Cardabela

'''ArticleTrois'''
, ''source : ''https://fr.wikibooks.org/w/index.php?oldid=632573
, ''licence : ''https://creativecommons.org/licenses/by-sa/3.0/
, ''auteur(s) : ''Goelette Cardabela

&lt;/small&gt;&lt;/small&gt;
{{Nouvelle page imprimée}}
== Sources des images licences et contributeurs ==
&lt;small&gt;Les ''sources'' listées pour chaque illustration fournissent des informations de licence plus détaillées, y compris le statut des droits d'auteurs, les détenteurs de ces droits et les conditions de licence.&lt;/small&gt;
 
&lt;small&gt;&lt;small&gt;
'''Illustration : '''Gabriel Garcia Marquez - Fresque.jpg
, ''source : ''https://fr.wikibooks.org/w/index.php?title=File:Gabriel_Garcia_Marquez_-_Fresque.jpg
, ''licence : ''CC BY-SA 4.0 
, ''auteur(s) : ''User:Pohline_Blast_Clm

'''Illustration : '''Commerce de communautés indigènes.JPG
, ''source : ''https://fr.wikibooks.org/w/index.php?title=File:Commerce_de_communautés_indigènes.JPG
, ''licence : ''CC BY-SA 3.0 
, ''auteur(s) : ''User:Goelette.Cardabela

'''Illustration : '''Fernando Botero (2018).jpg
, ''source : ''https://fr.wikibooks.org/w/index.php?title=File:Fernando_Botero_(2018).jpg
, ''licence : ''CC BY 3.0 
, ''auteur(s) : ''-

'''Illustration : '''Pano Plazo Botero.jpg
, ''source : ''https://fr.wikibooks.org/w/index.php?title=File:Pano_Plazo_Botero.jpg
, ''licence : ''Public domain
, ''auteur(s) : ''User:Scabredon~commonswiki

&lt;/small&gt;&lt;/small&gt;
{{Nouvelle page imprimée}}
== Licence ==
https://creativecommons.org/licenses/by-sa/3.0/

{{Nouvelle page imprimée}}
&lt;/pre&gt;
===== Impression visuelle de cette annexe =====
[[Utilisateur:Goelette_Cardabela/Sandbox/LivreTest/Annexe_bis]]

; Comparer avec la versions manuelle ou semi-automatique :
[[Utilisateur:Goelette_Cardabela/Sandbox/LivreTest/Annexe]]
{{Nouvelle page imprimée}}

=== Lister (module) ===
; (List)
Créer une liste des liens vers les pages qui composent le livre.
; Documentation :
   L'objet de cette commande est de créer le fichier de liste $Projet/$1.list
     avec le fichier &quot;contenu&quot; prioritaire, sinon avec le fichier &quot;compilé&quot;
     si il existe.
   Le 23 avril; créer la liste de projet $Projet/$1.prj a été jugée nécessaire
     pour que l'utilisation des boucles de commandes s'exécutent dans l'ordre
     de présentation des textes et des images afin de créer la page &quot;Annexe&quot;
     du livre (ou de la page).
  
   Si le fichier &quot;&lt;livre&gt;.contenu&quot; (copie de la page &quot;Contenus&quot; de la version
     imprimable) n'existe pas le programme teste la présence du fichier de
     compilation &quot;&lt;livre&gt;.compilé&quot;, et si celui-ci n'est pas présent le
     programme se termine  avec un code de retour à 1.
   Lorsque le programme se termine normalement le code de retour est 0, le
     fichier examiné aura été protégé contre l'effacement, donc en lecture
     seule, et le fichier projet.list aura été créé.
   Le contenu des listes sont affichés pour être validés.
  
; Organigramme :
  ## lister #################
   effacer tous les fichiers *.list,
   initialiser la variable de retour à 0
   créer le fichier de liste $Projet/$1.list avec le fichier &quot;contenu&quot; prioritaire, sinon avec le fichier &quot;compilé&quot; s'il existe.
   si le fichier LivreTest.contenu existe,
   alors :
      s'assurer que le fichier sera en lecture seule,
      créer la liste des articles de la page avec la page de Contenus du livre.
      créer le fichier de projet avec la page de Contenus du livre.
   sinon, si le fichier LivreTest.compilé existe,
   alors :
      s'assurer que le fichier sera en lecture seule,
      créer la liste avec la page compilée.
      créer le fichier de projet avec la page compilée
   sinon afficher les raisons de l'échec et recommander la marche à suivre.
   fin si
   afficher le code de retour de la commande.
   afficher les listes pour contrôle et retourner la valeur 0 si tout est correct.

{{Boîte déroulante début|titre=Code du module ''lister''|styleFrame=width:100%;|fondtitre=#F0F0F0&lt;!--|styleTitre=color:white;&lt;!|style=headerbleu--&gt;}}
; Référence pour cet article : [https://fr.wikibooks.org/w/index.php?title=Auto-%C3%A9diter_un_wikilivre/Auto-r%C3%A9f%C3%A9rencer/lister.sh&amp;oldid=641603 lister]
; Article actualisé :{{:Auto-éditer_un_wikilivre/Auto-référencer/lister.sh}}
{{Boîte déroulante fin}}

==== Exemple de page ''Contenus'' du livre en test LivreTest ====
: LivreTest.contenu
&lt;pre&gt;
; Article maître du livre
[[Utilisateur:Goelette Cardabela/Sandbox/LivreTest|LivreTest]]
; Contenus
[[Utilisateur:Goelette Cardabela/Sandbox/LivreTest/ArticleUn|ArticleUn]]&lt;br /&gt;
[[Utilisateur:Goelette Cardabela/Sandbox/LivreTest/ArticleDeux|ArticleDeux]]&lt;br /&gt;
[[Utilisateur:Goelette Cardabela/Sandbox/LivreTest/ArticleTrois|ArticleTrois]]
{{Autocat}}
&lt;/pre&gt;
La page ''Contenus'' d'une version imprimable contient l'Article maître du livre '''OU''' la liste des articles qui composent le livre. Dans ces tests nous incluons les deux versions qui nous permettrons de distinguer des présentations  différentes de la page ''Annexe'' du livre.

==== Exemple de page du livre en test, LivreTest compilé ====
: LivreTest.compilé
&lt;pre&gt;
== LivreTest ==
=== Tests de référencement ===
; Article maître du livre
:[[Utilisateur:Goelette Cardabela/Sandbox/LivreTest|LivreTest]]
; Contenus
:[[Utilisateur:Goelette Cardabela/Sandbox/LivreTest/ArticleUn]]
:[[Utilisateur:Goelette Cardabela/Sandbox/LivreTest/ArticleDeux]]
:[[Utilisateur:Goelette Cardabela/Sandbox/LivreTest/ArticleTrois]]

[[Catégorie:Compilations|LivreTest]]
&lt;/pre&gt;
Nous faisons ici les mêmes remarques que pour la page ''Contenus'' de la version imprimable. La première ligne, qui est un lien vers la page principale n'existe pas, normalement, dans une version compilée. Si elle est présente dans de fichier, c'est pour la même raison de démonstration que précédemment: voir les différences de présentation de la page ''Annexe'' du livre.

==== Exemple de listes obtenues pour le livre ''LivreTest'' ====
: LivreTest.list
&lt;pre&gt;
https://fr.wikibooks.org/wiki/Utilisateur:Goelette Cardabela/Sandbox/LivreTest
https://fr.wikibooks.org/wiki/Utilisateur:Goelette Cardabela/Sandbox/LivreTest/ArticleUn
https://fr.wikibooks.org/wiki/Utilisateur:Goelette Cardabela/Sandbox/LivreTest/ArticleDeux
https://fr.wikibooks.org/wiki/Utilisateur:Goelette Cardabela/Sandbox/LivreTest/ArticleTrois
&lt;/pre&gt;
: LivreTest.prj
&lt;pre&gt;
LivreTest
LivreTest/ArticleUn
LivreTest/ArticleDeux
LivreTest/ArticleTrois
&lt;/pre&gt;

==== Tests du module lister ====
Le but est d'obtenir un fichier qui content la liste des liens vers les pages d'un livre de wikilivres à documenter.

Nous pouvons obtenir ces liens grâce aux pages « Contenus » des Versions imprimables et « Compilation » issue de la compilation d'une page. (Menu à gauche d'une page wikimedia.)&lt;br /&gt;
Il est aussi possible d'éditer et d'enregistrer manuellement une telle liste.

===== Les lignes qui méritent notre attention =====
La ligne 65 dans l'édition du 26 avril 2020 :&lt;br /&gt;
&lt;small&gt;{{bleu|Remarque : ''$Projet'' est un répertoire et ''$1.contenu'' est un fichier.}}&lt;/small&gt;
&lt;syntaxhighlight lang=&quot;bash&quot;&gt;cat $Projet/$1.contenu | sed &quot;s/\[\[/$SitePrefix/g&quot; | tr '|' '\n' | sed &quot;s/\]\]//g&quot; | grep &quot;wiki&quot; &gt; $Projet/$1.list&lt;/syntaxhighlight&gt;
Cette ligne prend en compte le texte de la page '''''Contenus''''' de la '''''Version imprimable''''' du livre pour créer le fichier de liste.

La ligne elle même signifie : &lt;br /&gt;
&lt;pre&gt;
&amp;nbsp; ouvrir le flux du fichier '''''$Projet/$1.contenu'''''
| filtrer et remplacer la chaîne &quot;[[&quot; par le préfixe du site $SitePréxixe (chaîne &quot;https://fr.wikibooks.org/wiki/&quot;),
| filtrer et remplacer le caractère '|' par le caractère '\n' (retour-chariot), (si ce caractère '|' existe !),
| filtrer et supprimer la chaîne &quot;]]&quot;, (si cette chaîne existe !),
| fitrer et ne retenir que la ligne qui contient la chaîne &quot;wiki&quot;,
&amp;nbsp; &gt; rediriger le flux vers la création du fichier '''''$Projet/$1.list'''''.&lt;/pre&gt;

La ligne 79 de la même édition :
&lt;syntaxhighlight lang=&quot;bash&quot;&gt;cat $Projet/$1.compilé | sed &quot;s/:\[\[/$SitePrefix/g&quot; | tr '|' '\n' | sed &quot;s/\]\]//g&quot; | grep &quot;wiki&quot; &gt; $Projet/$1.list&lt;/syntaxhighlight&gt;
Cette ligne prend en compte le texte de la page '''''Compilation''''' de la '''''Version compilée''''' du livre pour créer le fichier de liste.

Le commentaire est le même que pour la ligne précédent à ceci près qu'au premier filtre on supprime aussi le caractère ':' du début de ligne des fichiers issus de la compilation.

===== Tests de la commande =====
# Copier le code du chapitre Lister dans un éditeur et enregistrer ce code dans le répertoire Annexe sous le nom « lister » ou « lister.sh »
# Autoriser l'exécution du code par la commande '''chmod 777 ~/Annexe/lister'''
# Copier le « Contenus » de la ''Version imprimable'' vu précédemment dans ce sous chapitre,
# Enregistrer ce « Contenus » dans le fichier '''Annexe/LivreTest/LivreTest.contenus'''
# Lancer la commande '''./lister LivreTest'''
Vérifier que l'on obtient les fichier 
:'''~/Annexe/LivreTest/LivreTest.list''' :
&lt;pre&gt;
https://fr.wikibooks.org/wiki/Utilisateur:Goelette Cardabela/Sandbox/LivreTest
https://fr.wikibooks.org/wiki/Utilisateur:Goelette Cardabela/Sandbox/LivreTest/ArticleUn
https://fr.wikibooks.org/wiki/Utilisateur:Goelette Cardabela/Sandbox/LivreTest/ArticleDeux
https://fr.wikibooks.org/wiki/Utilisateur:Goelette Cardabela/Sandbox/LivreTest/ArticleTrois&lt;/pre&gt;
Vérifier que l'on a modifié les autorisations du fichier LivreTest.contenus afin qu'il ne puisse pas être supprimé par mégarde lors des manipulations de fichiers. &lt;br /&gt;
:'''~/Annexe/LivreTest/LivreTest.prj''' :
&lt;pre&gt;
LivreTest
LivreTest/ArticleUn
LivreTest/ArticleDeux
LivreTest/ArticleTrois
&lt;/pre&gt;
Vérifier avec la commande : ''~/Annexer$ ls -l ~/Annexer/LivreTest/LivreTest.contenu'', que le fichier LivreTest.contenu est en lecture seule pour tous les utilisateurs : -r--r--r--.
 -r--r--r-- 1 gc gc 353 avril  3 16:57 /home/gc/Annexer/LivreTest/LivreTest.contenu
{{Nouvelle page imprimée}}

=== Télécharger (module) ===
; (Download) :Télécharger le code source de la page ou la sous page grâce à la liste obtenue dans la section lister.
; Documentation :
  La commande ./télécharger &lt;wikilivre&gt; télécharge la page complète d'une
     &quot;page&quot; ou d'un &quot;livre&quot; de wikilivre. Elle crée les répertoires de travail
     avec la même hiérarchie que dans la page originale du livre, ou de sa
     version imprimable, ou de sa page de compilation.
  
   On procède par le téléchargement complet de la page et des sous-pages du
     livre. Viennent ensuite la création des répertoires de travail des pages
     qui composent le livre, puis on copie des pages html dans ces répertoires.
     Pendant tout ce processus des lichiers temporaires de liste sont créés en
     local:
     $Projet/$1.locale.list qui est une image locale de la structure du livre.
     $Projet/$1.mainPage. lien local vers l' &quot;Article maître du livre&quot;
     $Projet/$1.dirs : liste des sous-pages de l'article principal du livre.
     
; Organigramme :   
  ## télécharger ############
   télécharger dans le répertoire de travail, la structure complète du livre.
   Déplacer les pages html dans des sous-répertoires de travail pour documenter les pages et sous pages
     créer une liste locale vers les répertoires téléchargés $Projet/$1.locale.list
   Copier les fichiers html dans les répertoires respectifs.
     créer un fichier avec le nom de la page $Projet/$1.mainPage.
     initialiser la variable $mainPage
     créer un fichier des répertoires de travail à créer. 
     copier les pages et sous pages html dans les répertoires respectifs.
   quitter le programme d'essai et passer à la création de la page &quot;Annexe&quot; des articles.

{{Boîte déroulante début|titre=Code du module télécharger|styleFrame=width:100%;|fondtitre=#F0F0F0&lt;!--|styleTitre=color:white;&lt;!|style=headerbleu--&gt;}}
{{/télécharger}}
{{Boîte déroulante fin}}

==== Test du module « télécharger » ====
Le but est de télécharger tous les fichiers html qui composent le livre grâce au fichier de liste obtenu précédemment.

===== Les lignes qui méritent notre attention =====
ligne48 de la version du 26 avril 2020
&lt;Syntaxhighlight lang=&quot;bash&quot;&gt;
wget -r -linf -k -p -E  -i $1.list -o wget-log.txt
echo &quot;----------&quot;
&lt;/Syntaxhighlight&gt;
Cette ligne crée la '''structure complète''' des répertoires et fichiers, depuis la racine du site, jusqu'aux fichiers html qui composent le livre.

{{Remarque| Il est à noter que les lignes du fichier de liste ''$1.list'' sont des liens internet vers des pages html bien que l'extension ''.html'' ne termine pas la ligne. {{Orange|Cette remarque est très importante car le dernier champ de chaque ligne n'est pas un répertoire, contrairement aux champs précèdents qui peuvent y faire penser.}} On peut utiliser cette ligne comme une ligne de texte ordinaire. Il faudra s'en souvenir, car nous utilisons le caractère '/' comme séparateur de champ qui fait penser à des répertoires. Des commandes comme ''cd'', ''cp'', et toute commandes qui a un rapport avec les répertoires peuvent ne pas vouloir s'exécuter.}}

; Exemple: lignes 80 à 96 de la version du 26avril 2020
&lt;Syntaxhighlight lang=&quot;bash&quot;&gt;
#O   copier les pages et sous pages html dans les répertoires respectifs.
      while read line
      do
        echo &quot;$line&quot;.html | sed &quot;s/https:\/\///g&quot; | tr '\n' ' ' &gt; source
        read Source &lt; source
        echo &quot;Source = $Source&quot;

        echo &quot;$line&quot; | awk -F&quot;/&quot; '{ print $NF }'| tr '\n' '/' &gt; destination 
        read dir &lt; destination
        mkdir $dir
        echo &quot;$line&quot;.html | awk -F&quot;/&quot; '{ print $NF }' &gt;&gt; destination
        read Destination &lt; destination
        echo &quot;Destination = $Destination&quot;
        echo &quot;Copier : cp ./$Source $Destination&quot;
        cp -f &quot;./$Source&quot; &quot;$Destination&quot;
      done &lt; $Projet/$1.list
      rm source ; rm destination
&lt;/syntaxhighlight&gt;
:ligne  4 : On ajoute ''.html'' à la variable ''$ligne'' puis on copie dans le fichier ''source'' local, toute la ligne en supprimant ''https://''.
:ligne  5 : On affecte la variable '''''S'''ource'' le texte enregistré dans le fichier '''''s'''ource''
:ligne  6 : On affiche à la console le nom de la variable $Source :
:: Exemple pour la première ligne : ''fr.wikibooks.org/wiki/Utilisateur:Goelette Cardabela/Sandbox/LivreTest.html''

:ligne  8 : On copie le dernier champ de la ligne dans le fichier ''destination''. {{bleu|C'est du ''texte'' !}}
:: Exemple pour la première ligne : ''LivreTest''
:ligne 10 : On en profite pour créer le répertoire correspondant à ce champ dans le répertoire courant.
:: ''~/Annexer/LivreTest'' est le répertoire racine du projet, ''~/Annexer/LivreTest/LivreTest'' sera le répertoire de travail de la page principale.
:ligne 11 : On ajoute à ce dernier champ l'extension ''.html'' que l'on ''concatène'' au fichier ''destination''. {{bleu|C'est une ''url'' !.}}
:ligne 15 : On copie les fichiers ''html'' du répertoire ''source'' (local) vers le répertoire de ''destination'' (local).
:: On obtient finalement le lien ''~/Annexer/LivreTest/LivreTest/LivreTest.html'' où la variable du projet ''$Projet'' est ''~/Annexer/LivreTest''.
:: Il faudrait ajouter ''$Projet/'' devant ''source'' et ''destination'' pour être certain de copier dans le répertoire de travail racine.

===== Tests de la commande ''télécharger'' =====
    Copier le code du chapitre Télécharger dans un éditeur et enregistrer ce code dans le répertoire Annexe sous le nom « télécharger » ou « télécharger.sh »
    Autoriser l'exécution du code par la commande chmod 777 ~/Annexe/télécharger
    Lancer la commande ./télécharger LivreTest

On devrait obtenir :

;Structure complète du téléchargement avec la commande ''wget -r -linf -k -p -E  -i $1.list -o wget-log-télécharger.txt''
 ~/Annexer$ '''ls -R LivreTest/fr.wikibooks.org'''
&lt;pre&gt;LivreTest/fr.wikibooks.org:
robots.txt  wiki

LivreTest/fr.wikibooks.org/wiki:
'Utilisateur:Goelette Cardabela'

'LivreTest/fr.wikibooks.org/wiki/Utilisateur:Goelette Cardabela':
Sandbox

'LivreTest/fr.wikibooks.org/wiki/Utilisateur:Goelette Cardabela/Sandbox':
LivreTest  LivreTest.html

'LivreTest/fr.wikibooks.org/wiki/Utilisateur:Goelette Cardabela/Sandbox/LivreTest':
ArticleDeux.html  ArticleTrois.html  ArticleUn.html
&lt;/pre&gt;

;Liste des {{violet|répertoires}} créés avec la commande ''télécharger LivreTest''.
 $ '''ls -a -1 ~/Annexer$/LivreTest'''
{{violet|&lt;b&gt;.&lt;br /&gt;
..&lt;br /&gt;
ArticleDeux&lt;br /&gt;
ArticleTrois&lt;br /&gt;
ArticleUn&lt;br /&gt;
fr.wikibooks.org&lt;br /&gt;
LivreTest&lt;/b&gt;}}&lt;br /&gt;
LivreTest.compilé&lt;br /&gt;
LivreTest.compilé.test&lt;br /&gt;
LivreTest.contenu&lt;br /&gt;
LivreTest.contenu.test&lt;br /&gt;
LivreTest.dirs&lt;br /&gt;
LivreTest.list&lt;br /&gt;
LivreTest.locale.list&lt;br /&gt;
LivreTest.mainPage&lt;br /&gt;
LivreTest.prj&lt;br /&gt;
wget-log-télécharger.txt
{{Nouvelle page imprimée}}
=== Ajouter sclt (module) ===
; (Adding sclt) or (Append sclt)
Ajouter la section article, source, licence, contributeur(s).
; Documentation 
&lt;pre&gt;
   La commande ./ajouter-sclt &lt;wikilivre&gt; commence par créer la page
     $Projet/$1.sclt comme elle apparaîtra dans la première partie de la page
     &quot;Annexe&quot; du livre avec les titre en wikitexte et les sections :
     Références: toutes celles qui n'ont pas été affichées dans les pages.
     Contenus: liens établis vers la page du livre et les articles (sous-pages)
     Source de l'édition: lien vers la page qui a permis de créer l' &quot;Annexe&quot;.
     Sources licences et contributeurs des articles: ne concerne que les
     articles, les sous-pages.&lt;/pre&gt;
     
; Organigramme 
&lt;pre&gt;
  ## ajouter_sclt ###########
   but final: créer la page &quot;Annexe&quot; avec les pages Projet.sclt et Projet.scli.
   ---
   créer la page PageSclt=$Projet/$1.sclt et afficher son contenu.
   ajouter la balise &lt;references /&gt;
   ajouter le lien vers : la page du livre imprimable, et vers les articles.
   créer la section 'Article', 'Source', 'licence', 'Contributeur(?)'
     ajouter le texte :
     Les ''sources'' listées pour chaque article fournissent des informations
     de licence plus détaillées, y compris le statut des droits d'auteurs, les
     détenteurs de ces droits et les conditions de licence.
   ou, valider l'un ou l'autre de ces textes : 
     Les textes sont disponibles avec leurs licences respectives, cependant
     d’autres termes peuvent s’appliquer.&lt;br /&gt;
     Voyez les termes d’utilisation pour plus de détails :&lt;br /&gt; 
     https://wikimediafoundation.org/wiki/Conditions_d'utilisation
   Créer ou recréer le fichier de liste $Projet/$1.pj
   tant qu'il y a des lignes dans le fichier de liste,
      afficher la ligne lue,
      extraire et copier toutes les chaînes de caractères du fichier html
        $ligne.html dans le fichier $ligne.str et les dupliquer à l'écran
      créer les fichiers de documentation des pages :
      article,
      source,
      auteur(s).&lt;/pre&gt;   

{{Boîte déroulante début|titre=Code du module ajouter_sclt|styleFrame=width:100%;|fondtitre=#F0F0F0&lt;!--|styleTitre=color:white;|style=headerbleu--&gt;}}
{{/ajouter_sclt}}
{{Boîte déroulante fin}}

==== Tests du module ajouter_sclt ====
Le but est de créer l'entête de la page Annexe et d'y ajouter la liste des ''articles avec les sources, licences, contributeurs''.

Les numéros des pages n'est possibles que lorsque la version imprimable aura été créée, avec une post-indexation et une post-annexion.

===== Les lignes qui méritent notre attention =====
'''Remarque : '''Dans les explications du code on entend par '''''projet''''' le nom du projet entré en paramètre dans la commande ''./ajouter_sclt projet''

Lignes 117-119 de la version du 29 avril 2020
 #O    extraire et copier toutes les chaînes de caractères du fichier html
 #O      $ligne.html dans le fichier $ligne.str et les dupliquer à l'écran
       mkd -pws '**' $Projet/$ligne/$ligne.html $Projet/$ligne/$ligne.tmp | tr ',' '\n' &gt; $Projet/$ligne/$ligne.str
'''mkd''' n'est pas inclus dans les distributions linux. les paquets et sources sont téléchargeable pour tous les systèmes d'exploitation.&lt;br /&gt;
Pour toute informations complémentaires : [[w:mkd (commande unix)|mkd (commande unix)]], [[Mkd_(Extracteur_de_documents)]]&lt;br /&gt;
Cette ligne de commandes extrait tous les commentaires avec une sortie dans un fichier ''projet.tmp'' ainsi que vers la ''sortie standard'' &lt;small&gt;''(l'écran par défaut)''&lt;/small&gt;  où elle est reprise pour être listée en colonne grâce au séparateur de chaînes ','.

Lignes 124-130
 #O    article,
       if [ $ligne != $1 ]
       then  
         echo &quot;'''&quot;$ligne&quot;'''&quot; &gt;&gt; $PageSclt
       fi
       echo &quot;'''&quot;$ligne&quot;'''&quot; &gt; $Projet/$ligne/$ligne.article
       cat $Projet/$ligne/$ligne.article
'''$ligne''' est la variable lue ligne par ligne du fichier de liste ''projet.pj'' dans une boucle ''tant qu'il y a des lignes à lire, faire ...''&lt;br /&gt;
Cette ligne est aussi le nom de l''''article''' qui va être analysé. Si $ligne n'est pas le nom du livre (de l'article principal) le nom de l'article est ajouté à la page $PageSclt.

Lignes 132-139 
 #O    source,
       echo -n &quot;, ''source : ''https://&quot;$Site&quot;/w/index.php?oldid=&quot; &gt; $Projet/$ligne/$ligne.RevisionId
       cat $Projet/$ligne/$ligne.str | grep -n -m 1 -i -e wgRevisionId | tr -d ':' | sed &quot;s/\&quot;/%/g&quot; | cut -d'%' -f3 &gt;&gt; $Projet/$ligne/$ligne.RevisionId
       if [ $ligne != $1 ]
       then          
         cat $Projet/$ligne/$ligne.RevisionId  &gt;&gt; $PageSclt
       fi
       cat $Projet/$ligne/$ligne.RevisionId
       
La deuxième ligne crée le fichier de ''.RevisionId'' dans lequel on écrit une chaîne de caractères sans retour à la ligne.&lt;br /&gt;
La troisième ligne :
 &amp;nbsp; cat ouvre le flux du fichier ''projet.str''
 | retient la ligne qui contient wgRevisionId,
 | supprime le caractère ':' qu'il contient
 | remplace les caractères '&quot;' par le caractère '%'
 | coupe la chaîne à l'endroit où se trouvent les caractères '%' et sélectionne le champ 3.
 &gt;&gt; la chaîne résultante est ajoutée au fichier ''projet.RevisionId''

Lignes 152-164
 1 #O    license :
 2      echo -n &quot;, ''licence : ''&quot; &gt; $Projet/$ligne/$ligne.license
 3   #T cat $Projet/$ligne/$ligne.str | grep -n -m 1 -i -e license | sed &quot;s/\&quot;\//%\//g&quot; | cut -d'%' -f4 &gt;&gt; $Projet/$ligne/$ligne.license
 4      cat $Projet/$ligne/$ligne.str | grep -n -m 1 -i -e license | sed &quot;s/\&quot;\//%\//g&quot; | tr '&quot;' '%' | cut -d'%' -f4 &gt;&gt; $Projet/$ligne/$ligne.license
 5   #T cat $Projet/$ligne/$ligne.str | grep -n -m 1 -i -e license | sed &quot;s/\&quot;\//%\//g&quot; | cut -d'%' -f2 | sed &quot;s/\/\//https:\/\//g&quot; &gt;&gt; $Projet/$ligne/$ligne.license
 6      if [ $ligne != $1 ]
 7      then  
 8        cat $Projet/$ligne/$ligne.license &gt;&gt; $PageSclt
 9      fi
 10      cat $Projet/$ligne/$ligne.license
 11      #
 12      #P spécial pour bas de page fr ## 
 13      cat $Projet/$ligne/$ligne.str | grep -n -m 1 -i -e footer-info-copyright | sed &quot;s/\&quot;\//%\//g&quot; | tr '&quot;' '%' | cut -d'%' -f4  &gt; $Projet/$ligne/$ligne.licence

* La ligne 2 initialise dans le répertoire $Projet/$ligne/, le fichier $ligne.license de l'article $ligne.
 exemple : le répertoire de l'ArticleUn est ~/Annexer/LivreTest/ArticleUn/ dans lequel on va écrire ArticleUn.license
* Les lignes 3 et 5 sont des commentaires de tests à l'usage des programmeurs.&lt;br /&gt;
* La ligne 4 produit les fichier .license dans le répertoire de l'article correspondant.&lt;br /&gt;
* La ligne 5 :
 &amp;nbsp; cat ouvre le flux du fichier ''projet.str'',
 | retient la ligne qui contient ''license'',
 | sélectionne la chaîne &quot;/ et la remplace par la chaîne %/,
 | supprime '%' et coupe la chaîne au caractère '%' puis sélectionne le deuxième tronçon (-f2), il existe aussi (-f2-3, -f2-4) etc.
 | remplacer les caractères // par https://
 &gt;&gt; copier la chaîne dans le fichier ''projet.license''
* Les lignes 6 à 9 ajoutent la '''''license''''' à $PageSclt si la licence concerne un article et non la page principale du livre.&lt;br /&gt;
* La ligne 10 affiche à l'écran le contenu du fichier qui vient d'être créé.&lt;br /&gt; 
* La ligne 13 : mêmes remarques que précédemment par sélection du bas de page en français avec '''''licence'''''.

Lignes 155-159
 #O    auteur(s).  
       echo -n &quot;, ''auteur(s) : ''&quot; &gt; $Projet/$ligne/$ligne.auteur
       cat $Projet/$ligne/$ligne.str | grep -n -m 1 -i -e wgRelevantUserName | sed &quot;s/\&quot;/%/g&quot; | cut -d'%' -f4 &gt;&gt; $Projet/$ligne/$ligne.auteur
       if [ $ligne != $1 ]
       then  
         cat $Projet/$ligne/$ligne.auteur &gt;&gt; $PageSclt
       fi
       cat $Projet/$ligne/$ligne.auteur     
* mêmes remarques que pour les actions précédentes.

===== Tests de la commande =====
; fichier obtenu avec la commande ~/Annexer/ajouter_sclt LivreTest
 '''cat LivreTest.sclt''' dans le répertoire du projet ''LivreTest''
 
&lt;pre&gt;
= Annexe =

== Références ==
&lt;references /&gt;
 
{{Nouvelle page imprimée}}
== Contenus ==
&lt;small&gt;
https://fr.wikibooks.org/wiki/Utilisateur:Goelette_Cardabela/Sandbox/LivreTest

https://fr.wikibooks.org/wiki/Utilisateur:Goelette_Cardabela/Sandbox/LivreTest/ArticleUn

https://fr.wikibooks.org/wiki/Utilisateur:Goelette_Cardabela/Sandbox/LivreTest/ArticleDeux

https://fr.wikibooks.org/wiki/Utilisateur:Goelette_Cardabela/Sandbox/LivreTest/ArticleTrois

&lt;/small&gt;
=== Source de cette édition ===
&lt;small&gt;
https://fr.wikibooks.org/wiki/Utilisateur:Goelette_Cardabela/Sandbox/LivreTest
&lt;/small&gt;
 
{{Nouvelle page imprimée}}
== Sources licences et contributeurs des articles ==

Les ''sources'' listées pour chaque article fournissent des informations de licence plus détaillées, y compris le statut des droits d'auteurs, les détenteurs de ces droits et les conditions de licence.
 
&lt;div style=&quot;font-size:72.5%;&quot;&gt;

'''ArticleUn'''
, ''source : ''https://fr.wikibooks.org/w/index.php?oldid=632571
, ''licence : ''https://creativecommons.org/licenses/by-sa/3.0/
, ''auteur(s) : ''Goelette Cardabela

'''ArticleDeux'''
, ''source : ''https://fr.wikibooks.org/w/index.php?oldid=632572
, ''licence : ''https://creativecommons.org/licenses/by-sa/3.0/
, ''auteur(s) : ''Goelette Cardabela

'''ArticleTrois'''
, ''source : ''https://fr.wikibooks.org/w/index.php?oldid=632573
, ''licence : ''https://creativecommons.org/licenses/by-sa/3.0/
, ''auteur(s) : ''Goelette Cardabela

&lt;/div&gt;
{{Nouvelle page imprimée}}
&lt;/pre&gt;
; Apparence provisoire un peu arrangée pour ne pas intervenir sur l'index des sections de cet article ...
----
&lt;big&gt;''' Annexe '''&lt;/big&gt;

''' Références '''
&lt;references /&gt;
 
{{Nouvelle page imprimée}}
''' Contenus '''

&lt;div style=&quot;font-size:85%;&quot;&gt;
https://fr.wikibooks.org/wiki/Utilisateur:Goelette_Cardabela/Sandbox/LivreTest

https://fr.wikibooks.org/wiki/Utilisateur:Goelette_Cardabela/Sandbox/LivreTest/ArticleUn

https://fr.wikibooks.org/wiki/Utilisateur:Goelette_Cardabela/Sandbox/LivreTest/ArticleDeux

https://fr.wikibooks.org/wiki/Utilisateur:Goelette_Cardabela/Sandbox/LivreTest/ArticleTrois

'''Source de cette édition''' 

https://fr.wikibooks.org/wiki/Utilisateur:Goelette_Cardabela/Sandbox/LivreTest
&lt;/div&gt;
 
{{Nouvelle page imprimée}}
''' Sources licences et contributeurs des articles '''

Les ''sources'' listées pour chaque article fournissent des informations de licence plus détaillées, y compris le statut des droits d'auteurs, les détenteurs de ces droits et les conditions de licence.
 
&lt;div style=&quot;font-size:72.5%;&quot;&gt;

'''ArticleUn'''
, ''source : ''https://fr.wikibooks.org/w/index.php?oldid=632571
, ''licence : ''https://creativecommons.org/licenses/by-sa/3.0/
, ''auteur(s) : ''Goelette Cardabela

'''ArticleDeux'''
, ''source : ''https://fr.wikibooks.org/w/index.php?oldid=632572
, ''licence : ''https://creativecommons.org/licenses/by-sa/3.0/
, ''auteur(s) : ''Goelette Cardabela

'''ArticleTrois'''
, ''source : ''https://fr.wikibooks.org/w/index.php?oldid=632573
, ''licence : ''https://creativecommons.org/licenses/by-sa/3.0/
, ''auteur(s) : ''Goelette Cardabela

&lt;/div&gt;

----
{{Nouvelle page imprimée}}
=== {{50}} Ajouter scli ''(trois modules indépendants)'' ===
; (Adding scli) or (Append scli)
Ajouter la section image, source, license, contributeurs(s) à la page ''Annexe''.
==== Les fichier de commandes scli ====
;On peut concevoir deux façon ce référencer les images:
* '''La version globale : '''on extrait les images de la page principale.
 &lt;div style=&quot;font-size:85%;&quot;&gt;'''Illustration 1''' ''Source : ''..., ''Licence : ''..., ''Contributeur : ''...
 '''Illustration 2''' ''Source : ''..., ''Licence : ''..., ''Contributeur : ''...
 '''Illustration 3''' ''Source : ''..., ''Licence : ''..., ''Contributeur : ''...
 '''Illustration 4''' ''Source : ''..., ''Licence : ''..., ''Contributeur : ''...
 &lt;/div&gt;
* '''La version par article : '''les images sont extraites de chaque article, ce qui donne :
 '''Article 1 :'''
 &lt;div style=&quot;font-size:85%;&quot;&gt;'''Illustration 1.0''' ''Source : ''..., ''Licence : ''..., ''Contributeur : ''...
 '''Illustration 1.n''' ''Source : ''..., ''Licence : ''..., ''Contributeur : ''...&lt;/div&gt;
 
 '''Article 2 :'''
 &lt;div style=&quot;font-size:85%;&quot;&gt;'''Illustration 2.0''' ''Source : ''..., ''Licence : ''..., ''Contributeur : ''...
 '''Illustration 2.n''' ''Source : ''..., ''Licence : ''..., ''Contributeur : ''...
 &lt;/div&gt;
{{Nouvelle page imprimée}}
===== {{100}} ''Version classique sclic (module)'' =====
&lt;!--{{En cours}}--&gt;
; Documentation programmeur
&lt;pre&gt;
  ## ajouter_sclic ##########
   Remarques :
   à ce stade, Les fichiers $1.list, $1.prj, $1.pj, $1.sclt, $.mainPage sont
     cencés préexister dans le répertoire racine du projet $1.
   De même, les fichiers &lt;Article&gt;.str sont sensés préexister dans les
     répertoires &lt;Article&gt; correspondants.
   seront créés :
   dans le rétoire de travail racine ~/Annexe/$1/. : le fichier $1.sclic qui
     vient compléter le fichier $1.sclt afin de créerle fichier &quot;Annexe&quot;,
   dans le sous-répertoire de travail ~/Annexe/$1/$1/. :
     $1.files, $1.pict, $1.illustrations, $1.links, html.list et
     les fichiers d'images .title, .source, .license, .auteur.
&lt;/pre&gt; 
; Organigramme programmeur
&lt;pre&gt;
   inclure le fichier d'entête header.sh
  ## ajouter_scli_classique ###########
     ligne de commande &quot;ajouter_sclic &lt;livre&gt;&quot; où &quot;livre&quot; = variable $1
   PageScliC sera la variable d'identifiation du fichier &quot;livre.sclic&quot; placé
      dans le répertoire&quot; de travail du projet : $Projet = ~/Annexe/$1/.
   se placer dans le sous-répertoire de travail &quot;$Projet/$1/&quot;
     rappel : $Projet = ~/Annexer/$1 d'où ss-rep = ~/Annexer/$1/$1/.
   créer la section 'Image', 'Source', 'licence', 'Contributeur(?)'
     ajouter le texte : style PediaPress ou personnalisé.; Organigramme 
   inclure le fichier d'entête header.sh
  ## ajouter_scli_classique ###########
     ligne de commande &quot;ajouter_sclic &lt;livre&gt;&quot; où &quot;livre&quot; = variable $1
   PageScliC sera la variable d'identifiation du fichier &quot;livre.sclic&quot; placé
      dans le répertoire&quot; de travail du projet : $Projet = ~/Annexe/$1/.
   se placer dans le sous-répertoire de travail &quot;$Projet/$1/&quot;
     rappel : $Projet = ~/Annexer/$1 d'où ss-rep = ~/Annexer/$1/$1/.
   créer la section 'Image', 'Source', 'licence', 'Contributeur(?)'
     ajouter le texte : style PediaPress ou personnalisé.
     style PediaPress :
     Les ''sources'' listées pour chaque article fournissent des informations
     de licence plus détaillées, y compris le statut des droits d'auteurs, les
     détenteurs de ces droits et les conditions de licence.
     ou: (imprimer l'un ou l'autre de ces textes)
     style personnalisé :
     Les textes sont disponibles avec leurs licences respectives, cependant
     d’autres termes peuvent s’appliquer.&lt;br /&gt;
     Voyez les termes d’utilisation pour plus de détails :&lt;br /&gt; 
     https://wikimediafoundation.org/wiki/Conditions_d'utilisation
   créer les fichiers de documentation des images de la page principale.
     ouvrir le flux $Projet/$1/$1.str de la page principale et sélectionner les
     chaînes de caractères contenant fichier:, file:, image:, dans le nouveau
     fichier $Projet/$1/$1.files
   télécharger les fichiers d'images depuis le serveur wikimedia.
   initialiser le fichier de liste html.list avec un texte vide.
   lister les fichiers d'images dans l'ordre d'impression ou de l'affichage,
     à laide de la liste $1.links.
   créer les fichiers de documentation des pages :
   tant qu'il y a des liens (locaux) dans le fichier d'images html.list
     afficher la ligne lue,
     sélectionner les chaînes du fichier d'image et les transférer dans 
       images,
       sources,
       licence,
       auteur(s).
     terminer la page $PageScliC
   fin du tant qu'il y a des lignes
   terminer la page $PageScliC
&lt;/pre&gt;
{{Boîte déroulante début|titre=Code ajouter_sclic|styleFrame=width:100%;|fondtitre=#F0F0F0&lt;!--|styleTitre=color:white;|style=headerbleu--&gt;}}
{{/ajouter_sclic}}
{{Boîte déroulante fin}}

===== Programme des tests du module ajouter_sclic =====

===== Les lignes qui méritent notre attention =====

===== Tests de la commande ajouter_sclic =====

====== Fichiers obtenus avec la commande ~/Annexer/ajouter_sclic LivreTest ======
;contenu du fichier /home/jpl/Annexer/LivreTest/LivreTest.pj :
 https://commons.wikimedia.org/wiki/File:Commerce_de_communautés_indigènes.JPG
 https://commons.wikimedia.org/wiki/File:Fernando_Botero_(2018).jpg
 https://commons.wikimedia.org/wiki/File:Gabriel_Garcia_Marquez_-_Fresque.jpg
 https://commons.wikimedia.org/wiki/File:Pano_Plazo_Botero.jpg
 
; fichier LivreTest.sclic
&lt;pre&gt;
 == Sources des images licences et contributeurs ==
&lt;small&gt;Les ''sources'' listées pour chaque illustration fournissent des informations de licence plus détaillées, y compris le statut des droits d'auteurs, les détenteurs de ces droits et les conditions de licence.&lt;/small&gt;
 
&lt;div style=&quot;font-size:72.5%;&quot;&gt;
'''Illustration : '''Gabriel Garcia Marquez - Fresque.jpg
, ''source : ''https://fr.wikibooks.org/w/index.php?title=File:Gabriel_Garcia_Marquez_-_Fresque.jpg
, ''licence : ''CC BY-SA 4.0 
, ''auteur(s) : ''User:Pohline_Blast_Clm

'''Illustration : '''Commerce de communautés indigènes.JPG
, ''source : ''https://fr.wikibooks.org/w/index.php?title=File:Commerce_de_communautés_indigènes.JPG
, ''licence : ''CC BY-SA 3.0 
, ''auteur(s) : ''User:Goelette.Cardabela

'''Illustration : '''Fernando Botero (2018).jpg
, ''source : ''https://fr.wikibooks.org/w/index.php?title=File:Fernando_Botero_(2018).jpg
, ''licence : ''CC BY 3.0 
, ''auteur(s) : ''-

'''Illustration : '''Pano Plazo Botero.jpg
, ''source : ''https://fr.wikibooks.org/w/index.php?title=File:Pano_Plazo_Botero.jpg
, ''licence : ''Public domain
, ''auteur(s) : ''User:Scabredon~commonswiki

&lt;/div&gt;
{{Nouvelle page imprimée}}
&lt;/pre&gt;
{{Nouvelle page imprimée}}
====={{0}} ''Version personnalisée par article sclip (module)'' =====
Cette commande est composée de trois parties : 
# Le module principal. Il prépare l'entête de la section ''Images, source, licence, auteur'' puis exécute l'un ou l'autre des modules de récupération des images.
# Le module de récupération des images de Commons dans le sous-répertoire de la page du livre.
# Le module de récupération des images sur le site Wikilivres.

Chacun de ces modules peut être éprouvé séparément.

Il n'est pas envisagé de détailler l'explication des lignes de codes, 
on peut considérer que la compréhension des codes de commandes bash est suffisamment assimilée à ce niveau de la programmation.&lt;br /&gt; Les explications éventuelles se trouvent au sein du code de programmation.
{{Nouvelle page imprimée}}
====={{100}} Entête ajouter_sclip =====
{{RemarqueIndex|Ce module est devenu l'entête des modules sclipco.inc et sclipwb.inc pour faciliter l'écriture de la page principale ''Annexer'', il peut être éprouvé séparément comme tous les modules de ce programme.}}
; Documentation :
## ajouter_sclic ##########
   Le répertoire de travail est le sous répertoire du projet $Projet/$1/$1
     plus précisément : ~/Annexer/&lt;nom du livre&gt;/&lt;nom du livre&gt;
     &lt;nom du livre&gt; pourrait être la sous-page 'Version imprimable' du livre
     et peut être considéré comme un 'Article'.

 Remarques :
   à ce stade, Les fichiers $1.list, $1.prj, $1.pj, $1.sclt, $.mainPage sont  
   censés préexister dans le répertoire racine du projet $1 (nom du livre).
   De même, les fichiers &lt;Article&gt;.str sont sensés préexister dans les
   répertoires &lt;Article&gt; correspondants.
 Seront créés :
   * Dans le répertoire de travail racine ~/Annexe/$1/. :
     le fichier $1.sclic qui vient compléter le fichier $1.sclt afin de créer
     le fichier &quot;Annexe&quot;,
   * dans le sous-répertoire de travail ~/Annexe/$1/$1/. :
     $1.files, $1.pict, $1.illustrations, $1.links, html.list et
     les fichiers d'images .str .title, .source, .license, .auteur.

## ajouter_sclip ##########
 Ce module est l'entête des programmes sclipco.inc et sclipwb.inc du
   programme Annexer :
   Si une des options -pc ou -pb de la ligne de commande 'annexer &lt;livre&gt;'
   est validée, le module ajouter_sclip est exécuté puis un des modules
   sclipco ou sclipwb est exécutés selon l'option choisie -pc ou -pb.
   (-pc pour images sur 'Commons', -pb pour images sur 'Wikilivres'.)
 Structure, organisation des fichiers :
 Les répertoires de travail sont les répertoires des 'Articles'.
 Le fichier $Projet/$ligne/$ligne.str a été créé avec la commande
   ajouter_sclt
 Remarques :
 1.les images extraites avec le fichier de commandes ajouter_sclic peuvent
   être copiées dans les répertoires des articles correspondants lorsqu'ils
   sont identifiés dans leurs répertoires respectifs pour créer une option
   d'images téléchargées de 'Commons'.
 2.le fichier de conversions url/html vers utf8 a été inclus dans l'entête
   header.sh depuis le 13 mai 2020
; Documentation programmeur :
&lt;pre&gt;
2:#P Nom du fichier de commandes : ajouter_sclip
3:#P Syntaxe : &quot;ajouter_sclip &lt;nom du livre&gt;&quot;
4:#P Exemple : &quot;./ajouter_sclip LivreTest&quot; à la console.
5:#P Date de création :  9 mai 2020
6:#P Modifié le : 15 mai 2020 par GC pour ajouter une version d'images depuis
7:#P   wilimedia commons
8:#P Modifié le : 16 mai 2020 par GC pour séparer les fichier en trois parties
9:#P   Partie 1 : entête des deux versions de téléchargement, 'ajouter_sclip'.
10:#P   Partie 2 : fichier de téléchargement des images sur wikibooks, sclipwb.inc
11:#P   Partie 3 : fichier de téléchargement des images sur coomons, sclipco.inc
12:#P Version sur WikiLivres le : 17 mai 2020
13:#P
14:#P LES FICHIERS DE COMMANDES 
15:#P
16:#P## header.sh ##############
17:#P header.sh, a créé le répertoire des commandes si celui-ci ne préexistait pas
18:#P   il a vérifié la validité ou invalidé de ligne de commande, initialisé
19:#P   les variables $Projet, $Site, $SitePrefix, vérifié l'existence des
20:#P   fichiers de liste &quot;$Projet/$1&quot;.list et &quot;$Projet/$1&quot;.prj, puis affiché le
21:#P   contenu du répertoire de travail.
22:#P
23:#P## lister #################
24:#P lister a créé le fichier de liste $Projet/$1.list par l'extraction du 
25:#P   fichier $Projet/$1.contenu, copie de la page &quot;Contenus&quot; de la version
26:#P   imprimable du livre, ou du fichier $Projet/$1.compilé issu d'une
27:#P   compilation destinée à la publication par PediaPress.
28:#P   il crée aussi le fichier $Projet/$1.prj qui conserve l'ordre d'affichage
29:#P   de la publication.
30:#P
31:#P## télécharger ############
32:#P la commande aura téléchargé toutes les pages du livre et aura copié les
33:#P   pages html dans des répertoires qui leurs sont dédiés pour y extraire
34:#P   toute la documentation nécessaire à la création de la page &quot;Annexe&quot;, et
35:#w      à ce stade, pour les tests avec LivreTest; on dispose des répertoires
36:#w      de travail : LivreTest, ArticleUn, ArticleDeux, ArticleTrois.
37:#P   qui contiennent chacun le fichier html de la page ou de l'article qui le
38:#P   concerne.
39:#P   L'ensemble des commandes aura créé les fichiers de listes :
40:#P   $Projet/$1.dirs, $Projet/$1.list, $Projet/$1.mainPage, $Projet/$1.prj
41:#P
42:#P## ajouter_sclt ###########
43:#P La commande ./ajouter-sclt &lt;wikilivre&gt; commence par créer la page
44:#P   $Projet/$1.sclt comme elle apparaîtra dans la première partie de la page
45:#P   &quot;Annexe&quot; du livre, avec les titres et les sections en wikitexte :
46:#P   * Références: toutes celles qui n'ont pas été affichées dans les pages.
47:#P   * Contenus: liens établis vers la page du livre et les articles.
48:#P     (les sous-pages).
49:#P   * Source de l'édition: lien vers la page qui a permis de créer l'Annexe.
50:#P   * Sources licences et contributeurs des articles: ne concerne que les
51:#P     articles, les sous-pages.
52:#P
53:#D## ajouter_sclic ##########
54:#D Le répertoire de travail est le sous répertoire du projet $Projet/$1/$1
55:#D   plus précisément : ~/Annexer/&lt;nom du livre&gt;/&lt;nom du livre&gt;
56:#D   &lt;nom du livre&gt; pourrait être la sous-page 'Version imprimable' du livre
57:#D   et peut être considéré comme un 'Article'.
58:#D Remarques :
59:#D   à ce stade, Les fichiers $1.list, $1.prj, $1.pj, $1.sclt, $.mainPage sont  
60:#D   censés préexister dans le répertoire racine du projet $1 (nom du livre).
61:#D De même, les fichiers &lt;Article&gt;.str sont sensés préexister dans les
62:#D   répertoires &lt;Article&gt; correspondants.
63:#D Seront créés :
64:#D   * Dans le répertoire de travail racine ~/Annexe/$1/. :
65:#D     le fichier $1.sclic qui vient compléter le fichier $1.sclt afin de créer
66:#D     le fichier &quot;Annexe&quot;,
67:#D   * dans le sous-répertoire de travail ~/Annexe/$1/$1/. :
68:#D     $1.files, $1.pict, $1.illustrations, $1.links, html.list et
69:#D     les fichiers d'images .str .title, .source, .license, .auteur.
70:#D
71:#D## ajouter_sclip ##########
72:#D Ce module est l'entête des programmes sclipco.inc et sclipwb.inc du
73:#D   programme Annexer :
74:#D   Si une des options -pc ou -pb de la ligne de commande 'annexer &lt;livre&gt;'
75:#D   est validée, le module ajouter_sclip est exécuté puis un des modules
76:#D   sclipco ou sclipwb est exécutés selon l'option choisie -pc ou -pb.
77:#D   (-pc pour images sur 'Commons', -pb pour images sur 'Wikilivres'.)
78:#D Structure, organisation des fichiers :
79:#D Les répertoires de travail sont les répertoires des 'Articles'.
80:#D Le fichier $Projet/$ligne/$ligne.str a été créé avec la commande
81:#D   ajouter_sclt
82:#D Remarques :
83:#D 1.les images extraites avec le fichier de commandes ajouter_sclic peuvent
84:#D   être copiées dans les répertoires des articles correspondants lorsqu'ils
85:#D   sont identifiés dans leurs répertoires respectifs pour créer une option
86:#D   d'images téléchargées de 'Commons'.
87:#D 2.le fichier de conversions url/html vers utf8 a été inclus dans l'entête
88:#D   header.sh depuis le 13 mai 2020
89:#D
90:#P Générer la documentation de cette page :
93:#P Générer la documentation programmeur :
96:#P Générer l'organigramme de cette commande :
99:#P
&lt;/pre&gt;
; Organigramme :
&lt;pre&gt;
101:#O inclure le fichier d'entête header.sh
104:#O## ajouter_scli_p (personnalisé) ############
106:#O   ligne de commande &quot;ajouter_sclip &lt;livre&gt;&quot; où &quot;livre&quot; = variable $1
108:#O PageScliP sera la variable d'identifiation du fichier &quot;livre.sclip&quot; placé
109:#O    dans le répertoire&quot; de travail du projet : $Projet = ~/Annexe/$1/.
114:#O créer la section 'Image', 'Source', 'licence', 'Contributeur(?)'
116:#O   ajouter le texte : style PediaPress ou personnalisé.
117:#O   style PediaPress :
118:#O   Les ''sources'' listées pour chaque article fournissent des informations
119:#O   de licence plus détaillées, y compris le statut des droits d'auteurs, les
120:#O   détenteurs de ces droits et les conditions de licence.
122:#O   ou: (imprimer l'un ou l'autre de ces textes)
123:#O   style personnalisé :
124:#O   Les textes sont disponibles avec leurs licences respectives, cependant
125:#O   d’autres termes peuvent s’appliquer.&lt;br /&gt;
126:#O   Voyez les termes d’utilisation pour plus de détails :&lt;br /&gt; 
127:#O   https://wikimediafoundation.org/wiki/Conditions_d'utilisation
&lt;/pre&gt;

{{Boîte déroulante début|titre=Code ajouter_sclip|styleFrame=width:100%;|fondtitre=#F0F0F0&lt;!--|styleTitre=color:white;|style=headerbleu--&gt;}}
{{/ajouter_sclip}}
{{Boîte déroulante fin}}
{{Nouvelle page imprimée}}
====={{50}} Module sclipco.inc =====
{{Boîte déroulante début|titre=Code sclipco.inc|styleFrame=width:100%;|fondtitre=#F0F0F0&lt;!--|styleTitre=color:white;|style=headerbleu--&gt;}}
{{/sclipco.inc}}
{{Boîte déroulante fin}}
{{Nouvelle page imprimée}}
====={{100}} Modude sclipwb.inc =====
{{Boîte déroulante début|titre=Code sclipwb.inc|styleFrame=width:100%;|fondtitre=#F0F0F0&lt;!--|styleTitre=color:white;|style=headerbleu--&gt;}}
{{/sclipwb.inc}}
{{Boîte déroulante fin}}
{{Nouvelle page imprimée}}
==== Comparaison des annexes obtenues pour la page ''LivreTest'' ====
===== Annexe classique avec sclic =====
{{RemarqueIndex|[[Utilisateur:Goelette_Cardabela/Sandbox/LivreTest/Annexe_bis|Annexe classique de LivreTest avec sclic]]&lt;br /&gt;Cette présentation peut être utile pour une extension d' ''Index'', ''Table des matières'' et numérotation des pages avec OpenOffice.}}
[https://fr.wikibooks.org/w/index.php?title=Utilisateur:Goelette_Cardabela/Sandbox/LivreTest/Annexe_bis&amp;action=edit Éditer cette annexe.]
{{Nouvelle page imprimée}}

===== Annexe personnalisée avec le téléchargement sur le serveur ''Commons'' =====
{{RemarqueIndex|[[Utilisateur:Goelette_Cardabela/Sandbox/LivreTest/Annexe_commons|Annexe pesonnalisée de LivreTest avec sclipco.inc]]&lt;br /&gt;Cette présentation simple permet de repérer les illustrations en fonction des chapitres, sans numérotation des pages.}}
[https://fr.wikibooks.org/w/index.php?title=Utilisateur:Goelette_Cardabela/Sandbox/LivreTest/Annexe_commons&amp;action=edit Éditer cette annexe.]
{{Nouvelle page imprimée}}

===== Annexe personnalisée avec le téléchargement sur le serveur ''Wikilivres'' =====
{{RemarqueIndex|[[Utilisateur:Goelette_Cardabela/Sandbox/LivreTest/Annexe_wikilivres|Annexe pesonnalisée de LivreTest avec sclipwb.inc]]&lt;br /&gt;Cette présentation simple permet de repérer les illustrations en fonction des chapitres, sans numérotation des pages. On notera la différence avec la version ''Commons'' pour la résolution du nom d'auteur de l'image.}}
[https://fr.wikibooks.org/w/index.php?title=Utilisateur:Goelette_Cardabela/Sandbox/LivreTest/Annexe_wikilivres&amp;action=edit Éditer cette annexe.]
{{Nouvelle page imprimée}}

===== Comparaison avec l'annexe manuelle ou semi-manuelle =====
{{RemarqueIndex|&lt;br /&gt;[[Utilisateur:Goelette_Cardabela/Sandbox/LivreTest/Annexe|Visualiser l' Annexe manuelle ou semi-manuelle de LivreTest]], produite avec des [[Go%C3%A9lette_Cardabela/Sommaire#Canevas|cannevas.]]}}

[https://fr.wikibooks.org/w/index.php?title=Utilisateur:Goelette_Cardabela/Sandbox/LivreTest/Annexe&amp;action=edit Éditer cette version manuelle.]
{{Nouvelle page imprimée}}

== Tests unitaires et d'intégration ==
Les fichiers de commandes shell peuvent être éprouvés successivement, sous linux ou sous d'autres systèmes d'exploitation acceptant les commandes '''''shell bash''''' :  Windows 10&lt;ref&gt;https://korben.info/installer-shell-bash-linux-windows-10.html&lt;/ref&gt;&lt;ref&gt;http://montefiore.ulg.ac.be/~nvecoven/ci/files/tuto_bash/tuto_bash.html&lt;/ref&gt;, [[w:MinGw|MinGw]], [[w:Cygwin|Cygwin]], ....

Pour effectuer ces tests il faut se placer dans le répertoire utilisateur et créer un répertoire qui regroupe les fichiers de commandes. Dans les exemples présentés : mkdir ~/Annexer

'''Les fichiers de commandes :''' &lt;br /&gt;
'''''header.sh, annexer, lister, télécharger, ajouter-sclt, ajouter-sclic, ajouter-sclip,''''' sont prévus pour être placés dans ce répertoire des commandes '''''~/Annexer'''''. Le fichier header.sh est non seulement un fichier de commandes, il est aussi un fichier d'entête pour tous les modules en tests unitaires.

Les commandes peuvent être éprouvées avec tous les livres disponibles. Pour les essais de ces versions en tests, nous avons utilisé le livre « LivreTest ».

La commande « annexer » permet le test d'intégration de tous les modules avec des points d'arrêt possibles après chaque module testé.

Rendez-vous dans le chapitre [[Auto-%C3%A9diter_un_wikilivre/Auto-r%C3%A9f%C3%A9rencer#Annexer_(main)|Annexer]] pour effectuer ces test et/ou avoir plus d'informations.
{{Nouvelle page imprimée}}
== Copier et installer les fichiers de l'application et des tests ==
{{orange|&lt;small&gt;Ces versions, mises à jour, peuvent être différentes des premières versions exposées dans les chapitres de cet article.&lt;/small&gt;}}

Éditer la page originale&lt;ref&gt;[https://fr.wikibooks.org/wiki/Auto-%C3%A9diter_un_wikilivre/Auto-référencer/Annexer_(Version_orignale) Installer les fichiers de l'application originale en français]&lt;/ref&gt;

{{:Auto-éditer_un_wikilivre/Auto-référencer/Annexer (Version orignale)}}
{{Nouvelle page imprimée}}

== Post-référencer post-indexer un wikilivre ==

{{:Auto-éditer_un_wikilivre/Post-référencer}}

== Références==
&lt;references /&gt;
{{Nouvelle page imprimée}}
== Index des sections ==

Sections ↑

    1 Codes shell pour créer la page « Annexe » d'un wikilivre
        1.1 Entête des modules
        1.2 Annexer (main)
            1.2.1 Tests unitaires du fichier de commandes annexer
            1.2.2 Annexe obtenue
                1.2.2.1 Impression visuelle de cette annexe
        1.3 Lister (module)
            1.3.1 Exemple de page Contenus du livre en test LivreTest
            1.3.2 Exemple de page du livre en test, LivreTest compilé
            1.3.3 Exemple de listes obtenues pour le livre LivreTest
            1.3.4 Tests du module lister
                1.3.4.1 Les lignes qui méritent notre attention
                1.3.4.2 Tests de la commande
        1.4 Télécharger (module)
            1.4.1 Test du module « télécharger »
                1.4.1.1 Les lignes qui méritent notre attention
                1.4.1.2 Tests de la commande télécharger
        1.5 Ajouter sclt (module)
            1.5.1 Tests du module ajouter_sclt
                1.5.1.1 Les lignes qui méritent notre attention
                1.5.1.2 Tests de la commande
        1.6 Ajouter scli (trois modules indépendants)
            1.6.1 Les fichier de commandes scli
                1.6.1.1 Version classique sclic (module)
                1.6.1.2 Programme des tests du module ajouter_sclic
                1.6.1.3 Les lignes qui méritent notre attention
                1.6.1.4 Tests de la commande ajouter_sclic
                    1.6.1.4.1 Fichiers obtenus avec la commande ~/Annexer/ajouter_sclic LivreTest
                1.6.1.5 Version personnalisée par article sclip (module)
                1.6.1.6 Entête ajouter_sclip
                1.6.1.7 Module sclipco.inc
                1.6.1.8 Modude sclipwb.inc
            1.6.2 Comparaison des annexes obtenues pour la page LivreTest
                1.6.2.1 Annexe classique avec sclic
                1.6.2.2 Annexe personnalisée avec le téléchargement sur le serveur Commons
                1.6.2.3 Annexe personnalisée avec le téléchargement sur le serveur Wikilivres
                1.6.2.4 Comparaison avec l'annexe manuelle ou semi-manuelle
    2 Tests unitaires et d'intégration
    3 Copier et installer les fichiers de l'application et des tests
    4 Post-référencer post-indexer un wikilivre
    5 Post indexer avec Open Office (OO) ou LibreOffice
        5.1 Survol rapide de post indexation avec le LivreTest
            5.1.1 Préparation du document avec OO
            5.1.2 Copier le document dans OO
                5.1.2.1 Créer l'« Index lexical »
                5.1.2.2 Créer la « Table des matières »
    6 Indexer un wikilivre
        6.1 Préparer le « Modèle de livre » pour OO
        6.2 Recopier le contenu WikiMedia (textes et images) dans OO
        6.3 Corriger et compléter les pages
        6.4 Documentation générale
        6.5 Conseils pour les cadres et les formules mathématiques dans OO
        6.6 Imprimer
    7 Alternative à l'indexation avec OpenOffice ou LibreOffice
    8 Références
    9 Index des sections


{{Nouvelle page imprimée}}

{{AutoCat}}
[[Catégorie:Shellscript]]</text>
      <sha1>h5fn6q4aimq41c8cdlv0pw6cf8sx83w</sha1>
    </revision>
  </page>
  <page>
    <title>Wikilivres:GUS2Wiki</title>
    <ns>4</ns>
    <id>78643</id>
    <revision>
      <id>744144</id>
      <parentid>743756</parentid>
      <timestamp>2025-06-05T11:49:09Z</timestamp>
      <contributor>
        <username>Alexis Jazz</username>
        <id>81580</id>
      </contributor>
      <comment>Updating gadget usage statistics from [[Special:GadgetUsage]] ([[phab:T121049]])</comment>
      <origin>744144</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="3796" sha1="oi4adikd2ijawx9uw2ien2jxh6riz6h" xml:space="preserve">{{#ifexist:Project:GUS2Wiki/top|{{/top}}|This page provides a historical record of [[Special:GadgetUsage]] through its page history. To get the data in CSV format, see wikitext. To customize this message or add categories, create [[/top]].}}
Les données suivantes sont en cache et ont été mises à jour pour la dernière fois le 2025-06-04T07:12:03Z. {{PLURAL:5000|1=Un seul|5000}} résultat{{PLURAL:5000||s}} au maximum {{PLURAL:5000|est|sont}} disponible{{PLURAL:5000||s}} dans le cache.
{| class=&quot;sortable wikitable&quot;
! Gadget !! data-sort-type=&quot;number&quot; | Nombre d’utilisateurs !! data-sort-type=&quot;number&quot; | Utilisateurs actifs
|-
|AncreTitres || 33 || 1
|-
|ArchiveLinks || 12 || 1
|-
|Barre de luxe || 36 || 2
|-
|BoutonsLiens || 42 || 1
|-
|CategoryAboveAll || 18 || 0
|-
|CategorySeparator || 23 || 1
|-
|CoinsArrondis || 100 || 2
|-
|CollapseSidebox || 36 || 2
|-
|CouleurContributions || 32 || 0
|-
|CouleursLiens || 25 || 0
|-
|DeluxeAdmin || 5 || 1
|-
|DeluxeEdit || 36 || 2
|-
|DeluxeHistory || 44 || 2
|-
|DeluxeImport || 19 || 1
|-
|DeluxeRename || 17 || 2
|-
|DeluxeSummary || 35 || 2
|-
|DevTools || 17 || 2
|-
|DirectPageLink || 25 || 2
|-
|Emoticons || 44 || 1
|-
|EmoticonsToolbar || 46 || 1
|-
|FastRevert || 37 || 2
|-
|FixArrayAltLines || 23 || 2
|-
|FlecheHaut || 67 || 2
|-
|GoogleTrans || 28 || 1
|-
|HotCats || 81 || 4
|-
|JournalDebug || 22 || 2
|-
|JournalEnTable || 2 || 2
|-
|LeftPaneSwitch || 5 || 2
|-
|ListeABordure || 30 || 2
|-
|LiveRC || 30 || 0
|-
|LocalLiveClock || 27 || 2
|-
|Logo || 41 || 0
|-
|MobileView || 17 || 2
|-
|NavigAdmin || 38 || 1
|-
|OngletEditCount || 45 || 2
|-
|OngletEditZeroth || 67 || 3
|-
|OngletGoogle || 28 || 2
|-
|OngletPurge || 55 || 3
|-
|OptimizedSuivi || 18 || 0
|-
|Popups || 59 || 1
|-
|RenommageCategorie || 6 || 2
|-
|RestaurationDeluxe || 12 || 1
|-
|RevertDiff || 36 || 5
|-
|ScriptAutoVersion || 17 || 2
|-
|ScriptSidebox || 32 || 1
|-
|ScriptToolbar || 43 || 1
|-
|SisterProjects || 16 || 1
|-
|SkinPreview || 4 || 2
|-
|Smart patrol || 3 || 2
|-
|SourceLanguage || 25 || 1
|-
|SousPages || 56 || 4
|-
|SpaceToolbar || 30 || 1
|-
|TableUnicode || 56 || 1
|-
|Tableau || 67 || 3
|-
|TitreDeluxe || 56 || 2
|-
|TitreHierarchique || 17 || 1
|-
|UTCLiveClock || 27 || 1
|-
|UnicodeEditRendering || 29 || 2
|-
|WikEd || 29 || 0
|-
|autonum || 1 || 0
|-
|massblock || 3 || 1
|-
|monBrouillon || 19 || 2
|-
|perpagecustomization || 17 || 2
|-
|recentchangesbox || 15 || 0
|-
|searchFocus || 18 || 0
|-
|searchbox || 30 || 3
|}
* [[Spécial:GadgetUsage]]
* [[m:Meta:GUS2Wiki/Script|GUS2Wiki]]
&lt;!-- data in CSV format:
AncreTitres,33,1
ArchiveLinks,12,1
Barre de luxe,36,2
BoutonsLiens,42,1
CategoryAboveAll,18,0
CategorySeparator,23,1
CoinsArrondis,100,2
CollapseSidebox,36,2
CouleurContributions,32,0
CouleursLiens,25,0
DeluxeAdmin,5,1
DeluxeEdit,36,2
DeluxeHistory,44,2
DeluxeImport,19,1
DeluxeRename,17,2
DeluxeSummary,35,2
DevTools,17,2
DirectPageLink,25,2
Emoticons,44,1
EmoticonsToolbar,46,1
FastRevert,37,2
FixArrayAltLines,23,2
FlecheHaut,67,2
GoogleTrans,28,1
HotCats,81,4
JournalDebug,22,2
JournalEnTable,2,2
LeftPaneSwitch,5,2
ListeABordure,30,2
LiveRC,30,0
LocalLiveClock,27,2
Logo,41,0
MobileView,17,2
NavigAdmin,38,1
OngletEditCount,45,2
OngletEditZeroth,67,3
OngletGoogle,28,2
OngletPurge,55,3
OptimizedSuivi,18,0
Popups,59,1
RenommageCategorie,6,2
RestaurationDeluxe,12,1
RevertDiff,36,5
ScriptAutoVersion,17,2
ScriptSidebox,32,1
ScriptToolbar,43,1
SisterProjects,16,1
SkinPreview,4,2
Smart patrol,3,2
SourceLanguage,25,1
SousPages,56,4
SpaceToolbar,30,1
TableUnicode,56,1
Tableau,67,3
TitreDeluxe,56,2
TitreHierarchique,17,1
UTCLiveClock,27,1
UnicodeEditRendering,29,2
WikEd,29,0
autonum,1,0
massblock,3,1
monBrouillon,19,2
perpagecustomization,17,2
recentchangesbox,15,0
searchFocus,18,0
searchbox,30,3
--&gt;</text>
      <sha1>oi4adikd2ijawx9uw2ien2jxh6riz6h</sha1>
    </revision>
  </page>
  <page>
    <title>Fonctionnement d'un ordinateur/Les optimisations du chargement des instructions</title>
    <ns>0</ns>
    <id>79799</id>
    <revision>
      <id>744057</id>
      <parentid>734092</parentid>
      <timestamp>2025-06-03T18:38:47Z</timestamp>
      <contributor>
        <username>Mewtow</username>
        <id>31375</id>
      </contributor>
      <minor />
      <comment>/* La file d'instruction et le cache de macro-opération */</comment>
      <origin>744057</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="47701" sha1="pa26y1hewfslhudlv8j8awpixdlvinc" xml:space="preserve">Les processeurs modernes disposent de plusieurs unités de calcul, de bancs de registres larges et de tout un tas d'optimisations permettent d’exécuter un grand nombre d'instructions par secondes. Les opérations de calcul, les accès mémoire : tout cela est très rapide. Mais rien de cela ne fonctionnerait si l'unité de chargement ne suivait pas le rythme. En soi, l'unité de chargement est simple : le ''program counter'', les circuits pour l'incrémenter et gérer les branchements, l'unité de prédiction de branchement, et de quoi communiquer avec le cache. On doit aussi ajouter le registre d'instruction. Difficile de trouver de quoi l'optimiser, à part rendre l'unité de prédiction plus efficace.

Pourtant, les processeurs incorporent diverses optimisations qui rendent le tout beaucoup plus rapide. La plupart de ces optimisations consistent à ajouter des files d'attente ou des mémoires caches dans le ''front-end'', que ce soit après l'étape de chargement ou de décodage. Les caches en question sont situés en aval du cache d'instruction, ce qui en fait des sortes de cache de niveau 0. Les optimisations incluent le préchargement d'instruction, l'usage de files d'attente pour découpler divers circuits et quelques autres. Voyons lesquelles dans ce chapitre.

==La file d'instruction et le cache de macro-opération==

L'unité de chargement contient de nombreux circuits fortement liés entre eux, et on peut découper le tout en plusieurs circuits. L'unité de calcul d'adresse émet les adresses des instructions à charger, qui sont consommées par le cache d'instruction, qui lui-même envoie les instructions lues dans le registre d'instruction ou la file d'instructions. L'unité de calcul d'adresse regroupe : l'unité de prédiction de branchement, le ''program counter'', le circuit pour incrémenter le ''program counter'', les MUX associés pour gérer les branchements. 

Le couplage de ces structures fait qu'au moindre défaut de cache d'instruction, l'ensemble stoppe. Par exemple, l'unité de chargement stoppe en cas de défaut de cache. Même chose si jamais une instruction multicycle s’exécute dans le pipeline et bloque toutes les étapes précédentes. Pourtant, il est en théorie possible, et même utile, que certaines structures prennent de l'avance même si d'autres sont bloquées. Par exemple, si le pipeline est bloqué en aval de l'unité de chargement, l'unité de chargement peut en théorie précharger à l'avance des instructions. Ou encore, en cas de défaut de cache d'instruction, l'unité de calcul d'adresse peut précalculer les adresses destinées au cache et les mettre en attente. Pour cela, l'unité de chargement incorpore un paquet de mémoires FIFOs, que nous voir en détail dans ce qui suit.

===Les files d'instruction===

Les processeurs modernes intègrent une '''file d'instruction''', une mémoire FIFO, placée entre le cache d'instruction et le décodeur d'instruction. Les instructions chargées par l'étape de chargement soient accumulées dans la '''file d'instructions''' et sont décodées quand l'unité de décodage est prête.

La file d'attente permet de précharger des instructions dans la file d’instructions à l'avance, permettant ainsi de masquer certains accès au cache ou à la mémoire assez longs. L'idée est que les instructions s'accumulent dans la file d'instruction si le processeur exécute les instructions moins vite qu'il ne les charge. C'est généralement signe qu'il effectue une instruction multicycle et/ou qu'il effectue un accès à la mémoire. À l'inverse, la file d'attente se vide quand le processeur éxecute les instructions plus vite qu'il n'en charge. C'est généralement signe qu'un défaut de cache d'instruction est en cours.

La présence d'une file d'attente fait que la première situation est compensée lors de la seconde. Les temps d'attentes liées aux instructions multicycles permettent de remplir la file d'attente, qui est ensuite vidée en cas de défaut de cache. Le processeur exécute en permanence des instructions, sans interruption. Alors que sans file d'attente, les défauts de cache entraineront des temps d'attente où le processeur s’exécuterait rien.

La seule limite de cette optimisation est l'influence des branchements. Lorsqu'un branchement est décodé, ce tampon d’instructions est totalement vidé de son contenu. Ce n'est ni plus ni moins ce que faisait la ''prefetch input queue'' des anciens processeurs Intel, dont nous avions parlé dans le chapitre sur l'unité de chargement et le séquenceur.

===La macro-fusion===

La présence d'une file d'instruction et/ou d'une ''Prefetch Input Queue'' permet d'ajouter une optimisation très importante au processeur, qui ne seraient pas possibles sans elle. L'une d'entre elle est la '''macro-fusion''', une technique qui permet de fusionner une suite d'instructions consécutives en une seule micro-opération. Par exemple, il est possible de fusionner une multiplication suivie d'une addition en une seule instruction MAD (''multiply and add''), si les conditions adéquates sont réunies pour les opérandes. Comme autre exemple, il est possible de fusionner un calcul d'adresse suivi d'une lecture à l'adresse calculée en une seule micro-opération d'accès mémoire. Et enfin, il est possible de fusionner une instruction de test et une instruction de branchement en une seule micro-opération de comparaison-branchement. C'est surtout cette dernière qui est utilisée sur les processeurs Intel modernes.

La macro-fusion est effectuée pendant le décodage, en décodant des instructions dans le tampon d'instruction. Le décodeur reconnait que plusieurs instructions dans le tampon d'instruction peuvent être fusionnées et fournit en sortie la micro-opération équivalent. L'avantage de cette technique est que le chemin de données est utilisé plus efficacement. Notons que la macro-fusion diminue le nombre d'instructions à stocker dans le ROB et dans les différentes mémoires intégrées aux processeur, qui stocke les micro-opérations.

La technique est parfois couplée à un circuit de prédiction, qui détermine si une série d'instruction à fusionner va apparaitre sous peu. L'idée est que dans certains cas, le tampon d'instruction contient le début d'une suite d'instruction combinables. Suivant ce qui sera chargé après, la macro-fusion pourra se faire, ou non. Mais le processeur ne sait pas exactement quelles seront les instructions chargées juste après et il ne sait pas si la macro-fusion aura lieu. Dans ce cas, il peut utiliser un circuit de prédiction de macro-fusion, qui essaye de prédire si les instructions chargées sous peu autoriseront une macro-fusion ou non. Si c'est le cas, les instructions potentiellement fusionnables, le début de la série macro-fusionnable, est mise en attente dans le tampon d'instruction, en attendant les futures instructions.

===Le cache de macro-opérations===

Le cache de macro-opérations est un cache présent en aval de l'unité de chargement, à côté de la file d’instruction. Il mémorise les dernières instructions envoyées à l'unité de décodage, à savoir non pas les instructions préchargées, mais celles qui sont en cours de décodage ou d’exécution, celles qui ont quitté la file d'instruction. Il sert dans le cas où ces instructions sont ré-éxecutées, ce qui est souvent le cas avec des boucles de petite taille.

A chaque cycle d'horloge, ce cache est consulté, de manière à vérifier si l'instruction voulue est dans ce cache ou non. Cela évite un accès au cache d'instruction. Son implémentation est simple : il s'agit d'un petit cache adressé par le ''program counter''. Si l'instruction a été chargée il y a peu, l'instruction machine est mémorisée dans une ligne de cache, le tag de cette ligne n'est autre que son adresse, le ''program counter'' associé. L'accès au cache de macro-opérations est de un seul cycle, pas plus.

[[File:Cache de macro-ops.png|centre|vignette|upright=2|Cache de macro-ops]]

L'intérêt n'est pas évident, mais disons que l'accès à ce cache gaspille moins d'énergie qu’accéder au cache d'instruction. C'est là l'intérêt principal, même s'il se peut qu'on puisse avoir un gain en performance. Le gain en question vient du fait que l'accès est plus rapide dans ce cache, ce qui n'est le cas que dans des conditions précise : si le cache d'instruction est pipeliné et a un temps d'accès de plusieurs cycles.

==La file de micro-opérations et le cache de micro-opérations==

[[File:File d'instruction.png|vignette|upright=1|File d'instruction]]

Sur les processeurs modernes, la sortie du décodeur est reliée à une mémoire FIFO semblable à la file d'instruction, mais placée juste après le décodeur. Elle mémorise les micro-opérations émises par le décodeur et les met en attente tant que le reste du pipeline n'est pas prêt. Nous l’appellerons la '''file de micro-opérations''', par simplicité. Le schéma ci-contre indique que la file de micro-opérations est située en sortie de l’unité de décodage, avant l'unité d'émission et avant l'unité de renommage de registres (que nous aborderons dans quelques chapitres).

La file de micro-opérations permet aux décodeurs de faire leur travail même si le reste du pipeline n'est pas prêt. Par exemple, imaginons que le processeur ne peut pas émettre de nouvelle instruction, soit car toutes les ALUs sont occupées, soit car il y a un accès mémoire qui bloque le pipeline, peu importe. Sans file de micro-opérations, tout ce qui précède l'unité d'émission devrait être totalement bloqué tant que l'instruction ne peut pas être émise. Mais avec une file de micro-opérations, le pipeline peut continuer à charger et décoder des instructions, et accumuler des instructions décodées dans la file de micro-opérations. En clair, la file de micro-opérations met en attente les instructions quand des bulles de pipeline sont émises.

Et à l'inverse, elle permet d'émettre des instructions quand les unités de décodage/chargement sont bloquées. Le cas classique est celui d'un défaut de cache dans le cache d'instruction. Des instructions ne peuvent plus être chargée et décodées durant quelques cycles. Sans file de micro-opérations, le processeur ne peut plus rien faire durant quelques cycles. Mais avec une file de micro-opérations, il peut en profiter pour émettre les instructions en attente dans la file de micro-opérations. En clair, si l'unité d'émission a mis en attente des instructions, le processeur se rattrape au prochain défaut de cache d'instruction.

Une autre situation où le décodeur bloque est le cas où certaines instructions mettent du temps à être décodées. C'est notamment le cas de certaines instructions complexes, dont le décodage prend facilement 2 à 3 cycles d'horloge, voire plus. Le pire est le décodage des instructions microcodées, qui peut demander plusieurs cycles. Or, le pipeline demande qu'on décode une instruction par cycle pour éviter de bloquer le pipeline. Mais ce temps de décodage peut être masqué si des micro-opérations sont en attente dans la file, elles sont exécutées pendant le décodage long.

La file de micro-opération est souvent complétée par plusieurs circuits, dont un circuit de micro-fusion, un cache de micro-opérations et le ''loop stream detector''. Voyons ces circuits dans ce qui suit.

[[File:File de micro-opérations et cache de micro-ops - Copie.png|centre|vignette|upright=2.5|File de micro-opérations et cache de micro-ops - Copie]]

===La micro-fusion===

La présence d'une file de micro-opération permet d'effectuer une optimisation appelée la '''micro-fusion'''. Elle remplace deux micro-opérations simples consécutives en une seule micro-opération complexe équivalente. Par exemple, sur certains processeurs, le chemin de données est capable d'effectuer une lecture/écriture en adressage base+index en une seule micro-opération. Mais le jeu d'instruction est une architecture Load-store où le calcul d'adresse et l'accès mémoire se font en deux instructions séparées. Dans ce cas, la micro-fusion peut faire son travail et fusionner le calcul d'adresse avec l'accès mémoire.

C'est une optimisation compatible avec la macro-fusion, les deux se ressemblant beaucoup. On peut se demander pourquoi les deux existent ensemble. La raison est historique, et tient au design des processeurs x86. Les premiers processeurs x86 avaient un chemin de données simple, avec les décodeurs qui allaient avec. Sur de tels processeurs, le calcul d'adresse et l'accès mémoire étaient séparés en deux instructions. Puis, avec l'évolution de la technologie, le chemin de données est devenu capable de faire les deux en une seule micro-opération. Pour compenser cela, Intel et AMD auraient pu changer leurs décodeurs en profondeur. A la place, ils ont préféré utiliser la technique de la micro-fusion, par simplicité.

===Le ''Loop Stream Detector''===

Les boucles sont une opportunité d'optimisation très intéressante sur les CPU avec une file de micro-opérations. L'idée est que lors d'une boucle, des instructions sont chargées, décodées et exécutées plusieurs fois de suite. Mais à, chaque répétition d'une instruction, le chargement et le décodage donnent toujours le même résultat, seule l'exécution n'est pas la même (les registres renommés sont aussi différents, mais passons). L'idée est simplement de mémoriser les N dernières instructions décodées et de les ré-exécuter si besoin. Ainsi, on évite de charger/décoder une même instruction machine plusieurs fois, mais de réutiliser les micro-opérations déjà décodées.

L'implémentation la plus simple conserve les N dernières instructions décodées dans la file d'instruction, qui se comporte alors comme une sorte de pseudo-cache FIFO. Un circuit annexe, appelé le ''Loop Stream Detector'' (LSD), détecte lesboucles dans la file de micro-opérations et optimise leur exécution. Avec un LSD, la file d'instruction ne supprime pas les micro-opérations une fois qu'elles sont émises. Elle mémorise là où se trouve la dernière micro-opération émise, mais conserve celles qui ont déjà été émises. Si une boucle adéquate est détectée par le ''Loop Stream Detector'', les micro-opérations de la boucle sont lues dans la file de micro-opération et sont injectées directement dans la suite du pipeline. De plus, les unités de chargement et de décodage sont désactivées pendant l’exécution de la boucle, ce qui réduit la consommation d'énergie du CPU.

L'optimisation accélère les petites boucles, à condition qu'elles s'exécutent de la même manière à chaque exécution. De telles boucles exécutent une suite de N instructions, qui reste identique à chaque itération de la boucle. Le cas le plus simple est celui d'une boucle dans laquelle il n'y a pas de branchements. Pour les boucles normales, le processeur reprend une exécution normale quand on quitte la boucle ou quand son exécution change, par exemple quand un if...else, un return ou tout autre changement de flot de contrôle a lieu. Vu que toutes ces situations impliquent un branchement qui n'a pas été pris comme avant, le processeur n'utilise plus le ''Loop Stream Detector'' en cas de mauvaise prédiction de branchement.

L'optimisation vise surtout à désactiver les décodeurs et l'unité de chargement lors de l'exécution d'une boucle. La désactivation peut être du ''clock gating'', voire du ''power gating'', être partielle ou totale. Dans le pire des cas, les unités de chargement peuvent continuer à charger des instructions en avance dans une file d'instruction, mais les décodeurs peuvent être désactivés. Dans le meilleur des cas, la totalité de ce qui précède la file de micro-opération est désactivé tant que la boucle s’exécute normalement. Y compris le cache de micro-opération.

[[File:Loop Stream Detector.png|centre|vignette|upright=2|Loop Stream Detector]]

Les CPU Intel modernes disposent d'un ''loop stream detector'', les CPU AMD en avaient sur les microarchitectures Zen 4 mais il a disparu sur la microarchitecture Zen 5. Quelques CPU ARM avaient aussi un ''loop stream detector'', notamment le Cortex A15. Évidemment, la taille des boucles optimisées ainsi est limitée par la taille de la file de micro-opération, ce qui fait que l'optimisation ne fonctionne que pour des boucles de petite taille. De plus, toute la file de micro-opération n'est pas gérée par le ''loop stream detector''. Par exemple, les processeurs avec une file de micro-opération de 64 micro-opération peuvent gérer des boucles de maximum 32 à 40 micro-opérations. Pour donner quelques chiffres, les processeurs ARM Cortex A15 géraient des boucles de maximum 32 micro-opérations.

Mais les contraintes principales portent sur la détection des boucles. Le ''Loop Stream Detector'' ne peut pas détecter toutes les boucles qui existent, et certaines boucles ne sont pas détectées. Par exemple, le ''Loop Stream Detector' ne peut pas détecter les boucles si un appel de fonction a lieu dans la boucle. Il y a aussi des contraintes quant au nombre de branchements à l'intérieur de la boucle et le nombre d'accès mémoire.

Il faut noter que le ''loop stream detector'' a été désactivé par des mises à jour de microcode sur quelques architectures, comme sur la microarchitecture Zen 4 d'AMD ou les CPU de microarchitecture Skylake et Kaby Lake d'Intel. Pour la microarchitecture Skylake , les raisons officielles pour cette désactivation sont un bug lié à l'interaction avec l'''hyperthreading''. Il est vraisemblable que des bugs ou des problèmes de sécurité aient amené à la désactivation sur les autres architectures.

===Le cache de micro-opérations===

Le '''cache de micro-opérations''' a le même but que le ''Loop Stream Detector'', à savoir optimiser l'exécution des boucles. La différence avec le ''Loop Stream Detector'' est qu'il y a un cache séparé de la file de micro-opérations, qui mémorise des micro-opérations décodées, dans le cas où elles soient réutilisées par la suite. La première itération d'une boucle décode les instructions en micro-opérations, qui sont accumulées dans le cache de micro-opérations. Les itérations suivantes de la boucle vont chercher les micro-opérations adéquates dans le cache de micro-opération : on n'a pas à décoder l'instruction une nouvelle fois.

Intuitivement, vous vous dites que son implémentation la plus simple mémorise les N dernières micro-opérations exécutées par le processeur, ce qui en fait un cache FIFO. Mais la réalité est que c'est déjà ce qui est fait par le couple LSD + file de micro-opération. Le cache de micro-opérations a une politique de remplacement des lignes de cache plus complexe que le FIFO, typiquement une politique LRU ou LFU approximée. De plus, le cache de micro-opération est séparé de la file de micro-opération. Et il est alimenté non pas par l'unité de décodage, mais par la file de micro-opérations. Ce sont les micro-opérations qui quittent la file de micro-opérations qui sont insérées dans le cache, pas celles qui quittent directement le décodeur.

Les avantages sont les mêmes qu'avec un ''Loop Stream Detector'' : une consommation énergétique réduite, des performances légèrement améliorées. Le décodeur et l'unité de chargement sont inutiles en cas de succès dans le cache de micro-opération, ce qui fait qu'ils sont désactivés, éteints, ou du moins subissent un ''clock-gating'' temporaire. Ils ne consomment pas d'énergie, seul le cache de micro-opération utilise de l'électricité. L'avantage en termes de performance est plus faible, assez variable suivant la situation, mais aussi bien le cache de micro-opérations que le LSD ne font pas de mal.

La différence avec le cache de micro-opération est que la boucle doit s’exécuter à l'identique avec un ''Loop Stream Detector'', pas avec un cache de micro-opérations. Prenons l'exemple d'une boucle contenant quelques instructions suivies par un IF...ELSE. Il arrive qu'une itération de la boucle exécute le IF, alors que d'autres exécutent le ELSE. Dans ce cas, le ''Loop Stream Detector'' ne sera pas activé, car la boucle ne s’exécute pas pareil d'une itération à l'autre. Par contre, avec un cache de macro/micro-opération, on pourra lire les instructions précédant le IF...ELSE dedans. Le cache de micro-opération est donc plus efficace que le ''Loop Stream Detector'', mais pour un cout en transistor plus élevé.

Le cache de micro-opérations et le ''Loop Stream Detector'' font la même chose, mais certains processeurs implémentaient les deux. L'avantage est que le cache de micro-opération peut être désactivé si jamais le LSD détecte une boucle dans la file d'instruction, ce qui réduit encore plus la consommation énergétique. En pratique, l'impact sur la consommation énergétique est très difficile à mesurer, mais il rajoute de la complexité pour la conception du processeur.

[[File:File de micro-opérations et cache de micro-ops.png|centre|vignette|upright=2|File de micro-opérations et cache de micro-ops]]

Le cache de micro-opération associe, pour chaque instruction machine, une ou plusieurs micro-opérations. Avec l'implémentation la plus simple, une ligne de cache est associée à une instruction machine. Par exemple, sur les processeurs Intel de microarchitecture Skylake, chaque ligne de cache était associée à une instruction machine et pouvait contenir de 1 à 6 micro-opérations. La suite de micro-opérations correspondant à une instruction devait tenir toute entière dans une ligne de cache, ce qui fait que les instructions décodées en plus de 6 micro-opérations ne pouvaient pas rentrer dans ce cache.

L'accès au cache de micro-opération se fait lors de l'étape de chargement. Le cache de micro-opérations est adressé en envoyant le  ''program counter'' sur son entrée d'adresse, en parallèle du cache d'instruction. Le cache de micro-opération est une voie de chargement parallèle au ''front-end'' proprement dit. En clair, il y a une voie qui regroupe cache d'instruction, file d'instruction et décodeur, et une seconde voie qui se résume au cache de micro-opération. Les deux voies sont accédées en parallèle. En cas de succès dans le cache de micro-opération, les micro-opérations adéquates sont lues directement depuis le cache de micro-opération.

Il existe deux méthodes différentes pour encoder les micro-opérations dans le cache de micro-opérations. La première est la plus intuitive : on mémorise les micro-opérations dans la ligne de cache, directement. Elle est utilisée sur les processeurs AMD, et sans doute sur les processeurs Intel récents. Mais les anciens processeurs Intel, comme ceux des architectures Sandy Bridge et Netburst, utilisent une autre méthode. Une ligne de cache mémorise non pas les micro-opération directement, mais un pointeur vers le ''control store'', qui indique à quelle adresse dans le micro-code se situe la micro-opération. La micro-opération est donc lue depuis le micro-code lors de l'émission.

Il faut noter que pour des raisons de performance, le cache de micro-opérations est virtuellement tagué, ce qui fait qu'il est invalidé en cas de changement de programme. Sur l'architecture Sandy Bridge, il est carrément inclus dans le cache L1, les deux sont des caches inclusifs l'un avec l'autre. Les premières implémentations étaient très limitées. Les micro-opérations devaient être séquentielles dans le code, le cache était consulté seulement après un branchement et non à chaque émission d'instruction, pour limiter la consommation d'énergie an détriment des performances. Ces limitations ne sont pas présentes sur les architectures récentes.

Aussi bien le cache de macro-opérations que le cache de micro-opérations optimisent l'exécution des boucles, mais ils ne sont pas au même endroit dans le pipeline : avant et après l'unité de décodage. Et le premier mémorise des instructions machines, l'autre des micro-opérations décodées. Les avantages et inconvénients sont totalement différents. Niveau capacité des deux caches, l'encodage des instructions machines est plus compact que la ou les micro-instructions équivalente, ce qui est un avantage pour le cache de macro-opérations à capacité équivalente. Par contre, le cache de micro-opérations permet de désactiver les décodeurs en cas de succès de cache, vu que les instructions ne doivent plus être décodées et renommées. Le gain est d'autant plus important si les instructions ont un encodage complexe, ou si les instructions sont à longueur variable, ce qui rend leur décodage complexe et donc lent. Globalement, plus le décodage est complexe et/ou long, plus le cache de micro-opérations fait des merveilles.

==Le préchargement d'instructions et la ''Fetch Target Queue''==

Les processeurs modernes incorporent une optimisation assez intéressante : ils découplent l'unité de prédiction de branchement et le ''program counter'' de l'accès au cache d'instruction. Pour cela, ils incorporent une mémoire FIFO entre l'unité de prédiction de branchement et le cache d'instruction. Les premiers articles scientifiques, qui ont proposé cette solution, l'ont appelée la '''''Fetch Target Queue''''', abréviée FTQ. Elle accumule les adresses à lire/écrire dans le cache d'instruction, peu importe que ces adresses viennent du ''program counter'' ou de l'unité de prédiction de branchement.

[[File:Fetch target queue.png|centre|vignette|upright=2.5|Fetch target queue]]

Elle se remplit quand le cache d'instruction est bloqué, soit à cause d'un défaut de cache, soit à cause d'un pipeline bloqué en amont de l'unité de chargement. Par exemple, si le cache d'instruction est bloqué par un défaut de cache, l'unité de prédiction de branchement peut accumuler des prédictions à l'avance dans la FTQ, qui sont ensuite consommées par le cache d'instruction une fois qu'il est redevenu disponible. De même, si l'unité de prédiction de branchement est bloquée par un évènement quelconque, le cache d'instruction peut consommer les prédictions faites à l'avance.

Une utilisation assez originale de la FTQ s'est vu sur les processeurs AMD d'architectures bulldozer. Sur cette architecture, les cœurs étaient regroupés par paquets de deux, et les deux cœurs partageaient certains circuits. Notamment, l'unité de prédiction de branchement était partagée entre les deux cœurs ! Pourtant, chaque cœur disposait de sa propre FTQ !

Un avantage de la FTQ tient dans le fait que les caches d'instructions sont pipelinés, sur le même modèle que les processeurs. On peut leur envoyer une demande de lecture/écriture par cycle, alors que chaque lecture/écriture prendra plusieurs cycles à s'effectuer. L'accès au cache d'instruction a donc une certaine latence, qui est partiellement masquée par la FTQ au point où elle ne s'exprime qu'en cas de défaut de cache assez important. Par exemple, si l'accès au cache d'instruction prend 4 cycles, une FTQ qui met en attente 4 adresses camouflera le temps d'accès au cache, tant qu'il n'y a pas de mauvaise prédiction de branchement.  La FTQ est aussi très utile avec les unités de branchement modernes, qui peuvent mettre plusieurs cycles pour fournir une prédiction. Prendre de l'avance avec une FTQ amorti partiellement le temps de calcul des prédictions.

: Si le cache d'instruction est multiport et accepte plusieurs accès simultanés, il peut consommer plusieurs entrées dans la FTQ à la fois.

Mais l'avantage principal de la FTQ est qu'elle permet l'implémentation d'une optimisation très importante. Il y a quelques chapitres, nous avions parlé des techniques de '''préchargement d'instruction''', qui permettent de charger à l'avance des instructions dans le cache d'instruction. Nous avions volontairement laissé de côté le préchargement des instructions, pour tout un tas de raisons. Et la raison est justement que la prédiction de branchement et le préchargement des instructions sont fortement liés sur les processeurs modernes. Il est maintenant possible d'aborder le préchargement pour les instructions, d’où cette section.

Notons que par préchargement des instructions, on peut parler de deux formes de préchargement, fortement différentes. La première correspond au préchargement normal, à savoir le préchargement des instructions dans le cache d'instruction L1, à partir du cache L2. Il s'agit donc d'un préchargement dans le cache d'instruction. Mais il existe aussi une autre forme de préchargement, qui consiste à précharger à l'avance des instructions dans la file d'instruction et qui a été abordée dans la section sur la ''prefetch input queue''. Les deux formes de préchargement n'ont pas lieu au même endroit dans la hiérarchie mémoire : l'une précharge du cache L2 vers le L1i, l'autre du cache L1i vers la file d'instruction (ou dans le cache de macro-opération). Mais les algorithmes utilisés pour sont sensiblement les mêmes. Aussi, nous allons les voir en même temps. Pour faire la distinction, nous parlerons de préchargement L2-L1i pour la première, de préchargement interne pour l'autre.

===Les algorithmes de préchargement d'instructions===

Les techniques basiques de préchargement consistent à charger des instructions qui suivent la dernière ligne de cache accédée. Quand on charge des instructions dans le cache d’instruction, les instructions qui suivent sont chargées automatiquement, ligne de cache par ligne de cache. il s'agit due préchargement séquentiel, la technique la plus simple de préchargement, qui profite de la localité spatiale. Elle est utilisée pour précharger des instructions du cache L2 vers le cache L1i, mais aussi pour le préchargement interne dans la file d'instructions. 

[[File:Branchements et préchargement séquentiel.png|centre|vignette|upright=2|Branchements et préchargement séquentiel.]]

Mais un ''prefetcher'' purement séquentiel gère mal les branchements. Si un branchement est pris, les instructions de destination ne sont pas chargées, si elles ne sont pas dans la ligne de cache suivante. Pour le préchargement L2-L1i, cela ne pose pas de problèmes majeurs, au-delà de la pollution du cache L1i par des instructions inutiles. Mais pour le préchargement interne, c'est autre chose. Les instructions préchargées par erreurs doivent être supprimées pour éviter qu'elles soient décodées et exécutées, ce qui fait que la file d’instruction doit être invalidée.

Il existe des techniques de préchargement plus élaborées qui marchent mieux en présence de branchements. Elles utilisent toutes une collaboration de l'unité de prédiction de branchement. Elles accèdent au ''Branch Target Buffer'', pour détecter les branchements, leur destination, etc. Le tout peut se coupler à la technique du prédécodage. Avec cette dernière, le prédécodage décode en partie les instructions lors de leur chargement dans le cache, et détecte les branchements et leur adresse de destination à ce moment-là. Ces informations sont alors mémorisées dans une table à part, ou dans le BTB. Mais la plupart des designs utilisent le BTB, par souci de simplicité. Il existe globalement deux à trois techniques principales, que nous allons voir dans ce qui suit.

La première technique prédit si le branchement est pris ou non, et agit différemment si le branchement est pris ou non. Si le branchement est pris, elle précharge les instructions à partir de l'adresse de destination des branchements pris. Sinon, elle précharge les instructions suivantes avec préchargement séquentiel. Il s'agit du '''''target line prefetching'''''

[[File:Target line prefetching.png|centre|vignette|upright=2|Target line prefetching.]]

Une autre technique ne prédit pas les branchements et précharge à la fois les instructions suivantes avec le ''next-line prefetching'', et la ligne de cache de destination du branchement avec le ''target line prefetching''. Comme ça, peu importe que le branchement soit pris ou non, les instructions adéquates seront préchargées quand même. On appelle cette technique le '''préchargement du mauvais chemin''' (''wrong path prefetching'').

[[File:Préchargement du mauvais chemin.png|centre|vignette|upright=2|Préchargement du mauvais chemin.]]

Le ''target line prefetching'' est plus complexe à implémenter, car il demande de prédire les branchements.  Mais elle a l'avantage de ne pas précharger inutilement deux lignes de cache par branchement, seulement une seule. Par contre, le préchargement est inutile en cas de mauvaise prédiction de branchement : non seulement on a préchargé une ligne de cache inutilement, mais en plus, la ligne de cache adéquate n'a pas été chargée. On n'a pas ce problème avec le préchargement du mauvais chemin, qui garantit que la ligne de cache adéquate est toujours préchargée.

===L'implémentation du préchargement interne, dans la file d'instruction===

Le préchargement dans la file d'instruction est généralement de type séquentiel, mais certains processeurs font autrement. Déjà, il faut remarquer que le ''target line prefetching'' correspond en réalité à la prédiction de branchement classique. L'adresse de destination est prédite, et on charge les instructions adéquates dans la file d'instruction. La prédiction de branchement, associée à une file d'instruction, est donc une forme de préchargement. Il fallait y penser. Enfin, des processeurs assez rares utilisaient le préchargement du mauvais chemin.

Le préchargement du mauvais chemin demande d'utiliser deux files d'instructions séparées. L'une dans laquelle on précharge de manière séquentielle, l'autre dans laquelle on utilise la prédiction de branchement pour faire du ''target line prefetching''. Une fois que l'on sait si la prédiction de branchement était correcte, on est certain qu'une des deux files contiendra les instructions valides. Le contenu de la file adéquate est conservé, alors que l'autre est intégralement invalidée. Le choix de la bonne file se fait avec un multiplexeur. C'est approximativement la technique qui était implémentée sur le processeur de mainframe IBM 370/165, par exemple, et sur quelques modèles IBM similaires.

Le problème est que cette méthode demande de charger deux instructions à chaque cycle. Cela demande donc d'utiliser un cache d'instruction multiport, avec un port par file d'instruction. Le cout en circuit d'un cache double port n'est pas négligeable. Et le gain en performance est assez faible. Le préchargement dans la file d’instruction permet d'économiser quelques cycles lors de l'accès au cache d'instruction, guère plus. Le gain est maximal lorsque les instructions préchargées ont généré un défaut de cache, qui a rapatrié les instructions adéquates pendant que le processeur exécutait les mauvaises instructions, avant que la mauvaise prédiction de branchement soit détectée. Dans ce cas, le défaut de cache a eu lieu pendant la mauvaise prédiction et sa réparation, et non après.

====La gestion des branchements successifs====

Un autre défaut de cette méthode est la présence de branchements successifs. Par exemple, si jamais on rencontre un branchement, le flux d'instructions se scinde en deux : un où le branchement est pris, un autre où il ne l'est pas. Chacun de ces flux peut lui-même contenir un branchement, et se scinder lui aussi. Et ainsi de suite. Et le processeur doit gérer cette situation en termes de préchargement.

[[File:Exécution stricte 04.png|centre|vignette|upright=2|Exécution stricte]]

Plusieurs solutions existent. La méthode la plus simple stoppe le chargement du flux en attendant que le premier branchement soit terminé. Cette solution est intuitive, mais est celle où on a les gains en performance les plus faibles. Elle est couramment implémentée d'une manière assez particulière, qui ne correspond pas tout à fait à un stop du chargement, mais qui utilise les lignes de cache. L'unité de préchargement est conçue pour copier des lignes de cache entières dans la file d'instruction. Le processeur (pré-)charge deux lignes de cache : celle du bon chemin, celle du mauvais chemin. Il les précharge dans deux files d'instructions, qui contiennent généralement une ligne de cache grand maximum. Le temps que l'on ait chargé les deux files d'instruction, le résultat du branchement est connu et on sait laquelle est la bonne.

L'autre possibilité est d'utiliser la prédiction de branchement pour ce flux, afin de poursuivre le chargement de manière spéculative. Elle donne de bonnes performances, mais demande des unités de prédiction de branchement spéciales, dans le cas où les deux flux tombent sur un branchement en même temps. Cette technique est indirectement liée au cache de traces que nous verrons dans le chapitre sur les processeurs superscalaires. Nous n'en parlons pas ici, car ce genre de techniques est plus liée aux processeurs superscalaires qu'un processeur avec un pipeline normal.

Une autre possibilité consiste à scinder ce flux en deux et charger les deux sous-flux. Cette dernière est impraticable car elle demande des caches avec un grand nombre de ports et la présence de plusieurs files d'instructions, qui sont utilisées assez rarement.

[[File:Exécution stricte 01.png|centre|vignette|upright=2|Exécution stricte, seconde.]]

====Les processeurs à exécution de chemins multiples====

L'idée précédente peut en théorie être améliorée, afin de non seulement charger les instructions en provenance des deux chemins (celui du branchement pris, et celui du branchement non pris), mais aussi de les exécuter : c'est ce qu'on appelle l''''exécution stricte''' (''eager execution''). Bien sûr, on n’est pas limité à un seul branchement, mais on peut poursuivre un peu plus loin. 

Quelques papiers de recherche ont étudié l'idée, mais ses défauts font qu'elle n'a jamais été utilisée dans un processeur en dehors de prototypes destinés à la recherche. Le gros problème de l'exécution stricte est qu'on est limité par le nombre d'unités de calculs, de registres, etc. Autant ce serait une technique idéale sur des processeurs avec un nombre illimité de registres ou d'unités de calcul, autant ce n'est pas le cas dans le monde réel. Au bout d'un certain nombre d’embranchements, le processeur finit par ne plus pouvoir poursuivre l’exécution, par manque de ressources matérielles et doit soit stopper, soit recourir à la prédiction de branchement. Il y a le même problème avec le préchargement interne simple, quand on utilise le préchargement du mauvais chemin, comme vu juste au-dessus.

===L'implémentation matérielle du préchargement de cache L2-L1i===

Pour comprendre comment s'effectue le préchargement L2-L1i, il faut regarder comment l'unité de chargement communique avec les caches. L'unité de prédiction de branchement est généralement regroupée avec le ''program counter'' et les circuits associés (les incrémenteurs/MUX associés), pour former l'unité de chargement proprement dite. L'unité de chargement émet des adresses consommées par le cache d'instruction, qui lui-même envoie les instructions lues dans le registre d'instruction ou la file d'instructions.

Le couplage de ces structures fait qu'au moindre défaut de cache d'instruction, l'ensemble stoppe. Et notamment, l'unité de prédiction de branchement stoppe en cas de défaut de cache. Même chose si jamais une instruction multicycle s’exécute dans le pipeline et bloque toutes les étapes précédentes. Les pertes de performance ne sont pas très importantes, mais elles existent. Et le préchargement se manifeste dans ces situations.

Le préchargement d'instructions consiste à découpler ces structures de manière à ce qu'elles fonctionnent plus ou moins indépendamment. Le but est qu'en plus des accès normaux au cache d'instruction, l'unité de chargement envoie des informations au cache L2 ou L1i en avance, pour effectuer le préchargement. L'unité de chargement doit alors prendre de l'avance sur le cache, pour effectuer les accès au cache L2 en avance, tout en maintenant l'état normal pour effectuer les accès normaux. C'est donc plus ou moins l'unité de chargement qui s'occupe du préchargement, ou du moins les deux sont très liées.

====L'anticipation du ''program counter''====

Avec la solution la plus simple, on a une unité de chargement qui s'occupe des accès au cache d'instruction, et une unité de préchargement qui prend de l'avance sur l'unité de chargement, et communique avec le cache L2. La technique la plus basique se base sur un ''Lookahead program counter'', un second ''program counter'' qui ne fonctionne que lors d'un défaut de cache d'instruction. Il est initialisé avec le ''program counter'' lors d'un défaut de cache, puis il est incrémenté à chaque cycle et les branchements sont prédits, ce qui fait qu'il est mis à jour comme si l’exécution du programme se poursuivait, alors que le reste du processeur est mis en attente.

La technique initiale utilisait ce second ''program counter'' pour accéder à une table de prédiction, qui associe à chaque valeur du ''program counter'', l'adresse des données chargées par l'instruction associée. Les adresses fournies à chaque cycle par cette table sont alors envoyées aux unités de préchargement pour qu'elles fassent leur travail. La technique permettait donc de précharger des données en cas de défaut de cache, mais pas d'instructions. Il ne s'agissait pas d'une technique de préchargement des instructions, mais de préchargement de données.

La technique a ensuite été adaptée pour le chargement des instructions par Chen, Lee et Mudge. Leur idée utilisait deux unités de prédiction de branchements : une couplée à l'unité de chargement, l'autre pour le préchargement. La première utilisait le ''program counter'' normal, l'autre se déclenchait en cas de défaut de cache et utilisait un ''lookahead program counter''. Les adresses générées par le ''lookahead program counter'' étaient envoyée au cache d'instruction, sur un port de lecture séparé. La ligne de cache lue était alors prédécodée pour détecter les branchements, qui étaient prédits, et rebelote. Il est possible d'adapter la méthode pour que les adresses soient accumulées dans une mémoire FIFO, et étaient consommée par le cache d'instruction L2 pour le préchargement si la ligne de cache associée n'était pas dans le cache d’instruction.

Les techniques modernes n'utilisent plus de seconde unité de prédiction de branchement, mais conservent un ''lookahead program counter''. Par contre, le BTB dispose de plusieurs ports : un pour la prédiction de branchement normale, l'autre pour le préchargement. L'unité de préchargement et l'unité de chargement accèdent toutes deux au BTB quand elles ont besoin de faire leurs prédictions, en parallèle. Typiquement, le BTB est accédé à chaque cycle pour la prédiction de branchement, à un rythme plus faible pour le préchargement.

====Le ''Fetch Directed Instruction Prefetching''====

Les processeurs modernes semblent utiliser un algorithme connu sous le nom de '''''Fetch Directed Instruction Prefetching'''''. Il utilise les adresses contenues dans la FTQ pour précharger les instructions adéquates du cache L2 vers le cache L1 d'instruction (L1i). L'unité de préchargement est placée en aval de la FTQ, elle lit son contenu, détecte quelles adresses correspondent à des lignes de cache à précharger, et envoie celles-ci au cache L2. Le préchargement du L2 vers le L1i a lieu quand le cache L2 est inutilisé, ou du moins quand il peut accepter une nouvelle lecture (dans le cas d'un cache multiport et/ou pipeliné).

[[File:Fetch directed instruction prefetching.png|centre|vignette|upright=2.5|Fetch directed instruction prefetching]]

On peut améliorer légèrement le design précédent sur plusieurs points. Pour éviter de polluer le cache L1 avec des lignes de caches préchargées à tort, il est possible d'ajouter un équivalent des ''stream buffer'' vus dans le chapitre sur le préchargement. Il s'agit d'une autre mémoire FIFO qui mémorise les lignes de cache préchargées. Les lignes de cache préchargées ne sont pas placées dans le cache L1i, mais dans cette file d'attente. Lors d'un accès au L1i, la file d'attente est consultée en parallèle. Si l'instruction voulue est dans la file d'attente, elle est lue depuis la file, et la ligne de cache associée est copiée dans le cache L1i. Mais c'est là une possibilité facultative.

Un autre point est que l'unité de préchargement doit attendre que le cache L2 puisse accepter une nouvelle lecture pour lancer le préchargement d'une autre ligne de cache. Pour corriger cela, on ajoute une file d'attente entre le cache L2 et l'unité de préchargement, qui est évidemment une mémoire FIFO. Son utilité dépend des temps de lectures du cache L2, ainsi que de la taille de la FTQ. Elle n'est pas toujours nécessaire, certains processeurs ont un cache L2 assez lent pour qu'on ne puisse précharger qu'une seule ligne de cache avant que la FTQ soit complétement vide.

Ces deux optimisations sont facultatives, mais elles étaient présentes dans l'article originel qui a proposé la technique. 

L'unité de préchargement doit détecter quelles sont les adresses de la FTQ qui ne sont pas déjà chargées dans le L1i. En effet, il est inutile de précharger une ligne de cache si celle-ci est déjà dans le cache L1i. L'unité de préchargement doit donc filtrer au mieux les adresses de la FTQ en deux classes : celles qui correspondent à une ligne de cache déjà dans le L1i, celles qui doivent être préchargées.

Pour cela, l'unité de préchargement utilise la technique dit du '''''Cache Probe Filtering'''''. L'idée part du principe que le cache d'instruction L1 est multiport. Les ports du cache d'instruction ne sont pas toujours utilisés en même temps et il arrive qu'il y ait un port de lecture de libre. Le CPF utilise alors ce port inutilisé pour vérifier si la prochaine ligne de cache à précharger est dans le cache ou non. Si c'est le cas, on aura un succès de cache : la ligne de cache est oubliée, elle ne sera pas préchargée. Si ce n'est pas le cas on aura un défaut de cache : la ligne sera préchargée.

Notez que l'on a pas besoin de lire la ligne en question, juste de vérifier les tags du cache. Dans ce cas, on peut ajouter des signaux de commande spécifiques pour le CPF, qui font une demi-lecture, qui ne vérifie que les tags, mais ne lit pas la donnée. On peut par exemple ajouter un port spécifique pour le CPF, purement en lecture et qui ne permet que de vérifier les tags. Ce port en plus a un cout en circuits plus faible qu'un port de lecture normal, mais ce n'est pas gratuit du tout.

&lt;noinclude&gt;
{{NavChapitre | book=Fonctionnement d'un ordinateur
           | prev=La prédiction de branchement
           | prevText=La prédiction de branchement
           | next=L'émission dans l'ordre des instructions
           | nextText=L'émission dans l'ordre des instructions
}}
&lt;/noinclude&gt;

{{AutoCat}}</text>
      <sha1>pa26y1hewfslhudlv8j8awpixdlvinc</sha1>
    </revision>
    <revision>
      <id>744081</id>
      <parentid>744057</parentid>
      <timestamp>2025-06-03T19:37:19Z</timestamp>
      <contributor>
        <username>Mewtow</username>
        <id>31375</id>
      </contributor>
      <minor />
      <comment>/* La macro-fusion */</comment>
      <origin>744081</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="47664" sha1="m320e057kfkff4frmhhdt0zxpsj9052" xml:space="preserve">Les processeurs modernes disposent de plusieurs unités de calcul, de bancs de registres larges et de tout un tas d'optimisations permettent d’exécuter un grand nombre d'instructions par secondes. Les opérations de calcul, les accès mémoire : tout cela est très rapide. Mais rien de cela ne fonctionnerait si l'unité de chargement ne suivait pas le rythme. En soi, l'unité de chargement est simple : le ''program counter'', les circuits pour l'incrémenter et gérer les branchements, l'unité de prédiction de branchement, et de quoi communiquer avec le cache. On doit aussi ajouter le registre d'instruction. Difficile de trouver de quoi l'optimiser, à part rendre l'unité de prédiction plus efficace.

Pourtant, les processeurs incorporent diverses optimisations qui rendent le tout beaucoup plus rapide. La plupart de ces optimisations consistent à ajouter des files d'attente ou des mémoires caches dans le ''front-end'', que ce soit après l'étape de chargement ou de décodage. Les caches en question sont situés en aval du cache d'instruction, ce qui en fait des sortes de cache de niveau 0. Les optimisations incluent le préchargement d'instruction, l'usage de files d'attente pour découpler divers circuits et quelques autres. Voyons lesquelles dans ce chapitre.

==La file d'instruction et le cache de macro-opération==

L'unité de chargement contient de nombreux circuits fortement liés entre eux, et on peut découper le tout en plusieurs circuits. L'unité de calcul d'adresse émet les adresses des instructions à charger, qui sont consommées par le cache d'instruction, qui lui-même envoie les instructions lues dans le registre d'instruction ou la file d'instructions. L'unité de calcul d'adresse regroupe : l'unité de prédiction de branchement, le ''program counter'', le circuit pour incrémenter le ''program counter'', les MUX associés pour gérer les branchements. 

Le couplage de ces structures fait qu'au moindre défaut de cache d'instruction, l'ensemble stoppe. Par exemple, l'unité de chargement stoppe en cas de défaut de cache. Même chose si jamais une instruction multicycle s’exécute dans le pipeline et bloque toutes les étapes précédentes. Pourtant, il est en théorie possible, et même utile, que certaines structures prennent de l'avance même si d'autres sont bloquées. Par exemple, si le pipeline est bloqué en aval de l'unité de chargement, l'unité de chargement peut en théorie précharger à l'avance des instructions. Ou encore, en cas de défaut de cache d'instruction, l'unité de calcul d'adresse peut précalculer les adresses destinées au cache et les mettre en attente. Pour cela, l'unité de chargement incorpore un paquet de mémoires FIFOs, que nous voir en détail dans ce qui suit.

===Les files d'instruction===

Les processeurs modernes intègrent une '''file d'instruction''', une mémoire FIFO, placée entre le cache d'instruction et le décodeur d'instruction. Les instructions chargées par l'étape de chargement soient accumulées dans la '''file d'instructions''' et sont décodées quand l'unité de décodage est prête.

La file d'attente permet de précharger des instructions dans la file d’instructions à l'avance, permettant ainsi de masquer certains accès au cache ou à la mémoire assez longs. L'idée est que les instructions s'accumulent dans la file d'instruction si le processeur exécute les instructions moins vite qu'il ne les charge. C'est généralement signe qu'il effectue une instruction multicycle et/ou qu'il effectue un accès à la mémoire. À l'inverse, la file d'attente se vide quand le processeur éxecute les instructions plus vite qu'il n'en charge. C'est généralement signe qu'un défaut de cache d'instruction est en cours.

La présence d'une file d'attente fait que la première situation est compensée lors de la seconde. Les temps d'attentes liées aux instructions multicycles permettent de remplir la file d'attente, qui est ensuite vidée en cas de défaut de cache. Le processeur exécute en permanence des instructions, sans interruption. Alors que sans file d'attente, les défauts de cache entraineront des temps d'attente où le processeur s’exécuterait rien.

La seule limite de cette optimisation est l'influence des branchements. Lorsqu'un branchement est décodé, ce tampon d’instructions est totalement vidé de son contenu. Ce n'est ni plus ni moins ce que faisait la ''prefetch input queue'' des anciens processeurs Intel, dont nous avions parlé dans le chapitre sur l'unité de chargement et le séquenceur.

===La macro-fusion===

La présence d'une file d'instruction permet d'ajouter une optimisation très importante au processeur, qui ne seraient pas possibles sans elle. L'une d'entre elle est la '''macro-fusion''', une technique qui permet de fusionner une suite d'instructions consécutives en une seule micro-opération. Par exemple, il est possible de fusionner une multiplication suivie d'une addition en une seule instruction MAD (''multiply and add''), si les conditions adéquates sont réunies pour les opérandes. Comme autre exemple, il est possible de fusionner un calcul d'adresse suivi d'une lecture à l'adresse calculée en une seule micro-opération d'accès mémoire. Et enfin, il est possible de fusionner une instruction de test et une instruction de branchement en une seule micro-opération de comparaison-branchement. C'est surtout cette dernière qui est utilisée sur les processeurs Intel modernes.

La macro-fusion est effectuée pendant le décodage, en décodant des instructions dans le tampon d'instruction. Le décodeur reconnait que plusieurs instructions dans le tampon d'instruction peuvent être fusionnées et fournit en sortie la micro-opération équivalent. L'avantage de cette technique est que le chemin de données est utilisé plus efficacement. Notons que la macro-fusion diminue le nombre d'instructions à stocker dans le ROB et dans les différentes mémoires intégrées aux processeur, qui stocke les micro-opérations.

La technique est parfois couplée à un circuit de prédiction, qui détermine si une série d'instruction à fusionner va apparaitre sous peu. L'idée est que dans certains cas, le tampon d'instruction contient le début d'une suite d'instruction combinables. Suivant ce qui sera chargé après, la macro-fusion pourra se faire, ou non. Mais le processeur ne sait pas exactement quelles seront les instructions chargées juste après et il ne sait pas si la macro-fusion aura lieu. Dans ce cas, il peut utiliser un circuit de prédiction de macro-fusion, qui essaye de prédire si les instructions chargées sous peu autoriseront une macro-fusion ou non. Si c'est le cas, les instructions potentiellement fusionnables, le début de la série macro-fusionnable, est mise en attente dans le tampon d'instruction, en attendant les futures instructions.

===Le cache de macro-opérations===

Le cache de macro-opérations est un cache présent en aval de l'unité de chargement, à côté de la file d’instruction. Il mémorise les dernières instructions envoyées à l'unité de décodage, à savoir non pas les instructions préchargées, mais celles qui sont en cours de décodage ou d’exécution, celles qui ont quitté la file d'instruction. Il sert dans le cas où ces instructions sont ré-éxecutées, ce qui est souvent le cas avec des boucles de petite taille.

A chaque cycle d'horloge, ce cache est consulté, de manière à vérifier si l'instruction voulue est dans ce cache ou non. Cela évite un accès au cache d'instruction. Son implémentation est simple : il s'agit d'un petit cache adressé par le ''program counter''. Si l'instruction a été chargée il y a peu, l'instruction machine est mémorisée dans une ligne de cache, le tag de cette ligne n'est autre que son adresse, le ''program counter'' associé. L'accès au cache de macro-opérations est de un seul cycle, pas plus.

[[File:Cache de macro-ops.png|centre|vignette|upright=2|Cache de macro-ops]]

L'intérêt n'est pas évident, mais disons que l'accès à ce cache gaspille moins d'énergie qu’accéder au cache d'instruction. C'est là l'intérêt principal, même s'il se peut qu'on puisse avoir un gain en performance. Le gain en question vient du fait que l'accès est plus rapide dans ce cache, ce qui n'est le cas que dans des conditions précise : si le cache d'instruction est pipeliné et a un temps d'accès de plusieurs cycles.

==La file de micro-opérations et le cache de micro-opérations==

[[File:File d'instruction.png|vignette|upright=1|File d'instruction]]

Sur les processeurs modernes, la sortie du décodeur est reliée à une mémoire FIFO semblable à la file d'instruction, mais placée juste après le décodeur. Elle mémorise les micro-opérations émises par le décodeur et les met en attente tant que le reste du pipeline n'est pas prêt. Nous l’appellerons la '''file de micro-opérations''', par simplicité. Le schéma ci-contre indique que la file de micro-opérations est située en sortie de l’unité de décodage, avant l'unité d'émission et avant l'unité de renommage de registres (que nous aborderons dans quelques chapitres).

La file de micro-opérations permet aux décodeurs de faire leur travail même si le reste du pipeline n'est pas prêt. Par exemple, imaginons que le processeur ne peut pas émettre de nouvelle instruction, soit car toutes les ALUs sont occupées, soit car il y a un accès mémoire qui bloque le pipeline, peu importe. Sans file de micro-opérations, tout ce qui précède l'unité d'émission devrait être totalement bloqué tant que l'instruction ne peut pas être émise. Mais avec une file de micro-opérations, le pipeline peut continuer à charger et décoder des instructions, et accumuler des instructions décodées dans la file de micro-opérations. En clair, la file de micro-opérations met en attente les instructions quand des bulles de pipeline sont émises.

Et à l'inverse, elle permet d'émettre des instructions quand les unités de décodage/chargement sont bloquées. Le cas classique est celui d'un défaut de cache dans le cache d'instruction. Des instructions ne peuvent plus être chargée et décodées durant quelques cycles. Sans file de micro-opérations, le processeur ne peut plus rien faire durant quelques cycles. Mais avec une file de micro-opérations, il peut en profiter pour émettre les instructions en attente dans la file de micro-opérations. En clair, si l'unité d'émission a mis en attente des instructions, le processeur se rattrape au prochain défaut de cache d'instruction.

Une autre situation où le décodeur bloque est le cas où certaines instructions mettent du temps à être décodées. C'est notamment le cas de certaines instructions complexes, dont le décodage prend facilement 2 à 3 cycles d'horloge, voire plus. Le pire est le décodage des instructions microcodées, qui peut demander plusieurs cycles. Or, le pipeline demande qu'on décode une instruction par cycle pour éviter de bloquer le pipeline. Mais ce temps de décodage peut être masqué si des micro-opérations sont en attente dans la file, elles sont exécutées pendant le décodage long.

La file de micro-opération est souvent complétée par plusieurs circuits, dont un circuit de micro-fusion, un cache de micro-opérations et le ''loop stream detector''. Voyons ces circuits dans ce qui suit.

[[File:File de micro-opérations et cache de micro-ops - Copie.png|centre|vignette|upright=2.5|File de micro-opérations et cache de micro-ops - Copie]]

===La micro-fusion===

La présence d'une file de micro-opération permet d'effectuer une optimisation appelée la '''micro-fusion'''. Elle remplace deux micro-opérations simples consécutives en une seule micro-opération complexe équivalente. Par exemple, sur certains processeurs, le chemin de données est capable d'effectuer une lecture/écriture en adressage base+index en une seule micro-opération. Mais le jeu d'instruction est une architecture Load-store où le calcul d'adresse et l'accès mémoire se font en deux instructions séparées. Dans ce cas, la micro-fusion peut faire son travail et fusionner le calcul d'adresse avec l'accès mémoire.

C'est une optimisation compatible avec la macro-fusion, les deux se ressemblant beaucoup. On peut se demander pourquoi les deux existent ensemble. La raison est historique, et tient au design des processeurs x86. Les premiers processeurs x86 avaient un chemin de données simple, avec les décodeurs qui allaient avec. Sur de tels processeurs, le calcul d'adresse et l'accès mémoire étaient séparés en deux instructions. Puis, avec l'évolution de la technologie, le chemin de données est devenu capable de faire les deux en une seule micro-opération. Pour compenser cela, Intel et AMD auraient pu changer leurs décodeurs en profondeur. A la place, ils ont préféré utiliser la technique de la micro-fusion, par simplicité.

===Le ''Loop Stream Detector''===

Les boucles sont une opportunité d'optimisation très intéressante sur les CPU avec une file de micro-opérations. L'idée est que lors d'une boucle, des instructions sont chargées, décodées et exécutées plusieurs fois de suite. Mais à, chaque répétition d'une instruction, le chargement et le décodage donnent toujours le même résultat, seule l'exécution n'est pas la même (les registres renommés sont aussi différents, mais passons). L'idée est simplement de mémoriser les N dernières instructions décodées et de les ré-exécuter si besoin. Ainsi, on évite de charger/décoder une même instruction machine plusieurs fois, mais de réutiliser les micro-opérations déjà décodées.

L'implémentation la plus simple conserve les N dernières instructions décodées dans la file d'instruction, qui se comporte alors comme une sorte de pseudo-cache FIFO. Un circuit annexe, appelé le ''Loop Stream Detector'' (LSD), détecte lesboucles dans la file de micro-opérations et optimise leur exécution. Avec un LSD, la file d'instruction ne supprime pas les micro-opérations une fois qu'elles sont émises. Elle mémorise là où se trouve la dernière micro-opération émise, mais conserve celles qui ont déjà été émises. Si une boucle adéquate est détectée par le ''Loop Stream Detector'', les micro-opérations de la boucle sont lues dans la file de micro-opération et sont injectées directement dans la suite du pipeline. De plus, les unités de chargement et de décodage sont désactivées pendant l’exécution de la boucle, ce qui réduit la consommation d'énergie du CPU.

L'optimisation accélère les petites boucles, à condition qu'elles s'exécutent de la même manière à chaque exécution. De telles boucles exécutent une suite de N instructions, qui reste identique à chaque itération de la boucle. Le cas le plus simple est celui d'une boucle dans laquelle il n'y a pas de branchements. Pour les boucles normales, le processeur reprend une exécution normale quand on quitte la boucle ou quand son exécution change, par exemple quand un if...else, un return ou tout autre changement de flot de contrôle a lieu. Vu que toutes ces situations impliquent un branchement qui n'a pas été pris comme avant, le processeur n'utilise plus le ''Loop Stream Detector'' en cas de mauvaise prédiction de branchement.

L'optimisation vise surtout à désactiver les décodeurs et l'unité de chargement lors de l'exécution d'une boucle. La désactivation peut être du ''clock gating'', voire du ''power gating'', être partielle ou totale. Dans le pire des cas, les unités de chargement peuvent continuer à charger des instructions en avance dans une file d'instruction, mais les décodeurs peuvent être désactivés. Dans le meilleur des cas, la totalité de ce qui précède la file de micro-opération est désactivé tant que la boucle s’exécute normalement. Y compris le cache de micro-opération.

[[File:Loop Stream Detector.png|centre|vignette|upright=2|Loop Stream Detector]]

Les CPU Intel modernes disposent d'un ''loop stream detector'', les CPU AMD en avaient sur les microarchitectures Zen 4 mais il a disparu sur la microarchitecture Zen 5. Quelques CPU ARM avaient aussi un ''loop stream detector'', notamment le Cortex A15. Évidemment, la taille des boucles optimisées ainsi est limitée par la taille de la file de micro-opération, ce qui fait que l'optimisation ne fonctionne que pour des boucles de petite taille. De plus, toute la file de micro-opération n'est pas gérée par le ''loop stream detector''. Par exemple, les processeurs avec une file de micro-opération de 64 micro-opération peuvent gérer des boucles de maximum 32 à 40 micro-opérations. Pour donner quelques chiffres, les processeurs ARM Cortex A15 géraient des boucles de maximum 32 micro-opérations.

Mais les contraintes principales portent sur la détection des boucles. Le ''Loop Stream Detector'' ne peut pas détecter toutes les boucles qui existent, et certaines boucles ne sont pas détectées. Par exemple, le ''Loop Stream Detector' ne peut pas détecter les boucles si un appel de fonction a lieu dans la boucle. Il y a aussi des contraintes quant au nombre de branchements à l'intérieur de la boucle et le nombre d'accès mémoire.

Il faut noter que le ''loop stream detector'' a été désactivé par des mises à jour de microcode sur quelques architectures, comme sur la microarchitecture Zen 4 d'AMD ou les CPU de microarchitecture Skylake et Kaby Lake d'Intel. Pour la microarchitecture Skylake , les raisons officielles pour cette désactivation sont un bug lié à l'interaction avec l'''hyperthreading''. Il est vraisemblable que des bugs ou des problèmes de sécurité aient amené à la désactivation sur les autres architectures.

===Le cache de micro-opérations===

Le '''cache de micro-opérations''' a le même but que le ''Loop Stream Detector'', à savoir optimiser l'exécution des boucles. La différence avec le ''Loop Stream Detector'' est qu'il y a un cache séparé de la file de micro-opérations, qui mémorise des micro-opérations décodées, dans le cas où elles soient réutilisées par la suite. La première itération d'une boucle décode les instructions en micro-opérations, qui sont accumulées dans le cache de micro-opérations. Les itérations suivantes de la boucle vont chercher les micro-opérations adéquates dans le cache de micro-opération : on n'a pas à décoder l'instruction une nouvelle fois.

Intuitivement, vous vous dites que son implémentation la plus simple mémorise les N dernières micro-opérations exécutées par le processeur, ce qui en fait un cache FIFO. Mais la réalité est que c'est déjà ce qui est fait par le couple LSD + file de micro-opération. Le cache de micro-opérations a une politique de remplacement des lignes de cache plus complexe que le FIFO, typiquement une politique LRU ou LFU approximée. De plus, le cache de micro-opération est séparé de la file de micro-opération. Et il est alimenté non pas par l'unité de décodage, mais par la file de micro-opérations. Ce sont les micro-opérations qui quittent la file de micro-opérations qui sont insérées dans le cache, pas celles qui quittent directement le décodeur.

Les avantages sont les mêmes qu'avec un ''Loop Stream Detector'' : une consommation énergétique réduite, des performances légèrement améliorées. Le décodeur et l'unité de chargement sont inutiles en cas de succès dans le cache de micro-opération, ce qui fait qu'ils sont désactivés, éteints, ou du moins subissent un ''clock-gating'' temporaire. Ils ne consomment pas d'énergie, seul le cache de micro-opération utilise de l'électricité. L'avantage en termes de performance est plus faible, assez variable suivant la situation, mais aussi bien le cache de micro-opérations que le LSD ne font pas de mal.

La différence avec le cache de micro-opération est que la boucle doit s’exécuter à l'identique avec un ''Loop Stream Detector'', pas avec un cache de micro-opérations. Prenons l'exemple d'une boucle contenant quelques instructions suivies par un IF...ELSE. Il arrive qu'une itération de la boucle exécute le IF, alors que d'autres exécutent le ELSE. Dans ce cas, le ''Loop Stream Detector'' ne sera pas activé, car la boucle ne s’exécute pas pareil d'une itération à l'autre. Par contre, avec un cache de macro/micro-opération, on pourra lire les instructions précédant le IF...ELSE dedans. Le cache de micro-opération est donc plus efficace que le ''Loop Stream Detector'', mais pour un cout en transistor plus élevé.

Le cache de micro-opérations et le ''Loop Stream Detector'' font la même chose, mais certains processeurs implémentaient les deux. L'avantage est que le cache de micro-opération peut être désactivé si jamais le LSD détecte une boucle dans la file d'instruction, ce qui réduit encore plus la consommation énergétique. En pratique, l'impact sur la consommation énergétique est très difficile à mesurer, mais il rajoute de la complexité pour la conception du processeur.

[[File:File de micro-opérations et cache de micro-ops.png|centre|vignette|upright=2|File de micro-opérations et cache de micro-ops]]

Le cache de micro-opération associe, pour chaque instruction machine, une ou plusieurs micro-opérations. Avec l'implémentation la plus simple, une ligne de cache est associée à une instruction machine. Par exemple, sur les processeurs Intel de microarchitecture Skylake, chaque ligne de cache était associée à une instruction machine et pouvait contenir de 1 à 6 micro-opérations. La suite de micro-opérations correspondant à une instruction devait tenir toute entière dans une ligne de cache, ce qui fait que les instructions décodées en plus de 6 micro-opérations ne pouvaient pas rentrer dans ce cache.

L'accès au cache de micro-opération se fait lors de l'étape de chargement. Le cache de micro-opérations est adressé en envoyant le  ''program counter'' sur son entrée d'adresse, en parallèle du cache d'instruction. Le cache de micro-opération est une voie de chargement parallèle au ''front-end'' proprement dit. En clair, il y a une voie qui regroupe cache d'instruction, file d'instruction et décodeur, et une seconde voie qui se résume au cache de micro-opération. Les deux voies sont accédées en parallèle. En cas de succès dans le cache de micro-opération, les micro-opérations adéquates sont lues directement depuis le cache de micro-opération.

Il existe deux méthodes différentes pour encoder les micro-opérations dans le cache de micro-opérations. La première est la plus intuitive : on mémorise les micro-opérations dans la ligne de cache, directement. Elle est utilisée sur les processeurs AMD, et sans doute sur les processeurs Intel récents. Mais les anciens processeurs Intel, comme ceux des architectures Sandy Bridge et Netburst, utilisent une autre méthode. Une ligne de cache mémorise non pas les micro-opération directement, mais un pointeur vers le ''control store'', qui indique à quelle adresse dans le micro-code se situe la micro-opération. La micro-opération est donc lue depuis le micro-code lors de l'émission.

Il faut noter que pour des raisons de performance, le cache de micro-opérations est virtuellement tagué, ce qui fait qu'il est invalidé en cas de changement de programme. Sur l'architecture Sandy Bridge, il est carrément inclus dans le cache L1, les deux sont des caches inclusifs l'un avec l'autre. Les premières implémentations étaient très limitées. Les micro-opérations devaient être séquentielles dans le code, le cache était consulté seulement après un branchement et non à chaque émission d'instruction, pour limiter la consommation d'énergie an détriment des performances. Ces limitations ne sont pas présentes sur les architectures récentes.

Aussi bien le cache de macro-opérations que le cache de micro-opérations optimisent l'exécution des boucles, mais ils ne sont pas au même endroit dans le pipeline : avant et après l'unité de décodage. Et le premier mémorise des instructions machines, l'autre des micro-opérations décodées. Les avantages et inconvénients sont totalement différents. Niveau capacité des deux caches, l'encodage des instructions machines est plus compact que la ou les micro-instructions équivalente, ce qui est un avantage pour le cache de macro-opérations à capacité équivalente. Par contre, le cache de micro-opérations permet de désactiver les décodeurs en cas de succès de cache, vu que les instructions ne doivent plus être décodées et renommées. Le gain est d'autant plus important si les instructions ont un encodage complexe, ou si les instructions sont à longueur variable, ce qui rend leur décodage complexe et donc lent. Globalement, plus le décodage est complexe et/ou long, plus le cache de micro-opérations fait des merveilles.

==Le préchargement d'instructions et la ''Fetch Target Queue''==

Les processeurs modernes incorporent une optimisation assez intéressante : ils découplent l'unité de prédiction de branchement et le ''program counter'' de l'accès au cache d'instruction. Pour cela, ils incorporent une mémoire FIFO entre l'unité de prédiction de branchement et le cache d'instruction. Les premiers articles scientifiques, qui ont proposé cette solution, l'ont appelée la '''''Fetch Target Queue''''', abréviée FTQ. Elle accumule les adresses à lire/écrire dans le cache d'instruction, peu importe que ces adresses viennent du ''program counter'' ou de l'unité de prédiction de branchement.

[[File:Fetch target queue.png|centre|vignette|upright=2.5|Fetch target queue]]

Elle se remplit quand le cache d'instruction est bloqué, soit à cause d'un défaut de cache, soit à cause d'un pipeline bloqué en amont de l'unité de chargement. Par exemple, si le cache d'instruction est bloqué par un défaut de cache, l'unité de prédiction de branchement peut accumuler des prédictions à l'avance dans la FTQ, qui sont ensuite consommées par le cache d'instruction une fois qu'il est redevenu disponible. De même, si l'unité de prédiction de branchement est bloquée par un évènement quelconque, le cache d'instruction peut consommer les prédictions faites à l'avance.

Une utilisation assez originale de la FTQ s'est vu sur les processeurs AMD d'architectures bulldozer. Sur cette architecture, les cœurs étaient regroupés par paquets de deux, et les deux cœurs partageaient certains circuits. Notamment, l'unité de prédiction de branchement était partagée entre les deux cœurs ! Pourtant, chaque cœur disposait de sa propre FTQ !

Un avantage de la FTQ tient dans le fait que les caches d'instructions sont pipelinés, sur le même modèle que les processeurs. On peut leur envoyer une demande de lecture/écriture par cycle, alors que chaque lecture/écriture prendra plusieurs cycles à s'effectuer. L'accès au cache d'instruction a donc une certaine latence, qui est partiellement masquée par la FTQ au point où elle ne s'exprime qu'en cas de défaut de cache assez important. Par exemple, si l'accès au cache d'instruction prend 4 cycles, une FTQ qui met en attente 4 adresses camouflera le temps d'accès au cache, tant qu'il n'y a pas de mauvaise prédiction de branchement.  La FTQ est aussi très utile avec les unités de branchement modernes, qui peuvent mettre plusieurs cycles pour fournir une prédiction. Prendre de l'avance avec une FTQ amorti partiellement le temps de calcul des prédictions.

: Si le cache d'instruction est multiport et accepte plusieurs accès simultanés, il peut consommer plusieurs entrées dans la FTQ à la fois.

Mais l'avantage principal de la FTQ est qu'elle permet l'implémentation d'une optimisation très importante. Il y a quelques chapitres, nous avions parlé des techniques de '''préchargement d'instruction''', qui permettent de charger à l'avance des instructions dans le cache d'instruction. Nous avions volontairement laissé de côté le préchargement des instructions, pour tout un tas de raisons. Et la raison est justement que la prédiction de branchement et le préchargement des instructions sont fortement liés sur les processeurs modernes. Il est maintenant possible d'aborder le préchargement pour les instructions, d’où cette section.

Notons que par préchargement des instructions, on peut parler de deux formes de préchargement, fortement différentes. La première correspond au préchargement normal, à savoir le préchargement des instructions dans le cache d'instruction L1, à partir du cache L2. Il s'agit donc d'un préchargement dans le cache d'instruction. Mais il existe aussi une autre forme de préchargement, qui consiste à précharger à l'avance des instructions dans la file d'instruction et qui a été abordée dans la section sur la ''prefetch input queue''. Les deux formes de préchargement n'ont pas lieu au même endroit dans la hiérarchie mémoire : l'une précharge du cache L2 vers le L1i, l'autre du cache L1i vers la file d'instruction (ou dans le cache de macro-opération). Mais les algorithmes utilisés pour sont sensiblement les mêmes. Aussi, nous allons les voir en même temps. Pour faire la distinction, nous parlerons de préchargement L2-L1i pour la première, de préchargement interne pour l'autre.

===Les algorithmes de préchargement d'instructions===

Les techniques basiques de préchargement consistent à charger des instructions qui suivent la dernière ligne de cache accédée. Quand on charge des instructions dans le cache d’instruction, les instructions qui suivent sont chargées automatiquement, ligne de cache par ligne de cache. il s'agit due préchargement séquentiel, la technique la plus simple de préchargement, qui profite de la localité spatiale. Elle est utilisée pour précharger des instructions du cache L2 vers le cache L1i, mais aussi pour le préchargement interne dans la file d'instructions. 

[[File:Branchements et préchargement séquentiel.png|centre|vignette|upright=2|Branchements et préchargement séquentiel.]]

Mais un ''prefetcher'' purement séquentiel gère mal les branchements. Si un branchement est pris, les instructions de destination ne sont pas chargées, si elles ne sont pas dans la ligne de cache suivante. Pour le préchargement L2-L1i, cela ne pose pas de problèmes majeurs, au-delà de la pollution du cache L1i par des instructions inutiles. Mais pour le préchargement interne, c'est autre chose. Les instructions préchargées par erreurs doivent être supprimées pour éviter qu'elles soient décodées et exécutées, ce qui fait que la file d’instruction doit être invalidée.

Il existe des techniques de préchargement plus élaborées qui marchent mieux en présence de branchements. Elles utilisent toutes une collaboration de l'unité de prédiction de branchement. Elles accèdent au ''Branch Target Buffer'', pour détecter les branchements, leur destination, etc. Le tout peut se coupler à la technique du prédécodage. Avec cette dernière, le prédécodage décode en partie les instructions lors de leur chargement dans le cache, et détecte les branchements et leur adresse de destination à ce moment-là. Ces informations sont alors mémorisées dans une table à part, ou dans le BTB. Mais la plupart des designs utilisent le BTB, par souci de simplicité. Il existe globalement deux à trois techniques principales, que nous allons voir dans ce qui suit.

La première technique prédit si le branchement est pris ou non, et agit différemment si le branchement est pris ou non. Si le branchement est pris, elle précharge les instructions à partir de l'adresse de destination des branchements pris. Sinon, elle précharge les instructions suivantes avec préchargement séquentiel. Il s'agit du '''''target line prefetching'''''

[[File:Target line prefetching.png|centre|vignette|upright=2|Target line prefetching.]]

Une autre technique ne prédit pas les branchements et précharge à la fois les instructions suivantes avec le ''next-line prefetching'', et la ligne de cache de destination du branchement avec le ''target line prefetching''. Comme ça, peu importe que le branchement soit pris ou non, les instructions adéquates seront préchargées quand même. On appelle cette technique le '''préchargement du mauvais chemin''' (''wrong path prefetching'').

[[File:Préchargement du mauvais chemin.png|centre|vignette|upright=2|Préchargement du mauvais chemin.]]

Le ''target line prefetching'' est plus complexe à implémenter, car il demande de prédire les branchements.  Mais elle a l'avantage de ne pas précharger inutilement deux lignes de cache par branchement, seulement une seule. Par contre, le préchargement est inutile en cas de mauvaise prédiction de branchement : non seulement on a préchargé une ligne de cache inutilement, mais en plus, la ligne de cache adéquate n'a pas été chargée. On n'a pas ce problème avec le préchargement du mauvais chemin, qui garantit que la ligne de cache adéquate est toujours préchargée.

===L'implémentation du préchargement interne, dans la file d'instruction===

Le préchargement dans la file d'instruction est généralement de type séquentiel, mais certains processeurs font autrement. Déjà, il faut remarquer que le ''target line prefetching'' correspond en réalité à la prédiction de branchement classique. L'adresse de destination est prédite, et on charge les instructions adéquates dans la file d'instruction. La prédiction de branchement, associée à une file d'instruction, est donc une forme de préchargement. Il fallait y penser. Enfin, des processeurs assez rares utilisaient le préchargement du mauvais chemin.

Le préchargement du mauvais chemin demande d'utiliser deux files d'instructions séparées. L'une dans laquelle on précharge de manière séquentielle, l'autre dans laquelle on utilise la prédiction de branchement pour faire du ''target line prefetching''. Une fois que l'on sait si la prédiction de branchement était correcte, on est certain qu'une des deux files contiendra les instructions valides. Le contenu de la file adéquate est conservé, alors que l'autre est intégralement invalidée. Le choix de la bonne file se fait avec un multiplexeur. C'est approximativement la technique qui était implémentée sur le processeur de mainframe IBM 370/165, par exemple, et sur quelques modèles IBM similaires.

Le problème est que cette méthode demande de charger deux instructions à chaque cycle. Cela demande donc d'utiliser un cache d'instruction multiport, avec un port par file d'instruction. Le cout en circuit d'un cache double port n'est pas négligeable. Et le gain en performance est assez faible. Le préchargement dans la file d’instruction permet d'économiser quelques cycles lors de l'accès au cache d'instruction, guère plus. Le gain est maximal lorsque les instructions préchargées ont généré un défaut de cache, qui a rapatrié les instructions adéquates pendant que le processeur exécutait les mauvaises instructions, avant que la mauvaise prédiction de branchement soit détectée. Dans ce cas, le défaut de cache a eu lieu pendant la mauvaise prédiction et sa réparation, et non après.

====La gestion des branchements successifs====

Un autre défaut de cette méthode est la présence de branchements successifs. Par exemple, si jamais on rencontre un branchement, le flux d'instructions se scinde en deux : un où le branchement est pris, un autre où il ne l'est pas. Chacun de ces flux peut lui-même contenir un branchement, et se scinder lui aussi. Et ainsi de suite. Et le processeur doit gérer cette situation en termes de préchargement.

[[File:Exécution stricte 04.png|centre|vignette|upright=2|Exécution stricte]]

Plusieurs solutions existent. La méthode la plus simple stoppe le chargement du flux en attendant que le premier branchement soit terminé. Cette solution est intuitive, mais est celle où on a les gains en performance les plus faibles. Elle est couramment implémentée d'une manière assez particulière, qui ne correspond pas tout à fait à un stop du chargement, mais qui utilise les lignes de cache. L'unité de préchargement est conçue pour copier des lignes de cache entières dans la file d'instruction. Le processeur (pré-)charge deux lignes de cache : celle du bon chemin, celle du mauvais chemin. Il les précharge dans deux files d'instructions, qui contiennent généralement une ligne de cache grand maximum. Le temps que l'on ait chargé les deux files d'instruction, le résultat du branchement est connu et on sait laquelle est la bonne.

L'autre possibilité est d'utiliser la prédiction de branchement pour ce flux, afin de poursuivre le chargement de manière spéculative. Elle donne de bonnes performances, mais demande des unités de prédiction de branchement spéciales, dans le cas où les deux flux tombent sur un branchement en même temps. Cette technique est indirectement liée au cache de traces que nous verrons dans le chapitre sur les processeurs superscalaires. Nous n'en parlons pas ici, car ce genre de techniques est plus liée aux processeurs superscalaires qu'un processeur avec un pipeline normal.

Une autre possibilité consiste à scinder ce flux en deux et charger les deux sous-flux. Cette dernière est impraticable car elle demande des caches avec un grand nombre de ports et la présence de plusieurs files d'instructions, qui sont utilisées assez rarement.

[[File:Exécution stricte 01.png|centre|vignette|upright=2|Exécution stricte, seconde.]]

====Les processeurs à exécution de chemins multiples====

L'idée précédente peut en théorie être améliorée, afin de non seulement charger les instructions en provenance des deux chemins (celui du branchement pris, et celui du branchement non pris), mais aussi de les exécuter : c'est ce qu'on appelle l''''exécution stricte''' (''eager execution''). Bien sûr, on n’est pas limité à un seul branchement, mais on peut poursuivre un peu plus loin. 

Quelques papiers de recherche ont étudié l'idée, mais ses défauts font qu'elle n'a jamais été utilisée dans un processeur en dehors de prototypes destinés à la recherche. Le gros problème de l'exécution stricte est qu'on est limité par le nombre d'unités de calculs, de registres, etc. Autant ce serait une technique idéale sur des processeurs avec un nombre illimité de registres ou d'unités de calcul, autant ce n'est pas le cas dans le monde réel. Au bout d'un certain nombre d’embranchements, le processeur finit par ne plus pouvoir poursuivre l’exécution, par manque de ressources matérielles et doit soit stopper, soit recourir à la prédiction de branchement. Il y a le même problème avec le préchargement interne simple, quand on utilise le préchargement du mauvais chemin, comme vu juste au-dessus.

===L'implémentation matérielle du préchargement de cache L2-L1i===

Pour comprendre comment s'effectue le préchargement L2-L1i, il faut regarder comment l'unité de chargement communique avec les caches. L'unité de prédiction de branchement est généralement regroupée avec le ''program counter'' et les circuits associés (les incrémenteurs/MUX associés), pour former l'unité de chargement proprement dite. L'unité de chargement émet des adresses consommées par le cache d'instruction, qui lui-même envoie les instructions lues dans le registre d'instruction ou la file d'instructions.

Le couplage de ces structures fait qu'au moindre défaut de cache d'instruction, l'ensemble stoppe. Et notamment, l'unité de prédiction de branchement stoppe en cas de défaut de cache. Même chose si jamais une instruction multicycle s’exécute dans le pipeline et bloque toutes les étapes précédentes. Les pertes de performance ne sont pas très importantes, mais elles existent. Et le préchargement se manifeste dans ces situations.

Le préchargement d'instructions consiste à découpler ces structures de manière à ce qu'elles fonctionnent plus ou moins indépendamment. Le but est qu'en plus des accès normaux au cache d'instruction, l'unité de chargement envoie des informations au cache L2 ou L1i en avance, pour effectuer le préchargement. L'unité de chargement doit alors prendre de l'avance sur le cache, pour effectuer les accès au cache L2 en avance, tout en maintenant l'état normal pour effectuer les accès normaux. C'est donc plus ou moins l'unité de chargement qui s'occupe du préchargement, ou du moins les deux sont très liées.

====L'anticipation du ''program counter''====

Avec la solution la plus simple, on a une unité de chargement qui s'occupe des accès au cache d'instruction, et une unité de préchargement qui prend de l'avance sur l'unité de chargement, et communique avec le cache L2. La technique la plus basique se base sur un ''Lookahead program counter'', un second ''program counter'' qui ne fonctionne que lors d'un défaut de cache d'instruction. Il est initialisé avec le ''program counter'' lors d'un défaut de cache, puis il est incrémenté à chaque cycle et les branchements sont prédits, ce qui fait qu'il est mis à jour comme si l’exécution du programme se poursuivait, alors que le reste du processeur est mis en attente.

La technique initiale utilisait ce second ''program counter'' pour accéder à une table de prédiction, qui associe à chaque valeur du ''program counter'', l'adresse des données chargées par l'instruction associée. Les adresses fournies à chaque cycle par cette table sont alors envoyées aux unités de préchargement pour qu'elles fassent leur travail. La technique permettait donc de précharger des données en cas de défaut de cache, mais pas d'instructions. Il ne s'agissait pas d'une technique de préchargement des instructions, mais de préchargement de données.

La technique a ensuite été adaptée pour le chargement des instructions par Chen, Lee et Mudge. Leur idée utilisait deux unités de prédiction de branchements : une couplée à l'unité de chargement, l'autre pour le préchargement. La première utilisait le ''program counter'' normal, l'autre se déclenchait en cas de défaut de cache et utilisait un ''lookahead program counter''. Les adresses générées par le ''lookahead program counter'' étaient envoyée au cache d'instruction, sur un port de lecture séparé. La ligne de cache lue était alors prédécodée pour détecter les branchements, qui étaient prédits, et rebelote. Il est possible d'adapter la méthode pour que les adresses soient accumulées dans une mémoire FIFO, et étaient consommée par le cache d'instruction L2 pour le préchargement si la ligne de cache associée n'était pas dans le cache d’instruction.

Les techniques modernes n'utilisent plus de seconde unité de prédiction de branchement, mais conservent un ''lookahead program counter''. Par contre, le BTB dispose de plusieurs ports : un pour la prédiction de branchement normale, l'autre pour le préchargement. L'unité de préchargement et l'unité de chargement accèdent toutes deux au BTB quand elles ont besoin de faire leurs prédictions, en parallèle. Typiquement, le BTB est accédé à chaque cycle pour la prédiction de branchement, à un rythme plus faible pour le préchargement.

====Le ''Fetch Directed Instruction Prefetching''====

Les processeurs modernes semblent utiliser un algorithme connu sous le nom de '''''Fetch Directed Instruction Prefetching'''''. Il utilise les adresses contenues dans la FTQ pour précharger les instructions adéquates du cache L2 vers le cache L1 d'instruction (L1i). L'unité de préchargement est placée en aval de la FTQ, elle lit son contenu, détecte quelles adresses correspondent à des lignes de cache à précharger, et envoie celles-ci au cache L2. Le préchargement du L2 vers le L1i a lieu quand le cache L2 est inutilisé, ou du moins quand il peut accepter une nouvelle lecture (dans le cas d'un cache multiport et/ou pipeliné).

[[File:Fetch directed instruction prefetching.png|centre|vignette|upright=2.5|Fetch directed instruction prefetching]]

On peut améliorer légèrement le design précédent sur plusieurs points. Pour éviter de polluer le cache L1 avec des lignes de caches préchargées à tort, il est possible d'ajouter un équivalent des ''stream buffer'' vus dans le chapitre sur le préchargement. Il s'agit d'une autre mémoire FIFO qui mémorise les lignes de cache préchargées. Les lignes de cache préchargées ne sont pas placées dans le cache L1i, mais dans cette file d'attente. Lors d'un accès au L1i, la file d'attente est consultée en parallèle. Si l'instruction voulue est dans la file d'attente, elle est lue depuis la file, et la ligne de cache associée est copiée dans le cache L1i. Mais c'est là une possibilité facultative.

Un autre point est que l'unité de préchargement doit attendre que le cache L2 puisse accepter une nouvelle lecture pour lancer le préchargement d'une autre ligne de cache. Pour corriger cela, on ajoute une file d'attente entre le cache L2 et l'unité de préchargement, qui est évidemment une mémoire FIFO. Son utilité dépend des temps de lectures du cache L2, ainsi que de la taille de la FTQ. Elle n'est pas toujours nécessaire, certains processeurs ont un cache L2 assez lent pour qu'on ne puisse précharger qu'une seule ligne de cache avant que la FTQ soit complétement vide.

Ces deux optimisations sont facultatives, mais elles étaient présentes dans l'article originel qui a proposé la technique. 

L'unité de préchargement doit détecter quelles sont les adresses de la FTQ qui ne sont pas déjà chargées dans le L1i. En effet, il est inutile de précharger une ligne de cache si celle-ci est déjà dans le cache L1i. L'unité de préchargement doit donc filtrer au mieux les adresses de la FTQ en deux classes : celles qui correspondent à une ligne de cache déjà dans le L1i, celles qui doivent être préchargées.

Pour cela, l'unité de préchargement utilise la technique dit du '''''Cache Probe Filtering'''''. L'idée part du principe que le cache d'instruction L1 est multiport. Les ports du cache d'instruction ne sont pas toujours utilisés en même temps et il arrive qu'il y ait un port de lecture de libre. Le CPF utilise alors ce port inutilisé pour vérifier si la prochaine ligne de cache à précharger est dans le cache ou non. Si c'est le cas, on aura un succès de cache : la ligne de cache est oubliée, elle ne sera pas préchargée. Si ce n'est pas le cas on aura un défaut de cache : la ligne sera préchargée.

Notez que l'on a pas besoin de lire la ligne en question, juste de vérifier les tags du cache. Dans ce cas, on peut ajouter des signaux de commande spécifiques pour le CPF, qui font une demi-lecture, qui ne vérifie que les tags, mais ne lit pas la donnée. On peut par exemple ajouter un port spécifique pour le CPF, purement en lecture et qui ne permet que de vérifier les tags. Ce port en plus a un cout en circuits plus faible qu'un port de lecture normal, mais ce n'est pas gratuit du tout.

&lt;noinclude&gt;
{{NavChapitre | book=Fonctionnement d'un ordinateur
           | prev=La prédiction de branchement
           | prevText=La prédiction de branchement
           | next=L'émission dans l'ordre des instructions
           | nextText=L'émission dans l'ordre des instructions
}}
&lt;/noinclude&gt;

{{AutoCat}}</text>
      <sha1>m320e057kfkff4frmhhdt0zxpsj9052</sha1>
    </revision>
  </page>
  <page>
    <title>Les cartes graphiques/La mémoire unifiée et la mémoire vidéo dédiée</title>
    <ns>0</ns>
    <id>80571</id>
    <revision>
      <id>744045</id>
      <parentid>744007</parentid>
      <timestamp>2025-06-03T14:29:34Z</timestamp>
      <contributor>
        <username>Mewtow</username>
        <id>31375</id>
      </contributor>
      <minor />
      <comment>/* Historique de la mémoire virtuelle sur les GPU */</comment>
      <origin>744045</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="18251" sha1="2wd36e573lnpf01ki229alhtbj59hvc" xml:space="preserve">Pour rappel, il existe deux types de cartes graphiques : les cartes dédiées et les cartes intégrées. Les '''cartes graphiques dédiées''' sont des cartes graphiques branchées sur des connecteurs/ports de la carte mère. A l'opposé, tous les processeurs modernes intègrent une carte graphique, appelée '''carte graphique intégrée''', ou encore '''IGP''' (''Integrated Graphic Processor''). En somme, les cartes dédiées sont opposées à celles intégrées dans les processeurs modernes.

La différence a un impact sur la mémoire vidéo. Les cartes graphiques dédiées ont souvent de la mémoire vidéo intégrée à la carte graphique. Il y a des exceptions, mais on en parlera plus tard. Les cartes graphiques intégrées au processeur n'ont pas de mémoire vidéo dédiée, vu qu'on ne peut pas intégrer beaucoup de mémoire vidéo dans un processeur. La conséquence est qu'il existe deux grandes manières d'organiser la mémoire à laquelle la carte graphique a accès.
* La première est celle de la '''mémoire vidéo dédiée''', à savoir que la carte graphique dispose de sa propre mémoire rien qu'à elle, séparée de la mémoire RAM de l'ordinateur. On fait alors la distinction entre ''RAM système'' et ''RAM vidéo''. Si les premières cartes graphiques n'avaient que quelques mégaoctets de RAM dédiée, elles disposent actuellement de plusieurs gigas-octets de RAM.
* A l'opposé, on trouve la '''mémoire unifiée''', avec une seule mémoire RAM est partagée entre le processeur et la carte graphique. Le terme &quot;unifiée&quot; sous-entend que l'on a unifié la mémoire vidéo et la mémoire système (la RAM).

[[File:Répartition de la mémoire entre RAM système et carte graphique.png|centre|vignette|upright=2.5|Répartition de la mémoire entre RAM système et carte graphique]]

Dans la grosse majorité des cas, les cartes vidéos dédiées ont une mémoire dédiée, alors que les cartes graphiques intégrées doivent utiliser la mémoire unifiée. Mais outre les cartes dédiées et intégrées, il faut aussi citer les cartes graphiques soudées sur la carte mère. Elles étaient utilisées sur les consoles de jeu vidéos assez anciennes, elles sont encore utilisées sur certains PC portables puissants, destinés aux ''gamers''. Pour ces dernières, il est possible d'utiliser aussi bien de la mémoire dédiée que de la mémoire unifiée. D'anciennes consoles de jeu avaient une carte graphique soudée sur la carte mère, qu'on peut facilement repérer à l’œil nu, avec une mémoire unifiée. C'est notamment le cas sur la Nintendo 64, pour ne citer qu'elle. D'autres avaient leur propre mémoire vidéo dédiée.

L'usage d'une carte vidéo dédiée se marie très bien avec une mémoire vidéo dédiée, mais il existe de nombreux cas où une carte vidéo dédiée est associée à de la mémoire unifiée. Comme exemple, la toute première carte graphique AGP, l'Intel 740, ne possédait pas de mémoire vidéo proprement dite, juste un simple ''framebuffer''. Tout le reste, texture comme géométrie, était placé en mémoire système et la carte graphique allait lire/écrire les données directement en mémoire RAM système ! Les performances sont généralement ridicules, pour des raisons très diverses, mais les cartes de ce type sont peu chères. Outre l'économie liée à l'absence de mémoire vidéo, les cartes graphiques de ce type sont peu puissantes, l'usage de la mémoire unifiée simplifie leur conception, etc. Par exemple, l'Intel 740 a eu un petit succès sur les ordinateurs d'entrée de gamme.

==Le partage de la mémoire unifiée==

Avec la mémoire unifiée, la quantité de mémoire système disponible pour la carte graphique est généralement réglable avec un réglage dans le BIOS. On peut ainsi choisir d'allouer 64, 128 ou 256 mégaoctets de mémoire système pour la carte vidéo, sur un ordinateur avec 4 gigaoctets de RAM. L'interprétation de ce réglage varie grandement selon les cartes mères ou l'IGP.

Pour les GPU les plus anciens, ce réglage implique que la RAM sélectionnée est réservée uniquement à la carte graphique, même si elle n'en utilise qu'une partie. La répartition entre mémoire vidéo et système est alors statique, fixée une fois pour toutes. Dans ce cas, la RAM allouée à la carte graphique est généralement petite par défaut. Les concepteurs de carte mère ne veulent pas qu'une trop quantité de RAM soit perdu et inutilisable pour les applications. Ils brident donc la carte vidéo et ne lui allouent que peu de RAM.

Heureusement, les GPU modernes sont plus souples. Ils fournissent deux réglages : une quantité de RAM minimale, totalement dédiée au GPU, et une quantité de RAM maximale que le GPU ne peut pas dépasser. Par exemple, il est possible de régler le GPU de manière à ce qu'il ait 64 mégaoctets rien que pour lui, mais qu'il puisse avoir accès à maximum 1 gigaoctet s'il en a besoin. Cela fait au total 960 mégaoctets (1024-64) qui peut être alloués au choix à la carte graphique ou au reste des programmes en cours d’exécution, selon les besoins. Il est possible d'allouer de grandes quantités de RAM au GPU, parfois la totalité de la mémoire système.

[[File:Partage de la mémoire unifiée entre CPU et GPU.png|centre|vignette|upright=2|Répartition de la mémoire entre RAM système et carte graphique]]

==Le partage de la mémoire système : la mémoire virtuelle des GPUs dédiés==

Après avoir vu la mémoire unifiée, voyons maintenant la mémoire dédiée. Intuitivement, on se dit que la carte graphique n'a accès qu'à la mémoire vidéo dédiée et ne peut pas lire de données dans la mémoire système, la RAM de l'ordinateur. Cependant, ce n'est pas le cas. Et ce pour plusieurs raisons. La raison principale est que des données doivent être copiées de la mémoire RAM vers la mémoire vidéo. Les copies en question se font souvent via ''Direct Memory Access'', ce qui fait que les GPU intègrent un contrôleur DMA dédié. Et ce contrôleur DMA lit des données en RAM système pour les copier en RAM vidéo.

La seconde raison est que les cartes graphiques intègrent presque toutes des technologies pour lire directement des données en RAM, sans forcément les copier en mémoire vidéo. Les technologies en question permettent à la carte graphique d'adresser plus de RAM qu'en a la mémoire vidéo. Par exemple, si la carte vidéo a 4 giga-octets de RAM, la carte graphique peut être capable d'en adresser 8 : 4 gigas en RAM vidéo, et 4 autres gigas en RAM système.

Les technologies de ce genre ressemblent beaucoup à la mémoire virtuelle des CPU, avec cependant quelques différences. La mémoire virtuelle permet à un processeur d'utiliser plus de RAM qu'il n'y en a d'installée dans l'ordinateur. Par exemple, elle permet au CPU de gérer 4 gigas de RAM sur un ordinateur qui n'en contient que trois, le gigaoctet de trop étant en réalité simulé par un fichier sur le disque dur. La technique est utilisée par tous les processeurs modernes. La mémoire virtuelle des GPUs dédiés fait la même chose, sauf que le surplus d'adresses n'est pas stockés sur le disque dur dans un fichier pagefile, mais est dans la RAM système. Pour le dire autrement, ces cartes dédiées peuvent utiliser la mémoire système si jamais la mémoire vidéo est pleine.

[[File:Mémoire virtuelle des cartes graphiques dédiées.png|centre|vignette|upright=2|Mémoire virtuelle des cartes graphiques dédiées]]

===La ''IO-Memory Management Unit'' (IOMMU)===

Pour que la carte graphique ait accès à la mémoire système, elle intègre un circuit appelé la '''''Graphics address remapping table''''', abrévié en GART. Cela vaut aussi bien pour les cartes graphiques utilisant le bus AGP que pour celles en PCI-Express. La GART est techniquement une  une ''Memory Management Unit'' (MMU), à savoir un circuit spécialisé qui prend en charge la mémoire virtuelle. La dite MMU étant intégrée dans un périphérique d'entrée-sortie (IO), ici la carte graphique, elle est appelée une IOMMU.

L'espace d'adressage est l'ensemble des adresses géré par le processeur ou la carte graphique. En théorie, l'espace d'adressage du processeur et de la carte graphique sont séparés, mais des standards comme l''''''Heterogeneous System Architecture''''' permettent au processeur et à une carte graphique de partager le même espace d'adressage. Une adresse mémoire est alors la même que ce soit pour le processeur ou la carte graphique.

{|class=&quot;wikitable&quot;
|-
! !! Mémoire vidéo dédiée !! Mémoire vidéo unifiée
|-
! Sans HSA
| [[File:Desktop computer bus bandwidths.svg|400px|Desktop computer bus bandwidths]]
| [[File:Integrated graphics with distinct memory allocation.svg|400px|Integrated graphics with distinct memory allocation]]
|-
! Avec HSA
| [[File:HSA-enabled virtual memory with distinct graphics card.svg|400px|HSA-enabled virtual memory with distinct graphics card]]
| [[File:HSA-enabled integrated graphics.svg|400px|HSA-enabled integrated graphics]]
|}

===Historique de la mémoire virtuelle sur les GPU===

La technologie existait déjà sur certaines cartes graphiques au format PCI, mais la documentation est assez rare. La carte graphique NV1 de NVIDIA, leur toute première carte graphique, disposait déjà de ce système de mémoire virtuelle. La carte graphique communiquait avec le processeur grâce à la fonctionnalité ''Direct Memory Access'' et intégrait donc un contrôleur DMA. Le ''driver'' de la carte graphique programmait le contrôleur DMA en utilisant les adresses fournies par les applications/logiciels. Et il s'agissait d'adresses virtuelles, non d'adresses physiques en mémoire RAM. Pour résoudre ce problème, le contrôleur DMA intégrait une MMU, une unité de traduction d'adresse, qui traduisait les adresses virtuelles fournies par les applications en adresse physique en mémoire système.

: Le fonctionnement de cette IOMMU est décrite dans le brevet &quot;US5758182A : DMA controller translates virtual I/O device address received directly from application program command to physical i/o device address of I/O device on device bus&quot;, des inventeurs David S. H. Rosenthal et Curtis Priem.

[[File:Microarchitecture du GPU NV1 de NVIDIA.png|centre|vignette|upright=2|Microarchitecture du GPU NV1 de NVIDIA]]

La technologie s'est démocratisée avec le bus AGP, dont la fonctionnalité dite d'''AGP texturing'' permettait de lire ou écrire directement dans la mémoire RAM, sans passer par le processeur. D'ailleurs, la carte graphique Intel i740 n'avait pas de mémoire vidéo et se débrouillait uniquement avec la mémoire système.

L'arrivée du bus PCI-Express ne changea pas la donne, si ce n'est que le bus était plus rapide, ce qui améliorait les performances. Au début, seules les cartes graphiques PCI-Express d'entrée de gamme pouvaient accéder à certaines portions de la mémoire RAM grâce à des technologies adaptées, comme le TurboCache de NVIDIA ou l'HyperMemory d'AMD. Mais la technologie s'est aujourd'hui étendue. De nos jours, toutes les cartes vidéos modernes utilisent la RAM système en plus de la mémoire vidéo, mais seulement en dernier recours, soit quand la mémoire vidéo est quasiment pleine, soit pour faciliter les échanges de données avec le processeur. C'est typiquement le pilote de la carte graphique qui décide ce qui va dans la mémoire vidéo et la mémoire système, et il fait au mieux de manière à avoir les performances optimales.

==Les échanges entre processeur et mémoire vidéo==

Quand on charge un niveau de jeux vidéo, on doit notamment charger la scène, les textures, et d'autres choses dans la mémoire RAM, puis les envoyer à la carte graphique. Ce processus se fait d'une manière fortement différente selon que l'on a une mémoire unifiée ou une mémoire vidéo dédiée.

===Avec la mémoire unifiée===

Avec la mémoire unifié, les échanges de données entre processeur et carte graphique sont fortement simplifiés et aucune copie n'est nécessaire. La carte vidéo peut y accéder directement, en lisant leur position initiale en RAM. Une partie de la RAM est visible seulement pour le CPU, une autre seulement pour le GPU, le reste est partagé. Les échanges de données entre CPU et GPU se font en écrivant/lisant des données dans la RAM partagée entre CPU et GPU. Pas besoin de faire de copie d'une mémoire à une autre : la donnée a juste besoin d'être placée au bon endroit. Le chargement des textures, du tampon de commandes ou d'autres données du genre, est donc très rapide, presque instantané.

Par contre, le débit de la RAM unifiée est partagé entre la carte graphique et le processeur. Alors qu'avec une mémoire dédiée, tout le débit de la mémoire vidéo aurait été dédié au GPU, le CPU ayant quant à lui accès à tout le débit de la RAM système. De plus, le partage du débit n'est pas chose facile. Les deux se marchent sur les pieds. La carte graphique doit parfois attendre que le processeur lui laisse l'accès à la RAM et inversement. Divers circuits d'arbitrage s'occupent de répartir équitablement les accès à RAM entre les deux, mais cela ne permet que d'avoir un compromis imparfait qui peut réduire les performances. Le seul moyen pour réduire la casse est d'ajouter des mémoires caches entre le GPU et la RAM, mais l'efficacité des caches est relativement limitée pour le rendu 3D.

[[File:Echanges de données entre CPU et GPU avec une mémoire unifiée.png|centre|vignette|upright=2|Échanges de données entre CPU et GPU avec une mémoire unifiée]]

Un autre défaut survient sur les cartes dédiées à mémoire unifiée, par exemple l'Intel 740. Pour lire en mémoire RAM, elles doivent passer par l'intermédiaire du bus AGP, PCI ou PCI-Express. Et ce bus est très lent, bien plus que ne le serait une mémoire vidéo normale. Aussi, les performances sont exécrables. J'insiste sur le fait que l'on parle des cartes graphiques dédiées, mais pas des cartes graphiques soudées des consoles de jeu.

D'ailleurs, de telles cartes dédiées incorporent un ''framebuffer'' directement dans la carte graphique. Il n'y a pas le choix, le VDC de la carte graphique doit accéder à une mémoire suffisamment rapide pour alimenter l'écran. Ils ne peuvent pas prendre le risque d'aller lire la RAM, dont le temps de latence est élevé, et qui peut potentiellement être réservée par le processeur pendant l’affichage d'une image à l'écran.

===Avec une mémoire vidéo dédiée===

Avec une mémoire vidéo dédiée, on doit copier les données adéquates dans la mémoire vidéo, ce qui implique des transferts de données passant par le bus PCI-Express. Le processeur voit une partie de la mémoire vidéo, dans laquelle il peut lire ou écrire comme bon lui semble. Le reste de la mémoire vidéo est invisible du point de vue du processeur, mais manipulable par le GPU à sa guise. Il est possible pour le CPU de copier des données dans la portion invisible de la mémoire vidéo, mais cela se fait de manière indirecte en passant par le GPU d'abord. Il faut typiquement envoyer une commande spéciale au GPU, pour lui dire de charger une texture en mémoire vidéo, par exemple. Le GPU effectue alors une copie de la mémoire système vers la mémoire vidéo, en utilisant un contrôleur DMA intégré au GPU.

[[File:Interaction du GPU avec la mémoire vidéo et la RAM système sur une carte graphique dédiée.png|centre|vignette|upright=2|Échanges de données entre CPU et GPU avec une mémoire vidéo dédiée]]

La gestion de la mémoire vidéo est prise en charge par le pilote de la carte graphique, sur le processeur. Elle a tendance à allouer les textures et d'autres données de grande taille dans la mémoire vidéo invisible, le reste étant placé ailleurs. Les copies DMA vers la mémoire vidéo invisible sont adaptées à des copies de grosses données comme les textures, mais elles marchent mal pour des données assez petites. Or, les jeux vidéos ont tendance à générer à la volée de nombreuses données de petite taille, qu'il faut copier en mémoire vidéo. Et c'est sans compter sur des ressources du pilote de périphériques, qui doivent être copiées en mémoire vidéo, comme le tampon de commande ou d'autres ressources. Et celles-ci ne peuvent pas forcément être copiées dans la mémoire vidéo invisible. Si la mémoire vidéo visible par le CPU est trop petite, les données précédentes sont copiées dans la mémoire visible par le CPU, en mémoire système, mais leur accès par le GPU est alors très lent. Aussi, plus la portion visible de la mémoire vidéo est grande, plus simple est la gestion de la mémoire vidéo par le pilote graphique. Et de ce point de vue, les choses ont évolué récemment.

Pour accéder à un périphérique PCI-Express, il faut configurer des registres spécialisés, appelés les ''Base Address Registers'' (BARs). La configuration des registres précise quelle portion de mémoire vidéo est adressable par le processeur, quelle est sa taille, sa position en mémoire vidéo, etc. Avant 2008, les BAR permettaient d’accéder à seulement 256 mégaoctets, pas plus. La gestion de la mémoire vidéo était alors difficile. Les échanges entre portion visible et invisible de la mémoire vidéo étaient complexes, demandaient d’exécuter des commandes spécifiques au GPU et autres. Après 2008, la spécification du PCI-Express ajouta un support de la technologie ''resizable bar'', qui permet au processeur d’accéder directement à plus de 256 mégaoctets de mémoire vidéo, voire à la totalité de la mémoire vidéo. De nombreux fabricants de cartes graphiques commencent à incorporer cette technologie, qui demande quelques changements au niveau du système d'exploitation, des pilotes de périphériques et du matériel.

{{NavChapitre | book=Les cartes graphiques
           | prev=La microarchitecture des processeurs de shaders
           | prevText=La microarchitecture des processeurs de shaders
           | next=La hiérarchie mémoire d'un GPU
           | netxText=La hiérarchie mémoire d'un GPU
}}{{autocat}}</text>
      <sha1>2wd36e573lnpf01ki229alhtbj59hvc</sha1>
    </revision>
    <revision>
      <id>744052</id>
      <parentid>744045</parentid>
      <timestamp>2025-06-03T16:46:51Z</timestamp>
      <contributor>
        <username>Mewtow</username>
        <id>31375</id>
      </contributor>
      <minor />
      <comment>/* La IO-Memory Management Unit (IOMMU) */</comment>
      <origin>744052</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="19616" sha1="kn4j3nom9b44fo6mwhk1bq3e5ir25ny" xml:space="preserve">Pour rappel, il existe deux types de cartes graphiques : les cartes dédiées et les cartes intégrées. Les '''cartes graphiques dédiées''' sont des cartes graphiques branchées sur des connecteurs/ports de la carte mère. A l'opposé, tous les processeurs modernes intègrent une carte graphique, appelée '''carte graphique intégrée''', ou encore '''IGP''' (''Integrated Graphic Processor''). En somme, les cartes dédiées sont opposées à celles intégrées dans les processeurs modernes.

La différence a un impact sur la mémoire vidéo. Les cartes graphiques dédiées ont souvent de la mémoire vidéo intégrée à la carte graphique. Il y a des exceptions, mais on en parlera plus tard. Les cartes graphiques intégrées au processeur n'ont pas de mémoire vidéo dédiée, vu qu'on ne peut pas intégrer beaucoup de mémoire vidéo dans un processeur. La conséquence est qu'il existe deux grandes manières d'organiser la mémoire à laquelle la carte graphique a accès.
* La première est celle de la '''mémoire vidéo dédiée''', à savoir que la carte graphique dispose de sa propre mémoire rien qu'à elle, séparée de la mémoire RAM de l'ordinateur. On fait alors la distinction entre ''RAM système'' et ''RAM vidéo''. Si les premières cartes graphiques n'avaient que quelques mégaoctets de RAM dédiée, elles disposent actuellement de plusieurs gigas-octets de RAM.
* A l'opposé, on trouve la '''mémoire unifiée''', avec une seule mémoire RAM est partagée entre le processeur et la carte graphique. Le terme &quot;unifiée&quot; sous-entend que l'on a unifié la mémoire vidéo et la mémoire système (la RAM).

[[File:Répartition de la mémoire entre RAM système et carte graphique.png|centre|vignette|upright=2.5|Répartition de la mémoire entre RAM système et carte graphique]]

Dans la grosse majorité des cas, les cartes vidéos dédiées ont une mémoire dédiée, alors que les cartes graphiques intégrées doivent utiliser la mémoire unifiée. Mais outre les cartes dédiées et intégrées, il faut aussi citer les cartes graphiques soudées sur la carte mère. Elles étaient utilisées sur les consoles de jeu vidéos assez anciennes, elles sont encore utilisées sur certains PC portables puissants, destinés aux ''gamers''. Pour ces dernières, il est possible d'utiliser aussi bien de la mémoire dédiée que de la mémoire unifiée. D'anciennes consoles de jeu avaient une carte graphique soudée sur la carte mère, qu'on peut facilement repérer à l’œil nu, avec une mémoire unifiée. C'est notamment le cas sur la Nintendo 64, pour ne citer qu'elle. D'autres avaient leur propre mémoire vidéo dédiée.

L'usage d'une carte vidéo dédiée se marie très bien avec une mémoire vidéo dédiée, mais il existe de nombreux cas où une carte vidéo dédiée est associée à de la mémoire unifiée. Comme exemple, la toute première carte graphique AGP, l'Intel 740, ne possédait pas de mémoire vidéo proprement dite, juste un simple ''framebuffer''. Tout le reste, texture comme géométrie, était placé en mémoire système et la carte graphique allait lire/écrire les données directement en mémoire RAM système ! Les performances sont généralement ridicules, pour des raisons très diverses, mais les cartes de ce type sont peu chères. Outre l'économie liée à l'absence de mémoire vidéo, les cartes graphiques de ce type sont peu puissantes, l'usage de la mémoire unifiée simplifie leur conception, etc. Par exemple, l'Intel 740 a eu un petit succès sur les ordinateurs d'entrée de gamme.

==Le partage de la mémoire unifiée==

Avec la mémoire unifiée, la quantité de mémoire système disponible pour la carte graphique est généralement réglable avec un réglage dans le BIOS. On peut ainsi choisir d'allouer 64, 128 ou 256 mégaoctets de mémoire système pour la carte vidéo, sur un ordinateur avec 4 gigaoctets de RAM. L'interprétation de ce réglage varie grandement selon les cartes mères ou l'IGP.

Pour les GPU les plus anciens, ce réglage implique que la RAM sélectionnée est réservée uniquement à la carte graphique, même si elle n'en utilise qu'une partie. La répartition entre mémoire vidéo et système est alors statique, fixée une fois pour toutes. Dans ce cas, la RAM allouée à la carte graphique est généralement petite par défaut. Les concepteurs de carte mère ne veulent pas qu'une trop quantité de RAM soit perdu et inutilisable pour les applications. Ils brident donc la carte vidéo et ne lui allouent que peu de RAM.

Heureusement, les GPU modernes sont plus souples. Ils fournissent deux réglages : une quantité de RAM minimale, totalement dédiée au GPU, et une quantité de RAM maximale que le GPU ne peut pas dépasser. Par exemple, il est possible de régler le GPU de manière à ce qu'il ait 64 mégaoctets rien que pour lui, mais qu'il puisse avoir accès à maximum 1 gigaoctet s'il en a besoin. Cela fait au total 960 mégaoctets (1024-64) qui peut être alloués au choix à la carte graphique ou au reste des programmes en cours d’exécution, selon les besoins. Il est possible d'allouer de grandes quantités de RAM au GPU, parfois la totalité de la mémoire système.

[[File:Partage de la mémoire unifiée entre CPU et GPU.png|centre|vignette|upright=2|Répartition de la mémoire entre RAM système et carte graphique]]

==Le partage de la mémoire système : la mémoire virtuelle des GPUs dédiés==

Après avoir vu la mémoire unifiée, voyons maintenant la mémoire dédiée. Intuitivement, on se dit que la carte graphique n'a accès qu'à la mémoire vidéo dédiée et ne peut pas lire de données dans la mémoire système, la RAM de l'ordinateur. Cependant, ce n'est pas le cas. Et ce pour plusieurs raisons. La raison principale est que des données doivent être copiées de la mémoire RAM vers la mémoire vidéo. Les copies en question se font souvent via ''Direct Memory Access'', ce qui fait que les GPU intègrent un contrôleur DMA dédié. Et ce contrôleur DMA lit des données en RAM système pour les copier en RAM vidéo.

La seconde raison est que les cartes graphiques intègrent presque toutes des technologies pour lire directement des données en RAM, sans forcément les copier en mémoire vidéo. Les technologies en question permettent à la carte graphique d'adresser plus de RAM qu'en a la mémoire vidéo. Par exemple, si la carte vidéo a 4 giga-octets de RAM, la carte graphique peut être capable d'en adresser 8 : 4 gigas en RAM vidéo, et 4 autres gigas en RAM système.

Les technologies de ce genre ressemblent beaucoup à la mémoire virtuelle des CPU, avec cependant quelques différences. La mémoire virtuelle permet à un processeur d'utiliser plus de RAM qu'il n'y en a d'installée dans l'ordinateur. Par exemple, elle permet au CPU de gérer 4 gigas de RAM sur un ordinateur qui n'en contient que trois, le gigaoctet de trop étant en réalité simulé par un fichier sur le disque dur. La technique est utilisée par tous les processeurs modernes. La mémoire virtuelle des GPUs dédiés fait la même chose, sauf que le surplus d'adresses n'est pas stockés sur le disque dur dans un fichier pagefile, mais est dans la RAM système. Pour le dire autrement, ces cartes dédiées peuvent utiliser la mémoire système si jamais la mémoire vidéo est pleine.

[[File:Mémoire virtuelle des cartes graphiques dédiées.png|centre|vignette|upright=2|Mémoire virtuelle des cartes graphiques dédiées]]

L'espace d'adressage est l'ensemble des adresses géré par le processeur ou la carte graphique. En théorie, l'espace d'adressage du processeur et de la carte graphique sont séparés, mais des standards comme l''''''Heterogeneous System Architecture''''' permettent au processeur et à une carte graphique de partager le même espace d'adressage. Une adresse mémoire est alors la même que ce soit pour le processeur ou la carte graphique.

{|class=&quot;wikitable&quot;
|-
! !! Mémoire vidéo dédiée !! Mémoire vidéo unifiée
|-
! Sans HSA
| [[File:Desktop computer bus bandwidths.svg|400px|Desktop computer bus bandwidths]]
| [[File:Integrated graphics with distinct memory allocation.svg|400px|Integrated graphics with distinct memory allocation]]
|-
! Avec HSA
| [[File:HSA-enabled virtual memory with distinct graphics card.svg|400px|HSA-enabled virtual memory with distinct graphics card]]
| [[File:HSA-enabled integrated graphics.svg|400px|HSA-enabled integrated graphics]]
|}

===La ''IO-Memory Management Unit'' (IOMMU)===

Pour que la carte graphique ait accès à la mémoire système, elle intègre un circuit appelé la '''''Graphics address remapping table''''', abrévié en GART. Cela vaut aussi bien pour les cartes graphiques utilisant le bus AGP que pour celles en PCI-Express. La GART est techniquement une  une ''Memory Management Unit'' (MMU), à savoir un circuit spécialisé qui prend en charge la mémoire virtuelle. La dite MMU étant intégrée dans un périphérique d'entrée-sortie (IO), ici la carte graphique, elle est appelée une IO-MMU (''Input Output-MMU'').

Le GPU utilise la technique dite de la pagination, à savoir que l'espace d'adressage est découpée en pages de taille fixe, généralement 4 kilo-octets. La traduction des adresses virtuelles en adresses physique se fait au niveau de la page. Une adresse est coupée en deux parts : un numéro de page, et la position de la donnée dans la page. La position dans la page ne change pas lors de la traduction d'adresse, mais le numéro de page est lui traduit. Le numéro de page virtuel est remplacé par un numéro de page physique lors de la traduction.

Pour remplacer le numéro de page virtuel en numéro physique, il faut utiliser une table de translation, appelée la '''table des pages''', qui associe un numéro de page logique à un numéro de page physique. Le système d'exploitation dispose de sa table des pages, qui n'est pas accesible au GPU. Par contre, le GPU dispose d'une sorte de mini-table des pages, qui contient les associations page virtuelle-physique utiles pour traiter les commandes GPU, et rien d'autre. En clair, une sorte de sous-ensemble de la table des pages de l'OS, mais spécifique au GPU. La mini-table des pages est gérée par le pilote de périphérique, qui remplit la mini-table des pages. La mini-table des pages est mémorisée dans une mémoire intégrée au GPU, et précisément dans la MMU.

===Historique de la mémoire virtuelle sur les GPU===

La technologie existait déjà sur certaines cartes graphiques au format PCI, mais la documentation est assez rare. La carte graphique NV1 de NVIDIA, leur toute première carte graphique, disposait déjà de ce système de mémoire virtuelle. La carte graphique communiquait avec le processeur grâce à la fonctionnalité ''Direct Memory Access'' et intégrait donc un contrôleur DMA. Le ''driver'' de la carte graphique programmait le contrôleur DMA en utilisant les adresses fournies par les applications/logiciels. Et il s'agissait d'adresses virtuelles, non d'adresses physiques en mémoire RAM. Pour résoudre ce problème, le contrôleur DMA intégrait une MMU, une unité de traduction d'adresse, qui traduisait les adresses virtuelles fournies par les applications en adresse physique en mémoire système.

: Le fonctionnement de cette IOMMU est décrite dans le brevet &quot;US5758182A : DMA controller translates virtual I/O device address received directly from application program command to physical i/o device address of I/O device on device bus&quot;, des inventeurs David S. H. Rosenthal et Curtis Priem.

[[File:Microarchitecture du GPU NV1 de NVIDIA.png|centre|vignette|upright=2|Microarchitecture du GPU NV1 de NVIDIA]]

La technologie s'est démocratisée avec le bus AGP, dont la fonctionnalité dite d'''AGP texturing'' permettait de lire ou écrire directement dans la mémoire RAM, sans passer par le processeur. D'ailleurs, la carte graphique Intel i740 n'avait pas de mémoire vidéo et se débrouillait uniquement avec la mémoire système.

L'arrivée du bus PCI-Express ne changea pas la donne, si ce n'est que le bus était plus rapide, ce qui améliorait les performances. Au début, seules les cartes graphiques PCI-Express d'entrée de gamme pouvaient accéder à certaines portions de la mémoire RAM grâce à des technologies adaptées, comme le TurboCache de NVIDIA ou l'HyperMemory d'AMD. Mais la technologie s'est aujourd'hui étendue. De nos jours, toutes les cartes vidéos modernes utilisent la RAM système en plus de la mémoire vidéo, mais seulement en dernier recours, soit quand la mémoire vidéo est quasiment pleine, soit pour faciliter les échanges de données avec le processeur. C'est typiquement le pilote de la carte graphique qui décide ce qui va dans la mémoire vidéo et la mémoire système, et il fait au mieux de manière à avoir les performances optimales.

==Les échanges entre processeur et mémoire vidéo==

Quand on charge un niveau de jeux vidéo, on doit notamment charger la scène, les textures, et d'autres choses dans la mémoire RAM, puis les envoyer à la carte graphique. Ce processus se fait d'une manière fortement différente selon que l'on a une mémoire unifiée ou une mémoire vidéo dédiée.

===Avec la mémoire unifiée===

Avec la mémoire unifié, les échanges de données entre processeur et carte graphique sont fortement simplifiés et aucune copie n'est nécessaire. La carte vidéo peut y accéder directement, en lisant leur position initiale en RAM. Une partie de la RAM est visible seulement pour le CPU, une autre seulement pour le GPU, le reste est partagé. Les échanges de données entre CPU et GPU se font en écrivant/lisant des données dans la RAM partagée entre CPU et GPU. Pas besoin de faire de copie d'une mémoire à une autre : la donnée a juste besoin d'être placée au bon endroit. Le chargement des textures, du tampon de commandes ou d'autres données du genre, est donc très rapide, presque instantané.

Par contre, le débit de la RAM unifiée est partagé entre la carte graphique et le processeur. Alors qu'avec une mémoire dédiée, tout le débit de la mémoire vidéo aurait été dédié au GPU, le CPU ayant quant à lui accès à tout le débit de la RAM système. De plus, le partage du débit n'est pas chose facile. Les deux se marchent sur les pieds. La carte graphique doit parfois attendre que le processeur lui laisse l'accès à la RAM et inversement. Divers circuits d'arbitrage s'occupent de répartir équitablement les accès à RAM entre les deux, mais cela ne permet que d'avoir un compromis imparfait qui peut réduire les performances. Le seul moyen pour réduire la casse est d'ajouter des mémoires caches entre le GPU et la RAM, mais l'efficacité des caches est relativement limitée pour le rendu 3D.

[[File:Echanges de données entre CPU et GPU avec une mémoire unifiée.png|centre|vignette|upright=2|Échanges de données entre CPU et GPU avec une mémoire unifiée]]

Un autre défaut survient sur les cartes dédiées à mémoire unifiée, par exemple l'Intel 740. Pour lire en mémoire RAM, elles doivent passer par l'intermédiaire du bus AGP, PCI ou PCI-Express. Et ce bus est très lent, bien plus que ne le serait une mémoire vidéo normale. Aussi, les performances sont exécrables. J'insiste sur le fait que l'on parle des cartes graphiques dédiées, mais pas des cartes graphiques soudées des consoles de jeu.

D'ailleurs, de telles cartes dédiées incorporent un ''framebuffer'' directement dans la carte graphique. Il n'y a pas le choix, le VDC de la carte graphique doit accéder à une mémoire suffisamment rapide pour alimenter l'écran. Ils ne peuvent pas prendre le risque d'aller lire la RAM, dont le temps de latence est élevé, et qui peut potentiellement être réservée par le processeur pendant l’affichage d'une image à l'écran.

===Avec une mémoire vidéo dédiée===

Avec une mémoire vidéo dédiée, on doit copier les données adéquates dans la mémoire vidéo, ce qui implique des transferts de données passant par le bus PCI-Express. Le processeur voit une partie de la mémoire vidéo, dans laquelle il peut lire ou écrire comme bon lui semble. Le reste de la mémoire vidéo est invisible du point de vue du processeur, mais manipulable par le GPU à sa guise. Il est possible pour le CPU de copier des données dans la portion invisible de la mémoire vidéo, mais cela se fait de manière indirecte en passant par le GPU d'abord. Il faut typiquement envoyer une commande spéciale au GPU, pour lui dire de charger une texture en mémoire vidéo, par exemple. Le GPU effectue alors une copie de la mémoire système vers la mémoire vidéo, en utilisant un contrôleur DMA intégré au GPU.

[[File:Interaction du GPU avec la mémoire vidéo et la RAM système sur une carte graphique dédiée.png|centre|vignette|upright=2|Échanges de données entre CPU et GPU avec une mémoire vidéo dédiée]]

La gestion de la mémoire vidéo est prise en charge par le pilote de la carte graphique, sur le processeur. Elle a tendance à allouer les textures et d'autres données de grande taille dans la mémoire vidéo invisible, le reste étant placé ailleurs. Les copies DMA vers la mémoire vidéo invisible sont adaptées à des copies de grosses données comme les textures, mais elles marchent mal pour des données assez petites. Or, les jeux vidéos ont tendance à générer à la volée de nombreuses données de petite taille, qu'il faut copier en mémoire vidéo. Et c'est sans compter sur des ressources du pilote de périphériques, qui doivent être copiées en mémoire vidéo, comme le tampon de commande ou d'autres ressources. Et celles-ci ne peuvent pas forcément être copiées dans la mémoire vidéo invisible. Si la mémoire vidéo visible par le CPU est trop petite, les données précédentes sont copiées dans la mémoire visible par le CPU, en mémoire système, mais leur accès par le GPU est alors très lent. Aussi, plus la portion visible de la mémoire vidéo est grande, plus simple est la gestion de la mémoire vidéo par le pilote graphique. Et de ce point de vue, les choses ont évolué récemment.

Pour accéder à un périphérique PCI-Express, il faut configurer des registres spécialisés, appelés les ''Base Address Registers'' (BARs). La configuration des registres précise quelle portion de mémoire vidéo est adressable par le processeur, quelle est sa taille, sa position en mémoire vidéo, etc. Avant 2008, les BAR permettaient d’accéder à seulement 256 mégaoctets, pas plus. La gestion de la mémoire vidéo était alors difficile. Les échanges entre portion visible et invisible de la mémoire vidéo étaient complexes, demandaient d’exécuter des commandes spécifiques au GPU et autres. Après 2008, la spécification du PCI-Express ajouta un support de la technologie ''resizable bar'', qui permet au processeur d’accéder directement à plus de 256 mégaoctets de mémoire vidéo, voire à la totalité de la mémoire vidéo. De nombreux fabricants de cartes graphiques commencent à incorporer cette technologie, qui demande quelques changements au niveau du système d'exploitation, des pilotes de périphériques et du matériel.

{{NavChapitre | book=Les cartes graphiques
           | prev=La microarchitecture des processeurs de shaders
           | prevText=La microarchitecture des processeurs de shaders
           | next=La hiérarchie mémoire d'un GPU
           | netxText=La hiérarchie mémoire d'un GPU
}}{{autocat}}</text>
      <sha1>kn4j3nom9b44fo6mwhk1bq3e5ir25ny</sha1>
    </revision>
    <revision>
      <id>744053</id>
      <parentid>744052</parentid>
      <timestamp>2025-06-03T16:53:10Z</timestamp>
      <contributor>
        <username>Mewtow</username>
        <id>31375</id>
      </contributor>
      <minor />
      <comment>/* Le partage de la mémoire système : la mémoire virtuelle des GPUs dédiés */</comment>
      <origin>744053</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="19661" sha1="6d46u3cwhewt67t0pr004dexeoifz9m" xml:space="preserve">Pour rappel, il existe deux types de cartes graphiques : les cartes dédiées et les cartes intégrées. Les '''cartes graphiques dédiées''' sont des cartes graphiques branchées sur des connecteurs/ports de la carte mère. A l'opposé, tous les processeurs modernes intègrent une carte graphique, appelée '''carte graphique intégrée''', ou encore '''IGP''' (''Integrated Graphic Processor''). En somme, les cartes dédiées sont opposées à celles intégrées dans les processeurs modernes.

La différence a un impact sur la mémoire vidéo. Les cartes graphiques dédiées ont souvent de la mémoire vidéo intégrée à la carte graphique. Il y a des exceptions, mais on en parlera plus tard. Les cartes graphiques intégrées au processeur n'ont pas de mémoire vidéo dédiée, vu qu'on ne peut pas intégrer beaucoup de mémoire vidéo dans un processeur. La conséquence est qu'il existe deux grandes manières d'organiser la mémoire à laquelle la carte graphique a accès.
* La première est celle de la '''mémoire vidéo dédiée''', à savoir que la carte graphique dispose de sa propre mémoire rien qu'à elle, séparée de la mémoire RAM de l'ordinateur. On fait alors la distinction entre ''RAM système'' et ''RAM vidéo''. Si les premières cartes graphiques n'avaient que quelques mégaoctets de RAM dédiée, elles disposent actuellement de plusieurs gigas-octets de RAM.
* A l'opposé, on trouve la '''mémoire unifiée''', avec une seule mémoire RAM est partagée entre le processeur et la carte graphique. Le terme &quot;unifiée&quot; sous-entend que l'on a unifié la mémoire vidéo et la mémoire système (la RAM).

[[File:Répartition de la mémoire entre RAM système et carte graphique.png|centre|vignette|upright=2.5|Répartition de la mémoire entre RAM système et carte graphique]]

Dans la grosse majorité des cas, les cartes vidéos dédiées ont une mémoire dédiée, alors que les cartes graphiques intégrées doivent utiliser la mémoire unifiée. Mais outre les cartes dédiées et intégrées, il faut aussi citer les cartes graphiques soudées sur la carte mère. Elles étaient utilisées sur les consoles de jeu vidéos assez anciennes, elles sont encore utilisées sur certains PC portables puissants, destinés aux ''gamers''. Pour ces dernières, il est possible d'utiliser aussi bien de la mémoire dédiée que de la mémoire unifiée. D'anciennes consoles de jeu avaient une carte graphique soudée sur la carte mère, qu'on peut facilement repérer à l’œil nu, avec une mémoire unifiée. C'est notamment le cas sur la Nintendo 64, pour ne citer qu'elle. D'autres avaient leur propre mémoire vidéo dédiée.

L'usage d'une carte vidéo dédiée se marie très bien avec une mémoire vidéo dédiée, mais il existe de nombreux cas où une carte vidéo dédiée est associée à de la mémoire unifiée. Comme exemple, la toute première carte graphique AGP, l'Intel 740, ne possédait pas de mémoire vidéo proprement dite, juste un simple ''framebuffer''. Tout le reste, texture comme géométrie, était placé en mémoire système et la carte graphique allait lire/écrire les données directement en mémoire RAM système ! Les performances sont généralement ridicules, pour des raisons très diverses, mais les cartes de ce type sont peu chères. Outre l'économie liée à l'absence de mémoire vidéo, les cartes graphiques de ce type sont peu puissantes, l'usage de la mémoire unifiée simplifie leur conception, etc. Par exemple, l'Intel 740 a eu un petit succès sur les ordinateurs d'entrée de gamme.

==Le partage de la mémoire unifiée==

Avec la mémoire unifiée, la quantité de mémoire système disponible pour la carte graphique est généralement réglable avec un réglage dans le BIOS. On peut ainsi choisir d'allouer 64, 128 ou 256 mégaoctets de mémoire système pour la carte vidéo, sur un ordinateur avec 4 gigaoctets de RAM. L'interprétation de ce réglage varie grandement selon les cartes mères ou l'IGP.

Pour les GPU les plus anciens, ce réglage implique que la RAM sélectionnée est réservée uniquement à la carte graphique, même si elle n'en utilise qu'une partie. La répartition entre mémoire vidéo et système est alors statique, fixée une fois pour toutes. Dans ce cas, la RAM allouée à la carte graphique est généralement petite par défaut. Les concepteurs de carte mère ne veulent pas qu'une trop quantité de RAM soit perdu et inutilisable pour les applications. Ils brident donc la carte vidéo et ne lui allouent que peu de RAM.

Heureusement, les GPU modernes sont plus souples. Ils fournissent deux réglages : une quantité de RAM minimale, totalement dédiée au GPU, et une quantité de RAM maximale que le GPU ne peut pas dépasser. Par exemple, il est possible de régler le GPU de manière à ce qu'il ait 64 mégaoctets rien que pour lui, mais qu'il puisse avoir accès à maximum 1 gigaoctet s'il en a besoin. Cela fait au total 960 mégaoctets (1024-64) qui peut être alloués au choix à la carte graphique ou au reste des programmes en cours d’exécution, selon les besoins. Il est possible d'allouer de grandes quantités de RAM au GPU, parfois la totalité de la mémoire système.

[[File:Partage de la mémoire unifiée entre CPU et GPU.png|centre|vignette|upright=2|Répartition de la mémoire entre RAM système et carte graphique]]

==Le partage de la mémoire système : la mémoire virtuelle des GPUs dédiés==

Après avoir vu la mémoire unifiée, voyons maintenant la mémoire dédiée. Intuitivement, on se dit que la carte graphique n'a accès qu'à la mémoire vidéo dédiée et ne peut pas lire de données dans la mémoire système, la RAM de l'ordinateur. Cependant, ce n'est pas le cas. Et ce pour plusieurs raisons. La raison principale est que des données doivent être copiées de la mémoire RAM vers la mémoire vidéo. Les copies en question se font souvent via ''Direct Memory Access'', ce qui fait que les GPU intègrent un contrôleur DMA dédié. Et ce contrôleur DMA lit des données en RAM système pour les copier en RAM vidéo.

La seconde raison est que les cartes graphiques intègrent presque toutes des technologies pour lire directement des données en RAM, sans forcément les copier en mémoire vidéo. Les technologies en question permettent à la carte graphique d'adresser plus de RAM qu'en a la mémoire vidéo. Par exemple, si la carte vidéo a 4 giga-octets de RAM, la carte graphique peut être capable d'en adresser 8 : 4 gigas en RAM vidéo, et 4 autres gigas en RAM système.

Les technologies de ce genre ressemblent beaucoup à la mémoire virtuelle des CPU, avec cependant quelques différences. La mémoire virtuelle permet à un processeur d'utiliser plus de RAM qu'il n'y en a d'installée dans l'ordinateur. Par exemple, elle permet au CPU de gérer 4 gigas de RAM sur un ordinateur qui n'en contient que trois, le gigaoctet de trop étant en réalité simulé par un fichier sur le disque dur. La technique est utilisée par tous les processeurs modernes. La mémoire virtuelle des GPUs dédiés fait la même chose, sauf que le surplus d'adresses n'est pas stockés sur le disque dur dans un fichier pagefile, mais est dans la RAM système. Pour le dire autrement, ces cartes dédiées peuvent utiliser la mémoire système si jamais la mémoire vidéo est pleine.

[[File:Mémoire virtuelle des cartes graphiques dédiées.png|centre|vignette|upright=2|Mémoire virtuelle des cartes graphiques dédiées]]

===La ''IO-Memory Management Unit'' (IOMMU)===

Pour que la carte graphique ait accès à la mémoire système, elle intègre un circuit appelé la '''''Graphics address remapping table''''', abrévié en GART. Cela vaut aussi bien pour les cartes graphiques utilisant le bus AGP que pour celles en PCI-Express. La GART est techniquement une  une ''Memory Management Unit'' (MMU), à savoir un circuit spécialisé qui prend en charge la mémoire virtuelle. La dite MMU étant intégrée dans un périphérique d'entrée-sortie (IO), ici la carte graphique, elle est appelée une IO-MMU (''Input Output-MMU'').

Le GPU utilise la technique dite de la pagination, à savoir que l'espace d'adressage est découpée en pages de taille fixe, généralement 4 kilo-octets. La traduction des adresses virtuelles en adresses physique se fait au niveau de la page. Une adresse est coupée en deux parts : un numéro de page, et la position de la donnée dans la page. La position dans la page ne change pas lors de la traduction d'adresse, mais le numéro de page est lui traduit. Le numéro de page virtuel est remplacé par un numéro de page physique lors de la traduction.

Pour remplacer le numéro de page virtuel en numéro physique, il faut utiliser une table de translation, appelée la '''table des pages''', qui associe un numéro de page logique à un numéro de page physique. Le système d'exploitation dispose de sa table des pages, qui n'est pas accesible au GPU. Par contre, le GPU dispose d'une sorte de mini-table des pages, qui contient les associations page virtuelle-physique utiles pour traiter les commandes GPU, et rien d'autre. En clair, une sorte de sous-ensemble de la table des pages de l'OS, mais spécifique au GPU. La mini-table des pages est gérée par le pilote de périphérique, qui remplit la mini-table des pages. La mini-table des pages est mémorisée dans une mémoire intégrée au GPU, et précisément dans la MMU.

===Historique de la mémoire virtuelle sur les GPU===

La technologie existait déjà sur certaines cartes graphiques au format PCI, mais la documentation est assez rare. La carte graphique NV1 de NVIDIA, leur toute première carte graphique, disposait déjà de ce système de mémoire virtuelle. La carte graphique communiquait avec le processeur grâce à la fonctionnalité ''Direct Memory Access'' et intégrait donc un contrôleur DMA. Le ''driver'' de la carte graphique programmait le contrôleur DMA en utilisant les adresses fournies par les applications/logiciels. Et il s'agissait d'adresses virtuelles, non d'adresses physiques en mémoire RAM. Pour résoudre ce problème, le contrôleur DMA intégrait une MMU, une unité de traduction d'adresse, qui traduisait les adresses virtuelles fournies par les applications en adresse physique en mémoire système.

: Le fonctionnement de cette IOMMU est décrite dans le brevet &quot;US5758182A : DMA controller translates virtual I/O device address received directly from application program command to physical i/o device address of I/O device on device bus&quot;, des inventeurs David S. H. Rosenthal et Curtis Priem.

[[File:Microarchitecture du GPU NV1 de NVIDIA.png|centre|vignette|upright=2|Microarchitecture du GPU NV1 de NVIDIA]]

La technologie s'est démocratisée avec le bus AGP, dont la fonctionnalité dite d'''AGP texturing'' permettait de lire ou écrire directement dans la mémoire RAM, sans passer par le processeur. D'ailleurs, la carte graphique Intel i740 n'avait pas de mémoire vidéo et se débrouillait uniquement avec la mémoire système.

L'arrivée du bus PCI-Express ne changea pas la donne, si ce n'est que le bus était plus rapide, ce qui améliorait les performances. Au début, seules les cartes graphiques PCI-Express d'entrée de gamme pouvaient accéder à certaines portions de la mémoire RAM grâce à des technologies adaptées, comme le TurboCache de NVIDIA ou l'HyperMemory d'AMD. Mais la technologie s'est aujourd'hui étendue. De nos jours, toutes les cartes vidéos modernes utilisent la RAM système en plus de la mémoire vidéo, mais seulement en dernier recours, soit quand la mémoire vidéo est quasiment pleine, soit pour faciliter les échanges de données avec le processeur. C'est typiquement le pilote de la carte graphique qui décide ce qui va dans la mémoire vidéo et la mémoire système, et il fait au mieux de manière à avoir les performances optimales.

===L'espace d'adressage du CPU et du GPU===

L'espace d'adressage est l'ensemble des adresses géré par le processeur ou la carte graphique. En théorie, l'espace d'adressage du processeur et de la carte graphique sont séparés, mais des standards comme l''''''Heterogeneous System Architecture''''' permettent au processeur et à une carte graphique de partager le même espace d'adressage. Une adresse mémoire est alors la même que ce soit pour le processeur ou la carte graphique.

{|class=&quot;wikitable&quot;
|-
! !! Mémoire vidéo dédiée !! Mémoire vidéo unifiée
|-
! Sans HSA
| [[File:Desktop computer bus bandwidths.svg|400px|Desktop computer bus bandwidths]]
| [[File:Integrated graphics with distinct memory allocation.svg|400px|Integrated graphics with distinct memory allocation]]
|-
! Avec HSA
| [[File:HSA-enabled virtual memory with distinct graphics card.svg|400px|HSA-enabled virtual memory with distinct graphics card]]
| [[File:HSA-enabled integrated graphics.svg|400px|HSA-enabled integrated graphics]]
|}

==Les échanges entre processeur et mémoire vidéo==

Quand on charge un niveau de jeux vidéo, on doit notamment charger la scène, les textures, et d'autres choses dans la mémoire RAM, puis les envoyer à la carte graphique. Ce processus se fait d'une manière fortement différente selon que l'on a une mémoire unifiée ou une mémoire vidéo dédiée.

===Avec la mémoire unifiée===

Avec la mémoire unifié, les échanges de données entre processeur et carte graphique sont fortement simplifiés et aucune copie n'est nécessaire. La carte vidéo peut y accéder directement, en lisant leur position initiale en RAM. Une partie de la RAM est visible seulement pour le CPU, une autre seulement pour le GPU, le reste est partagé. Les échanges de données entre CPU et GPU se font en écrivant/lisant des données dans la RAM partagée entre CPU et GPU. Pas besoin de faire de copie d'une mémoire à une autre : la donnée a juste besoin d'être placée au bon endroit. Le chargement des textures, du tampon de commandes ou d'autres données du genre, est donc très rapide, presque instantané.

Par contre, le débit de la RAM unifiée est partagé entre la carte graphique et le processeur. Alors qu'avec une mémoire dédiée, tout le débit de la mémoire vidéo aurait été dédié au GPU, le CPU ayant quant à lui accès à tout le débit de la RAM système. De plus, le partage du débit n'est pas chose facile. Les deux se marchent sur les pieds. La carte graphique doit parfois attendre que le processeur lui laisse l'accès à la RAM et inversement. Divers circuits d'arbitrage s'occupent de répartir équitablement les accès à RAM entre les deux, mais cela ne permet que d'avoir un compromis imparfait qui peut réduire les performances. Le seul moyen pour réduire la casse est d'ajouter des mémoires caches entre le GPU et la RAM, mais l'efficacité des caches est relativement limitée pour le rendu 3D.

[[File:Echanges de données entre CPU et GPU avec une mémoire unifiée.png|centre|vignette|upright=2|Échanges de données entre CPU et GPU avec une mémoire unifiée]]

Un autre défaut survient sur les cartes dédiées à mémoire unifiée, par exemple l'Intel 740. Pour lire en mémoire RAM, elles doivent passer par l'intermédiaire du bus AGP, PCI ou PCI-Express. Et ce bus est très lent, bien plus que ne le serait une mémoire vidéo normale. Aussi, les performances sont exécrables. J'insiste sur le fait que l'on parle des cartes graphiques dédiées, mais pas des cartes graphiques soudées des consoles de jeu.

D'ailleurs, de telles cartes dédiées incorporent un ''framebuffer'' directement dans la carte graphique. Il n'y a pas le choix, le VDC de la carte graphique doit accéder à une mémoire suffisamment rapide pour alimenter l'écran. Ils ne peuvent pas prendre le risque d'aller lire la RAM, dont le temps de latence est élevé, et qui peut potentiellement être réservée par le processeur pendant l’affichage d'une image à l'écran.

===Avec une mémoire vidéo dédiée===

Avec une mémoire vidéo dédiée, on doit copier les données adéquates dans la mémoire vidéo, ce qui implique des transferts de données passant par le bus PCI-Express. Le processeur voit une partie de la mémoire vidéo, dans laquelle il peut lire ou écrire comme bon lui semble. Le reste de la mémoire vidéo est invisible du point de vue du processeur, mais manipulable par le GPU à sa guise. Il est possible pour le CPU de copier des données dans la portion invisible de la mémoire vidéo, mais cela se fait de manière indirecte en passant par le GPU d'abord. Il faut typiquement envoyer une commande spéciale au GPU, pour lui dire de charger une texture en mémoire vidéo, par exemple. Le GPU effectue alors une copie de la mémoire système vers la mémoire vidéo, en utilisant un contrôleur DMA intégré au GPU.

[[File:Interaction du GPU avec la mémoire vidéo et la RAM système sur une carte graphique dédiée.png|centre|vignette|upright=2|Échanges de données entre CPU et GPU avec une mémoire vidéo dédiée]]

La gestion de la mémoire vidéo est prise en charge par le pilote de la carte graphique, sur le processeur. Elle a tendance à allouer les textures et d'autres données de grande taille dans la mémoire vidéo invisible, le reste étant placé ailleurs. Les copies DMA vers la mémoire vidéo invisible sont adaptées à des copies de grosses données comme les textures, mais elles marchent mal pour des données assez petites. Or, les jeux vidéos ont tendance à générer à la volée de nombreuses données de petite taille, qu'il faut copier en mémoire vidéo. Et c'est sans compter sur des ressources du pilote de périphériques, qui doivent être copiées en mémoire vidéo, comme le tampon de commande ou d'autres ressources. Et celles-ci ne peuvent pas forcément être copiées dans la mémoire vidéo invisible. Si la mémoire vidéo visible par le CPU est trop petite, les données précédentes sont copiées dans la mémoire visible par le CPU, en mémoire système, mais leur accès par le GPU est alors très lent. Aussi, plus la portion visible de la mémoire vidéo est grande, plus simple est la gestion de la mémoire vidéo par le pilote graphique. Et de ce point de vue, les choses ont évolué récemment.

Pour accéder à un périphérique PCI-Express, il faut configurer des registres spécialisés, appelés les ''Base Address Registers'' (BARs). La configuration des registres précise quelle portion de mémoire vidéo est adressable par le processeur, quelle est sa taille, sa position en mémoire vidéo, etc. Avant 2008, les BAR permettaient d’accéder à seulement 256 mégaoctets, pas plus. La gestion de la mémoire vidéo était alors difficile. Les échanges entre portion visible et invisible de la mémoire vidéo étaient complexes, demandaient d’exécuter des commandes spécifiques au GPU et autres. Après 2008, la spécification du PCI-Express ajouta un support de la technologie ''resizable bar'', qui permet au processeur d’accéder directement à plus de 256 mégaoctets de mémoire vidéo, voire à la totalité de la mémoire vidéo. De nombreux fabricants de cartes graphiques commencent à incorporer cette technologie, qui demande quelques changements au niveau du système d'exploitation, des pilotes de périphériques et du matériel.

{{NavChapitre | book=Les cartes graphiques
           | prev=La microarchitecture des processeurs de shaders
           | prevText=La microarchitecture des processeurs de shaders
           | next=La hiérarchie mémoire d'un GPU
           | netxText=La hiérarchie mémoire d'un GPU
}}{{autocat}}</text>
      <sha1>6d46u3cwhewt67t0pr004dexeoifz9m</sha1>
    </revision>
    <revision>
      <id>744054</id>
      <parentid>744053</parentid>
      <timestamp>2025-06-03T16:53:19Z</timestamp>
      <contributor>
        <username>Mewtow</username>
        <id>31375</id>
      </contributor>
      <minor />
      <comment>/* L'espace d'adressage du CPU et du GPU */</comment>
      <origin>744054</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="19662" sha1="dboeqjmxsb1hya9dbz479k3fygw6a0u" xml:space="preserve">Pour rappel, il existe deux types de cartes graphiques : les cartes dédiées et les cartes intégrées. Les '''cartes graphiques dédiées''' sont des cartes graphiques branchées sur des connecteurs/ports de la carte mère. A l'opposé, tous les processeurs modernes intègrent une carte graphique, appelée '''carte graphique intégrée''', ou encore '''IGP''' (''Integrated Graphic Processor''). En somme, les cartes dédiées sont opposées à celles intégrées dans les processeurs modernes.

La différence a un impact sur la mémoire vidéo. Les cartes graphiques dédiées ont souvent de la mémoire vidéo intégrée à la carte graphique. Il y a des exceptions, mais on en parlera plus tard. Les cartes graphiques intégrées au processeur n'ont pas de mémoire vidéo dédiée, vu qu'on ne peut pas intégrer beaucoup de mémoire vidéo dans un processeur. La conséquence est qu'il existe deux grandes manières d'organiser la mémoire à laquelle la carte graphique a accès.
* La première est celle de la '''mémoire vidéo dédiée''', à savoir que la carte graphique dispose de sa propre mémoire rien qu'à elle, séparée de la mémoire RAM de l'ordinateur. On fait alors la distinction entre ''RAM système'' et ''RAM vidéo''. Si les premières cartes graphiques n'avaient que quelques mégaoctets de RAM dédiée, elles disposent actuellement de plusieurs gigas-octets de RAM.
* A l'opposé, on trouve la '''mémoire unifiée''', avec une seule mémoire RAM est partagée entre le processeur et la carte graphique. Le terme &quot;unifiée&quot; sous-entend que l'on a unifié la mémoire vidéo et la mémoire système (la RAM).

[[File:Répartition de la mémoire entre RAM système et carte graphique.png|centre|vignette|upright=2.5|Répartition de la mémoire entre RAM système et carte graphique]]

Dans la grosse majorité des cas, les cartes vidéos dédiées ont une mémoire dédiée, alors que les cartes graphiques intégrées doivent utiliser la mémoire unifiée. Mais outre les cartes dédiées et intégrées, il faut aussi citer les cartes graphiques soudées sur la carte mère. Elles étaient utilisées sur les consoles de jeu vidéos assez anciennes, elles sont encore utilisées sur certains PC portables puissants, destinés aux ''gamers''. Pour ces dernières, il est possible d'utiliser aussi bien de la mémoire dédiée que de la mémoire unifiée. D'anciennes consoles de jeu avaient une carte graphique soudée sur la carte mère, qu'on peut facilement repérer à l’œil nu, avec une mémoire unifiée. C'est notamment le cas sur la Nintendo 64, pour ne citer qu'elle. D'autres avaient leur propre mémoire vidéo dédiée.

L'usage d'une carte vidéo dédiée se marie très bien avec une mémoire vidéo dédiée, mais il existe de nombreux cas où une carte vidéo dédiée est associée à de la mémoire unifiée. Comme exemple, la toute première carte graphique AGP, l'Intel 740, ne possédait pas de mémoire vidéo proprement dite, juste un simple ''framebuffer''. Tout le reste, texture comme géométrie, était placé en mémoire système et la carte graphique allait lire/écrire les données directement en mémoire RAM système ! Les performances sont généralement ridicules, pour des raisons très diverses, mais les cartes de ce type sont peu chères. Outre l'économie liée à l'absence de mémoire vidéo, les cartes graphiques de ce type sont peu puissantes, l'usage de la mémoire unifiée simplifie leur conception, etc. Par exemple, l'Intel 740 a eu un petit succès sur les ordinateurs d'entrée de gamme.

==Le partage de la mémoire unifiée==

Avec la mémoire unifiée, la quantité de mémoire système disponible pour la carte graphique est généralement réglable avec un réglage dans le BIOS. On peut ainsi choisir d'allouer 64, 128 ou 256 mégaoctets de mémoire système pour la carte vidéo, sur un ordinateur avec 4 gigaoctets de RAM. L'interprétation de ce réglage varie grandement selon les cartes mères ou l'IGP.

Pour les GPU les plus anciens, ce réglage implique que la RAM sélectionnée est réservée uniquement à la carte graphique, même si elle n'en utilise qu'une partie. La répartition entre mémoire vidéo et système est alors statique, fixée une fois pour toutes. Dans ce cas, la RAM allouée à la carte graphique est généralement petite par défaut. Les concepteurs de carte mère ne veulent pas qu'une trop quantité de RAM soit perdu et inutilisable pour les applications. Ils brident donc la carte vidéo et ne lui allouent que peu de RAM.

Heureusement, les GPU modernes sont plus souples. Ils fournissent deux réglages : une quantité de RAM minimale, totalement dédiée au GPU, et une quantité de RAM maximale que le GPU ne peut pas dépasser. Par exemple, il est possible de régler le GPU de manière à ce qu'il ait 64 mégaoctets rien que pour lui, mais qu'il puisse avoir accès à maximum 1 gigaoctet s'il en a besoin. Cela fait au total 960 mégaoctets (1024-64) qui peut être alloués au choix à la carte graphique ou au reste des programmes en cours d’exécution, selon les besoins. Il est possible d'allouer de grandes quantités de RAM au GPU, parfois la totalité de la mémoire système.

[[File:Partage de la mémoire unifiée entre CPU et GPU.png|centre|vignette|upright=2|Répartition de la mémoire entre RAM système et carte graphique]]

==Le partage de la mémoire système : la mémoire virtuelle des GPUs dédiés==

Après avoir vu la mémoire unifiée, voyons maintenant la mémoire dédiée. Intuitivement, on se dit que la carte graphique n'a accès qu'à la mémoire vidéo dédiée et ne peut pas lire de données dans la mémoire système, la RAM de l'ordinateur. Cependant, ce n'est pas le cas. Et ce pour plusieurs raisons. La raison principale est que des données doivent être copiées de la mémoire RAM vers la mémoire vidéo. Les copies en question se font souvent via ''Direct Memory Access'', ce qui fait que les GPU intègrent un contrôleur DMA dédié. Et ce contrôleur DMA lit des données en RAM système pour les copier en RAM vidéo.

La seconde raison est que les cartes graphiques intègrent presque toutes des technologies pour lire directement des données en RAM, sans forcément les copier en mémoire vidéo. Les technologies en question permettent à la carte graphique d'adresser plus de RAM qu'en a la mémoire vidéo. Par exemple, si la carte vidéo a 4 giga-octets de RAM, la carte graphique peut être capable d'en adresser 8 : 4 gigas en RAM vidéo, et 4 autres gigas en RAM système.

Les technologies de ce genre ressemblent beaucoup à la mémoire virtuelle des CPU, avec cependant quelques différences. La mémoire virtuelle permet à un processeur d'utiliser plus de RAM qu'il n'y en a d'installée dans l'ordinateur. Par exemple, elle permet au CPU de gérer 4 gigas de RAM sur un ordinateur qui n'en contient que trois, le gigaoctet de trop étant en réalité simulé par un fichier sur le disque dur. La technique est utilisée par tous les processeurs modernes. La mémoire virtuelle des GPUs dédiés fait la même chose, sauf que le surplus d'adresses n'est pas stockés sur le disque dur dans un fichier pagefile, mais est dans la RAM système. Pour le dire autrement, ces cartes dédiées peuvent utiliser la mémoire système si jamais la mémoire vidéo est pleine.

[[File:Mémoire virtuelle des cartes graphiques dédiées.png|centre|vignette|upright=2|Mémoire virtuelle des cartes graphiques dédiées]]

===La ''IO-Memory Management Unit'' (IOMMU)===

Pour que la carte graphique ait accès à la mémoire système, elle intègre un circuit appelé la '''''Graphics address remapping table''''', abrévié en GART. Cela vaut aussi bien pour les cartes graphiques utilisant le bus AGP que pour celles en PCI-Express. La GART est techniquement une  une ''Memory Management Unit'' (MMU), à savoir un circuit spécialisé qui prend en charge la mémoire virtuelle. La dite MMU étant intégrée dans un périphérique d'entrée-sortie (IO), ici la carte graphique, elle est appelée une IO-MMU (''Input Output-MMU'').

Le GPU utilise la technique dite de la pagination, à savoir que l'espace d'adressage est découpée en pages de taille fixe, généralement 4 kilo-octets. La traduction des adresses virtuelles en adresses physique se fait au niveau de la page. Une adresse est coupée en deux parts : un numéro de page, et la position de la donnée dans la page. La position dans la page ne change pas lors de la traduction d'adresse, mais le numéro de page est lui traduit. Le numéro de page virtuel est remplacé par un numéro de page physique lors de la traduction.

Pour remplacer le numéro de page virtuel en numéro physique, il faut utiliser une table de translation, appelée la '''table des pages''', qui associe un numéro de page logique à un numéro de page physique. Le système d'exploitation dispose de sa table des pages, qui n'est pas accesible au GPU. Par contre, le GPU dispose d'une sorte de mini-table des pages, qui contient les associations page virtuelle-physique utiles pour traiter les commandes GPU, et rien d'autre. En clair, une sorte de sous-ensemble de la table des pages de l'OS, mais spécifique au GPU. La mini-table des pages est gérée par le pilote de périphérique, qui remplit la mini-table des pages. La mini-table des pages est mémorisée dans une mémoire intégrée au GPU, et précisément dans la MMU.

===Historique de la mémoire virtuelle sur les GPU===

La technologie existait déjà sur certaines cartes graphiques au format PCI, mais la documentation est assez rare. La carte graphique NV1 de NVIDIA, leur toute première carte graphique, disposait déjà de ce système de mémoire virtuelle. La carte graphique communiquait avec le processeur grâce à la fonctionnalité ''Direct Memory Access'' et intégrait donc un contrôleur DMA. Le ''driver'' de la carte graphique programmait le contrôleur DMA en utilisant les adresses fournies par les applications/logiciels. Et il s'agissait d'adresses virtuelles, non d'adresses physiques en mémoire RAM. Pour résoudre ce problème, le contrôleur DMA intégrait une MMU, une unité de traduction d'adresse, qui traduisait les adresses virtuelles fournies par les applications en adresse physique en mémoire système.

: Le fonctionnement de cette IOMMU est décrite dans le brevet &quot;US5758182A : DMA controller translates virtual I/O device address received directly from application program command to physical i/o device address of I/O device on device bus&quot;, des inventeurs David S. H. Rosenthal et Curtis Priem.

[[File:Microarchitecture du GPU NV1 de NVIDIA.png|centre|vignette|upright=2|Microarchitecture du GPU NV1 de NVIDIA]]

La technologie s'est démocratisée avec le bus AGP, dont la fonctionnalité dite d'''AGP texturing'' permettait de lire ou écrire directement dans la mémoire RAM, sans passer par le processeur. D'ailleurs, la carte graphique Intel i740 n'avait pas de mémoire vidéo et se débrouillait uniquement avec la mémoire système.

L'arrivée du bus PCI-Express ne changea pas la donne, si ce n'est que le bus était plus rapide, ce qui améliorait les performances. Au début, seules les cartes graphiques PCI-Express d'entrée de gamme pouvaient accéder à certaines portions de la mémoire RAM grâce à des technologies adaptées, comme le TurboCache de NVIDIA ou l'HyperMemory d'AMD. Mais la technologie s'est aujourd'hui étendue. De nos jours, toutes les cartes vidéos modernes utilisent la RAM système en plus de la mémoire vidéo, mais seulement en dernier recours, soit quand la mémoire vidéo est quasiment pleine, soit pour faciliter les échanges de données avec le processeur. C'est typiquement le pilote de la carte graphique qui décide ce qui va dans la mémoire vidéo et la mémoire système, et il fait au mieux de manière à avoir les performances optimales.

===L'espace d'adressage du CPU et du GPU===

L'espace d'adressage est l'ensemble des adresses géré par le processeur ou la carte graphique. En général, l'espace d'adressage du processeur et de la carte graphique sont séparés, mais des standards comme l''''''Heterogeneous System Architecture''''' permettent au processeur et à une carte graphique de partager le même espace d'adressage. Une adresse mémoire est alors la même que ce soit pour le processeur ou la carte graphique.

{|class=&quot;wikitable&quot;
|-
! !! Mémoire vidéo dédiée !! Mémoire vidéo unifiée
|-
! Sans HSA
| [[File:Desktop computer bus bandwidths.svg|400px|Desktop computer bus bandwidths]]
| [[File:Integrated graphics with distinct memory allocation.svg|400px|Integrated graphics with distinct memory allocation]]
|-
! Avec HSA
| [[File:HSA-enabled virtual memory with distinct graphics card.svg|400px|HSA-enabled virtual memory with distinct graphics card]]
| [[File:HSA-enabled integrated graphics.svg|400px|HSA-enabled integrated graphics]]
|}

==Les échanges entre processeur et mémoire vidéo==

Quand on charge un niveau de jeux vidéo, on doit notamment charger la scène, les textures, et d'autres choses dans la mémoire RAM, puis les envoyer à la carte graphique. Ce processus se fait d'une manière fortement différente selon que l'on a une mémoire unifiée ou une mémoire vidéo dédiée.

===Avec la mémoire unifiée===

Avec la mémoire unifié, les échanges de données entre processeur et carte graphique sont fortement simplifiés et aucune copie n'est nécessaire. La carte vidéo peut y accéder directement, en lisant leur position initiale en RAM. Une partie de la RAM est visible seulement pour le CPU, une autre seulement pour le GPU, le reste est partagé. Les échanges de données entre CPU et GPU se font en écrivant/lisant des données dans la RAM partagée entre CPU et GPU. Pas besoin de faire de copie d'une mémoire à une autre : la donnée a juste besoin d'être placée au bon endroit. Le chargement des textures, du tampon de commandes ou d'autres données du genre, est donc très rapide, presque instantané.

Par contre, le débit de la RAM unifiée est partagé entre la carte graphique et le processeur. Alors qu'avec une mémoire dédiée, tout le débit de la mémoire vidéo aurait été dédié au GPU, le CPU ayant quant à lui accès à tout le débit de la RAM système. De plus, le partage du débit n'est pas chose facile. Les deux se marchent sur les pieds. La carte graphique doit parfois attendre que le processeur lui laisse l'accès à la RAM et inversement. Divers circuits d'arbitrage s'occupent de répartir équitablement les accès à RAM entre les deux, mais cela ne permet que d'avoir un compromis imparfait qui peut réduire les performances. Le seul moyen pour réduire la casse est d'ajouter des mémoires caches entre le GPU et la RAM, mais l'efficacité des caches est relativement limitée pour le rendu 3D.

[[File:Echanges de données entre CPU et GPU avec une mémoire unifiée.png|centre|vignette|upright=2|Échanges de données entre CPU et GPU avec une mémoire unifiée]]

Un autre défaut survient sur les cartes dédiées à mémoire unifiée, par exemple l'Intel 740. Pour lire en mémoire RAM, elles doivent passer par l'intermédiaire du bus AGP, PCI ou PCI-Express. Et ce bus est très lent, bien plus que ne le serait une mémoire vidéo normale. Aussi, les performances sont exécrables. J'insiste sur le fait que l'on parle des cartes graphiques dédiées, mais pas des cartes graphiques soudées des consoles de jeu.

D'ailleurs, de telles cartes dédiées incorporent un ''framebuffer'' directement dans la carte graphique. Il n'y a pas le choix, le VDC de la carte graphique doit accéder à une mémoire suffisamment rapide pour alimenter l'écran. Ils ne peuvent pas prendre le risque d'aller lire la RAM, dont le temps de latence est élevé, et qui peut potentiellement être réservée par le processeur pendant l’affichage d'une image à l'écran.

===Avec une mémoire vidéo dédiée===

Avec une mémoire vidéo dédiée, on doit copier les données adéquates dans la mémoire vidéo, ce qui implique des transferts de données passant par le bus PCI-Express. Le processeur voit une partie de la mémoire vidéo, dans laquelle il peut lire ou écrire comme bon lui semble. Le reste de la mémoire vidéo est invisible du point de vue du processeur, mais manipulable par le GPU à sa guise. Il est possible pour le CPU de copier des données dans la portion invisible de la mémoire vidéo, mais cela se fait de manière indirecte en passant par le GPU d'abord. Il faut typiquement envoyer une commande spéciale au GPU, pour lui dire de charger une texture en mémoire vidéo, par exemple. Le GPU effectue alors une copie de la mémoire système vers la mémoire vidéo, en utilisant un contrôleur DMA intégré au GPU.

[[File:Interaction du GPU avec la mémoire vidéo et la RAM système sur une carte graphique dédiée.png|centre|vignette|upright=2|Échanges de données entre CPU et GPU avec une mémoire vidéo dédiée]]

La gestion de la mémoire vidéo est prise en charge par le pilote de la carte graphique, sur le processeur. Elle a tendance à allouer les textures et d'autres données de grande taille dans la mémoire vidéo invisible, le reste étant placé ailleurs. Les copies DMA vers la mémoire vidéo invisible sont adaptées à des copies de grosses données comme les textures, mais elles marchent mal pour des données assez petites. Or, les jeux vidéos ont tendance à générer à la volée de nombreuses données de petite taille, qu'il faut copier en mémoire vidéo. Et c'est sans compter sur des ressources du pilote de périphériques, qui doivent être copiées en mémoire vidéo, comme le tampon de commande ou d'autres ressources. Et celles-ci ne peuvent pas forcément être copiées dans la mémoire vidéo invisible. Si la mémoire vidéo visible par le CPU est trop petite, les données précédentes sont copiées dans la mémoire visible par le CPU, en mémoire système, mais leur accès par le GPU est alors très lent. Aussi, plus la portion visible de la mémoire vidéo est grande, plus simple est la gestion de la mémoire vidéo par le pilote graphique. Et de ce point de vue, les choses ont évolué récemment.

Pour accéder à un périphérique PCI-Express, il faut configurer des registres spécialisés, appelés les ''Base Address Registers'' (BARs). La configuration des registres précise quelle portion de mémoire vidéo est adressable par le processeur, quelle est sa taille, sa position en mémoire vidéo, etc. Avant 2008, les BAR permettaient d’accéder à seulement 256 mégaoctets, pas plus. La gestion de la mémoire vidéo était alors difficile. Les échanges entre portion visible et invisible de la mémoire vidéo étaient complexes, demandaient d’exécuter des commandes spécifiques au GPU et autres. Après 2008, la spécification du PCI-Express ajouta un support de la technologie ''resizable bar'', qui permet au processeur d’accéder directement à plus de 256 mégaoctets de mémoire vidéo, voire à la totalité de la mémoire vidéo. De nombreux fabricants de cartes graphiques commencent à incorporer cette technologie, qui demande quelques changements au niveau du système d'exploitation, des pilotes de périphériques et du matériel.

{{NavChapitre | book=Les cartes graphiques
           | prev=La microarchitecture des processeurs de shaders
           | prevText=La microarchitecture des processeurs de shaders
           | next=La hiérarchie mémoire d'un GPU
           | netxText=La hiérarchie mémoire d'un GPU
}}{{autocat}}</text>
      <sha1>dboeqjmxsb1hya9dbz479k3fygw6a0u</sha1>
    </revision>
  </page>
  <page>
    <title>Fonctionnement d'un ordinateur/L'unité de chargement et le program counter</title>
    <ns>0</ns>
    <id>80691</id>
    <revision>
      <id>744058</id>
      <parentid>743108</parentid>
      <timestamp>2025-06-03T18:38:48Z</timestamp>
      <contributor>
        <username>Mewtow</username>
        <id>31375</id>
      </contributor>
      <minor />
      <comment>/* Le Zero-overhead looping */</comment>
      <origin>744058</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="39738" sha1="3n8559z9ofqeorlcqy087zvwixtqb5c" xml:space="preserve">L'unité de contrôle s'occupe du chargement des instructions et de leur interprétation, leur décodage. Elle contient deux circuits : l''''unité de chargement''' qui charge l'instruction depuis la mémoire, et le '''séquenceur''' qui commande le chemin de données. Les deux circuits sont séparés, mais ils communiquent entre eux, notamment pour gérer les branchements. Dans ce chapitre, nous allons nous intéresser au chargement d'une instruction depuis la RAM/ROM, nous verrons l'étape de décodage de l'instruction au prochain chapitre.

==Le chargement d'une instruction==

[[File:Étape de chargement.png|vignette|upright=1|Étape de chargement.]]

L'étape de chargement (ou ''fetch'') doit faire deux choses : mettre à jour le ''program counter'' et lire l'instruction en mémoire RAM ou en ROM. Les deux étapes peuvent être faites en parallèle, dans des circuits séparés. Pendant que l'instruction est lue depuis la mémoire RAM/ROM, le ''program counter'' est incrémenté et/ou altéré par un branchement.

Pour lire l'instruction, on envoie le ''program counter'' sur le bus d'adresse et on récupère l'instruction sur le bus de données pour l'envoyer sur l'entrée du séquenceur. Et cela demande de connecter le séquenceur au bus mémoire, à travers l'interface mémoire. Et sur ce point, la situation est différente selon que l'on parler d'une architecture Harvard ou Von Neumann.

===Les interconnexions entre séquenceur et bus mémoire===

Sur les architectures Harvard, le séquenceur et le chemin de donnée utilisent des interfaces mémoire séparées. Le séquenceur est directement relié au bus mémoire de la ROM, alors que le chemin de données est connecté à la RAM.

[[File:Microarchitecture de l'interface mémoire d'une architecture Harvard.png|centre|vignette|upright=2|Microarchitecture de l'interface mémoire d'une architecture Harvard]]

Mais sur les architectures Von-Neumann et affiliées, le séquenceur et le chemin de donnée partagent la même interface mémoire. Et cela pose deux problèmes.

Le premier problème est que le bus mémoire doit être libéré une fois l'instruction chargée, pour un éventuel accès mémoire. Mais le séquenceur doit conserver une copie de l'instruction chargée, sans quoi il ne peut pas décoder l'instruction correctement. Par exemple, si l'instruction met plusieurs cycles à s'exécuter, le séquenceur doit conserver une copie de l'instruction durant ces plusieurs cycles. La solution à ce problème est un '''registre d'instruction''' situé juste avant le séquenceur, qui mémorise l'instruction chargée.

[[File:Registre d'instruction.png|centre|vignette|upright=2|Registre d'instruction.]]

Le second problème est de gérer le flot des instructions/données entre le bus mémoire, le chemin de données et le séquenceur. Le processeur doit connecter l'interface mémoire soit au séquenceur, soit au chemin de données et cela complique le réseau d'interconnexion interne au processeur.

Une première solution utilise un bus unique qui relie l'interface mémoire, le séquenceur et le chemin de données. Pour charger une instruction, le séquenceur copie le ''program counter'' sur le bus d'adresse, attend que l'instruction lue soit disponible sur le bus de données, puis la copie dans le registre d'instruction. Le bus mémoire est alors libre et peut être utilisé pour lire ou écrire des données, si le besoin s'en fait sentir.

Il faut noter que l'usage d'un bus unique a un impact sur l'organisation interne du chemin de données. Par exemple, le chapitre précédent nous a montré comment implémenter un chemin de données basique, avec des multiplexeurs et démultiplexeurs. Et bien ces chemins de données ne marchent pas vraiment avec un bus interne unique. Il est possible de les adapter, mais au prix d'une complexité largement supérieure. Un bus interne unique marche mieux quand le banc de registre est mono-port. C'est pourquoi il a été utilisé sur d'anciennes architectures appelées des architectures à accumulateur et à pile, que nous verrons dans quelques chapitres, qui utilisaient un banc de registre mono-port.

[[File:Microarchitecture de l'interface mémoire d'une architecture von neumann.png|centre|vignette|upright=2|Microarchitecture de l'interface mémoire d'une architecture von neumann]]

Une autre solution utilise deux bus interne séparés : un connecté au bus d'adresse, l'autre au bus de données. Le ''program counter'' est alors connecté au bus interne d'adresse, le séquenceur est relié au bus interne de données. Notons que la technique marche bien si le ''program counter'' est dans le banc de registre : les interconnexions utilisées pour gérer l'adressage indirect permettent d'envoyer le ''program counter'' sur le bus d'adresse sans ajout de circuit.

Le tout peut être amélioré en remplaçant les deux bus par des multiplexeurs et démultiplexeurs. Le bus d'adresse est précédé par un multiplexeur, qui permet de faire le choix entre ''Program Counter'', adresse venant du chemin de données, ou adresse provenant du séquenceur (adressage absolu). De même, le bus de données est suivi par un démultiplexeur qui envoie la donnée/instruction lue soit au registre d'instruction, soit au chemin de données. Le tout se marie très bien avec les chemins de donnée vu dans le chapitre précédent. Au passage, il faut noter que cette solution nécessite un banc de registre multi-port.

[[File:Connexion du program counter sur les bus avec PC isolé.png|centre|vignette|upright=2|Connexion du program counter sur les bus avec PC isolé]]

===Le chargement des instructions de longueur variable===

Le chargement des instructions de longueur variable pose de nombreux problèmes. Le premier est que mettre à jour le ''program counter'' demande de connaitre la longueur de l'instruction chargée, pour l'ajouter au ''program counter''. Si la longueur d'une instruction est variable, on doit connaitre cette longueur d'une manière où d'une autre. La solution la plus simple indique la longueur de l'instruction dans une partie de l'opcode ou de la représentation en binaire de l'instruction. Mais les processeurs haute performance de nos PC utilisent d'autres solutions, qui n'encodent pas explicitement la taille de l'instruction.

Les processeurs récents utilisent un registre d'instruction de grande taille, capable de mémoriser l'instruction la plus longue du processeur. Par exemple, si un processeur supporte des instructions allant de 1 à 8 octets, comme les CPU x86, le registre d'instruction fera 8 octets. Le décodeur d'instruction vérifie à chaque cycle le contenu du registre d'instruction. Si une instruction est détectée dedans, son décodage commence, peu importe la taille de l'instruction. Une fois l'instruction exécutée, elle est retirée du registre d'instruction. Reste à alimenter le registre d'instruction, à charger des instructions dedans. Et pour cela deux solutions : soit on charge l'instruction en plusieurs fois, soit d'un seul coup.

La solution la plus simple charge les instructions par mots de 8, 16, 32, 64 bits. Ils sont accumulés dans le registre d'instruction jusqu'à détecter une instruction complète. La technique marche nettement mieux si les instructions sont très longues. Par exemple, les CPU x86 ont des instructions qui vont de 1 à 15 octets, ce qui fait qu'ils utilisent cette technique. Précisément, elle marche si les instructions les plus longues sont plus grandes que le bus mémoire.

Une autre solution charge un bloc de mots mémoire aussi grand que la plus grande instruction. Par exemple, si le processeur gère des instructions allant de 1 à 4 octets, il charge 4 octets d'un seul coup dans le registre d'instruction. Il va de soit que cette solution ne marche que si les instructions du processeur sont assez courtes, au plus aussi courtes que le bus mémoire. Ainsi, on est sûr de charger obligatoirement au moins une instruction complète, et peut-être même plusieurs. Le contenu du registre d'instruction est alors découpé en instructions au fil de l'eau. 

Utiliser un registre d'instruction large pose problème avec des instructions à cheval entre deux blocs. Il se peut qu'on n'ait pas une instruction complète lorsque l'on arrive à la fin du bloc, mais seulement un morceau. Le problème se manifeste peu importe que l'instruction soit chargée d'un seul coup ou bien en plusieurs fois.

[[File:Instructions non alignées.png|centre|vignette|upright=2|Instructions non alignées.]]

Dans ce cas, on doit décaler le morceau de bloc pour le mettre au bon endroit (au début du registre d'instruction), et charger le prochain bloc juste à côté. On a donc besoin d'un circuit qui décale tous les bits du registre d'instruction, couplé à un circuit qui décide où placer dans le registre d'instruction ce qui a été chargé, avec quelques circuits autour pour configurer les deux circuits précédents.

[[File:Décaleur d’instruction.png|centre|vignette|upright=2|Décaleur d’instruction.]]

Une autre solution se passe de registre d'instruction en utilisant à la place l'état interne du séquenceur. Là encore, elle charge l'instruction morceau par morceau, typiquement par blocs de 8, 16 ou 32 bits. Les morceaux ne sont pas accumulés dans le registre d'instruction, la solution utilise à la place l'état interne du séquenceur. Les mots mémoire de l'instruction sont chargés à chaque cycle, faisant passer le séquenceur d'un état interne à un autre à chaque mot mémoire. Tant qu'il n'a pas reçu tous les mots mémoire de l'instruction, chaque mot mémoire non terminal le fera passer d'un état interne à un autre, chaque état interne encodant les mots mémoire chargés auparavant. S'il tombe sur le dernier mot mémoire d'une instruction, il rentre dans un état de décodage.

==L'incrémentation du ''program counter''==

À chaque chargement, le ''program counter'' est mis à jour afin de pointer sur la prochaine instruction à charger. Sur la quasi-totalité des processeurs, les instructions sont placées dans l'ordre d’exécution dans la RAM. En faisant ainsi, on peut mettre à jour le ''program counter'' en lui ajoutant la longueur de l'instruction courante. Déterminer la longueur de l'instruction est simple quand les instructions ont toutes la même taille, mais certains processeurs ont des instructions de taille variable, ce qui complique le calcul. Dans ce qui va suivre, nous allons supposer que les instructions sont de taille fixe, ce qui fait que le ''program counter'' est toujours incrémenté de la même valeur.

Il existe deux méthodes principales pour incrémenter le ''program counter'' : soit le ''program counter'' a son propre additionneur, soit le ''program counter'' est mis à jour par l'ALU. Pour ce qui est de l'organisation des registres, soit le ''program counter'' est un registre séparé des autres, soit il est regroupé avec d'autres registres dans un banc de registre. En tout, cela donne quatre organisations possibles.
* Un ''program counter'' séparé relié à un incrémenteur séparé.
* Un ''program counter'' séparé des autres registres, incrémenté par l'ALU.
* Un ''program counter'' intégré au banc de registre, relié à un incrémenteur séparé.
* Un ''program counter'' intégré au banc de registre, incrémenté par l'ALU.

[[File:Calcul du program counter.png|centre|vignette|upright=2|les différentes méthodes de calcul du program counter.]]

Les processeurs haute performance modernes utilisent tous la première méthode. Les autres méthodes étaient surtout utilisées sur les processeurs 8 ou 16 bits, elles sont encore utilisées sur quelques microcontrôleurs de faible puissance. Nous auront l'occasion de donner des exemples quand nous parlerons des processeurs 8 bits anciens, dans le chapitre sur les architectures à accumulateur et affiliées.

===Le ''program counter'' mis à jour par l'ALU===

Sur certains processeurs, le calcul de l'adresse de la prochaine instruction est effectué par l'ALU. L'avantage de cette méthode est qu'elle économise un incrémenteur dédié au ''program counter''. Ce qui explique que cette méthode était utilisée sur les processeurs assez anciens, à une époque où un additionneur pouvait facilement prendre 10 à 20% des transistors disponibles. Le désavantage principal est une augmentation de la complexité du séquenceur, qui doit gérer la mise à jour du ''program counter''. De plus, la mise à jour du ''program counter'' ne peut pas se faire en même temps qu'une opération arithmétique, ce qui réduit les performances.

Si on incrémente le ''program counter'' avec l'ALU, il est intéressant de le placer dans le banc de registres. Un désavantage est qu'on perd un registre. Par exemple, avec un banc de registre de 16 registres, on ne peut adresser que 15 registres généraux. De plus ce n'est pas l'idéal pour le décodage des instructions et pour le séquenceur. Si le processeur dispose de plusieurs bancs de registres, le ''program counter'' est généralement placé dans le banc de registre dédié aux adresses. Sinon, il est placé avec les nombres entiers/adresses.

D'anciens processeurs incrémentaient le ''program counter'' avec l'ALU, mais utilisaient bien un registre séparé pour le ''program counter''. Cette méthode est relativement simple à implémenter : il suffit de connecter/déconnecter le ''program counter'' du bus interne suivant les besoins. Le ''program counter'' est déconnecté pendant l’exécution d'une instruction, il est connecté au bus interne pour l'incrémenter. C'est le séquenceur qui gère le tout. L'avantage de cette séparation est qu'elle est plus facile à gérer pour le séquenceur. De plus, on gagne un registre général/entier dans le banc de registre.

===Le compteur programme===

Dans la quasi-totalité des processeurs modernes, le ''program counter'' est un vulgaire compteur comme on en a vu dans les chapitres sur les circuits, ce qui fait qu'il passe automatiquement d'une adresse à la suivante. Dans ce qui suit, nous allons appeler ce registre compteur : le '''compteur ordinal'''. L'usage d'un compteur simplifie fortement la conception du séquenceur. Le séquenceur n'a pas à gérer la mise à jour du ''program counter'', sauf en cas de branchements. De plus, il est possible d'incrémenter le ''program counter'' pendant que l'unité de calcul effectue une opération arithmétique, ce qui améliore grandement les performances. Le seul désavantage est qu'elle demande d'ajouter un incrémenteur dédié au ''program counter''.

Sur les processeurs très anciens, les instructions faisaient toutes un seul mot mémoire et le compteur ordinal était un circuit incrémenteur des plus basique. Sur les processeurs modernes, le compteur est incrémenté par pas de 4 si les instructions sont codées sur 4 octets, 8 si les instructions sont codées sur 8 octets, etc. Concrètement, le compteur est un circuit incrémenteur auquel on aurait retiré quelques bits de poids faible. Par exemple, si les instructions sont codées sur 4 octets, on coupe les 2 derniers bits du compteur. Si les instructions sont codées sur 8 octets, on coupe les 3 derniers bits du compteur. Et ainsi de suite.

Il a existé quelques processeurs pour lesquelles le ''program counter'' était non pas un compteur binaire classique, mais un ''linear feedback shift register''. L'avantage est que le circuit d'incrémentation utilisait bien moins de portes logiques, l'économie était substantielle. Mais un défaut est que des instructions consécutives dans le programme n'étaient pas consécutives en mémoire. Il existait cependant une table de correspondance pour dire : la première instruction est à telle adresse, la seconde à telle autre, etc. Un exemple de processeur de ce type est le TMS 1000 de Texas Instrument, un des premiers microcontrôleur 4 bits datant des années 70.

Une amélioration de la solution précédente utilise un circuit incrémenteur partagé entre le ''program counter'' et d'autres registres. L'incrémenteur est utilisé pour incrémenter le ''program counter'', mais aussi pour effectuer d'autres calculs d'adresse. Par exemple, sur les architectures avec une pile d'adresse de retour, il est possible de partager l'incrémenteur/décrémenteur avec le pointeur de pile ( la technique ne marche pas avec une pile d'appel). Un autre exemple est celui des processeurs qui gèrent automatiquement le rafraichissement mémoire, grâce à, un compteur intégré dans le processeur. Il est possible de partager l'incrémenteur du ''program counter'' avec le compteur de rafraichissement mémoire, qui mémorise la prochaine adresse mémoire à rafraichir. Nous avions déjà abordé ce genre de partage dans le chapitre sur le chemin de données, dans l'annexe sur le pointeur de pile, mais nous verrons d'autres exemples dans le chapitre sur les architectures hybride accumulateur-registre 8/16 bits.

===Quand est mis à jour le ''program counter'' ?===

Le ''program counter'' est mis à jour quand il faut charger une nouvelle instruction. Reste qu'il faut savoir quand le mettre à jour. Incrémenter le ''program counter'' à intervalle régulier, par exemple à chaque cycle d’horloge, fonctionne sur les processeurs où toutes les instructions mettent le même temps pour s’exécuter. Mais de tels processeurs sont très rares. Sur la quasi-totalité des processeurs, les instructions ont une durée d’exécution variable, elles ne prennent pas le même nombre de cycle d'horloge pour s’exécuter. Le temps d’exécution d'une instruction varie selon l'instruction, certaines sont plus longues que d'autres. Tout cela amène un problème : comment incrémenter le ''program counter'' avec des instructions avec des temps d’exécution variables ?

La réponse est que la mise à jour du ''program counter'' démarre quand l'instruction précédente a terminée de s’exécuter, plus précisément un cycle avant. C'est un cycle avant pour que l'instruction chargée soit disponible au prochain cycle pour le décodeur. Pour cela, le séquenceur doit déterminer quand l'instruction est terminée et prévenir le ''program counter'' au bon moment. Il faut donc une interaction entre séquenceur et circuit de chargement. Le circuit de chargement contient une entrée Enable, qui autorise la mise à jour du ''program counter''. Le séquenceur met à 1 cette entrée pour prévenir au ''program counter'' qu'il doit être incrémenté au cycle suivant ou lors du cycle courant. Cela permet de gérer simplement le cas des instructions multicycles. 

[[File:Commande de la mise à jour du program counter.png|centre|vignette|upright=2|Commande de la mise à jour du program counter.]]

Toute la difficulté est alors reportée dans le séquenceur, qui doit déterminer la durée d'une instruction. Pour gérer la mise à jour du ''program counter'', le séquenceur doit déterminer la durée d'une instruction. Cela est simple pour les instructions arithmétiques et logiques, qui ont un nombre de cycles fixe, toujours le même. Une fois l'instruction identifiée par le séquenceur, il connait son nombre de cycles et peut programmer un compteur interne au séquenceur, qui compte le nombre de cycles de l'instruction, et fournit le signal Enable au ''program counter''. Mais cette technique ne marche pas vraiment pour les accès mémoire, dont la durée n'est pas connue à l'avance, surtout sur les processeurs avec des mémoires caches. Pour cela, le séquenceur détermine quand l'instruction mémoire est finie et prévient le ''program counter'' quand c'est le cas.

Il existe quelques processeurs pour lesquels le temps de calcul dépend des opérandes de l'instruction. On peut par exemple avoir une division qui prend 10 cycles avec certaines opérandes, mais 40 cycles avec d'autres opérandes. Mais ces processeurs sont rares et cela est surtout valable pour les opérations de multiplication/division, guère plus. Le problème est alors le même qu'avec les accès mémoire et la solution est la même : l'ALU prévient le séquenceur quand le résultat est disponible.

==Les branchements et le ''program counter''==

Un branchement consiste juste à écrire l'adresse de destination dans le ''program counter''. L'implémentation des branchements demande d'extraire l'adresse de destination et d'altérer le ''program counter'' quand un branchement est détecté. Pour cela, le décodeur d'instruction détecte si l'instruction exécutée est un branchement ou non, et il en déduit où trouver l'adresse de destination.

L'adresse de destination se trouve à un endroit qui dépend du mode d'adressage du branchement. Pour rappel, on distingue quatre modes d'adressage pour les branchements : direct, indirect, relatif et implicite. Pour les branchements directs, l'adresse est intégrée dans l'instruction de branchement elle-même et est extraite par le séquenceur. Pour les branchements indirects, l'adresse de destination est dans le banc de registre. Pour les branchements relatifs, il faut ajouter un décalage au ''program counter'', décalage extrait de l'instruction par le séquenceur. Enfin, les instructions de retour de fonction lisent l'adresse de destination depuis la pile. L'implémentation de ces quatre types de branchements est très différente.

L'altération du ''program counter'' dépend de si le ''program counter'' est dans un compteur séparé ou s'il est dans le banc de registre. Nous avons vu plus haut qu'il y a quatre cas différents, mais nous n'allons voir que deux cas : celui où le ''program counter'' est dans le banc de registre et est incrémenté par l'unité de calcul, celui avec un ''program counter'' séparé avec son propre incrémenteur. Les deux autres cas ne sont utilisés que sur des architectures à accumulateur ou à pile spécifiques, que nous n'avons pas encore vu à ce stade du cours et que nous verrons en temps voulu dans le chapitre sur ces architectures.

===L’implémentation des branchements avec un ''program counter'' intégré au banc de registres===

Le cas le plus simple est celui où le ''program counter'' est intégré au banc de registre, avec une incrémentation faite par l'unité de calcul. Charger une instruction revient alors à effectuer une instruction LOAD en adressage indirect, à deux différences près : le registre sélectionné est le ''program counter'', l’instruction est copiée dans le registre d'instruction et non dans le banc de registre. L'incrémentation du ''porgram counter'' est implémenté avec des micro-opérations qui agissent sur le chemin de données, au même titre que les branchements indirects, relatifs et directs.
* Les branchements indirects copient un registre dans le ''program counter'', ce qui revient simplement à faire une opération MOV entre deux registres, dont le ''program counter'' est la destination.
* L'opération inverse d'un branchement indirect, qui copie le ''program counter'' dans un registre général, est utile pour sauvegarder l'adresse de retour d'une fonction.
* Les branchements directs copient une adresse dans le ''program counter'', ce qui les rend équivalents à une opération MOV avec une constante immédiate, dont le ''program counter'' est la destination.
* Les branchements relatifs sont une opération arithmétique entre le ''program counter'' et un opérande en adressage immédiat.

En clair, à partir du moment où le chemin de données supporte les instructions MOV et l'addition, avec les modes d'adressage adéquat, il supporte les branchements. Aucune modification du chemin de données n'est nécessaire, le séquenceur gére le chargement d'une instruction avec les micro-instructions adéquates : une micro-opération ADD pour incrémenter le ''program counter'', une micro-opération LOAD pour le chargement de l'instruction.

Notons que sur certaines architectures, le ''program counter'' est adressable au même titre que les autres registres du banc de registre. Les instructions de branchement sont alors remplacées par des instructions MOV ou des instructions arithmétique équivalentes, comme décrit plus haut.

===L’implémentation des branchements avec un ''program counter'' séparé===

Étudions maintenant le cas où le ''program counter'' est dans un registre/compteur séparé. Rappelons que tout compteur digne de ce nom possède une entrée de réinitialisation, qui remet le compteur à zéro. De plus, on peut préciser à quelle valeur il doit être réinitialisé. Ici, la valeur à laquelle on veut réinitialiser le compteur n'est autre que l'adresse de destination du branchement. Implémenter un branchement est donc simple : l'entrée de réinitialisation est commandée par le circuit de détection des branchements, alors que la valeur de réinitialisation est envoyée sur l'entrée adéquate. En clair, nous partons du principe que le ''program counter'' est implémenté avec ce type de compteur :

[[File:Fonctionnement d'un compteur (décompteur), schématique.jpg|centre|vignette|upright=1.5|Fonctionnement d'un compteur (décompteur), schématique]]

Toute la difficulté est de présenter l'adresse de destination au ''program counter''. Pour les branchements directs, l'adresse de destination est fournie par le séquenceur. L'adresse de destination du branchement sort du séquenceur et est présentée au ''program counter'' sur l'entrée adéquate. Voici donc comment sont implémentés les branchements directs avec un ''program counter'' séparé du banc de registres. Le schéma ci-dessous marche peu importe que le ''program counter'' soit incrémenté par l'ALU ou par un additionneur dédié.

[[File:Unité de détection des branchements dans le décodeur.png|centre|vignette|upright=2|Unité de détection des branchements dans le décodeur]]

Les branchements relatifs sont ceux qui font sauter X instructions plus loin dans le programme. Leur implémentation demande d'ajouter une constante au ''program counter'', la constante étant fournie dans l’instruction. Là encore, deux solutions sont possibles : réutiliser l'ALU pour calculer l'adresse, ou utiliser un additionneur séparé. L'additionneur séparé peut être fusionné avec l'additionneur qui incrémente le ''program counter'' pour passer à l’instruction suivante.

[[File:Unité de chargement qui gère les branchements relatifs.png|centre|vignette|upright=2|Unité de chargement qui gère les branchements relatifs.]]

Pour les branchements indirects, il suffit de lire le registre voulu et d'envoyer le tout sur l'entrée adéquate du ''program counter''. Il faut alors rajouter un multiplexeur pour que l'entrée de réinitialisationr ecoive la bonne adresse de destination.

[[File:Unité de chargement qui gère les branchements directs.png|centre|vignette|upright=2|Unité de chargement qui gère les branchements directs et indirects.]]

Toute la difficulté de l'implémentation des branchements est de configurer les multiplexeurs, ce qui est réalisé par le séquenceur en fonction du mode d'adressage du branchement.

==Les optimisations du chargement des instructions==

Charger une instruction est techniquement une forme d'accès mémoire un peu particulier. En clair, charger une instruction prend au minimum un cycle d'horloge, et cela peut rapidement monter à 3-5 cycles, si ce n'est plus. L'exécution des instructions est alors fortement ralentit par la mémoire. Par exemple, imaginez que la mémoire mette 3 cycles d'horloges pour charger une instruction, alors qu'une instruction s’exécute en 1 cycle (si les opérandes sont dans les registres). La perte de performance liée au chargement des instructions est alors substantielle. Heureusement, il est possible de limiter la casse en utilisant des mémoires caches, ainsi que d'autres optimisations, que nous allons voir dans ce qui suit.

===Le tampon de préchargement===

La technique dite du '''préchargement''' est utilisée dans le cas où la mémoire a un temps d'accès important. Mais si la latence de la RAM est un problème, le débit ne l'est pas. Il est possible d'avoir une RAM lente, mais à fort débit. Par exemple, supposons que la mémoire puisse charger 4 instructions (de taille fixe) en 3 cycles. Le processeur peut alors charger 4 instructions en un seul accès mémoire, et les exécuter l'une après l'autre, une par cycle d'horloge. Les temps d'attente sont éliminés : le processeur peut décoder une nouvelle instruction à chaque cycle. Et quand la dernière instruction préchargée est exécutée, la mémoire est de nouveau libre, ce qui masque la latence des accès mémoire.

[[File:Tampon de préchargement d'instruction.png|vignette|Tampon de préchargement d'instruction]]

La seule contrainte est de mettre les instructions préchargées en attente. La solution pour cela est d'utiliser un registre d'instruction très large, capable de mémoriser plusieurs instructions à la fois. Ce registre est de plus connecté à un multiplexeur qui permet de sélectionner l'instruction adéquate dans ce registre. Ce multiplexeur est commandé par le ''program counter'' et quelques circuits annexes. Ce super-registre d'instruction est appelé un '''tampon de préchargement'''.

La méthode a une implémentation nettement plus simple avec des instructions de taille fixe, alignées en mémoire. La commande du multiplexeur de sélection de l'instruction est alors beaucoup plus simple : il suffit d'utiliser les bits de poids fort du ''program counter''. Par exemple, prenons le cas d'un registre d'instruction de 32 octets pour des instructions de 4 octets, soit 8 instructions. Le choix de l'instruction à sélectionner se fait en utilisant les 3 bits de poids faible du ''program counter''. 

Mais cette méthode ajoute de nouvelles contraintes d'alignement, similaires à celles vues dans le chapitre sur l'alignement et le boutisme, sauf que l'alignement porte ici sur des blocs d'instructions de même taille que le tampon de préchargement. Si on prend l'exemple d'un tampon de préchargement de 128 bits, les instructions devront être alignées par blocs de 128 bits. C'est à dire qu'idéalement, les fonctions et autres blocs de code isolés doivent commencer à des adresses multiples de 128, pour pouvoir charger un bloc d'instruction en une seule fois. Sans cela, les performances seront sous-optimales.

: Il arrive que le tampon de préchargement ait la même taille qu'une ligne de cache.

Lorsque l'on passe d'un bloc d'instruction à un autre, le tampon de préchargement est mis à jour. Par exemple, si on prend un tampon de préchargement de 4 instructions, on doit changer son contenu toutes les 4 instructions. La seule exception est l'exécution d'un branchement. En effet, lors d'un branchement, la destination du branchement n'est pas dans le tampon de préchargement et elle doit être chargée dedans (sauf si le branchement pointe vers une instruction très proche, ce qui est improbable). Pour cela, le tampon de préchargement est mis à jour précocement quand le processeur détecte un branchement.

Le même problème survient avec du code auto-modifiant. Un code auto-modifiant est un programme qui se modifie lui-même, en remplaçant certaines instructions par d'autres, en en retirant, en en ajoutant, lors de sa propre exécution. De tels programmes sont rares, mais la technique était utilisée dans quelques cas au tout début de l'informatique sur des ordinateurs rudimentaires. Ceux-ci avaient des modes d'adressages tellement limités que gérer des tableaux de taille variable demandait d'utiliser du code auto-modifiant pour écrire des boucles. Le problème survient quand des instructions sont modifiées immédiatement après avoir été préchargées. Les instructions dans le tampon de préchargement sont l'ancienne version, alors que la mémoire RAM contient les instructions modifiées. Gérer ce genre de cas demande de vider le tampon de préchargement si le cas arrive, mais ça ne vaut que très rarement le coup, aussi les ingénieurs ne s’embêtent pas à mettre ce correctif en place. Le code automodifiant est alors buggé.

===Le ''Zero-overhead looping''===

Nous avions vu dans le chapitre sur les instructions machines, qu'il existe des instructions qui permettent de grandement faciliter l'implémentation des boucles. Il s'agit de l'instruction REPEAT, utilisée sur certains processeurs de traitement de signal. Elle répète l'instruction suivante, voire une série d'instructions, un certain nombre de fois. Le nombre de répétitions est mémorisé dans un registre décrémenté à chaque itération de la boucle. Elle permet donc d'implémenter une boucle FOR facilement, sans recourir à des branchements ou des conditions.

Une technique en lien avec cette instruction permet de grandement améliorer les performances et la consommation d'énergie. L'idée est de mémoriser la boucle, les instructions à répéter, dans une petite mémoire cache située entre l'unité de chargement et le séquenceur. Le cache en question s'appelle un '''tampon de boucle''', ou encore un ''hardware loop buffer''. Grâce à lui, il n'y a pas besoin de charger les instructions à chaque fois qu'on les exécute, on les charge une bonne fois pour toute : c'est plus rapide. Bien sûr, il ne fonctionne que pour de petites boucles, mais il en est de même avec l'instruction REPEAT.


===La ''prefetch input queue''===

Avec un pipeline, plusieurs instructions sont présentes en même temps dans le pipeline. Et cela fait que des accès mémoires simultanés peuvent avoir lieu. Pour comprendre pourquoi, regardons dans quels étages du pipeline il peut y avoir un accès mémoire. Le premier, assez évident, est celui dédié aux accès mémoire, lors de l’exécution d'une instruction. Si une instruction effectue un accès mémoire, c'est cet étage qui le prend en charge. Il n'est pas systématique, seules certaines instructions l'utilisent. Par contre, un second étage utilise systématiquement un accès mémoire : le chargement de l'instruction depuis la mémoire ou le cache.

En clair, il n'est pas rare qu'on ait accès simultané à la mémoire : un pour charger l'instruction, un autre pour charger la donnée. Pour éviter cela, une solution simple consiste à séparer les voies d'accès aux instructions et aux données, de manière à autoriser des accès simultanés. Dans le cas le plus fréquent, les processeurs disposent d'un cache, et la solution est alors évidente : le cache L1 est séparé en deux, avec un cache d’instruction séparé du cache L1 de données. Les accès concurrents à la mémoire ne sont plus un problème. Sur les processeurs ne disposant pas de mémoire cache, la solution la plus est d'utiliser une architecture Harvard. Dans tous les cas, il faut utiliser une architecture harvard, ou harvard modifiée (caches séparés).

Sur les architectures Von Neumann, il est possible de limiter la casse en utilisant une optimisation appelée la ''prefetch input queue'', vue dans le chapitre sur le chargement des instructions. l'idée est que le processeur précharge les instructions quand la mémoire est libre, dans une mémoire tampon située avant l'unité de décodage. Si un accès aux données a lieu, le processeur peut décoder les instructions préchargées, en les piochant dans la mémoire tampon, sans accéder à la RAM ou au cache.

Pour implémenter le préchargement d'instruction, le registre d'instruction est remplacé par une mémoire FIFO appelée la '''''Prefetch input queue'''''. On peut la voir comme un registre d'instruction sous stéroïde, capable de mémoriser plusieurs instructions consécutives. Les instructions sont chargées dans la ''Prefetch input queue'' et y attendent que le processeur les lise et les décode. Les instructions y sont conservées dans leur ordre d'arrivée, afin qu'elles soient exécutées dans le bon ordre, ce qui fait que la ''Prefetch input queue'' est une mémoire de type FIFO. L'étape de décodage pioche l'instruction à décoder dans la ''Prefetch input queue'', cette instruction étant par définition la plus ancienne, puis la retire de la file.

Le premier processeur commercial grand public à utiliser cette méthode était le 8086, un processeur d'Intel de jeu d'instruction x86. Il pouvait précharger à l'avance 6 octets d’instruction. L'Intel 8088 avait lui aussi une ''Prefetch input queue'', mais qui ne permattait que de précharger 4 instructions. La taille idéale de la FIFO dépend de nombreux paramètres. On pourrait croire que plus elle peut contenir d'instructions, mieux c'est, mais ce n'est pas le cas, pour des raisons que nous allons voir dans ce qui suit.

[[File:80186 arch.png|centre|vignette|700px|upright=2|Architecture du 8086, du 80186 et de ses variantes.]]

Les branchements posent des problèmes avec la ''Prefetch input queue'' : à cause d'eux, on peut charger à l'avance des instructions qui sont zappées par un branchement et ne sont pas censées être exécutées. Si un branchement est chargé, toutes les instructions préchargées après sont potentiellement invalides. Si le branchement est non-pris, les instructions chargées sont valides, elles sont censées s’exécuter. Mais si le branchement est pris, elles ont été chargées à tort et ne doivent pas s’exécuter. 

Pour éviter cela, la ''Prefetch input queue'' est vidée quand le processeur détecte un branchement. Cette détection ne peut se faire qu'une fois le branchement décodé : on ne sait pas si l'instruction est un branchement ou autre chose tant que le décodage n'a pas eu lieu, par définition. En clair, le décodeur invalide la ''Prefetch input queue'' quand il détecte un branchement. Les interruptions posent le même genre de problèmes. Il faut impérativement vider la ''Prefetch input queue'' quand une interruption survient, avant de la traiter.

Un autre défaut est que la ''Prefetch input queue'' se marie assez mal avec du code auto-modifiant. Un code auto-modifiant est un programme qui se modifie lui-même, en remplaçant certaines instructions par d'autres, en en retirant, en en ajoutant, lors de sa propre exécution. De tels programmes sont rares, mais la technique était utilisée dans quelques cas au tout début de l'informatique sur des ordinateurs rudimentaires. Ceux-ci avaient des modes d'adressages tellement limités que gérer des tableaux de taille variable demandait d'utiliser du code auto-modifiant pour écrire des boucles.

Le problème avec la ''Prefetch input queue'' survient quand des instructions sont modifiées immédiatement après avoir été préchargées. Les instructions dans la ''Prefetch input queue'' sont l'ancienne version, alors que la mémoire RAM contient les instructions modifiées. Gérer ce genre de cas est quelque peu complexe. Il faut en effet vider la ''Prefetch input queue'' si le cas arrive, ce qui demande d'identifier les écritures qui écrasent des instructions préchargées. C'est parfaitement possible, mais demande de transformer la ''Prefetch input queue'' en une mémoire hybride, à la fois mémoire associative et mémoire FIFO. Cela ne vaut que très rarement le coup, aussi les ingénieurs ne s’embêtent pas à mettre ce correctif en place, le code automodifiant est alors buggé.

&lt;noinclude&gt;
{{NavChapitre | book=Fonctionnement d'un ordinateur
           | prev=Le chemin de données
           | prevText=Le chemin de données
           | next=L'unité de contrôle
           | nextText=L'unité de contrôle
}}
&lt;/noinclude&gt;</text>
      <sha1>3n8559z9ofqeorlcqy087zvwixtqb5c</sha1>
    </revision>
    <revision>
      <id>744059</id>
      <parentid>744058</parentid>
      <timestamp>2025-06-03T18:45:02Z</timestamp>
      <contributor>
        <username>Mewtow</username>
        <id>31375</id>
      </contributor>
      <minor />
      <comment>/* Les optimisations du chargement des instructions */</comment>
      <origin>744059</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="39216" sha1="bezoq4ld7y16mmcptxruvcvvi1uzxbn" xml:space="preserve">L'unité de contrôle s'occupe du chargement des instructions et de leur interprétation, leur décodage. Elle contient deux circuits : l''''unité de chargement''' qui charge l'instruction depuis la mémoire, et le '''séquenceur''' qui commande le chemin de données. Les deux circuits sont séparés, mais ils communiquent entre eux, notamment pour gérer les branchements. Dans ce chapitre, nous allons nous intéresser au chargement d'une instruction depuis la RAM/ROM, nous verrons l'étape de décodage de l'instruction au prochain chapitre.

==Le chargement d'une instruction==

[[File:Étape de chargement.png|vignette|upright=1|Étape de chargement.]]

L'étape de chargement (ou ''fetch'') doit faire deux choses : mettre à jour le ''program counter'' et lire l'instruction en mémoire RAM ou en ROM. Les deux étapes peuvent être faites en parallèle, dans des circuits séparés. Pendant que l'instruction est lue depuis la mémoire RAM/ROM, le ''program counter'' est incrémenté et/ou altéré par un branchement.

Pour lire l'instruction, on envoie le ''program counter'' sur le bus d'adresse et on récupère l'instruction sur le bus de données pour l'envoyer sur l'entrée du séquenceur. Et cela demande de connecter le séquenceur au bus mémoire, à travers l'interface mémoire. Et sur ce point, la situation est différente selon que l'on parler d'une architecture Harvard ou Von Neumann.

===Les interconnexions entre séquenceur et bus mémoire===

Sur les architectures Harvard, le séquenceur et le chemin de donnée utilisent des interfaces mémoire séparées. Le séquenceur est directement relié au bus mémoire de la ROM, alors que le chemin de données est connecté à la RAM.

[[File:Microarchitecture de l'interface mémoire d'une architecture Harvard.png|centre|vignette|upright=2|Microarchitecture de l'interface mémoire d'une architecture Harvard]]

Mais sur les architectures Von-Neumann et affiliées, le séquenceur et le chemin de donnée partagent la même interface mémoire. Et cela pose deux problèmes.

Le premier problème est que le bus mémoire doit être libéré une fois l'instruction chargée, pour un éventuel accès mémoire. Mais le séquenceur doit conserver une copie de l'instruction chargée, sans quoi il ne peut pas décoder l'instruction correctement. Par exemple, si l'instruction met plusieurs cycles à s'exécuter, le séquenceur doit conserver une copie de l'instruction durant ces plusieurs cycles. La solution à ce problème est un '''registre d'instruction''' situé juste avant le séquenceur, qui mémorise l'instruction chargée.

[[File:Registre d'instruction.png|centre|vignette|upright=2|Registre d'instruction.]]

Le second problème est de gérer le flot des instructions/données entre le bus mémoire, le chemin de données et le séquenceur. Le processeur doit connecter l'interface mémoire soit au séquenceur, soit au chemin de données et cela complique le réseau d'interconnexion interne au processeur.

Une première solution utilise un bus unique qui relie l'interface mémoire, le séquenceur et le chemin de données. Pour charger une instruction, le séquenceur copie le ''program counter'' sur le bus d'adresse, attend que l'instruction lue soit disponible sur le bus de données, puis la copie dans le registre d'instruction. Le bus mémoire est alors libre et peut être utilisé pour lire ou écrire des données, si le besoin s'en fait sentir.

Il faut noter que l'usage d'un bus unique a un impact sur l'organisation interne du chemin de données. Par exemple, le chapitre précédent nous a montré comment implémenter un chemin de données basique, avec des multiplexeurs et démultiplexeurs. Et bien ces chemins de données ne marchent pas vraiment avec un bus interne unique. Il est possible de les adapter, mais au prix d'une complexité largement supérieure. Un bus interne unique marche mieux quand le banc de registre est mono-port. C'est pourquoi il a été utilisé sur d'anciennes architectures appelées des architectures à accumulateur et à pile, que nous verrons dans quelques chapitres, qui utilisaient un banc de registre mono-port.

[[File:Microarchitecture de l'interface mémoire d'une architecture von neumann.png|centre|vignette|upright=2|Microarchitecture de l'interface mémoire d'une architecture von neumann]]

Une autre solution utilise deux bus interne séparés : un connecté au bus d'adresse, l'autre au bus de données. Le ''program counter'' est alors connecté au bus interne d'adresse, le séquenceur est relié au bus interne de données. Notons que la technique marche bien si le ''program counter'' est dans le banc de registre : les interconnexions utilisées pour gérer l'adressage indirect permettent d'envoyer le ''program counter'' sur le bus d'adresse sans ajout de circuit.

Le tout peut être amélioré en remplaçant les deux bus par des multiplexeurs et démultiplexeurs. Le bus d'adresse est précédé par un multiplexeur, qui permet de faire le choix entre ''Program Counter'', adresse venant du chemin de données, ou adresse provenant du séquenceur (adressage absolu). De même, le bus de données est suivi par un démultiplexeur qui envoie la donnée/instruction lue soit au registre d'instruction, soit au chemin de données. Le tout se marie très bien avec les chemins de donnée vu dans le chapitre précédent. Au passage, il faut noter que cette solution nécessite un banc de registre multi-port.

[[File:Connexion du program counter sur les bus avec PC isolé.png|centre|vignette|upright=2|Connexion du program counter sur les bus avec PC isolé]]

===Le chargement des instructions de longueur variable===

Le chargement des instructions de longueur variable pose de nombreux problèmes. Le premier est que mettre à jour le ''program counter'' demande de connaitre la longueur de l'instruction chargée, pour l'ajouter au ''program counter''. Si la longueur d'une instruction est variable, on doit connaitre cette longueur d'une manière où d'une autre. La solution la plus simple indique la longueur de l'instruction dans une partie de l'opcode ou de la représentation en binaire de l'instruction. Mais les processeurs haute performance de nos PC utilisent d'autres solutions, qui n'encodent pas explicitement la taille de l'instruction.

Les processeurs récents utilisent un registre d'instruction de grande taille, capable de mémoriser l'instruction la plus longue du processeur. Par exemple, si un processeur supporte des instructions allant de 1 à 8 octets, comme les CPU x86, le registre d'instruction fera 8 octets. Le décodeur d'instruction vérifie à chaque cycle le contenu du registre d'instruction. Si une instruction est détectée dedans, son décodage commence, peu importe la taille de l'instruction. Une fois l'instruction exécutée, elle est retirée du registre d'instruction. Reste à alimenter le registre d'instruction, à charger des instructions dedans. Et pour cela deux solutions : soit on charge l'instruction en plusieurs fois, soit d'un seul coup.

La solution la plus simple charge les instructions par mots de 8, 16, 32, 64 bits. Ils sont accumulés dans le registre d'instruction jusqu'à détecter une instruction complète. La technique marche nettement mieux si les instructions sont très longues. Par exemple, les CPU x86 ont des instructions qui vont de 1 à 15 octets, ce qui fait qu'ils utilisent cette technique. Précisément, elle marche si les instructions les plus longues sont plus grandes que le bus mémoire.

Une autre solution charge un bloc de mots mémoire aussi grand que la plus grande instruction. Par exemple, si le processeur gère des instructions allant de 1 à 4 octets, il charge 4 octets d'un seul coup dans le registre d'instruction. Il va de soit que cette solution ne marche que si les instructions du processeur sont assez courtes, au plus aussi courtes que le bus mémoire. Ainsi, on est sûr de charger obligatoirement au moins une instruction complète, et peut-être même plusieurs. Le contenu du registre d'instruction est alors découpé en instructions au fil de l'eau. 

Utiliser un registre d'instruction large pose problème avec des instructions à cheval entre deux blocs. Il se peut qu'on n'ait pas une instruction complète lorsque l'on arrive à la fin du bloc, mais seulement un morceau. Le problème se manifeste peu importe que l'instruction soit chargée d'un seul coup ou bien en plusieurs fois.

[[File:Instructions non alignées.png|centre|vignette|upright=2|Instructions non alignées.]]

Dans ce cas, on doit décaler le morceau de bloc pour le mettre au bon endroit (au début du registre d'instruction), et charger le prochain bloc juste à côté. On a donc besoin d'un circuit qui décale tous les bits du registre d'instruction, couplé à un circuit qui décide où placer dans le registre d'instruction ce qui a été chargé, avec quelques circuits autour pour configurer les deux circuits précédents.

[[File:Décaleur d’instruction.png|centre|vignette|upright=2|Décaleur d’instruction.]]

Une autre solution se passe de registre d'instruction en utilisant à la place l'état interne du séquenceur. Là encore, elle charge l'instruction morceau par morceau, typiquement par blocs de 8, 16 ou 32 bits. Les morceaux ne sont pas accumulés dans le registre d'instruction, la solution utilise à la place l'état interne du séquenceur. Les mots mémoire de l'instruction sont chargés à chaque cycle, faisant passer le séquenceur d'un état interne à un autre à chaque mot mémoire. Tant qu'il n'a pas reçu tous les mots mémoire de l'instruction, chaque mot mémoire non terminal le fera passer d'un état interne à un autre, chaque état interne encodant les mots mémoire chargés auparavant. S'il tombe sur le dernier mot mémoire d'une instruction, il rentre dans un état de décodage.

==L'incrémentation du ''program counter''==

À chaque chargement, le ''program counter'' est mis à jour afin de pointer sur la prochaine instruction à charger. Sur la quasi-totalité des processeurs, les instructions sont placées dans l'ordre d’exécution dans la RAM. En faisant ainsi, on peut mettre à jour le ''program counter'' en lui ajoutant la longueur de l'instruction courante. Déterminer la longueur de l'instruction est simple quand les instructions ont toutes la même taille, mais certains processeurs ont des instructions de taille variable, ce qui complique le calcul. Dans ce qui va suivre, nous allons supposer que les instructions sont de taille fixe, ce qui fait que le ''program counter'' est toujours incrémenté de la même valeur.

Il existe deux méthodes principales pour incrémenter le ''program counter'' : soit le ''program counter'' a son propre additionneur, soit le ''program counter'' est mis à jour par l'ALU. Pour ce qui est de l'organisation des registres, soit le ''program counter'' est un registre séparé des autres, soit il est regroupé avec d'autres registres dans un banc de registre. En tout, cela donne quatre organisations possibles.
* Un ''program counter'' séparé relié à un incrémenteur séparé.
* Un ''program counter'' séparé des autres registres, incrémenté par l'ALU.
* Un ''program counter'' intégré au banc de registre, relié à un incrémenteur séparé.
* Un ''program counter'' intégré au banc de registre, incrémenté par l'ALU.

[[File:Calcul du program counter.png|centre|vignette|upright=2|les différentes méthodes de calcul du program counter.]]

Les processeurs haute performance modernes utilisent tous la première méthode. Les autres méthodes étaient surtout utilisées sur les processeurs 8 ou 16 bits, elles sont encore utilisées sur quelques microcontrôleurs de faible puissance. Nous auront l'occasion de donner des exemples quand nous parlerons des processeurs 8 bits anciens, dans le chapitre sur les architectures à accumulateur et affiliées.

===Le ''program counter'' mis à jour par l'ALU===

Sur certains processeurs, le calcul de l'adresse de la prochaine instruction est effectué par l'ALU. L'avantage de cette méthode est qu'elle économise un incrémenteur dédié au ''program counter''. Ce qui explique que cette méthode était utilisée sur les processeurs assez anciens, à une époque où un additionneur pouvait facilement prendre 10 à 20% des transistors disponibles. Le désavantage principal est une augmentation de la complexité du séquenceur, qui doit gérer la mise à jour du ''program counter''. De plus, la mise à jour du ''program counter'' ne peut pas se faire en même temps qu'une opération arithmétique, ce qui réduit les performances.

Si on incrémente le ''program counter'' avec l'ALU, il est intéressant de le placer dans le banc de registres. Un désavantage est qu'on perd un registre. Par exemple, avec un banc de registre de 16 registres, on ne peut adresser que 15 registres généraux. De plus ce n'est pas l'idéal pour le décodage des instructions et pour le séquenceur. Si le processeur dispose de plusieurs bancs de registres, le ''program counter'' est généralement placé dans le banc de registre dédié aux adresses. Sinon, il est placé avec les nombres entiers/adresses.

D'anciens processeurs incrémentaient le ''program counter'' avec l'ALU, mais utilisaient bien un registre séparé pour le ''program counter''. Cette méthode est relativement simple à implémenter : il suffit de connecter/déconnecter le ''program counter'' du bus interne suivant les besoins. Le ''program counter'' est déconnecté pendant l’exécution d'une instruction, il est connecté au bus interne pour l'incrémenter. C'est le séquenceur qui gère le tout. L'avantage de cette séparation est qu'elle est plus facile à gérer pour le séquenceur. De plus, on gagne un registre général/entier dans le banc de registre.

===Le compteur programme===

Dans la quasi-totalité des processeurs modernes, le ''program counter'' est un vulgaire compteur comme on en a vu dans les chapitres sur les circuits, ce qui fait qu'il passe automatiquement d'une adresse à la suivante. Dans ce qui suit, nous allons appeler ce registre compteur : le '''compteur ordinal'''. L'usage d'un compteur simplifie fortement la conception du séquenceur. Le séquenceur n'a pas à gérer la mise à jour du ''program counter'', sauf en cas de branchements. De plus, il est possible d'incrémenter le ''program counter'' pendant que l'unité de calcul effectue une opération arithmétique, ce qui améliore grandement les performances. Le seul désavantage est qu'elle demande d'ajouter un incrémenteur dédié au ''program counter''.

Sur les processeurs très anciens, les instructions faisaient toutes un seul mot mémoire et le compteur ordinal était un circuit incrémenteur des plus basique. Sur les processeurs modernes, le compteur est incrémenté par pas de 4 si les instructions sont codées sur 4 octets, 8 si les instructions sont codées sur 8 octets, etc. Concrètement, le compteur est un circuit incrémenteur auquel on aurait retiré quelques bits de poids faible. Par exemple, si les instructions sont codées sur 4 octets, on coupe les 2 derniers bits du compteur. Si les instructions sont codées sur 8 octets, on coupe les 3 derniers bits du compteur. Et ainsi de suite.

Il a existé quelques processeurs pour lesquelles le ''program counter'' était non pas un compteur binaire classique, mais un ''linear feedback shift register''. L'avantage est que le circuit d'incrémentation utilisait bien moins de portes logiques, l'économie était substantielle. Mais un défaut est que des instructions consécutives dans le programme n'étaient pas consécutives en mémoire. Il existait cependant une table de correspondance pour dire : la première instruction est à telle adresse, la seconde à telle autre, etc. Un exemple de processeur de ce type est le TMS 1000 de Texas Instrument, un des premiers microcontrôleur 4 bits datant des années 70.

Une amélioration de la solution précédente utilise un circuit incrémenteur partagé entre le ''program counter'' et d'autres registres. L'incrémenteur est utilisé pour incrémenter le ''program counter'', mais aussi pour effectuer d'autres calculs d'adresse. Par exemple, sur les architectures avec une pile d'adresse de retour, il est possible de partager l'incrémenteur/décrémenteur avec le pointeur de pile ( la technique ne marche pas avec une pile d'appel). Un autre exemple est celui des processeurs qui gèrent automatiquement le rafraichissement mémoire, grâce à, un compteur intégré dans le processeur. Il est possible de partager l'incrémenteur du ''program counter'' avec le compteur de rafraichissement mémoire, qui mémorise la prochaine adresse mémoire à rafraichir. Nous avions déjà abordé ce genre de partage dans le chapitre sur le chemin de données, dans l'annexe sur le pointeur de pile, mais nous verrons d'autres exemples dans le chapitre sur les architectures hybride accumulateur-registre 8/16 bits.

===Quand est mis à jour le ''program counter'' ?===

Le ''program counter'' est mis à jour quand il faut charger une nouvelle instruction. Reste qu'il faut savoir quand le mettre à jour. Incrémenter le ''program counter'' à intervalle régulier, par exemple à chaque cycle d’horloge, fonctionne sur les processeurs où toutes les instructions mettent le même temps pour s’exécuter. Mais de tels processeurs sont très rares. Sur la quasi-totalité des processeurs, les instructions ont une durée d’exécution variable, elles ne prennent pas le même nombre de cycle d'horloge pour s’exécuter. Le temps d’exécution d'une instruction varie selon l'instruction, certaines sont plus longues que d'autres. Tout cela amène un problème : comment incrémenter le ''program counter'' avec des instructions avec des temps d’exécution variables ?

La réponse est que la mise à jour du ''program counter'' démarre quand l'instruction précédente a terminée de s’exécuter, plus précisément un cycle avant. C'est un cycle avant pour que l'instruction chargée soit disponible au prochain cycle pour le décodeur. Pour cela, le séquenceur doit déterminer quand l'instruction est terminée et prévenir le ''program counter'' au bon moment. Il faut donc une interaction entre séquenceur et circuit de chargement. Le circuit de chargement contient une entrée Enable, qui autorise la mise à jour du ''program counter''. Le séquenceur met à 1 cette entrée pour prévenir au ''program counter'' qu'il doit être incrémenté au cycle suivant ou lors du cycle courant. Cela permet de gérer simplement le cas des instructions multicycles. 

[[File:Commande de la mise à jour du program counter.png|centre|vignette|upright=2|Commande de la mise à jour du program counter.]]

Toute la difficulté est alors reportée dans le séquenceur, qui doit déterminer la durée d'une instruction. Pour gérer la mise à jour du ''program counter'', le séquenceur doit déterminer la durée d'une instruction. Cela est simple pour les instructions arithmétiques et logiques, qui ont un nombre de cycles fixe, toujours le même. Une fois l'instruction identifiée par le séquenceur, il connait son nombre de cycles et peut programmer un compteur interne au séquenceur, qui compte le nombre de cycles de l'instruction, et fournit le signal Enable au ''program counter''. Mais cette technique ne marche pas vraiment pour les accès mémoire, dont la durée n'est pas connue à l'avance, surtout sur les processeurs avec des mémoires caches. Pour cela, le séquenceur détermine quand l'instruction mémoire est finie et prévient le ''program counter'' quand c'est le cas.

Il existe quelques processeurs pour lesquels le temps de calcul dépend des opérandes de l'instruction. On peut par exemple avoir une division qui prend 10 cycles avec certaines opérandes, mais 40 cycles avec d'autres opérandes. Mais ces processeurs sont rares et cela est surtout valable pour les opérations de multiplication/division, guère plus. Le problème est alors le même qu'avec les accès mémoire et la solution est la même : l'ALU prévient le séquenceur quand le résultat est disponible.

==Les branchements et le ''program counter''==

Un branchement consiste juste à écrire l'adresse de destination dans le ''program counter''. L'implémentation des branchements demande d'extraire l'adresse de destination et d'altérer le ''program counter'' quand un branchement est détecté. Pour cela, le décodeur d'instruction détecte si l'instruction exécutée est un branchement ou non, et il en déduit où trouver l'adresse de destination.

L'adresse de destination se trouve à un endroit qui dépend du mode d'adressage du branchement. Pour rappel, on distingue quatre modes d'adressage pour les branchements : direct, indirect, relatif et implicite. Pour les branchements directs, l'adresse est intégrée dans l'instruction de branchement elle-même et est extraite par le séquenceur. Pour les branchements indirects, l'adresse de destination est dans le banc de registre. Pour les branchements relatifs, il faut ajouter un décalage au ''program counter'', décalage extrait de l'instruction par le séquenceur. Enfin, les instructions de retour de fonction lisent l'adresse de destination depuis la pile. L'implémentation de ces quatre types de branchements est très différente.

L'altération du ''program counter'' dépend de si le ''program counter'' est dans un compteur séparé ou s'il est dans le banc de registre. Nous avons vu plus haut qu'il y a quatre cas différents, mais nous n'allons voir que deux cas : celui où le ''program counter'' est dans le banc de registre et est incrémenté par l'unité de calcul, celui avec un ''program counter'' séparé avec son propre incrémenteur. Les deux autres cas ne sont utilisés que sur des architectures à accumulateur ou à pile spécifiques, que nous n'avons pas encore vu à ce stade du cours et que nous verrons en temps voulu dans le chapitre sur ces architectures.

===L’implémentation des branchements avec un ''program counter'' intégré au banc de registres===

Le cas le plus simple est celui où le ''program counter'' est intégré au banc de registre, avec une incrémentation faite par l'unité de calcul. Charger une instruction revient alors à effectuer une instruction LOAD en adressage indirect, à deux différences près : le registre sélectionné est le ''program counter'', l’instruction est copiée dans le registre d'instruction et non dans le banc de registre. L'incrémentation du ''porgram counter'' est implémenté avec des micro-opérations qui agissent sur le chemin de données, au même titre que les branchements indirects, relatifs et directs.
* Les branchements indirects copient un registre dans le ''program counter'', ce qui revient simplement à faire une opération MOV entre deux registres, dont le ''program counter'' est la destination.
* L'opération inverse d'un branchement indirect, qui copie le ''program counter'' dans un registre général, est utile pour sauvegarder l'adresse de retour d'une fonction.
* Les branchements directs copient une adresse dans le ''program counter'', ce qui les rend équivalents à une opération MOV avec une constante immédiate, dont le ''program counter'' est la destination.
* Les branchements relatifs sont une opération arithmétique entre le ''program counter'' et un opérande en adressage immédiat.

En clair, à partir du moment où le chemin de données supporte les instructions MOV et l'addition, avec les modes d'adressage adéquat, il supporte les branchements. Aucune modification du chemin de données n'est nécessaire, le séquenceur gére le chargement d'une instruction avec les micro-instructions adéquates : une micro-opération ADD pour incrémenter le ''program counter'', une micro-opération LOAD pour le chargement de l'instruction.

Notons que sur certaines architectures, le ''program counter'' est adressable au même titre que les autres registres du banc de registre. Les instructions de branchement sont alors remplacées par des instructions MOV ou des instructions arithmétique équivalentes, comme décrit plus haut.

===L’implémentation des branchements avec un ''program counter'' séparé===

Étudions maintenant le cas où le ''program counter'' est dans un registre/compteur séparé. Rappelons que tout compteur digne de ce nom possède une entrée de réinitialisation, qui remet le compteur à zéro. De plus, on peut préciser à quelle valeur il doit être réinitialisé. Ici, la valeur à laquelle on veut réinitialiser le compteur n'est autre que l'adresse de destination du branchement. Implémenter un branchement est donc simple : l'entrée de réinitialisation est commandée par le circuit de détection des branchements, alors que la valeur de réinitialisation est envoyée sur l'entrée adéquate. En clair, nous partons du principe que le ''program counter'' est implémenté avec ce type de compteur :

[[File:Fonctionnement d'un compteur (décompteur), schématique.jpg|centre|vignette|upright=1.5|Fonctionnement d'un compteur (décompteur), schématique]]

Toute la difficulté est de présenter l'adresse de destination au ''program counter''. Pour les branchements directs, l'adresse de destination est fournie par le séquenceur. L'adresse de destination du branchement sort du séquenceur et est présentée au ''program counter'' sur l'entrée adéquate. Voici donc comment sont implémentés les branchements directs avec un ''program counter'' séparé du banc de registres. Le schéma ci-dessous marche peu importe que le ''program counter'' soit incrémenté par l'ALU ou par un additionneur dédié.

[[File:Unité de détection des branchements dans le décodeur.png|centre|vignette|upright=2|Unité de détection des branchements dans le décodeur]]

Les branchements relatifs sont ceux qui font sauter X instructions plus loin dans le programme. Leur implémentation demande d'ajouter une constante au ''program counter'', la constante étant fournie dans l’instruction. Là encore, deux solutions sont possibles : réutiliser l'ALU pour calculer l'adresse, ou utiliser un additionneur séparé. L'additionneur séparé peut être fusionné avec l'additionneur qui incrémente le ''program counter'' pour passer à l’instruction suivante.

[[File:Unité de chargement qui gère les branchements relatifs.png|centre|vignette|upright=2|Unité de chargement qui gère les branchements relatifs.]]

Pour les branchements indirects, il suffit de lire le registre voulu et d'envoyer le tout sur l'entrée adéquate du ''program counter''. Il faut alors rajouter un multiplexeur pour que l'entrée de réinitialisationr ecoive la bonne adresse de destination.

[[File:Unité de chargement qui gère les branchements directs.png|centre|vignette|upright=2|Unité de chargement qui gère les branchements directs et indirects.]]

Toute la difficulté de l'implémentation des branchements est de configurer les multiplexeurs, ce qui est réalisé par le séquenceur en fonction du mode d'adressage du branchement.

==Les optimisations du chargement des instructions==

Charger une instruction est techniquement une forme d'accès mémoire un peu particulier. En clair, charger une instruction prend au minimum un cycle d'horloge, et cela peut rapidement monter à 3-5 cycles, si ce n'est plus. L'exécution des instructions est alors fortement ralentit par la mémoire. Par exemple, imaginez que la mémoire mette 3 cycles d'horloges pour charger une instruction, alors qu'une instruction s’exécute en 1 cycle (si les opérandes sont dans les registres). La perte de performance liée au chargement des instructions est alors substantielle. Heureusement, il est possible de limiter la casse en utilisant des mémoires caches, ainsi que d'autres optimisations, que nous allons voir dans ce qui suit.

===Le tampon de préchargement===

La technique dite du '''préchargement''' est utilisée dans le cas où la mémoire a un temps d'accès important. Mais si la latence de la RAM est un problème, le débit ne l'est pas. Il est possible d'avoir une RAM lente, mais à fort débit. Par exemple, supposons que la mémoire puisse charger 4 instructions (de taille fixe) en 3 cycles. Le processeur peut alors charger 4 instructions en un seul accès mémoire, et les exécuter l'une après l'autre, une par cycle d'horloge. Les temps d'attente sont éliminés : le processeur peut décoder une nouvelle instruction à chaque cycle. Et quand la dernière instruction préchargée est exécutée, la mémoire est de nouveau libre, ce qui masque la latence des accès mémoire.

[[File:Tampon de préchargement d'instruction.png|vignette|Tampon de préchargement d'instruction]]

La seule contrainte est de mettre les instructions préchargées en attente. La solution pour cela est d'utiliser un registre d'instruction très large, capable de mémoriser plusieurs instructions à la fois. Ce registre est de plus connecté à un multiplexeur qui permet de sélectionner l'instruction adéquate dans ce registre. Ce multiplexeur est commandé par le ''program counter'' et quelques circuits annexes. Ce super-registre d'instruction est appelé un '''tampon de préchargement'''.

La méthode a une implémentation nettement plus simple avec des instructions de taille fixe, alignées en mémoire. La commande du multiplexeur de sélection de l'instruction est alors beaucoup plus simple : il suffit d'utiliser les bits de poids fort du ''program counter''. Par exemple, prenons le cas d'un registre d'instruction de 32 octets pour des instructions de 4 octets, soit 8 instructions. Le choix de l'instruction à sélectionner se fait en utilisant les 3 bits de poids faible du ''program counter''. 

Mais cette méthode ajoute de nouvelles contraintes d'alignement, similaires à celles vues dans le chapitre sur l'alignement et le boutisme, sauf que l'alignement porte ici sur des blocs d'instructions de même taille que le tampon de préchargement. Si on prend l'exemple d'un tampon de préchargement de 128 bits, les instructions devront être alignées par blocs de 128 bits. C'est à dire qu'idéalement, les fonctions et autres blocs de code isolés doivent commencer à des adresses multiples de 128, pour pouvoir charger un bloc d'instruction en une seule fois. Sans cela, les performances seront sous-optimales.

: Il arrive que le tampon de préchargement ait la même taille qu'une ligne de cache.

Lorsque l'on passe d'un bloc d'instruction à un autre, le tampon de préchargement est mis à jour. Par exemple, si on prend un tampon de préchargement de 4 instructions, on doit changer son contenu toutes les 4 instructions. La seule exception est l'exécution d'un branchement. En effet, lors d'un branchement, la destination du branchement n'est pas dans le tampon de préchargement et elle doit être chargée dedans (sauf si le branchement pointe vers une instruction très proche, ce qui est improbable). Pour cela, le tampon de préchargement est mis à jour précocement quand le processeur détecte un branchement.

Le même problème survient avec du code auto-modifiant. Un code auto-modifiant est un programme qui se modifie lui-même, en remplaçant certaines instructions par d'autres, en en retirant, en en ajoutant, lors de sa propre exécution. De tels programmes sont rares, mais la technique était utilisée dans quelques cas au tout début de l'informatique sur des ordinateurs rudimentaires. Ceux-ci avaient des modes d'adressages tellement limités que gérer des tableaux de taille variable demandait d'utiliser du code auto-modifiant pour écrire des boucles. Le problème survient quand des instructions sont modifiées immédiatement après avoir été préchargées. Les instructions dans le tampon de préchargement sont l'ancienne version, alors que la mémoire RAM contient les instructions modifiées. Gérer ce genre de cas demande de vider le tampon de préchargement si le cas arrive, mais ça ne vaut que très rarement le coup, aussi les ingénieurs ne s’embêtent pas à mettre ce correctif en place. Le code automodifiant est alors buggé.

===La ''prefetch input queue''===

La ''prefetch input queue'' est une sorte de cousine du tampon de préchargement. L'idée est là encore de précharger des instructions en avance. Sauf que cette fois-ci, on ne part pas du principe que la mémoire a un débit binaire important. L'idée est que pendant que le processeur exécute une instruction, on précharge la suivante. Évidemment, les instructions préchargées sont accumulées dans une mémoire FIFO appelée la '''''prefetch input queue''''', elles en sortent une par une au fur et à mesure pour alimenter le décodeur d'instruction.

La ''prefetch input queue'' a été utilisée sur les processeurs Intel assez ancien. Elle est apparue sur le 8086 et le 8088, des processeurs respectivement 8 et 16 bits. Elle été présente sur le 286 et le 386, mais était un peu améliorée. Elle est apparue sur ces processeurs à une époque où le processeur devenait plus rapide que la mémoire. Sans ''prefetch input queue'', le processeur chargeait une instruction, la décodait et l'exécutait, puis chargeait la suivante, et ainsi de suite. Avec la ''prefetch input queue'', pendant qu'une instruction est en cours de décodage/exécution, le processeur précharge l'instruction suivante. Si une instruction prend vraiment beaucoup de temps pour s'exécuter, le processeur peutr en profiter pour précharger l'instruction encore suivante, et ainsi de suite, jusqu'à une limite de 4/6 instructions (la limite dépend du processeur).

Pour implémenter le préchargement d'instruction, le registre d'instruction est remplacé par une mémoire FIFO appelée la '''''Prefetch input queue'''''. On peut la voir comme un registre d'instruction sous stéroïde, capable de mémoriser plusieurs instructions consécutives. Les instructions sont chargées dans la ''Prefetch input queue'' et y attendent que le processeur les lise et les décode. Les instructions y sont conservées dans leur ordre d'arrivée, afin qu'elles soient exécutées dans le bon ordre, ce qui fait que la ''Prefetch input queue'' est une mémoire de type FIFO. L'étape de décodage pioche l'instruction à décoder dans la ''Prefetch input queue'', cette instruction étant par définition la plus ancienne, puis la retire de la file.

Le premier processeur commercial grand public à utiliser cette méthode était le 8086, un processeur d'Intel de jeu d'instruction x86. Il pouvait précharger à l'avance 6 octets d’instruction. L'Intel 8088 avait lui aussi une ''Prefetch input queue'', mais qui ne permattait que de précharger 4 instructions. La taille idéale de la FIFO dépend de nombreux paramètres. On pourrait croire que plus elle peut contenir d'instructions, mieux c'est, mais ce n'est pas le cas, pour des raisons que nous allons voir dans ce qui suit.

[[File:80186 arch.png|centre|vignette|700px|upright=2|Architecture du 8086, du 80186 et de ses variantes.]]

Les branchements posent des problèmes avec la ''Prefetch input queue'' : à cause d'eux, on peut charger à l'avance des instructions qui sont zappées par un branchement et ne sont pas censées être exécutées. Si un branchement est chargé, toutes les instructions préchargées après sont potentiellement invalides. Si le branchement est non-pris, les instructions chargées sont valides, elles sont censées s’exécuter. Mais si le branchement est pris, elles ont été chargées à tort et ne doivent pas s’exécuter. 

Pour éviter cela, la ''Prefetch input queue'' est vidée quand le processeur détecte un branchement. Cette détection ne peut se faire qu'une fois le branchement décodé : on ne sait pas si l'instruction est un branchement ou autre chose tant que le décodage n'a pas eu lieu, par définition. En clair, le décodeur invalide la ''Prefetch input queue'' quand il détecte un branchement. Les interruptions posent le même genre de problèmes. Il faut impérativement vider la ''Prefetch input queue'' quand une interruption survient, avant de la traiter.

Un autre défaut est que la ''Prefetch input queue'' se marie assez mal avec du code auto-modifiant. Un code auto-modifiant est un programme qui se modifie lui-même, en remplaçant certaines instructions par d'autres, en en retirant, en en ajoutant, lors de sa propre exécution. De tels programmes sont rares, mais la technique était utilisée dans quelques cas au tout début de l'informatique sur des ordinateurs rudimentaires. Ceux-ci avaient des modes d'adressages tellement limités que gérer des tableaux de taille variable demandait d'utiliser du code auto-modifiant pour écrire des boucles.

Le problème avec la ''Prefetch input queue'' survient quand des instructions sont modifiées immédiatement après avoir été préchargées. Les instructions dans la ''Prefetch input queue'' sont l'ancienne version, alors que la mémoire RAM contient les instructions modifiées. Gérer ce genre de cas est quelque peu complexe. Il faut en effet vider la ''Prefetch input queue'' si le cas arrive, ce qui demande d'identifier les écritures qui écrasent des instructions préchargées. C'est parfaitement possible, mais demande de transformer la ''Prefetch input queue'' en une mémoire hybride, à la fois mémoire associative et mémoire FIFO. Cela ne vaut que très rarement le coup, aussi les ingénieurs ne s’embêtent pas à mettre ce correctif en place, le code automodifiant est alors buggé.

===Le ''Zero-overhead looping''===

Nous avions vu dans le chapitre sur les instructions machines, qu'il existe des instructions qui permettent de grandement faciliter l'implémentation des boucles. Il s'agit de l'instruction REPEAT, utilisée sur certains processeurs de traitement de signal. Elle répète l'instruction suivante, voire une série d'instructions, un certain nombre de fois. Le nombre de répétitions est mémorisé dans un registre décrémenté à chaque itération de la boucle. Elle permet donc d'implémenter une boucle FOR facilement, sans recourir à des branchements ou des conditions.

Une technique en lien avec cette instruction permet de grandement améliorer les performances et la consommation d'énergie. L'idée est de mémoriser la boucle, les instructions à répéter, dans une petite mémoire cache située entre l'unité de chargement et le séquenceur. Le cache en question s'appelle un '''tampon de boucle''', ou encore un ''hardware loop buffer''. Grâce à lui, il n'y a pas besoin de charger les instructions à chaque fois qu'on les exécute, on les charge une bonne fois pour toute : c'est plus rapide. Bien sûr, il ne fonctionne que pour de petites boucles, mais il en est de même avec l'instruction REPEAT.

&lt;noinclude&gt;
{{NavChapitre | book=Fonctionnement d'un ordinateur
           | prev=Le chemin de données
           | prevText=Le chemin de données
           | next=L'unité de contrôle
           | nextText=L'unité de contrôle
}}
&lt;/noinclude&gt;</text>
      <sha1>bezoq4ld7y16mmcptxruvcvvi1uzxbn</sha1>
    </revision>
    <revision>
      <id>744060</id>
      <parentid>744059</parentid>
      <timestamp>2025-06-03T18:46:36Z</timestamp>
      <contributor>
        <username>Mewtow</username>
        <id>31375</id>
      </contributor>
      <minor />
      <comment>/* La prefetch input queue */</comment>
      <origin>744060</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="39382" sha1="fi2iwpl6xji8eutkiarejqxzmj3xtcp" xml:space="preserve">L'unité de contrôle s'occupe du chargement des instructions et de leur interprétation, leur décodage. Elle contient deux circuits : l''''unité de chargement''' qui charge l'instruction depuis la mémoire, et le '''séquenceur''' qui commande le chemin de données. Les deux circuits sont séparés, mais ils communiquent entre eux, notamment pour gérer les branchements. Dans ce chapitre, nous allons nous intéresser au chargement d'une instruction depuis la RAM/ROM, nous verrons l'étape de décodage de l'instruction au prochain chapitre.

==Le chargement d'une instruction==

[[File:Étape de chargement.png|vignette|upright=1|Étape de chargement.]]

L'étape de chargement (ou ''fetch'') doit faire deux choses : mettre à jour le ''program counter'' et lire l'instruction en mémoire RAM ou en ROM. Les deux étapes peuvent être faites en parallèle, dans des circuits séparés. Pendant que l'instruction est lue depuis la mémoire RAM/ROM, le ''program counter'' est incrémenté et/ou altéré par un branchement.

Pour lire l'instruction, on envoie le ''program counter'' sur le bus d'adresse et on récupère l'instruction sur le bus de données pour l'envoyer sur l'entrée du séquenceur. Et cela demande de connecter le séquenceur au bus mémoire, à travers l'interface mémoire. Et sur ce point, la situation est différente selon que l'on parler d'une architecture Harvard ou Von Neumann.

===Les interconnexions entre séquenceur et bus mémoire===

Sur les architectures Harvard, le séquenceur et le chemin de donnée utilisent des interfaces mémoire séparées. Le séquenceur est directement relié au bus mémoire de la ROM, alors que le chemin de données est connecté à la RAM.

[[File:Microarchitecture de l'interface mémoire d'une architecture Harvard.png|centre|vignette|upright=2|Microarchitecture de l'interface mémoire d'une architecture Harvard]]

Mais sur les architectures Von-Neumann et affiliées, le séquenceur et le chemin de donnée partagent la même interface mémoire. Et cela pose deux problèmes.

Le premier problème est que le bus mémoire doit être libéré une fois l'instruction chargée, pour un éventuel accès mémoire. Mais le séquenceur doit conserver une copie de l'instruction chargée, sans quoi il ne peut pas décoder l'instruction correctement. Par exemple, si l'instruction met plusieurs cycles à s'exécuter, le séquenceur doit conserver une copie de l'instruction durant ces plusieurs cycles. La solution à ce problème est un '''registre d'instruction''' situé juste avant le séquenceur, qui mémorise l'instruction chargée.

[[File:Registre d'instruction.png|centre|vignette|upright=2|Registre d'instruction.]]

Le second problème est de gérer le flot des instructions/données entre le bus mémoire, le chemin de données et le séquenceur. Le processeur doit connecter l'interface mémoire soit au séquenceur, soit au chemin de données et cela complique le réseau d'interconnexion interne au processeur.

Une première solution utilise un bus unique qui relie l'interface mémoire, le séquenceur et le chemin de données. Pour charger une instruction, le séquenceur copie le ''program counter'' sur le bus d'adresse, attend que l'instruction lue soit disponible sur le bus de données, puis la copie dans le registre d'instruction. Le bus mémoire est alors libre et peut être utilisé pour lire ou écrire des données, si le besoin s'en fait sentir.

Il faut noter que l'usage d'un bus unique a un impact sur l'organisation interne du chemin de données. Par exemple, le chapitre précédent nous a montré comment implémenter un chemin de données basique, avec des multiplexeurs et démultiplexeurs. Et bien ces chemins de données ne marchent pas vraiment avec un bus interne unique. Il est possible de les adapter, mais au prix d'une complexité largement supérieure. Un bus interne unique marche mieux quand le banc de registre est mono-port. C'est pourquoi il a été utilisé sur d'anciennes architectures appelées des architectures à accumulateur et à pile, que nous verrons dans quelques chapitres, qui utilisaient un banc de registre mono-port.

[[File:Microarchitecture de l'interface mémoire d'une architecture von neumann.png|centre|vignette|upright=2|Microarchitecture de l'interface mémoire d'une architecture von neumann]]

Une autre solution utilise deux bus interne séparés : un connecté au bus d'adresse, l'autre au bus de données. Le ''program counter'' est alors connecté au bus interne d'adresse, le séquenceur est relié au bus interne de données. Notons que la technique marche bien si le ''program counter'' est dans le banc de registre : les interconnexions utilisées pour gérer l'adressage indirect permettent d'envoyer le ''program counter'' sur le bus d'adresse sans ajout de circuit.

Le tout peut être amélioré en remplaçant les deux bus par des multiplexeurs et démultiplexeurs. Le bus d'adresse est précédé par un multiplexeur, qui permet de faire le choix entre ''Program Counter'', adresse venant du chemin de données, ou adresse provenant du séquenceur (adressage absolu). De même, le bus de données est suivi par un démultiplexeur qui envoie la donnée/instruction lue soit au registre d'instruction, soit au chemin de données. Le tout se marie très bien avec les chemins de donnée vu dans le chapitre précédent. Au passage, il faut noter que cette solution nécessite un banc de registre multi-port.

[[File:Connexion du program counter sur les bus avec PC isolé.png|centre|vignette|upright=2|Connexion du program counter sur les bus avec PC isolé]]

===Le chargement des instructions de longueur variable===

Le chargement des instructions de longueur variable pose de nombreux problèmes. Le premier est que mettre à jour le ''program counter'' demande de connaitre la longueur de l'instruction chargée, pour l'ajouter au ''program counter''. Si la longueur d'une instruction est variable, on doit connaitre cette longueur d'une manière où d'une autre. La solution la plus simple indique la longueur de l'instruction dans une partie de l'opcode ou de la représentation en binaire de l'instruction. Mais les processeurs haute performance de nos PC utilisent d'autres solutions, qui n'encodent pas explicitement la taille de l'instruction.

Les processeurs récents utilisent un registre d'instruction de grande taille, capable de mémoriser l'instruction la plus longue du processeur. Par exemple, si un processeur supporte des instructions allant de 1 à 8 octets, comme les CPU x86, le registre d'instruction fera 8 octets. Le décodeur d'instruction vérifie à chaque cycle le contenu du registre d'instruction. Si une instruction est détectée dedans, son décodage commence, peu importe la taille de l'instruction. Une fois l'instruction exécutée, elle est retirée du registre d'instruction. Reste à alimenter le registre d'instruction, à charger des instructions dedans. Et pour cela deux solutions : soit on charge l'instruction en plusieurs fois, soit d'un seul coup.

La solution la plus simple charge les instructions par mots de 8, 16, 32, 64 bits. Ils sont accumulés dans le registre d'instruction jusqu'à détecter une instruction complète. La technique marche nettement mieux si les instructions sont très longues. Par exemple, les CPU x86 ont des instructions qui vont de 1 à 15 octets, ce qui fait qu'ils utilisent cette technique. Précisément, elle marche si les instructions les plus longues sont plus grandes que le bus mémoire.

Une autre solution charge un bloc de mots mémoire aussi grand que la plus grande instruction. Par exemple, si le processeur gère des instructions allant de 1 à 4 octets, il charge 4 octets d'un seul coup dans le registre d'instruction. Il va de soit que cette solution ne marche que si les instructions du processeur sont assez courtes, au plus aussi courtes que le bus mémoire. Ainsi, on est sûr de charger obligatoirement au moins une instruction complète, et peut-être même plusieurs. Le contenu du registre d'instruction est alors découpé en instructions au fil de l'eau. 

Utiliser un registre d'instruction large pose problème avec des instructions à cheval entre deux blocs. Il se peut qu'on n'ait pas une instruction complète lorsque l'on arrive à la fin du bloc, mais seulement un morceau. Le problème se manifeste peu importe que l'instruction soit chargée d'un seul coup ou bien en plusieurs fois.

[[File:Instructions non alignées.png|centre|vignette|upright=2|Instructions non alignées.]]

Dans ce cas, on doit décaler le morceau de bloc pour le mettre au bon endroit (au début du registre d'instruction), et charger le prochain bloc juste à côté. On a donc besoin d'un circuit qui décale tous les bits du registre d'instruction, couplé à un circuit qui décide où placer dans le registre d'instruction ce qui a été chargé, avec quelques circuits autour pour configurer les deux circuits précédents.

[[File:Décaleur d’instruction.png|centre|vignette|upright=2|Décaleur d’instruction.]]

Une autre solution se passe de registre d'instruction en utilisant à la place l'état interne du séquenceur. Là encore, elle charge l'instruction morceau par morceau, typiquement par blocs de 8, 16 ou 32 bits. Les morceaux ne sont pas accumulés dans le registre d'instruction, la solution utilise à la place l'état interne du séquenceur. Les mots mémoire de l'instruction sont chargés à chaque cycle, faisant passer le séquenceur d'un état interne à un autre à chaque mot mémoire. Tant qu'il n'a pas reçu tous les mots mémoire de l'instruction, chaque mot mémoire non terminal le fera passer d'un état interne à un autre, chaque état interne encodant les mots mémoire chargés auparavant. S'il tombe sur le dernier mot mémoire d'une instruction, il rentre dans un état de décodage.

==L'incrémentation du ''program counter''==

À chaque chargement, le ''program counter'' est mis à jour afin de pointer sur la prochaine instruction à charger. Sur la quasi-totalité des processeurs, les instructions sont placées dans l'ordre d’exécution dans la RAM. En faisant ainsi, on peut mettre à jour le ''program counter'' en lui ajoutant la longueur de l'instruction courante. Déterminer la longueur de l'instruction est simple quand les instructions ont toutes la même taille, mais certains processeurs ont des instructions de taille variable, ce qui complique le calcul. Dans ce qui va suivre, nous allons supposer que les instructions sont de taille fixe, ce qui fait que le ''program counter'' est toujours incrémenté de la même valeur.

Il existe deux méthodes principales pour incrémenter le ''program counter'' : soit le ''program counter'' a son propre additionneur, soit le ''program counter'' est mis à jour par l'ALU. Pour ce qui est de l'organisation des registres, soit le ''program counter'' est un registre séparé des autres, soit il est regroupé avec d'autres registres dans un banc de registre. En tout, cela donne quatre organisations possibles.
* Un ''program counter'' séparé relié à un incrémenteur séparé.
* Un ''program counter'' séparé des autres registres, incrémenté par l'ALU.
* Un ''program counter'' intégré au banc de registre, relié à un incrémenteur séparé.
* Un ''program counter'' intégré au banc de registre, incrémenté par l'ALU.

[[File:Calcul du program counter.png|centre|vignette|upright=2|les différentes méthodes de calcul du program counter.]]

Les processeurs haute performance modernes utilisent tous la première méthode. Les autres méthodes étaient surtout utilisées sur les processeurs 8 ou 16 bits, elles sont encore utilisées sur quelques microcontrôleurs de faible puissance. Nous auront l'occasion de donner des exemples quand nous parlerons des processeurs 8 bits anciens, dans le chapitre sur les architectures à accumulateur et affiliées.

===Le ''program counter'' mis à jour par l'ALU===

Sur certains processeurs, le calcul de l'adresse de la prochaine instruction est effectué par l'ALU. L'avantage de cette méthode est qu'elle économise un incrémenteur dédié au ''program counter''. Ce qui explique que cette méthode était utilisée sur les processeurs assez anciens, à une époque où un additionneur pouvait facilement prendre 10 à 20% des transistors disponibles. Le désavantage principal est une augmentation de la complexité du séquenceur, qui doit gérer la mise à jour du ''program counter''. De plus, la mise à jour du ''program counter'' ne peut pas se faire en même temps qu'une opération arithmétique, ce qui réduit les performances.

Si on incrémente le ''program counter'' avec l'ALU, il est intéressant de le placer dans le banc de registres. Un désavantage est qu'on perd un registre. Par exemple, avec un banc de registre de 16 registres, on ne peut adresser que 15 registres généraux. De plus ce n'est pas l'idéal pour le décodage des instructions et pour le séquenceur. Si le processeur dispose de plusieurs bancs de registres, le ''program counter'' est généralement placé dans le banc de registre dédié aux adresses. Sinon, il est placé avec les nombres entiers/adresses.

D'anciens processeurs incrémentaient le ''program counter'' avec l'ALU, mais utilisaient bien un registre séparé pour le ''program counter''. Cette méthode est relativement simple à implémenter : il suffit de connecter/déconnecter le ''program counter'' du bus interne suivant les besoins. Le ''program counter'' est déconnecté pendant l’exécution d'une instruction, il est connecté au bus interne pour l'incrémenter. C'est le séquenceur qui gère le tout. L'avantage de cette séparation est qu'elle est plus facile à gérer pour le séquenceur. De plus, on gagne un registre général/entier dans le banc de registre.

===Le compteur programme===

Dans la quasi-totalité des processeurs modernes, le ''program counter'' est un vulgaire compteur comme on en a vu dans les chapitres sur les circuits, ce qui fait qu'il passe automatiquement d'une adresse à la suivante. Dans ce qui suit, nous allons appeler ce registre compteur : le '''compteur ordinal'''. L'usage d'un compteur simplifie fortement la conception du séquenceur. Le séquenceur n'a pas à gérer la mise à jour du ''program counter'', sauf en cas de branchements. De plus, il est possible d'incrémenter le ''program counter'' pendant que l'unité de calcul effectue une opération arithmétique, ce qui améliore grandement les performances. Le seul désavantage est qu'elle demande d'ajouter un incrémenteur dédié au ''program counter''.

Sur les processeurs très anciens, les instructions faisaient toutes un seul mot mémoire et le compteur ordinal était un circuit incrémenteur des plus basique. Sur les processeurs modernes, le compteur est incrémenté par pas de 4 si les instructions sont codées sur 4 octets, 8 si les instructions sont codées sur 8 octets, etc. Concrètement, le compteur est un circuit incrémenteur auquel on aurait retiré quelques bits de poids faible. Par exemple, si les instructions sont codées sur 4 octets, on coupe les 2 derniers bits du compteur. Si les instructions sont codées sur 8 octets, on coupe les 3 derniers bits du compteur. Et ainsi de suite.

Il a existé quelques processeurs pour lesquelles le ''program counter'' était non pas un compteur binaire classique, mais un ''linear feedback shift register''. L'avantage est que le circuit d'incrémentation utilisait bien moins de portes logiques, l'économie était substantielle. Mais un défaut est que des instructions consécutives dans le programme n'étaient pas consécutives en mémoire. Il existait cependant une table de correspondance pour dire : la première instruction est à telle adresse, la seconde à telle autre, etc. Un exemple de processeur de ce type est le TMS 1000 de Texas Instrument, un des premiers microcontrôleur 4 bits datant des années 70.

Une amélioration de la solution précédente utilise un circuit incrémenteur partagé entre le ''program counter'' et d'autres registres. L'incrémenteur est utilisé pour incrémenter le ''program counter'', mais aussi pour effectuer d'autres calculs d'adresse. Par exemple, sur les architectures avec une pile d'adresse de retour, il est possible de partager l'incrémenteur/décrémenteur avec le pointeur de pile ( la technique ne marche pas avec une pile d'appel). Un autre exemple est celui des processeurs qui gèrent automatiquement le rafraichissement mémoire, grâce à, un compteur intégré dans le processeur. Il est possible de partager l'incrémenteur du ''program counter'' avec le compteur de rafraichissement mémoire, qui mémorise la prochaine adresse mémoire à rafraichir. Nous avions déjà abordé ce genre de partage dans le chapitre sur le chemin de données, dans l'annexe sur le pointeur de pile, mais nous verrons d'autres exemples dans le chapitre sur les architectures hybride accumulateur-registre 8/16 bits.

===Quand est mis à jour le ''program counter'' ?===

Le ''program counter'' est mis à jour quand il faut charger une nouvelle instruction. Reste qu'il faut savoir quand le mettre à jour. Incrémenter le ''program counter'' à intervalle régulier, par exemple à chaque cycle d’horloge, fonctionne sur les processeurs où toutes les instructions mettent le même temps pour s’exécuter. Mais de tels processeurs sont très rares. Sur la quasi-totalité des processeurs, les instructions ont une durée d’exécution variable, elles ne prennent pas le même nombre de cycle d'horloge pour s’exécuter. Le temps d’exécution d'une instruction varie selon l'instruction, certaines sont plus longues que d'autres. Tout cela amène un problème : comment incrémenter le ''program counter'' avec des instructions avec des temps d’exécution variables ?

La réponse est que la mise à jour du ''program counter'' démarre quand l'instruction précédente a terminée de s’exécuter, plus précisément un cycle avant. C'est un cycle avant pour que l'instruction chargée soit disponible au prochain cycle pour le décodeur. Pour cela, le séquenceur doit déterminer quand l'instruction est terminée et prévenir le ''program counter'' au bon moment. Il faut donc une interaction entre séquenceur et circuit de chargement. Le circuit de chargement contient une entrée Enable, qui autorise la mise à jour du ''program counter''. Le séquenceur met à 1 cette entrée pour prévenir au ''program counter'' qu'il doit être incrémenté au cycle suivant ou lors du cycle courant. Cela permet de gérer simplement le cas des instructions multicycles. 

[[File:Commande de la mise à jour du program counter.png|centre|vignette|upright=2|Commande de la mise à jour du program counter.]]

Toute la difficulté est alors reportée dans le séquenceur, qui doit déterminer la durée d'une instruction. Pour gérer la mise à jour du ''program counter'', le séquenceur doit déterminer la durée d'une instruction. Cela est simple pour les instructions arithmétiques et logiques, qui ont un nombre de cycles fixe, toujours le même. Une fois l'instruction identifiée par le séquenceur, il connait son nombre de cycles et peut programmer un compteur interne au séquenceur, qui compte le nombre de cycles de l'instruction, et fournit le signal Enable au ''program counter''. Mais cette technique ne marche pas vraiment pour les accès mémoire, dont la durée n'est pas connue à l'avance, surtout sur les processeurs avec des mémoires caches. Pour cela, le séquenceur détermine quand l'instruction mémoire est finie et prévient le ''program counter'' quand c'est le cas.

Il existe quelques processeurs pour lesquels le temps de calcul dépend des opérandes de l'instruction. On peut par exemple avoir une division qui prend 10 cycles avec certaines opérandes, mais 40 cycles avec d'autres opérandes. Mais ces processeurs sont rares et cela est surtout valable pour les opérations de multiplication/division, guère plus. Le problème est alors le même qu'avec les accès mémoire et la solution est la même : l'ALU prévient le séquenceur quand le résultat est disponible.

==Les branchements et le ''program counter''==

Un branchement consiste juste à écrire l'adresse de destination dans le ''program counter''. L'implémentation des branchements demande d'extraire l'adresse de destination et d'altérer le ''program counter'' quand un branchement est détecté. Pour cela, le décodeur d'instruction détecte si l'instruction exécutée est un branchement ou non, et il en déduit où trouver l'adresse de destination.

L'adresse de destination se trouve à un endroit qui dépend du mode d'adressage du branchement. Pour rappel, on distingue quatre modes d'adressage pour les branchements : direct, indirect, relatif et implicite. Pour les branchements directs, l'adresse est intégrée dans l'instruction de branchement elle-même et est extraite par le séquenceur. Pour les branchements indirects, l'adresse de destination est dans le banc de registre. Pour les branchements relatifs, il faut ajouter un décalage au ''program counter'', décalage extrait de l'instruction par le séquenceur. Enfin, les instructions de retour de fonction lisent l'adresse de destination depuis la pile. L'implémentation de ces quatre types de branchements est très différente.

L'altération du ''program counter'' dépend de si le ''program counter'' est dans un compteur séparé ou s'il est dans le banc de registre. Nous avons vu plus haut qu'il y a quatre cas différents, mais nous n'allons voir que deux cas : celui où le ''program counter'' est dans le banc de registre et est incrémenté par l'unité de calcul, celui avec un ''program counter'' séparé avec son propre incrémenteur. Les deux autres cas ne sont utilisés que sur des architectures à accumulateur ou à pile spécifiques, que nous n'avons pas encore vu à ce stade du cours et que nous verrons en temps voulu dans le chapitre sur ces architectures.

===L’implémentation des branchements avec un ''program counter'' intégré au banc de registres===

Le cas le plus simple est celui où le ''program counter'' est intégré au banc de registre, avec une incrémentation faite par l'unité de calcul. Charger une instruction revient alors à effectuer une instruction LOAD en adressage indirect, à deux différences près : le registre sélectionné est le ''program counter'', l’instruction est copiée dans le registre d'instruction et non dans le banc de registre. L'incrémentation du ''porgram counter'' est implémenté avec des micro-opérations qui agissent sur le chemin de données, au même titre que les branchements indirects, relatifs et directs.
* Les branchements indirects copient un registre dans le ''program counter'', ce qui revient simplement à faire une opération MOV entre deux registres, dont le ''program counter'' est la destination.
* L'opération inverse d'un branchement indirect, qui copie le ''program counter'' dans un registre général, est utile pour sauvegarder l'adresse de retour d'une fonction.
* Les branchements directs copient une adresse dans le ''program counter'', ce qui les rend équivalents à une opération MOV avec une constante immédiate, dont le ''program counter'' est la destination.
* Les branchements relatifs sont une opération arithmétique entre le ''program counter'' et un opérande en adressage immédiat.

En clair, à partir du moment où le chemin de données supporte les instructions MOV et l'addition, avec les modes d'adressage adéquat, il supporte les branchements. Aucune modification du chemin de données n'est nécessaire, le séquenceur gére le chargement d'une instruction avec les micro-instructions adéquates : une micro-opération ADD pour incrémenter le ''program counter'', une micro-opération LOAD pour le chargement de l'instruction.

Notons que sur certaines architectures, le ''program counter'' est adressable au même titre que les autres registres du banc de registre. Les instructions de branchement sont alors remplacées par des instructions MOV ou des instructions arithmétique équivalentes, comme décrit plus haut.

===L’implémentation des branchements avec un ''program counter'' séparé===

Étudions maintenant le cas où le ''program counter'' est dans un registre/compteur séparé. Rappelons que tout compteur digne de ce nom possède une entrée de réinitialisation, qui remet le compteur à zéro. De plus, on peut préciser à quelle valeur il doit être réinitialisé. Ici, la valeur à laquelle on veut réinitialiser le compteur n'est autre que l'adresse de destination du branchement. Implémenter un branchement est donc simple : l'entrée de réinitialisation est commandée par le circuit de détection des branchements, alors que la valeur de réinitialisation est envoyée sur l'entrée adéquate. En clair, nous partons du principe que le ''program counter'' est implémenté avec ce type de compteur :

[[File:Fonctionnement d'un compteur (décompteur), schématique.jpg|centre|vignette|upright=1.5|Fonctionnement d'un compteur (décompteur), schématique]]

Toute la difficulté est de présenter l'adresse de destination au ''program counter''. Pour les branchements directs, l'adresse de destination est fournie par le séquenceur. L'adresse de destination du branchement sort du séquenceur et est présentée au ''program counter'' sur l'entrée adéquate. Voici donc comment sont implémentés les branchements directs avec un ''program counter'' séparé du banc de registres. Le schéma ci-dessous marche peu importe que le ''program counter'' soit incrémenté par l'ALU ou par un additionneur dédié.

[[File:Unité de détection des branchements dans le décodeur.png|centre|vignette|upright=2|Unité de détection des branchements dans le décodeur]]

Les branchements relatifs sont ceux qui font sauter X instructions plus loin dans le programme. Leur implémentation demande d'ajouter une constante au ''program counter'', la constante étant fournie dans l’instruction. Là encore, deux solutions sont possibles : réutiliser l'ALU pour calculer l'adresse, ou utiliser un additionneur séparé. L'additionneur séparé peut être fusionné avec l'additionneur qui incrémente le ''program counter'' pour passer à l’instruction suivante.

[[File:Unité de chargement qui gère les branchements relatifs.png|centre|vignette|upright=2|Unité de chargement qui gère les branchements relatifs.]]

Pour les branchements indirects, il suffit de lire le registre voulu et d'envoyer le tout sur l'entrée adéquate du ''program counter''. Il faut alors rajouter un multiplexeur pour que l'entrée de réinitialisationr ecoive la bonne adresse de destination.

[[File:Unité de chargement qui gère les branchements directs.png|centre|vignette|upright=2|Unité de chargement qui gère les branchements directs et indirects.]]

Toute la difficulté de l'implémentation des branchements est de configurer les multiplexeurs, ce qui est réalisé par le séquenceur en fonction du mode d'adressage du branchement.

==Les optimisations du chargement des instructions==

Charger une instruction est techniquement une forme d'accès mémoire un peu particulier. En clair, charger une instruction prend au minimum un cycle d'horloge, et cela peut rapidement monter à 3-5 cycles, si ce n'est plus. L'exécution des instructions est alors fortement ralentit par la mémoire. Par exemple, imaginez que la mémoire mette 3 cycles d'horloges pour charger une instruction, alors qu'une instruction s’exécute en 1 cycle (si les opérandes sont dans les registres). La perte de performance liée au chargement des instructions est alors substantielle. Heureusement, il est possible de limiter la casse en utilisant des mémoires caches, ainsi que d'autres optimisations, que nous allons voir dans ce qui suit.

===Le tampon de préchargement===

La technique dite du '''préchargement''' est utilisée dans le cas où la mémoire a un temps d'accès important. Mais si la latence de la RAM est un problème, le débit ne l'est pas. Il est possible d'avoir une RAM lente, mais à fort débit. Par exemple, supposons que la mémoire puisse charger 4 instructions (de taille fixe) en 3 cycles. Le processeur peut alors charger 4 instructions en un seul accès mémoire, et les exécuter l'une après l'autre, une par cycle d'horloge. Les temps d'attente sont éliminés : le processeur peut décoder une nouvelle instruction à chaque cycle. Et quand la dernière instruction préchargée est exécutée, la mémoire est de nouveau libre, ce qui masque la latence des accès mémoire.

[[File:Tampon de préchargement d'instruction.png|vignette|Tampon de préchargement d'instruction]]

La seule contrainte est de mettre les instructions préchargées en attente. La solution pour cela est d'utiliser un registre d'instruction très large, capable de mémoriser plusieurs instructions à la fois. Ce registre est de plus connecté à un multiplexeur qui permet de sélectionner l'instruction adéquate dans ce registre. Ce multiplexeur est commandé par le ''program counter'' et quelques circuits annexes. Ce super-registre d'instruction est appelé un '''tampon de préchargement'''.

La méthode a une implémentation nettement plus simple avec des instructions de taille fixe, alignées en mémoire. La commande du multiplexeur de sélection de l'instruction est alors beaucoup plus simple : il suffit d'utiliser les bits de poids fort du ''program counter''. Par exemple, prenons le cas d'un registre d'instruction de 32 octets pour des instructions de 4 octets, soit 8 instructions. Le choix de l'instruction à sélectionner se fait en utilisant les 3 bits de poids faible du ''program counter''. 

Mais cette méthode ajoute de nouvelles contraintes d'alignement, similaires à celles vues dans le chapitre sur l'alignement et le boutisme, sauf que l'alignement porte ici sur des blocs d'instructions de même taille que le tampon de préchargement. Si on prend l'exemple d'un tampon de préchargement de 128 bits, les instructions devront être alignées par blocs de 128 bits. C'est à dire qu'idéalement, les fonctions et autres blocs de code isolés doivent commencer à des adresses multiples de 128, pour pouvoir charger un bloc d'instruction en une seule fois. Sans cela, les performances seront sous-optimales.

: Il arrive que le tampon de préchargement ait la même taille qu'une ligne de cache.

Lorsque l'on passe d'un bloc d'instruction à un autre, le tampon de préchargement est mis à jour. Par exemple, si on prend un tampon de préchargement de 4 instructions, on doit changer son contenu toutes les 4 instructions. La seule exception est l'exécution d'un branchement. En effet, lors d'un branchement, la destination du branchement n'est pas dans le tampon de préchargement et elle doit être chargée dedans (sauf si le branchement pointe vers une instruction très proche, ce qui est improbable). Pour cela, le tampon de préchargement est mis à jour précocement quand le processeur détecte un branchement.

Le même problème survient avec du code auto-modifiant. Un code auto-modifiant est un programme qui se modifie lui-même, en remplaçant certaines instructions par d'autres, en en retirant, en en ajoutant, lors de sa propre exécution. De tels programmes sont rares, mais la technique était utilisée dans quelques cas au tout début de l'informatique sur des ordinateurs rudimentaires. Ceux-ci avaient des modes d'adressages tellement limités que gérer des tableaux de taille variable demandait d'utiliser du code auto-modifiant pour écrire des boucles. Le problème survient quand des instructions sont modifiées immédiatement après avoir été préchargées. Les instructions dans le tampon de préchargement sont l'ancienne version, alors que la mémoire RAM contient les instructions modifiées. Gérer ce genre de cas demande de vider le tampon de préchargement si le cas arrive, mais ça ne vaut que très rarement le coup, aussi les ingénieurs ne s’embêtent pas à mettre ce correctif en place. Le code automodifiant est alors buggé.

===La ''prefetch input queue''===

La ''prefetch input queue'' est une optimisation matérielle qui a été utilisée sur les processeurs Intel assez ancien. Elle est apparue sur le 8086 et le 8088, des processeurs respectivement 8 et 16 bits. Elle été présente sur le 286 et le 386, mais était un peu améliorée. Elle est apparue sur ces processeurs à une époque où le processeur devenait plus rapide que la mémoire.

La ''prefetch input queue'' est une sorte de cousine du tampon de préchargement. L'idée est là encore de précharger des instructions en avance. Sauf que cette fois-ci, on ne part pas du principe que la mémoire a un débit binaire important, on ne charge pas plusieurs instructions à la fois. Les instructions sont préchargées séquentiellement, un octet à la fois. Évidemment, les instructions préchargées sont accumulées dans une mémoire FIFO appelée la '''''prefetch input queue''''', elles en sortent une par une au fur et à mesure pour alimenter le décodeur d'instruction.

L'idée est que pendant que le processeur exécute une instruction, on précharge la suivante. Sans ''prefetch input queue'', le processeur chargeait une instruction, la décodait et l'exécutait, puis chargeait la suivante, et ainsi de suite. Avec la ''prefetch input queue'', pendant qu'une instruction est en cours de décodage/exécution, le processeur précharge l'instruction suivante. Si une instruction prend vraiment beaucoup de temps pour s'exécuter, le processeur peutr en profiter pour précharger l'instruction encore suivante, et ainsi de suite, jusqu'à une limite de 4/6 instructions (la limite dépend du processeur).

Pour implémenter le préchargement d'instruction, le registre d'instruction est remplacé par une mémoire FIFO appelée la '''''Prefetch input queue'''''. On peut la voir comme un registre d'instruction sous stéroïde, capable de mémoriser plusieurs instructions consécutives. Les instructions sont chargées dans la ''Prefetch input queue'' et y attendent que le processeur les lise et les décode. Les instructions y sont conservées dans leur ordre d'arrivée, afin qu'elles soient exécutées dans le bon ordre, ce qui fait que la ''Prefetch input queue'' est une mémoire de type FIFO. L'étape de décodage pioche l'instruction à décoder dans la ''Prefetch input queue'', cette instruction étant par définition la plus ancienne, puis la retire de la file.

Le premier processeur commercial grand public à utiliser cette méthode était le 8086, un processeur d'Intel de jeu d'instruction x86. Il pouvait précharger à l'avance 6 octets d’instruction. L'Intel 8088 avait lui aussi une ''Prefetch input queue'', mais qui ne permattait que de précharger 4 instructions. La taille idéale de la FIFO dépend de nombreux paramètres. On pourrait croire que plus elle peut contenir d'instructions, mieux c'est, mais ce n'est pas le cas, pour des raisons que nous allons voir dans ce qui suit.

[[File:80186 arch.png|centre|vignette|700px|upright=2|Architecture du 8086, du 80186 et de ses variantes.]]

Les branchements posent des problèmes avec la ''Prefetch input queue'' : à cause d'eux, on peut charger à l'avance des instructions qui sont zappées par un branchement et ne sont pas censées être exécutées. Si un branchement est chargé, toutes les instructions préchargées après sont potentiellement invalides. Si le branchement est non-pris, les instructions chargées sont valides, elles sont censées s’exécuter. Mais si le branchement est pris, elles ont été chargées à tort et ne doivent pas s’exécuter. 

Pour éviter cela, la ''Prefetch input queue'' est vidée quand le processeur détecte un branchement. Cette détection ne peut se faire qu'une fois le branchement décodé : on ne sait pas si l'instruction est un branchement ou autre chose tant que le décodage n'a pas eu lieu, par définition. En clair, le décodeur invalide la ''Prefetch input queue'' quand il détecte un branchement. Les interruptions posent le même genre de problèmes. Il faut impérativement vider la ''Prefetch input queue'' quand une interruption survient, avant de la traiter.

Un autre défaut est que la ''Prefetch input queue'' se marie assez mal avec du code auto-modifiant. Un code auto-modifiant est un programme qui se modifie lui-même, en remplaçant certaines instructions par d'autres, en en retirant, en en ajoutant, lors de sa propre exécution. De tels programmes sont rares, mais la technique était utilisée dans quelques cas au tout début de l'informatique sur des ordinateurs rudimentaires. Ceux-ci avaient des modes d'adressages tellement limités que gérer des tableaux de taille variable demandait d'utiliser du code auto-modifiant pour écrire des boucles.

Le problème avec la ''Prefetch input queue'' survient quand des instructions sont modifiées immédiatement après avoir été préchargées. Les instructions dans la ''Prefetch input queue'' sont l'ancienne version, alors que la mémoire RAM contient les instructions modifiées. Gérer ce genre de cas est quelque peu complexe. Il faut en effet vider la ''Prefetch input queue'' si le cas arrive, ce qui demande d'identifier les écritures qui écrasent des instructions préchargées. C'est parfaitement possible, mais demande de transformer la ''Prefetch input queue'' en une mémoire hybride, à la fois mémoire associative et mémoire FIFO. Cela ne vaut que très rarement le coup, aussi les ingénieurs ne s’embêtent pas à mettre ce correctif en place, le code automodifiant est alors buggé.

===Le ''Zero-overhead looping''===

Nous avions vu dans le chapitre sur les instructions machines, qu'il existe des instructions qui permettent de grandement faciliter l'implémentation des boucles. Il s'agit de l'instruction REPEAT, utilisée sur certains processeurs de traitement de signal. Elle répète l'instruction suivante, voire une série d'instructions, un certain nombre de fois. Le nombre de répétitions est mémorisé dans un registre décrémenté à chaque itération de la boucle. Elle permet donc d'implémenter une boucle FOR facilement, sans recourir à des branchements ou des conditions.

Une technique en lien avec cette instruction permet de grandement améliorer les performances et la consommation d'énergie. L'idée est de mémoriser la boucle, les instructions à répéter, dans une petite mémoire cache située entre l'unité de chargement et le séquenceur. Le cache en question s'appelle un '''tampon de boucle''', ou encore un ''hardware loop buffer''. Grâce à lui, il n'y a pas besoin de charger les instructions à chaque fois qu'on les exécute, on les charge une bonne fois pour toute : c'est plus rapide. Bien sûr, il ne fonctionne que pour de petites boucles, mais il en est de même avec l'instruction REPEAT.

&lt;noinclude&gt;
{{NavChapitre | book=Fonctionnement d'un ordinateur
           | prev=Le chemin de données
           | prevText=Le chemin de données
           | next=L'unité de contrôle
           | nextText=L'unité de contrôle
}}
&lt;/noinclude&gt;</text>
      <sha1>fi2iwpl6xji8eutkiarejqxzmj3xtcp</sha1>
    </revision>
    <revision>
      <id>744061</id>
      <parentid>744060</parentid>
      <timestamp>2025-06-03T18:48:36Z</timestamp>
      <contributor>
        <username>Mewtow</username>
        <id>31375</id>
      </contributor>
      <minor />
      <comment>/* La prefetch input queue */</comment>
      <origin>744061</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="39386" sha1="2cultaozuhamxcjzpyiuj1v1j124j13" xml:space="preserve">L'unité de contrôle s'occupe du chargement des instructions et de leur interprétation, leur décodage. Elle contient deux circuits : l''''unité de chargement''' qui charge l'instruction depuis la mémoire, et le '''séquenceur''' qui commande le chemin de données. Les deux circuits sont séparés, mais ils communiquent entre eux, notamment pour gérer les branchements. Dans ce chapitre, nous allons nous intéresser au chargement d'une instruction depuis la RAM/ROM, nous verrons l'étape de décodage de l'instruction au prochain chapitre.

==Le chargement d'une instruction==

[[File:Étape de chargement.png|vignette|upright=1|Étape de chargement.]]

L'étape de chargement (ou ''fetch'') doit faire deux choses : mettre à jour le ''program counter'' et lire l'instruction en mémoire RAM ou en ROM. Les deux étapes peuvent être faites en parallèle, dans des circuits séparés. Pendant que l'instruction est lue depuis la mémoire RAM/ROM, le ''program counter'' est incrémenté et/ou altéré par un branchement.

Pour lire l'instruction, on envoie le ''program counter'' sur le bus d'adresse et on récupère l'instruction sur le bus de données pour l'envoyer sur l'entrée du séquenceur. Et cela demande de connecter le séquenceur au bus mémoire, à travers l'interface mémoire. Et sur ce point, la situation est différente selon que l'on parler d'une architecture Harvard ou Von Neumann.

===Les interconnexions entre séquenceur et bus mémoire===

Sur les architectures Harvard, le séquenceur et le chemin de donnée utilisent des interfaces mémoire séparées. Le séquenceur est directement relié au bus mémoire de la ROM, alors que le chemin de données est connecté à la RAM.

[[File:Microarchitecture de l'interface mémoire d'une architecture Harvard.png|centre|vignette|upright=2|Microarchitecture de l'interface mémoire d'une architecture Harvard]]

Mais sur les architectures Von-Neumann et affiliées, le séquenceur et le chemin de donnée partagent la même interface mémoire. Et cela pose deux problèmes.

Le premier problème est que le bus mémoire doit être libéré une fois l'instruction chargée, pour un éventuel accès mémoire. Mais le séquenceur doit conserver une copie de l'instruction chargée, sans quoi il ne peut pas décoder l'instruction correctement. Par exemple, si l'instruction met plusieurs cycles à s'exécuter, le séquenceur doit conserver une copie de l'instruction durant ces plusieurs cycles. La solution à ce problème est un '''registre d'instruction''' situé juste avant le séquenceur, qui mémorise l'instruction chargée.

[[File:Registre d'instruction.png|centre|vignette|upright=2|Registre d'instruction.]]

Le second problème est de gérer le flot des instructions/données entre le bus mémoire, le chemin de données et le séquenceur. Le processeur doit connecter l'interface mémoire soit au séquenceur, soit au chemin de données et cela complique le réseau d'interconnexion interne au processeur.

Une première solution utilise un bus unique qui relie l'interface mémoire, le séquenceur et le chemin de données. Pour charger une instruction, le séquenceur copie le ''program counter'' sur le bus d'adresse, attend que l'instruction lue soit disponible sur le bus de données, puis la copie dans le registre d'instruction. Le bus mémoire est alors libre et peut être utilisé pour lire ou écrire des données, si le besoin s'en fait sentir.

Il faut noter que l'usage d'un bus unique a un impact sur l'organisation interne du chemin de données. Par exemple, le chapitre précédent nous a montré comment implémenter un chemin de données basique, avec des multiplexeurs et démultiplexeurs. Et bien ces chemins de données ne marchent pas vraiment avec un bus interne unique. Il est possible de les adapter, mais au prix d'une complexité largement supérieure. Un bus interne unique marche mieux quand le banc de registre est mono-port. C'est pourquoi il a été utilisé sur d'anciennes architectures appelées des architectures à accumulateur et à pile, que nous verrons dans quelques chapitres, qui utilisaient un banc de registre mono-port.

[[File:Microarchitecture de l'interface mémoire d'une architecture von neumann.png|centre|vignette|upright=2|Microarchitecture de l'interface mémoire d'une architecture von neumann]]

Une autre solution utilise deux bus interne séparés : un connecté au bus d'adresse, l'autre au bus de données. Le ''program counter'' est alors connecté au bus interne d'adresse, le séquenceur est relié au bus interne de données. Notons que la technique marche bien si le ''program counter'' est dans le banc de registre : les interconnexions utilisées pour gérer l'adressage indirect permettent d'envoyer le ''program counter'' sur le bus d'adresse sans ajout de circuit.

Le tout peut être amélioré en remplaçant les deux bus par des multiplexeurs et démultiplexeurs. Le bus d'adresse est précédé par un multiplexeur, qui permet de faire le choix entre ''Program Counter'', adresse venant du chemin de données, ou adresse provenant du séquenceur (adressage absolu). De même, le bus de données est suivi par un démultiplexeur qui envoie la donnée/instruction lue soit au registre d'instruction, soit au chemin de données. Le tout se marie très bien avec les chemins de donnée vu dans le chapitre précédent. Au passage, il faut noter que cette solution nécessite un banc de registre multi-port.

[[File:Connexion du program counter sur les bus avec PC isolé.png|centre|vignette|upright=2|Connexion du program counter sur les bus avec PC isolé]]

===Le chargement des instructions de longueur variable===

Le chargement des instructions de longueur variable pose de nombreux problèmes. Le premier est que mettre à jour le ''program counter'' demande de connaitre la longueur de l'instruction chargée, pour l'ajouter au ''program counter''. Si la longueur d'une instruction est variable, on doit connaitre cette longueur d'une manière où d'une autre. La solution la plus simple indique la longueur de l'instruction dans une partie de l'opcode ou de la représentation en binaire de l'instruction. Mais les processeurs haute performance de nos PC utilisent d'autres solutions, qui n'encodent pas explicitement la taille de l'instruction.

Les processeurs récents utilisent un registre d'instruction de grande taille, capable de mémoriser l'instruction la plus longue du processeur. Par exemple, si un processeur supporte des instructions allant de 1 à 8 octets, comme les CPU x86, le registre d'instruction fera 8 octets. Le décodeur d'instruction vérifie à chaque cycle le contenu du registre d'instruction. Si une instruction est détectée dedans, son décodage commence, peu importe la taille de l'instruction. Une fois l'instruction exécutée, elle est retirée du registre d'instruction. Reste à alimenter le registre d'instruction, à charger des instructions dedans. Et pour cela deux solutions : soit on charge l'instruction en plusieurs fois, soit d'un seul coup.

La solution la plus simple charge les instructions par mots de 8, 16, 32, 64 bits. Ils sont accumulés dans le registre d'instruction jusqu'à détecter une instruction complète. La technique marche nettement mieux si les instructions sont très longues. Par exemple, les CPU x86 ont des instructions qui vont de 1 à 15 octets, ce qui fait qu'ils utilisent cette technique. Précisément, elle marche si les instructions les plus longues sont plus grandes que le bus mémoire.

Une autre solution charge un bloc de mots mémoire aussi grand que la plus grande instruction. Par exemple, si le processeur gère des instructions allant de 1 à 4 octets, il charge 4 octets d'un seul coup dans le registre d'instruction. Il va de soit que cette solution ne marche que si les instructions du processeur sont assez courtes, au plus aussi courtes que le bus mémoire. Ainsi, on est sûr de charger obligatoirement au moins une instruction complète, et peut-être même plusieurs. Le contenu du registre d'instruction est alors découpé en instructions au fil de l'eau. 

Utiliser un registre d'instruction large pose problème avec des instructions à cheval entre deux blocs. Il se peut qu'on n'ait pas une instruction complète lorsque l'on arrive à la fin du bloc, mais seulement un morceau. Le problème se manifeste peu importe que l'instruction soit chargée d'un seul coup ou bien en plusieurs fois.

[[File:Instructions non alignées.png|centre|vignette|upright=2|Instructions non alignées.]]

Dans ce cas, on doit décaler le morceau de bloc pour le mettre au bon endroit (au début du registre d'instruction), et charger le prochain bloc juste à côté. On a donc besoin d'un circuit qui décale tous les bits du registre d'instruction, couplé à un circuit qui décide où placer dans le registre d'instruction ce qui a été chargé, avec quelques circuits autour pour configurer les deux circuits précédents.

[[File:Décaleur d’instruction.png|centre|vignette|upright=2|Décaleur d’instruction.]]

Une autre solution se passe de registre d'instruction en utilisant à la place l'état interne du séquenceur. Là encore, elle charge l'instruction morceau par morceau, typiquement par blocs de 8, 16 ou 32 bits. Les morceaux ne sont pas accumulés dans le registre d'instruction, la solution utilise à la place l'état interne du séquenceur. Les mots mémoire de l'instruction sont chargés à chaque cycle, faisant passer le séquenceur d'un état interne à un autre à chaque mot mémoire. Tant qu'il n'a pas reçu tous les mots mémoire de l'instruction, chaque mot mémoire non terminal le fera passer d'un état interne à un autre, chaque état interne encodant les mots mémoire chargés auparavant. S'il tombe sur le dernier mot mémoire d'une instruction, il rentre dans un état de décodage.

==L'incrémentation du ''program counter''==

À chaque chargement, le ''program counter'' est mis à jour afin de pointer sur la prochaine instruction à charger. Sur la quasi-totalité des processeurs, les instructions sont placées dans l'ordre d’exécution dans la RAM. En faisant ainsi, on peut mettre à jour le ''program counter'' en lui ajoutant la longueur de l'instruction courante. Déterminer la longueur de l'instruction est simple quand les instructions ont toutes la même taille, mais certains processeurs ont des instructions de taille variable, ce qui complique le calcul. Dans ce qui va suivre, nous allons supposer que les instructions sont de taille fixe, ce qui fait que le ''program counter'' est toujours incrémenté de la même valeur.

Il existe deux méthodes principales pour incrémenter le ''program counter'' : soit le ''program counter'' a son propre additionneur, soit le ''program counter'' est mis à jour par l'ALU. Pour ce qui est de l'organisation des registres, soit le ''program counter'' est un registre séparé des autres, soit il est regroupé avec d'autres registres dans un banc de registre. En tout, cela donne quatre organisations possibles.
* Un ''program counter'' séparé relié à un incrémenteur séparé.
* Un ''program counter'' séparé des autres registres, incrémenté par l'ALU.
* Un ''program counter'' intégré au banc de registre, relié à un incrémenteur séparé.
* Un ''program counter'' intégré au banc de registre, incrémenté par l'ALU.

[[File:Calcul du program counter.png|centre|vignette|upright=2|les différentes méthodes de calcul du program counter.]]

Les processeurs haute performance modernes utilisent tous la première méthode. Les autres méthodes étaient surtout utilisées sur les processeurs 8 ou 16 bits, elles sont encore utilisées sur quelques microcontrôleurs de faible puissance. Nous auront l'occasion de donner des exemples quand nous parlerons des processeurs 8 bits anciens, dans le chapitre sur les architectures à accumulateur et affiliées.

===Le ''program counter'' mis à jour par l'ALU===

Sur certains processeurs, le calcul de l'adresse de la prochaine instruction est effectué par l'ALU. L'avantage de cette méthode est qu'elle économise un incrémenteur dédié au ''program counter''. Ce qui explique que cette méthode était utilisée sur les processeurs assez anciens, à une époque où un additionneur pouvait facilement prendre 10 à 20% des transistors disponibles. Le désavantage principal est une augmentation de la complexité du séquenceur, qui doit gérer la mise à jour du ''program counter''. De plus, la mise à jour du ''program counter'' ne peut pas se faire en même temps qu'une opération arithmétique, ce qui réduit les performances.

Si on incrémente le ''program counter'' avec l'ALU, il est intéressant de le placer dans le banc de registres. Un désavantage est qu'on perd un registre. Par exemple, avec un banc de registre de 16 registres, on ne peut adresser que 15 registres généraux. De plus ce n'est pas l'idéal pour le décodage des instructions et pour le séquenceur. Si le processeur dispose de plusieurs bancs de registres, le ''program counter'' est généralement placé dans le banc de registre dédié aux adresses. Sinon, il est placé avec les nombres entiers/adresses.

D'anciens processeurs incrémentaient le ''program counter'' avec l'ALU, mais utilisaient bien un registre séparé pour le ''program counter''. Cette méthode est relativement simple à implémenter : il suffit de connecter/déconnecter le ''program counter'' du bus interne suivant les besoins. Le ''program counter'' est déconnecté pendant l’exécution d'une instruction, il est connecté au bus interne pour l'incrémenter. C'est le séquenceur qui gère le tout. L'avantage de cette séparation est qu'elle est plus facile à gérer pour le séquenceur. De plus, on gagne un registre général/entier dans le banc de registre.

===Le compteur programme===

Dans la quasi-totalité des processeurs modernes, le ''program counter'' est un vulgaire compteur comme on en a vu dans les chapitres sur les circuits, ce qui fait qu'il passe automatiquement d'une adresse à la suivante. Dans ce qui suit, nous allons appeler ce registre compteur : le '''compteur ordinal'''. L'usage d'un compteur simplifie fortement la conception du séquenceur. Le séquenceur n'a pas à gérer la mise à jour du ''program counter'', sauf en cas de branchements. De plus, il est possible d'incrémenter le ''program counter'' pendant que l'unité de calcul effectue une opération arithmétique, ce qui améliore grandement les performances. Le seul désavantage est qu'elle demande d'ajouter un incrémenteur dédié au ''program counter''.

Sur les processeurs très anciens, les instructions faisaient toutes un seul mot mémoire et le compteur ordinal était un circuit incrémenteur des plus basique. Sur les processeurs modernes, le compteur est incrémenté par pas de 4 si les instructions sont codées sur 4 octets, 8 si les instructions sont codées sur 8 octets, etc. Concrètement, le compteur est un circuit incrémenteur auquel on aurait retiré quelques bits de poids faible. Par exemple, si les instructions sont codées sur 4 octets, on coupe les 2 derniers bits du compteur. Si les instructions sont codées sur 8 octets, on coupe les 3 derniers bits du compteur. Et ainsi de suite.

Il a existé quelques processeurs pour lesquelles le ''program counter'' était non pas un compteur binaire classique, mais un ''linear feedback shift register''. L'avantage est que le circuit d'incrémentation utilisait bien moins de portes logiques, l'économie était substantielle. Mais un défaut est que des instructions consécutives dans le programme n'étaient pas consécutives en mémoire. Il existait cependant une table de correspondance pour dire : la première instruction est à telle adresse, la seconde à telle autre, etc. Un exemple de processeur de ce type est le TMS 1000 de Texas Instrument, un des premiers microcontrôleur 4 bits datant des années 70.

Une amélioration de la solution précédente utilise un circuit incrémenteur partagé entre le ''program counter'' et d'autres registres. L'incrémenteur est utilisé pour incrémenter le ''program counter'', mais aussi pour effectuer d'autres calculs d'adresse. Par exemple, sur les architectures avec une pile d'adresse de retour, il est possible de partager l'incrémenteur/décrémenteur avec le pointeur de pile ( la technique ne marche pas avec une pile d'appel). Un autre exemple est celui des processeurs qui gèrent automatiquement le rafraichissement mémoire, grâce à, un compteur intégré dans le processeur. Il est possible de partager l'incrémenteur du ''program counter'' avec le compteur de rafraichissement mémoire, qui mémorise la prochaine adresse mémoire à rafraichir. Nous avions déjà abordé ce genre de partage dans le chapitre sur le chemin de données, dans l'annexe sur le pointeur de pile, mais nous verrons d'autres exemples dans le chapitre sur les architectures hybride accumulateur-registre 8/16 bits.

===Quand est mis à jour le ''program counter'' ?===

Le ''program counter'' est mis à jour quand il faut charger une nouvelle instruction. Reste qu'il faut savoir quand le mettre à jour. Incrémenter le ''program counter'' à intervalle régulier, par exemple à chaque cycle d’horloge, fonctionne sur les processeurs où toutes les instructions mettent le même temps pour s’exécuter. Mais de tels processeurs sont très rares. Sur la quasi-totalité des processeurs, les instructions ont une durée d’exécution variable, elles ne prennent pas le même nombre de cycle d'horloge pour s’exécuter. Le temps d’exécution d'une instruction varie selon l'instruction, certaines sont plus longues que d'autres. Tout cela amène un problème : comment incrémenter le ''program counter'' avec des instructions avec des temps d’exécution variables ?

La réponse est que la mise à jour du ''program counter'' démarre quand l'instruction précédente a terminée de s’exécuter, plus précisément un cycle avant. C'est un cycle avant pour que l'instruction chargée soit disponible au prochain cycle pour le décodeur. Pour cela, le séquenceur doit déterminer quand l'instruction est terminée et prévenir le ''program counter'' au bon moment. Il faut donc une interaction entre séquenceur et circuit de chargement. Le circuit de chargement contient une entrée Enable, qui autorise la mise à jour du ''program counter''. Le séquenceur met à 1 cette entrée pour prévenir au ''program counter'' qu'il doit être incrémenté au cycle suivant ou lors du cycle courant. Cela permet de gérer simplement le cas des instructions multicycles. 

[[File:Commande de la mise à jour du program counter.png|centre|vignette|upright=2|Commande de la mise à jour du program counter.]]

Toute la difficulté est alors reportée dans le séquenceur, qui doit déterminer la durée d'une instruction. Pour gérer la mise à jour du ''program counter'', le séquenceur doit déterminer la durée d'une instruction. Cela est simple pour les instructions arithmétiques et logiques, qui ont un nombre de cycles fixe, toujours le même. Une fois l'instruction identifiée par le séquenceur, il connait son nombre de cycles et peut programmer un compteur interne au séquenceur, qui compte le nombre de cycles de l'instruction, et fournit le signal Enable au ''program counter''. Mais cette technique ne marche pas vraiment pour les accès mémoire, dont la durée n'est pas connue à l'avance, surtout sur les processeurs avec des mémoires caches. Pour cela, le séquenceur détermine quand l'instruction mémoire est finie et prévient le ''program counter'' quand c'est le cas.

Il existe quelques processeurs pour lesquels le temps de calcul dépend des opérandes de l'instruction. On peut par exemple avoir une division qui prend 10 cycles avec certaines opérandes, mais 40 cycles avec d'autres opérandes. Mais ces processeurs sont rares et cela est surtout valable pour les opérations de multiplication/division, guère plus. Le problème est alors le même qu'avec les accès mémoire et la solution est la même : l'ALU prévient le séquenceur quand le résultat est disponible.

==Les branchements et le ''program counter''==

Un branchement consiste juste à écrire l'adresse de destination dans le ''program counter''. L'implémentation des branchements demande d'extraire l'adresse de destination et d'altérer le ''program counter'' quand un branchement est détecté. Pour cela, le décodeur d'instruction détecte si l'instruction exécutée est un branchement ou non, et il en déduit où trouver l'adresse de destination.

L'adresse de destination se trouve à un endroit qui dépend du mode d'adressage du branchement. Pour rappel, on distingue quatre modes d'adressage pour les branchements : direct, indirect, relatif et implicite. Pour les branchements directs, l'adresse est intégrée dans l'instruction de branchement elle-même et est extraite par le séquenceur. Pour les branchements indirects, l'adresse de destination est dans le banc de registre. Pour les branchements relatifs, il faut ajouter un décalage au ''program counter'', décalage extrait de l'instruction par le séquenceur. Enfin, les instructions de retour de fonction lisent l'adresse de destination depuis la pile. L'implémentation de ces quatre types de branchements est très différente.

L'altération du ''program counter'' dépend de si le ''program counter'' est dans un compteur séparé ou s'il est dans le banc de registre. Nous avons vu plus haut qu'il y a quatre cas différents, mais nous n'allons voir que deux cas : celui où le ''program counter'' est dans le banc de registre et est incrémenté par l'unité de calcul, celui avec un ''program counter'' séparé avec son propre incrémenteur. Les deux autres cas ne sont utilisés que sur des architectures à accumulateur ou à pile spécifiques, que nous n'avons pas encore vu à ce stade du cours et que nous verrons en temps voulu dans le chapitre sur ces architectures.

===L’implémentation des branchements avec un ''program counter'' intégré au banc de registres===

Le cas le plus simple est celui où le ''program counter'' est intégré au banc de registre, avec une incrémentation faite par l'unité de calcul. Charger une instruction revient alors à effectuer une instruction LOAD en adressage indirect, à deux différences près : le registre sélectionné est le ''program counter'', l’instruction est copiée dans le registre d'instruction et non dans le banc de registre. L'incrémentation du ''porgram counter'' est implémenté avec des micro-opérations qui agissent sur le chemin de données, au même titre que les branchements indirects, relatifs et directs.
* Les branchements indirects copient un registre dans le ''program counter'', ce qui revient simplement à faire une opération MOV entre deux registres, dont le ''program counter'' est la destination.
* L'opération inverse d'un branchement indirect, qui copie le ''program counter'' dans un registre général, est utile pour sauvegarder l'adresse de retour d'une fonction.
* Les branchements directs copient une adresse dans le ''program counter'', ce qui les rend équivalents à une opération MOV avec une constante immédiate, dont le ''program counter'' est la destination.
* Les branchements relatifs sont une opération arithmétique entre le ''program counter'' et un opérande en adressage immédiat.

En clair, à partir du moment où le chemin de données supporte les instructions MOV et l'addition, avec les modes d'adressage adéquat, il supporte les branchements. Aucune modification du chemin de données n'est nécessaire, le séquenceur gére le chargement d'une instruction avec les micro-instructions adéquates : une micro-opération ADD pour incrémenter le ''program counter'', une micro-opération LOAD pour le chargement de l'instruction.

Notons que sur certaines architectures, le ''program counter'' est adressable au même titre que les autres registres du banc de registre. Les instructions de branchement sont alors remplacées par des instructions MOV ou des instructions arithmétique équivalentes, comme décrit plus haut.

===L’implémentation des branchements avec un ''program counter'' séparé===

Étudions maintenant le cas où le ''program counter'' est dans un registre/compteur séparé. Rappelons que tout compteur digne de ce nom possède une entrée de réinitialisation, qui remet le compteur à zéro. De plus, on peut préciser à quelle valeur il doit être réinitialisé. Ici, la valeur à laquelle on veut réinitialiser le compteur n'est autre que l'adresse de destination du branchement. Implémenter un branchement est donc simple : l'entrée de réinitialisation est commandée par le circuit de détection des branchements, alors que la valeur de réinitialisation est envoyée sur l'entrée adéquate. En clair, nous partons du principe que le ''program counter'' est implémenté avec ce type de compteur :

[[File:Fonctionnement d'un compteur (décompteur), schématique.jpg|centre|vignette|upright=1.5|Fonctionnement d'un compteur (décompteur), schématique]]

Toute la difficulté est de présenter l'adresse de destination au ''program counter''. Pour les branchements directs, l'adresse de destination est fournie par le séquenceur. L'adresse de destination du branchement sort du séquenceur et est présentée au ''program counter'' sur l'entrée adéquate. Voici donc comment sont implémentés les branchements directs avec un ''program counter'' séparé du banc de registres. Le schéma ci-dessous marche peu importe que le ''program counter'' soit incrémenté par l'ALU ou par un additionneur dédié.

[[File:Unité de détection des branchements dans le décodeur.png|centre|vignette|upright=2|Unité de détection des branchements dans le décodeur]]

Les branchements relatifs sont ceux qui font sauter X instructions plus loin dans le programme. Leur implémentation demande d'ajouter une constante au ''program counter'', la constante étant fournie dans l’instruction. Là encore, deux solutions sont possibles : réutiliser l'ALU pour calculer l'adresse, ou utiliser un additionneur séparé. L'additionneur séparé peut être fusionné avec l'additionneur qui incrémente le ''program counter'' pour passer à l’instruction suivante.

[[File:Unité de chargement qui gère les branchements relatifs.png|centre|vignette|upright=2|Unité de chargement qui gère les branchements relatifs.]]

Pour les branchements indirects, il suffit de lire le registre voulu et d'envoyer le tout sur l'entrée adéquate du ''program counter''. Il faut alors rajouter un multiplexeur pour que l'entrée de réinitialisationr ecoive la bonne adresse de destination.

[[File:Unité de chargement qui gère les branchements directs.png|centre|vignette|upright=2|Unité de chargement qui gère les branchements directs et indirects.]]

Toute la difficulté de l'implémentation des branchements est de configurer les multiplexeurs, ce qui est réalisé par le séquenceur en fonction du mode d'adressage du branchement.

==Les optimisations du chargement des instructions==

Charger une instruction est techniquement une forme d'accès mémoire un peu particulier. En clair, charger une instruction prend au minimum un cycle d'horloge, et cela peut rapidement monter à 3-5 cycles, si ce n'est plus. L'exécution des instructions est alors fortement ralentit par la mémoire. Par exemple, imaginez que la mémoire mette 3 cycles d'horloges pour charger une instruction, alors qu'une instruction s’exécute en 1 cycle (si les opérandes sont dans les registres). La perte de performance liée au chargement des instructions est alors substantielle. Heureusement, il est possible de limiter la casse en utilisant des mémoires caches, ainsi que d'autres optimisations, que nous allons voir dans ce qui suit.

===Le tampon de préchargement===

La technique dite du '''préchargement''' est utilisée dans le cas où la mémoire a un temps d'accès important. Mais si la latence de la RAM est un problème, le débit ne l'est pas. Il est possible d'avoir une RAM lente, mais à fort débit. Par exemple, supposons que la mémoire puisse charger 4 instructions (de taille fixe) en 3 cycles. Le processeur peut alors charger 4 instructions en un seul accès mémoire, et les exécuter l'une après l'autre, une par cycle d'horloge. Les temps d'attente sont éliminés : le processeur peut décoder une nouvelle instruction à chaque cycle. Et quand la dernière instruction préchargée est exécutée, la mémoire est de nouveau libre, ce qui masque la latence des accès mémoire.

[[File:Tampon de préchargement d'instruction.png|vignette|Tampon de préchargement d'instruction]]

La seule contrainte est de mettre les instructions préchargées en attente. La solution pour cela est d'utiliser un registre d'instruction très large, capable de mémoriser plusieurs instructions à la fois. Ce registre est de plus connecté à un multiplexeur qui permet de sélectionner l'instruction adéquate dans ce registre. Ce multiplexeur est commandé par le ''program counter'' et quelques circuits annexes. Ce super-registre d'instruction est appelé un '''tampon de préchargement'''.

La méthode a une implémentation nettement plus simple avec des instructions de taille fixe, alignées en mémoire. La commande du multiplexeur de sélection de l'instruction est alors beaucoup plus simple : il suffit d'utiliser les bits de poids fort du ''program counter''. Par exemple, prenons le cas d'un registre d'instruction de 32 octets pour des instructions de 4 octets, soit 8 instructions. Le choix de l'instruction à sélectionner se fait en utilisant les 3 bits de poids faible du ''program counter''. 

Mais cette méthode ajoute de nouvelles contraintes d'alignement, similaires à celles vues dans le chapitre sur l'alignement et le boutisme, sauf que l'alignement porte ici sur des blocs d'instructions de même taille que le tampon de préchargement. Si on prend l'exemple d'un tampon de préchargement de 128 bits, les instructions devront être alignées par blocs de 128 bits. C'est à dire qu'idéalement, les fonctions et autres blocs de code isolés doivent commencer à des adresses multiples de 128, pour pouvoir charger un bloc d'instruction en une seule fois. Sans cela, les performances seront sous-optimales.

: Il arrive que le tampon de préchargement ait la même taille qu'une ligne de cache.

Lorsque l'on passe d'un bloc d'instruction à un autre, le tampon de préchargement est mis à jour. Par exemple, si on prend un tampon de préchargement de 4 instructions, on doit changer son contenu toutes les 4 instructions. La seule exception est l'exécution d'un branchement. En effet, lors d'un branchement, la destination du branchement n'est pas dans le tampon de préchargement et elle doit être chargée dedans (sauf si le branchement pointe vers une instruction très proche, ce qui est improbable). Pour cela, le tampon de préchargement est mis à jour précocement quand le processeur détecte un branchement.

Le même problème survient avec du code auto-modifiant. Un code auto-modifiant est un programme qui se modifie lui-même, en remplaçant certaines instructions par d'autres, en en retirant, en en ajoutant, lors de sa propre exécution. De tels programmes sont rares, mais la technique était utilisée dans quelques cas au tout début de l'informatique sur des ordinateurs rudimentaires. Ceux-ci avaient des modes d'adressages tellement limités que gérer des tableaux de taille variable demandait d'utiliser du code auto-modifiant pour écrire des boucles. Le problème survient quand des instructions sont modifiées immédiatement après avoir été préchargées. Les instructions dans le tampon de préchargement sont l'ancienne version, alors que la mémoire RAM contient les instructions modifiées. Gérer ce genre de cas demande de vider le tampon de préchargement si le cas arrive, mais ça ne vaut que très rarement le coup, aussi les ingénieurs ne s’embêtent pas à mettre ce correctif en place. Le code automodifiant est alors buggé.

===La ''prefetch input queue''===

La ''prefetch input queue'' est une optimisation matérielle qui a été utilisée sur les processeurs Intel assez ancien. Elle est apparue sur le 8086 et le 8088, des processeurs respectivement 8 et 16 bits. Elle été présente sur le 286 et le 386, mais était un peu améliorée. Elle est apparue sur ces processeurs à une époque où le processeur devenait plus rapide que la mémoire.

L'idée est là encore de précharger des instructions en avance. Sauf que cette fois-ci, on ne charge pas plusieurs instructions à la fois. Au contraire, les instructions sont préchargées séquentiellement, un octet à la fois. Le tampon de préchargement est remplacé par une mémoire FIFO appelée la '''''Prefetch Input Queue''''', terme abrévié en PIQ. Les instructions sont accumulées une par une dans la PIQ, elles en sortent une par une au fur et à mesure pour alimenter le décodeur d'instruction. La ''prefetch input queue'' est une sorte de cousine du tampon de préchargement. 

L'idée est que pendant que le processeur exécute une instruction, on précharge la suivante. Sans ''prefetch input queue'', le processeur chargeait une instruction, la décodait et l'exécutait, puis chargeait la suivante, et ainsi de suite. Avec la ''prefetch input queue'', pendant qu'une instruction est en cours de décodage/exécution, le processeur précharge l'instruction suivante. Si une instruction prend vraiment beaucoup de temps pour s'exécuter, le processeur peutr en profiter pour précharger l'instruction encore suivante, et ainsi de suite, jusqu'à une limite de 4/6 instructions (la limite dépend du processeur).

Pour implémenter le préchargement d'instruction, le registre d'instruction est remplacé par une mémoire FIFO appelée la '''''Prefetch input queue'''''. On peut la voir comme un registre d'instruction sous stéroïde, capable de mémoriser plusieurs instructions consécutives. Les instructions sont chargées dans la ''Prefetch input queue'' et y attendent que le processeur les lise et les décode. Les instructions y sont conservées dans leur ordre d'arrivée, afin qu'elles soient exécutées dans le bon ordre, ce qui fait que la ''Prefetch input queue'' est une mémoire de type FIFO. L'étape de décodage pioche l'instruction à décoder dans la ''Prefetch input queue'', cette instruction étant par définition la plus ancienne, puis la retire de la file.

Le premier processeur commercial grand public à utiliser cette méthode était le 8086, un processeur d'Intel de jeu d'instruction x86. Il pouvait précharger à l'avance 6 octets d’instruction. L'Intel 8088 avait lui aussi une ''Prefetch input queue'', mais qui ne permattait que de précharger 4 instructions. La taille idéale de la FIFO dépend de nombreux paramètres. On pourrait croire que plus elle peut contenir d'instructions, mieux c'est, mais ce n'est pas le cas, pour des raisons que nous allons voir dans ce qui suit.

[[File:80186 arch.png|centre|vignette|700px|upright=2|Architecture du 8086, du 80186 et de ses variantes.]]

Les branchements posent des problèmes avec la ''Prefetch input queue'' : à cause d'eux, on peut charger à l'avance des instructions qui sont zappées par un branchement et ne sont pas censées être exécutées. Si un branchement est chargé, toutes les instructions préchargées après sont potentiellement invalides. Si le branchement est non-pris, les instructions chargées sont valides, elles sont censées s’exécuter. Mais si le branchement est pris, elles ont été chargées à tort et ne doivent pas s’exécuter. 

Pour éviter cela, la ''Prefetch input queue'' est vidée quand le processeur détecte un branchement. Cette détection ne peut se faire qu'une fois le branchement décodé : on ne sait pas si l'instruction est un branchement ou autre chose tant que le décodage n'a pas eu lieu, par définition. En clair, le décodeur invalide la ''Prefetch input queue'' quand il détecte un branchement. Les interruptions posent le même genre de problèmes. Il faut impérativement vider la ''Prefetch input queue'' quand une interruption survient, avant de la traiter.

Un autre défaut est que la ''Prefetch input queue'' se marie assez mal avec du code auto-modifiant. Un code auto-modifiant est un programme qui se modifie lui-même, en remplaçant certaines instructions par d'autres, en en retirant, en en ajoutant, lors de sa propre exécution. De tels programmes sont rares, mais la technique était utilisée dans quelques cas au tout début de l'informatique sur des ordinateurs rudimentaires. Ceux-ci avaient des modes d'adressages tellement limités que gérer des tableaux de taille variable demandait d'utiliser du code auto-modifiant pour écrire des boucles.

Le problème avec la ''Prefetch input queue'' survient quand des instructions sont modifiées immédiatement après avoir été préchargées. Les instructions dans la ''Prefetch input queue'' sont l'ancienne version, alors que la mémoire RAM contient les instructions modifiées. Gérer ce genre de cas est quelque peu complexe. Il faut en effet vider la ''Prefetch input queue'' si le cas arrive, ce qui demande d'identifier les écritures qui écrasent des instructions préchargées. C'est parfaitement possible, mais demande de transformer la ''Prefetch input queue'' en une mémoire hybride, à la fois mémoire associative et mémoire FIFO. Cela ne vaut que très rarement le coup, aussi les ingénieurs ne s’embêtent pas à mettre ce correctif en place, le code automodifiant est alors buggé.

===Le ''Zero-overhead looping''===

Nous avions vu dans le chapitre sur les instructions machines, qu'il existe des instructions qui permettent de grandement faciliter l'implémentation des boucles. Il s'agit de l'instruction REPEAT, utilisée sur certains processeurs de traitement de signal. Elle répète l'instruction suivante, voire une série d'instructions, un certain nombre de fois. Le nombre de répétitions est mémorisé dans un registre décrémenté à chaque itération de la boucle. Elle permet donc d'implémenter une boucle FOR facilement, sans recourir à des branchements ou des conditions.

Une technique en lien avec cette instruction permet de grandement améliorer les performances et la consommation d'énergie. L'idée est de mémoriser la boucle, les instructions à répéter, dans une petite mémoire cache située entre l'unité de chargement et le séquenceur. Le cache en question s'appelle un '''tampon de boucle''', ou encore un ''hardware loop buffer''. Grâce à lui, il n'y a pas besoin de charger les instructions à chaque fois qu'on les exécute, on les charge une bonne fois pour toute : c'est plus rapide. Bien sûr, il ne fonctionne que pour de petites boucles, mais il en est de même avec l'instruction REPEAT.

&lt;noinclude&gt;
{{NavChapitre | book=Fonctionnement d'un ordinateur
           | prev=Le chemin de données
           | prevText=Le chemin de données
           | next=L'unité de contrôle
           | nextText=L'unité de contrôle
}}
&lt;/noinclude&gt;</text>
      <sha1>2cultaozuhamxcjzpyiuj1v1j124j13</sha1>
    </revision>
    <revision>
      <id>744062</id>
      <parentid>744061</parentid>
      <timestamp>2025-06-03T18:50:21Z</timestamp>
      <contributor>
        <username>Mewtow</username>
        <id>31375</id>
      </contributor>
      <minor />
      <comment>/* La prefetch input queue */</comment>
      <origin>744062</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="39891" sha1="ch0joxm7ppqk23jk2crzi01sbt6nozj" xml:space="preserve">L'unité de contrôle s'occupe du chargement des instructions et de leur interprétation, leur décodage. Elle contient deux circuits : l''''unité de chargement''' qui charge l'instruction depuis la mémoire, et le '''séquenceur''' qui commande le chemin de données. Les deux circuits sont séparés, mais ils communiquent entre eux, notamment pour gérer les branchements. Dans ce chapitre, nous allons nous intéresser au chargement d'une instruction depuis la RAM/ROM, nous verrons l'étape de décodage de l'instruction au prochain chapitre.

==Le chargement d'une instruction==

[[File:Étape de chargement.png|vignette|upright=1|Étape de chargement.]]

L'étape de chargement (ou ''fetch'') doit faire deux choses : mettre à jour le ''program counter'' et lire l'instruction en mémoire RAM ou en ROM. Les deux étapes peuvent être faites en parallèle, dans des circuits séparés. Pendant que l'instruction est lue depuis la mémoire RAM/ROM, le ''program counter'' est incrémenté et/ou altéré par un branchement.

Pour lire l'instruction, on envoie le ''program counter'' sur le bus d'adresse et on récupère l'instruction sur le bus de données pour l'envoyer sur l'entrée du séquenceur. Et cela demande de connecter le séquenceur au bus mémoire, à travers l'interface mémoire. Et sur ce point, la situation est différente selon que l'on parler d'une architecture Harvard ou Von Neumann.

===Les interconnexions entre séquenceur et bus mémoire===

Sur les architectures Harvard, le séquenceur et le chemin de donnée utilisent des interfaces mémoire séparées. Le séquenceur est directement relié au bus mémoire de la ROM, alors que le chemin de données est connecté à la RAM.

[[File:Microarchitecture de l'interface mémoire d'une architecture Harvard.png|centre|vignette|upright=2|Microarchitecture de l'interface mémoire d'une architecture Harvard]]

Mais sur les architectures Von-Neumann et affiliées, le séquenceur et le chemin de donnée partagent la même interface mémoire. Et cela pose deux problèmes.

Le premier problème est que le bus mémoire doit être libéré une fois l'instruction chargée, pour un éventuel accès mémoire. Mais le séquenceur doit conserver une copie de l'instruction chargée, sans quoi il ne peut pas décoder l'instruction correctement. Par exemple, si l'instruction met plusieurs cycles à s'exécuter, le séquenceur doit conserver une copie de l'instruction durant ces plusieurs cycles. La solution à ce problème est un '''registre d'instruction''' situé juste avant le séquenceur, qui mémorise l'instruction chargée.

[[File:Registre d'instruction.png|centre|vignette|upright=2|Registre d'instruction.]]

Le second problème est de gérer le flot des instructions/données entre le bus mémoire, le chemin de données et le séquenceur. Le processeur doit connecter l'interface mémoire soit au séquenceur, soit au chemin de données et cela complique le réseau d'interconnexion interne au processeur.

Une première solution utilise un bus unique qui relie l'interface mémoire, le séquenceur et le chemin de données. Pour charger une instruction, le séquenceur copie le ''program counter'' sur le bus d'adresse, attend que l'instruction lue soit disponible sur le bus de données, puis la copie dans le registre d'instruction. Le bus mémoire est alors libre et peut être utilisé pour lire ou écrire des données, si le besoin s'en fait sentir.

Il faut noter que l'usage d'un bus unique a un impact sur l'organisation interne du chemin de données. Par exemple, le chapitre précédent nous a montré comment implémenter un chemin de données basique, avec des multiplexeurs et démultiplexeurs. Et bien ces chemins de données ne marchent pas vraiment avec un bus interne unique. Il est possible de les adapter, mais au prix d'une complexité largement supérieure. Un bus interne unique marche mieux quand le banc de registre est mono-port. C'est pourquoi il a été utilisé sur d'anciennes architectures appelées des architectures à accumulateur et à pile, que nous verrons dans quelques chapitres, qui utilisaient un banc de registre mono-port.

[[File:Microarchitecture de l'interface mémoire d'une architecture von neumann.png|centre|vignette|upright=2|Microarchitecture de l'interface mémoire d'une architecture von neumann]]

Une autre solution utilise deux bus interne séparés : un connecté au bus d'adresse, l'autre au bus de données. Le ''program counter'' est alors connecté au bus interne d'adresse, le séquenceur est relié au bus interne de données. Notons que la technique marche bien si le ''program counter'' est dans le banc de registre : les interconnexions utilisées pour gérer l'adressage indirect permettent d'envoyer le ''program counter'' sur le bus d'adresse sans ajout de circuit.

Le tout peut être amélioré en remplaçant les deux bus par des multiplexeurs et démultiplexeurs. Le bus d'adresse est précédé par un multiplexeur, qui permet de faire le choix entre ''Program Counter'', adresse venant du chemin de données, ou adresse provenant du séquenceur (adressage absolu). De même, le bus de données est suivi par un démultiplexeur qui envoie la donnée/instruction lue soit au registre d'instruction, soit au chemin de données. Le tout se marie très bien avec les chemins de donnée vu dans le chapitre précédent. Au passage, il faut noter que cette solution nécessite un banc de registre multi-port.

[[File:Connexion du program counter sur les bus avec PC isolé.png|centre|vignette|upright=2|Connexion du program counter sur les bus avec PC isolé]]

===Le chargement des instructions de longueur variable===

Le chargement des instructions de longueur variable pose de nombreux problèmes. Le premier est que mettre à jour le ''program counter'' demande de connaitre la longueur de l'instruction chargée, pour l'ajouter au ''program counter''. Si la longueur d'une instruction est variable, on doit connaitre cette longueur d'une manière où d'une autre. La solution la plus simple indique la longueur de l'instruction dans une partie de l'opcode ou de la représentation en binaire de l'instruction. Mais les processeurs haute performance de nos PC utilisent d'autres solutions, qui n'encodent pas explicitement la taille de l'instruction.

Les processeurs récents utilisent un registre d'instruction de grande taille, capable de mémoriser l'instruction la plus longue du processeur. Par exemple, si un processeur supporte des instructions allant de 1 à 8 octets, comme les CPU x86, le registre d'instruction fera 8 octets. Le décodeur d'instruction vérifie à chaque cycle le contenu du registre d'instruction. Si une instruction est détectée dedans, son décodage commence, peu importe la taille de l'instruction. Une fois l'instruction exécutée, elle est retirée du registre d'instruction. Reste à alimenter le registre d'instruction, à charger des instructions dedans. Et pour cela deux solutions : soit on charge l'instruction en plusieurs fois, soit d'un seul coup.

La solution la plus simple charge les instructions par mots de 8, 16, 32, 64 bits. Ils sont accumulés dans le registre d'instruction jusqu'à détecter une instruction complète. La technique marche nettement mieux si les instructions sont très longues. Par exemple, les CPU x86 ont des instructions qui vont de 1 à 15 octets, ce qui fait qu'ils utilisent cette technique. Précisément, elle marche si les instructions les plus longues sont plus grandes que le bus mémoire.

Une autre solution charge un bloc de mots mémoire aussi grand que la plus grande instruction. Par exemple, si le processeur gère des instructions allant de 1 à 4 octets, il charge 4 octets d'un seul coup dans le registre d'instruction. Il va de soit que cette solution ne marche que si les instructions du processeur sont assez courtes, au plus aussi courtes que le bus mémoire. Ainsi, on est sûr de charger obligatoirement au moins une instruction complète, et peut-être même plusieurs. Le contenu du registre d'instruction est alors découpé en instructions au fil de l'eau. 

Utiliser un registre d'instruction large pose problème avec des instructions à cheval entre deux blocs. Il se peut qu'on n'ait pas une instruction complète lorsque l'on arrive à la fin du bloc, mais seulement un morceau. Le problème se manifeste peu importe que l'instruction soit chargée d'un seul coup ou bien en plusieurs fois.

[[File:Instructions non alignées.png|centre|vignette|upright=2|Instructions non alignées.]]

Dans ce cas, on doit décaler le morceau de bloc pour le mettre au bon endroit (au début du registre d'instruction), et charger le prochain bloc juste à côté. On a donc besoin d'un circuit qui décale tous les bits du registre d'instruction, couplé à un circuit qui décide où placer dans le registre d'instruction ce qui a été chargé, avec quelques circuits autour pour configurer les deux circuits précédents.

[[File:Décaleur d’instruction.png|centre|vignette|upright=2|Décaleur d’instruction.]]

Une autre solution se passe de registre d'instruction en utilisant à la place l'état interne du séquenceur. Là encore, elle charge l'instruction morceau par morceau, typiquement par blocs de 8, 16 ou 32 bits. Les morceaux ne sont pas accumulés dans le registre d'instruction, la solution utilise à la place l'état interne du séquenceur. Les mots mémoire de l'instruction sont chargés à chaque cycle, faisant passer le séquenceur d'un état interne à un autre à chaque mot mémoire. Tant qu'il n'a pas reçu tous les mots mémoire de l'instruction, chaque mot mémoire non terminal le fera passer d'un état interne à un autre, chaque état interne encodant les mots mémoire chargés auparavant. S'il tombe sur le dernier mot mémoire d'une instruction, il rentre dans un état de décodage.

==L'incrémentation du ''program counter''==

À chaque chargement, le ''program counter'' est mis à jour afin de pointer sur la prochaine instruction à charger. Sur la quasi-totalité des processeurs, les instructions sont placées dans l'ordre d’exécution dans la RAM. En faisant ainsi, on peut mettre à jour le ''program counter'' en lui ajoutant la longueur de l'instruction courante. Déterminer la longueur de l'instruction est simple quand les instructions ont toutes la même taille, mais certains processeurs ont des instructions de taille variable, ce qui complique le calcul. Dans ce qui va suivre, nous allons supposer que les instructions sont de taille fixe, ce qui fait que le ''program counter'' est toujours incrémenté de la même valeur.

Il existe deux méthodes principales pour incrémenter le ''program counter'' : soit le ''program counter'' a son propre additionneur, soit le ''program counter'' est mis à jour par l'ALU. Pour ce qui est de l'organisation des registres, soit le ''program counter'' est un registre séparé des autres, soit il est regroupé avec d'autres registres dans un banc de registre. En tout, cela donne quatre organisations possibles.
* Un ''program counter'' séparé relié à un incrémenteur séparé.
* Un ''program counter'' séparé des autres registres, incrémenté par l'ALU.
* Un ''program counter'' intégré au banc de registre, relié à un incrémenteur séparé.
* Un ''program counter'' intégré au banc de registre, incrémenté par l'ALU.

[[File:Calcul du program counter.png|centre|vignette|upright=2|les différentes méthodes de calcul du program counter.]]

Les processeurs haute performance modernes utilisent tous la première méthode. Les autres méthodes étaient surtout utilisées sur les processeurs 8 ou 16 bits, elles sont encore utilisées sur quelques microcontrôleurs de faible puissance. Nous auront l'occasion de donner des exemples quand nous parlerons des processeurs 8 bits anciens, dans le chapitre sur les architectures à accumulateur et affiliées.

===Le ''program counter'' mis à jour par l'ALU===

Sur certains processeurs, le calcul de l'adresse de la prochaine instruction est effectué par l'ALU. L'avantage de cette méthode est qu'elle économise un incrémenteur dédié au ''program counter''. Ce qui explique que cette méthode était utilisée sur les processeurs assez anciens, à une époque où un additionneur pouvait facilement prendre 10 à 20% des transistors disponibles. Le désavantage principal est une augmentation de la complexité du séquenceur, qui doit gérer la mise à jour du ''program counter''. De plus, la mise à jour du ''program counter'' ne peut pas se faire en même temps qu'une opération arithmétique, ce qui réduit les performances.

Si on incrémente le ''program counter'' avec l'ALU, il est intéressant de le placer dans le banc de registres. Un désavantage est qu'on perd un registre. Par exemple, avec un banc de registre de 16 registres, on ne peut adresser que 15 registres généraux. De plus ce n'est pas l'idéal pour le décodage des instructions et pour le séquenceur. Si le processeur dispose de plusieurs bancs de registres, le ''program counter'' est généralement placé dans le banc de registre dédié aux adresses. Sinon, il est placé avec les nombres entiers/adresses.

D'anciens processeurs incrémentaient le ''program counter'' avec l'ALU, mais utilisaient bien un registre séparé pour le ''program counter''. Cette méthode est relativement simple à implémenter : il suffit de connecter/déconnecter le ''program counter'' du bus interne suivant les besoins. Le ''program counter'' est déconnecté pendant l’exécution d'une instruction, il est connecté au bus interne pour l'incrémenter. C'est le séquenceur qui gère le tout. L'avantage de cette séparation est qu'elle est plus facile à gérer pour le séquenceur. De plus, on gagne un registre général/entier dans le banc de registre.

===Le compteur programme===

Dans la quasi-totalité des processeurs modernes, le ''program counter'' est un vulgaire compteur comme on en a vu dans les chapitres sur les circuits, ce qui fait qu'il passe automatiquement d'une adresse à la suivante. Dans ce qui suit, nous allons appeler ce registre compteur : le '''compteur ordinal'''. L'usage d'un compteur simplifie fortement la conception du séquenceur. Le séquenceur n'a pas à gérer la mise à jour du ''program counter'', sauf en cas de branchements. De plus, il est possible d'incrémenter le ''program counter'' pendant que l'unité de calcul effectue une opération arithmétique, ce qui améliore grandement les performances. Le seul désavantage est qu'elle demande d'ajouter un incrémenteur dédié au ''program counter''.

Sur les processeurs très anciens, les instructions faisaient toutes un seul mot mémoire et le compteur ordinal était un circuit incrémenteur des plus basique. Sur les processeurs modernes, le compteur est incrémenté par pas de 4 si les instructions sont codées sur 4 octets, 8 si les instructions sont codées sur 8 octets, etc. Concrètement, le compteur est un circuit incrémenteur auquel on aurait retiré quelques bits de poids faible. Par exemple, si les instructions sont codées sur 4 octets, on coupe les 2 derniers bits du compteur. Si les instructions sont codées sur 8 octets, on coupe les 3 derniers bits du compteur. Et ainsi de suite.

Il a existé quelques processeurs pour lesquelles le ''program counter'' était non pas un compteur binaire classique, mais un ''linear feedback shift register''. L'avantage est que le circuit d'incrémentation utilisait bien moins de portes logiques, l'économie était substantielle. Mais un défaut est que des instructions consécutives dans le programme n'étaient pas consécutives en mémoire. Il existait cependant une table de correspondance pour dire : la première instruction est à telle adresse, la seconde à telle autre, etc. Un exemple de processeur de ce type est le TMS 1000 de Texas Instrument, un des premiers microcontrôleur 4 bits datant des années 70.

Une amélioration de la solution précédente utilise un circuit incrémenteur partagé entre le ''program counter'' et d'autres registres. L'incrémenteur est utilisé pour incrémenter le ''program counter'', mais aussi pour effectuer d'autres calculs d'adresse. Par exemple, sur les architectures avec une pile d'adresse de retour, il est possible de partager l'incrémenteur/décrémenteur avec le pointeur de pile ( la technique ne marche pas avec une pile d'appel). Un autre exemple est celui des processeurs qui gèrent automatiquement le rafraichissement mémoire, grâce à, un compteur intégré dans le processeur. Il est possible de partager l'incrémenteur du ''program counter'' avec le compteur de rafraichissement mémoire, qui mémorise la prochaine adresse mémoire à rafraichir. Nous avions déjà abordé ce genre de partage dans le chapitre sur le chemin de données, dans l'annexe sur le pointeur de pile, mais nous verrons d'autres exemples dans le chapitre sur les architectures hybride accumulateur-registre 8/16 bits.

===Quand est mis à jour le ''program counter'' ?===

Le ''program counter'' est mis à jour quand il faut charger une nouvelle instruction. Reste qu'il faut savoir quand le mettre à jour. Incrémenter le ''program counter'' à intervalle régulier, par exemple à chaque cycle d’horloge, fonctionne sur les processeurs où toutes les instructions mettent le même temps pour s’exécuter. Mais de tels processeurs sont très rares. Sur la quasi-totalité des processeurs, les instructions ont une durée d’exécution variable, elles ne prennent pas le même nombre de cycle d'horloge pour s’exécuter. Le temps d’exécution d'une instruction varie selon l'instruction, certaines sont plus longues que d'autres. Tout cela amène un problème : comment incrémenter le ''program counter'' avec des instructions avec des temps d’exécution variables ?

La réponse est que la mise à jour du ''program counter'' démarre quand l'instruction précédente a terminée de s’exécuter, plus précisément un cycle avant. C'est un cycle avant pour que l'instruction chargée soit disponible au prochain cycle pour le décodeur. Pour cela, le séquenceur doit déterminer quand l'instruction est terminée et prévenir le ''program counter'' au bon moment. Il faut donc une interaction entre séquenceur et circuit de chargement. Le circuit de chargement contient une entrée Enable, qui autorise la mise à jour du ''program counter''. Le séquenceur met à 1 cette entrée pour prévenir au ''program counter'' qu'il doit être incrémenté au cycle suivant ou lors du cycle courant. Cela permet de gérer simplement le cas des instructions multicycles. 

[[File:Commande de la mise à jour du program counter.png|centre|vignette|upright=2|Commande de la mise à jour du program counter.]]

Toute la difficulté est alors reportée dans le séquenceur, qui doit déterminer la durée d'une instruction. Pour gérer la mise à jour du ''program counter'', le séquenceur doit déterminer la durée d'une instruction. Cela est simple pour les instructions arithmétiques et logiques, qui ont un nombre de cycles fixe, toujours le même. Une fois l'instruction identifiée par le séquenceur, il connait son nombre de cycles et peut programmer un compteur interne au séquenceur, qui compte le nombre de cycles de l'instruction, et fournit le signal Enable au ''program counter''. Mais cette technique ne marche pas vraiment pour les accès mémoire, dont la durée n'est pas connue à l'avance, surtout sur les processeurs avec des mémoires caches. Pour cela, le séquenceur détermine quand l'instruction mémoire est finie et prévient le ''program counter'' quand c'est le cas.

Il existe quelques processeurs pour lesquels le temps de calcul dépend des opérandes de l'instruction. On peut par exemple avoir une division qui prend 10 cycles avec certaines opérandes, mais 40 cycles avec d'autres opérandes. Mais ces processeurs sont rares et cela est surtout valable pour les opérations de multiplication/division, guère plus. Le problème est alors le même qu'avec les accès mémoire et la solution est la même : l'ALU prévient le séquenceur quand le résultat est disponible.

==Les branchements et le ''program counter''==

Un branchement consiste juste à écrire l'adresse de destination dans le ''program counter''. L'implémentation des branchements demande d'extraire l'adresse de destination et d'altérer le ''program counter'' quand un branchement est détecté. Pour cela, le décodeur d'instruction détecte si l'instruction exécutée est un branchement ou non, et il en déduit où trouver l'adresse de destination.

L'adresse de destination se trouve à un endroit qui dépend du mode d'adressage du branchement. Pour rappel, on distingue quatre modes d'adressage pour les branchements : direct, indirect, relatif et implicite. Pour les branchements directs, l'adresse est intégrée dans l'instruction de branchement elle-même et est extraite par le séquenceur. Pour les branchements indirects, l'adresse de destination est dans le banc de registre. Pour les branchements relatifs, il faut ajouter un décalage au ''program counter'', décalage extrait de l'instruction par le séquenceur. Enfin, les instructions de retour de fonction lisent l'adresse de destination depuis la pile. L'implémentation de ces quatre types de branchements est très différente.

L'altération du ''program counter'' dépend de si le ''program counter'' est dans un compteur séparé ou s'il est dans le banc de registre. Nous avons vu plus haut qu'il y a quatre cas différents, mais nous n'allons voir que deux cas : celui où le ''program counter'' est dans le banc de registre et est incrémenté par l'unité de calcul, celui avec un ''program counter'' séparé avec son propre incrémenteur. Les deux autres cas ne sont utilisés que sur des architectures à accumulateur ou à pile spécifiques, que nous n'avons pas encore vu à ce stade du cours et que nous verrons en temps voulu dans le chapitre sur ces architectures.

===L’implémentation des branchements avec un ''program counter'' intégré au banc de registres===

Le cas le plus simple est celui où le ''program counter'' est intégré au banc de registre, avec une incrémentation faite par l'unité de calcul. Charger une instruction revient alors à effectuer une instruction LOAD en adressage indirect, à deux différences près : le registre sélectionné est le ''program counter'', l’instruction est copiée dans le registre d'instruction et non dans le banc de registre. L'incrémentation du ''porgram counter'' est implémenté avec des micro-opérations qui agissent sur le chemin de données, au même titre que les branchements indirects, relatifs et directs.
* Les branchements indirects copient un registre dans le ''program counter'', ce qui revient simplement à faire une opération MOV entre deux registres, dont le ''program counter'' est la destination.
* L'opération inverse d'un branchement indirect, qui copie le ''program counter'' dans un registre général, est utile pour sauvegarder l'adresse de retour d'une fonction.
* Les branchements directs copient une adresse dans le ''program counter'', ce qui les rend équivalents à une opération MOV avec une constante immédiate, dont le ''program counter'' est la destination.
* Les branchements relatifs sont une opération arithmétique entre le ''program counter'' et un opérande en adressage immédiat.

En clair, à partir du moment où le chemin de données supporte les instructions MOV et l'addition, avec les modes d'adressage adéquat, il supporte les branchements. Aucune modification du chemin de données n'est nécessaire, le séquenceur gére le chargement d'une instruction avec les micro-instructions adéquates : une micro-opération ADD pour incrémenter le ''program counter'', une micro-opération LOAD pour le chargement de l'instruction.

Notons que sur certaines architectures, le ''program counter'' est adressable au même titre que les autres registres du banc de registre. Les instructions de branchement sont alors remplacées par des instructions MOV ou des instructions arithmétique équivalentes, comme décrit plus haut.

===L’implémentation des branchements avec un ''program counter'' séparé===

Étudions maintenant le cas où le ''program counter'' est dans un registre/compteur séparé. Rappelons que tout compteur digne de ce nom possède une entrée de réinitialisation, qui remet le compteur à zéro. De plus, on peut préciser à quelle valeur il doit être réinitialisé. Ici, la valeur à laquelle on veut réinitialiser le compteur n'est autre que l'adresse de destination du branchement. Implémenter un branchement est donc simple : l'entrée de réinitialisation est commandée par le circuit de détection des branchements, alors que la valeur de réinitialisation est envoyée sur l'entrée adéquate. En clair, nous partons du principe que le ''program counter'' est implémenté avec ce type de compteur :

[[File:Fonctionnement d'un compteur (décompteur), schématique.jpg|centre|vignette|upright=1.5|Fonctionnement d'un compteur (décompteur), schématique]]

Toute la difficulté est de présenter l'adresse de destination au ''program counter''. Pour les branchements directs, l'adresse de destination est fournie par le séquenceur. L'adresse de destination du branchement sort du séquenceur et est présentée au ''program counter'' sur l'entrée adéquate. Voici donc comment sont implémentés les branchements directs avec un ''program counter'' séparé du banc de registres. Le schéma ci-dessous marche peu importe que le ''program counter'' soit incrémenté par l'ALU ou par un additionneur dédié.

[[File:Unité de détection des branchements dans le décodeur.png|centre|vignette|upright=2|Unité de détection des branchements dans le décodeur]]

Les branchements relatifs sont ceux qui font sauter X instructions plus loin dans le programme. Leur implémentation demande d'ajouter une constante au ''program counter'', la constante étant fournie dans l’instruction. Là encore, deux solutions sont possibles : réutiliser l'ALU pour calculer l'adresse, ou utiliser un additionneur séparé. L'additionneur séparé peut être fusionné avec l'additionneur qui incrémente le ''program counter'' pour passer à l’instruction suivante.

[[File:Unité de chargement qui gère les branchements relatifs.png|centre|vignette|upright=2|Unité de chargement qui gère les branchements relatifs.]]

Pour les branchements indirects, il suffit de lire le registre voulu et d'envoyer le tout sur l'entrée adéquate du ''program counter''. Il faut alors rajouter un multiplexeur pour que l'entrée de réinitialisationr ecoive la bonne adresse de destination.

[[File:Unité de chargement qui gère les branchements directs.png|centre|vignette|upright=2|Unité de chargement qui gère les branchements directs et indirects.]]

Toute la difficulté de l'implémentation des branchements est de configurer les multiplexeurs, ce qui est réalisé par le séquenceur en fonction du mode d'adressage du branchement.

==Les optimisations du chargement des instructions==

Charger une instruction est techniquement une forme d'accès mémoire un peu particulier. En clair, charger une instruction prend au minimum un cycle d'horloge, et cela peut rapidement monter à 3-5 cycles, si ce n'est plus. L'exécution des instructions est alors fortement ralentit par la mémoire. Par exemple, imaginez que la mémoire mette 3 cycles d'horloges pour charger une instruction, alors qu'une instruction s’exécute en 1 cycle (si les opérandes sont dans les registres). La perte de performance liée au chargement des instructions est alors substantielle. Heureusement, il est possible de limiter la casse en utilisant des mémoires caches, ainsi que d'autres optimisations, que nous allons voir dans ce qui suit.

===Le tampon de préchargement===

La technique dite du '''préchargement''' est utilisée dans le cas où la mémoire a un temps d'accès important. Mais si la latence de la RAM est un problème, le débit ne l'est pas. Il est possible d'avoir une RAM lente, mais à fort débit. Par exemple, supposons que la mémoire puisse charger 4 instructions (de taille fixe) en 3 cycles. Le processeur peut alors charger 4 instructions en un seul accès mémoire, et les exécuter l'une après l'autre, une par cycle d'horloge. Les temps d'attente sont éliminés : le processeur peut décoder une nouvelle instruction à chaque cycle. Et quand la dernière instruction préchargée est exécutée, la mémoire est de nouveau libre, ce qui masque la latence des accès mémoire.

[[File:Tampon de préchargement d'instruction.png|vignette|Tampon de préchargement d'instruction]]

La seule contrainte est de mettre les instructions préchargées en attente. La solution pour cela est d'utiliser un registre d'instruction très large, capable de mémoriser plusieurs instructions à la fois. Ce registre est de plus connecté à un multiplexeur qui permet de sélectionner l'instruction adéquate dans ce registre. Ce multiplexeur est commandé par le ''program counter'' et quelques circuits annexes. Ce super-registre d'instruction est appelé un '''tampon de préchargement'''.

La méthode a une implémentation nettement plus simple avec des instructions de taille fixe, alignées en mémoire. La commande du multiplexeur de sélection de l'instruction est alors beaucoup plus simple : il suffit d'utiliser les bits de poids fort du ''program counter''. Par exemple, prenons le cas d'un registre d'instruction de 32 octets pour des instructions de 4 octets, soit 8 instructions. Le choix de l'instruction à sélectionner se fait en utilisant les 3 bits de poids faible du ''program counter''. 

Mais cette méthode ajoute de nouvelles contraintes d'alignement, similaires à celles vues dans le chapitre sur l'alignement et le boutisme, sauf que l'alignement porte ici sur des blocs d'instructions de même taille que le tampon de préchargement. Si on prend l'exemple d'un tampon de préchargement de 128 bits, les instructions devront être alignées par blocs de 128 bits. C'est à dire qu'idéalement, les fonctions et autres blocs de code isolés doivent commencer à des adresses multiples de 128, pour pouvoir charger un bloc d'instruction en une seule fois. Sans cela, les performances seront sous-optimales.

: Il arrive que le tampon de préchargement ait la même taille qu'une ligne de cache.

Lorsque l'on passe d'un bloc d'instruction à un autre, le tampon de préchargement est mis à jour. Par exemple, si on prend un tampon de préchargement de 4 instructions, on doit changer son contenu toutes les 4 instructions. La seule exception est l'exécution d'un branchement. En effet, lors d'un branchement, la destination du branchement n'est pas dans le tampon de préchargement et elle doit être chargée dedans (sauf si le branchement pointe vers une instruction très proche, ce qui est improbable). Pour cela, le tampon de préchargement est mis à jour précocement quand le processeur détecte un branchement.

Le même problème survient avec du code auto-modifiant. Un code auto-modifiant est un programme qui se modifie lui-même, en remplaçant certaines instructions par d'autres, en en retirant, en en ajoutant, lors de sa propre exécution. De tels programmes sont rares, mais la technique était utilisée dans quelques cas au tout début de l'informatique sur des ordinateurs rudimentaires. Ceux-ci avaient des modes d'adressages tellement limités que gérer des tableaux de taille variable demandait d'utiliser du code auto-modifiant pour écrire des boucles. Le problème survient quand des instructions sont modifiées immédiatement après avoir été préchargées. Les instructions dans le tampon de préchargement sont l'ancienne version, alors que la mémoire RAM contient les instructions modifiées. Gérer ce genre de cas demande de vider le tampon de préchargement si le cas arrive, mais ça ne vaut que très rarement le coup, aussi les ingénieurs ne s’embêtent pas à mettre ce correctif en place. Le code automodifiant est alors buggé.

===La ''prefetch input queue''===

La ''prefetch input queue'' est une optimisation matérielle qui a été utilisée sur les processeurs Intel assez ancien. Elle est apparue sur le 8086 et le 8088, des processeurs respectivement 8 et 16 bits. Elle été présente sur le 286 et le 386, mais était un peu améliorée. Elle est apparue sur ces processeurs à une époque où le processeur devenait plus rapide que la mémoire.

L'idée est là encore de précharger des instructions en avance. Sauf que cette fois-ci, on ne charge pas plusieurs instructions à la fois. Au contraire, les instructions sont préchargées séquentiellement, un octet à la fois. Le tampon de préchargement est remplacé par une mémoire FIFO appelée la '''''Prefetch Input Queue''''', terme abrévié en PIQ. Les instructions sont accumulées une par une dans la PIQ, elles en sortent une par une au fur et à mesure pour alimenter le décodeur d'instruction. La ''prefetch input queue'' est une sorte de cousine du tampon de préchargement. 

L'idée est que pendant que le processeur exécute une instruction, on précharge la suivante. Sans ''prefetch input queue'', le processeur chargeait une instruction, la décodait et l'exécutait, puis chargeait la suivante, et ainsi de suite. Avec la ''prefetch input queue'', pendant qu'une instruction est en cours de décodage/exécution, le processeur précharge l'instruction suivante. Si une instruction prend vraiment beaucoup de temps pour s'exécuter, le processeur peutr en profiter pour précharger l'instruction encore suivante, et ainsi de suite, jusqu'à une limite de 4/6 instructions (la limite dépend du processeur).

La ''prefetch input queue'' permet de précharger l'instruction suivante à condition qu'aucun autre accès mémoire n'ait lieu. Si l'instruction en cours d'exécution effectue des accès mémoire, ceux-ci sont prioritaires sur tout le reste, le préchargement de l'instruction suivante est alors mis en pause ou inhibé. Par contre, si la mémoire n'est pas utilisée par l'instruction en cours d'exécution, le processeur lit l'instruction suivante en RAM et la copie dans la ''prefetch input queue''.

Pour implémenter le préchargement d'instruction, le registre d'instruction est remplacé par une mémoire FIFO appelée la '''''Prefetch input queue'''''. On peut la voir comme un registre d'instruction sous stéroïde, capable de mémoriser plusieurs instructions consécutives. Les instructions sont chargées dans la ''Prefetch input queue'' et y attendent que le processeur les lise et les décode. Les instructions y sont conservées dans leur ordre d'arrivée, afin qu'elles soient exécutées dans le bon ordre, ce qui fait que la ''Prefetch input queue'' est une mémoire de type FIFO. L'étape de décodage pioche l'instruction à décoder dans la ''Prefetch input queue'', cette instruction étant par définition la plus ancienne, puis la retire de la file.

Le premier processeur commercial grand public à utiliser cette méthode était le 8086, un processeur d'Intel de jeu d'instruction x86. Il pouvait précharger à l'avance 6 octets d’instruction. L'Intel 8088 avait lui aussi une ''Prefetch input queue'', mais qui ne permattait que de précharger 4 instructions. La taille idéale de la FIFO dépend de nombreux paramètres. On pourrait croire que plus elle peut contenir d'instructions, mieux c'est, mais ce n'est pas le cas, pour des raisons que nous allons voir dans ce qui suit.

[[File:80186 arch.png|centre|vignette|700px|upright=2|Architecture du 8086, du 80186 et de ses variantes.]]

Les branchements posent des problèmes avec la ''Prefetch input queue'' : à cause d'eux, on peut charger à l'avance des instructions qui sont zappées par un branchement et ne sont pas censées être exécutées. Si un branchement est chargé, toutes les instructions préchargées après sont potentiellement invalides. Si le branchement est non-pris, les instructions chargées sont valides, elles sont censées s’exécuter. Mais si le branchement est pris, elles ont été chargées à tort et ne doivent pas s’exécuter. 

Pour éviter cela, la ''Prefetch input queue'' est vidée quand le processeur détecte un branchement. Cette détection ne peut se faire qu'une fois le branchement décodé : on ne sait pas si l'instruction est un branchement ou autre chose tant que le décodage n'a pas eu lieu, par définition. En clair, le décodeur invalide la ''Prefetch input queue'' quand il détecte un branchement. Les interruptions posent le même genre de problèmes. Il faut impérativement vider la ''Prefetch input queue'' quand une interruption survient, avant de la traiter.

Un autre défaut est que la ''Prefetch input queue'' se marie assez mal avec du code auto-modifiant. Un code auto-modifiant est un programme qui se modifie lui-même, en remplaçant certaines instructions par d'autres, en en retirant, en en ajoutant, lors de sa propre exécution. De tels programmes sont rares, mais la technique était utilisée dans quelques cas au tout début de l'informatique sur des ordinateurs rudimentaires. Ceux-ci avaient des modes d'adressages tellement limités que gérer des tableaux de taille variable demandait d'utiliser du code auto-modifiant pour écrire des boucles.

Le problème avec la ''Prefetch input queue'' survient quand des instructions sont modifiées immédiatement après avoir été préchargées. Les instructions dans la ''Prefetch input queue'' sont l'ancienne version, alors que la mémoire RAM contient les instructions modifiées. Gérer ce genre de cas est quelque peu complexe. Il faut en effet vider la ''Prefetch input queue'' si le cas arrive, ce qui demande d'identifier les écritures qui écrasent des instructions préchargées. C'est parfaitement possible, mais demande de transformer la ''Prefetch input queue'' en une mémoire hybride, à la fois mémoire associative et mémoire FIFO. Cela ne vaut que très rarement le coup, aussi les ingénieurs ne s’embêtent pas à mettre ce correctif en place, le code automodifiant est alors buggé.

===Le ''Zero-overhead looping''===

Nous avions vu dans le chapitre sur les instructions machines, qu'il existe des instructions qui permettent de grandement faciliter l'implémentation des boucles. Il s'agit de l'instruction REPEAT, utilisée sur certains processeurs de traitement de signal. Elle répète l'instruction suivante, voire une série d'instructions, un certain nombre de fois. Le nombre de répétitions est mémorisé dans un registre décrémenté à chaque itération de la boucle. Elle permet donc d'implémenter une boucle FOR facilement, sans recourir à des branchements ou des conditions.

Une technique en lien avec cette instruction permet de grandement améliorer les performances et la consommation d'énergie. L'idée est de mémoriser la boucle, les instructions à répéter, dans une petite mémoire cache située entre l'unité de chargement et le séquenceur. Le cache en question s'appelle un '''tampon de boucle''', ou encore un ''hardware loop buffer''. Grâce à lui, il n'y a pas besoin de charger les instructions à chaque fois qu'on les exécute, on les charge une bonne fois pour toute : c'est plus rapide. Bien sûr, il ne fonctionne que pour de petites boucles, mais il en est de même avec l'instruction REPEAT.

&lt;noinclude&gt;
{{NavChapitre | book=Fonctionnement d'un ordinateur
           | prev=Le chemin de données
           | prevText=Le chemin de données
           | next=L'unité de contrôle
           | nextText=L'unité de contrôle
}}
&lt;/noinclude&gt;</text>
      <sha1>ch0joxm7ppqk23jk2crzi01sbt6nozj</sha1>
    </revision>
    <revision>
      <id>744063</id>
      <parentid>744062</parentid>
      <timestamp>2025-06-03T18:51:39Z</timestamp>
      <contributor>
        <username>Mewtow</username>
        <id>31375</id>
      </contributor>
      <minor />
      <comment>/* La prefetch input queue */</comment>
      <origin>744063</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="39617" sha1="rg33t8sc0vpy6t2r62t5ipkntsiwgoj" xml:space="preserve">L'unité de contrôle s'occupe du chargement des instructions et de leur interprétation, leur décodage. Elle contient deux circuits : l''''unité de chargement''' qui charge l'instruction depuis la mémoire, et le '''séquenceur''' qui commande le chemin de données. Les deux circuits sont séparés, mais ils communiquent entre eux, notamment pour gérer les branchements. Dans ce chapitre, nous allons nous intéresser au chargement d'une instruction depuis la RAM/ROM, nous verrons l'étape de décodage de l'instruction au prochain chapitre.

==Le chargement d'une instruction==

[[File:Étape de chargement.png|vignette|upright=1|Étape de chargement.]]

L'étape de chargement (ou ''fetch'') doit faire deux choses : mettre à jour le ''program counter'' et lire l'instruction en mémoire RAM ou en ROM. Les deux étapes peuvent être faites en parallèle, dans des circuits séparés. Pendant que l'instruction est lue depuis la mémoire RAM/ROM, le ''program counter'' est incrémenté et/ou altéré par un branchement.

Pour lire l'instruction, on envoie le ''program counter'' sur le bus d'adresse et on récupère l'instruction sur le bus de données pour l'envoyer sur l'entrée du séquenceur. Et cela demande de connecter le séquenceur au bus mémoire, à travers l'interface mémoire. Et sur ce point, la situation est différente selon que l'on parler d'une architecture Harvard ou Von Neumann.

===Les interconnexions entre séquenceur et bus mémoire===

Sur les architectures Harvard, le séquenceur et le chemin de donnée utilisent des interfaces mémoire séparées. Le séquenceur est directement relié au bus mémoire de la ROM, alors que le chemin de données est connecté à la RAM.

[[File:Microarchitecture de l'interface mémoire d'une architecture Harvard.png|centre|vignette|upright=2|Microarchitecture de l'interface mémoire d'une architecture Harvard]]

Mais sur les architectures Von-Neumann et affiliées, le séquenceur et le chemin de donnée partagent la même interface mémoire. Et cela pose deux problèmes.

Le premier problème est que le bus mémoire doit être libéré une fois l'instruction chargée, pour un éventuel accès mémoire. Mais le séquenceur doit conserver une copie de l'instruction chargée, sans quoi il ne peut pas décoder l'instruction correctement. Par exemple, si l'instruction met plusieurs cycles à s'exécuter, le séquenceur doit conserver une copie de l'instruction durant ces plusieurs cycles. La solution à ce problème est un '''registre d'instruction''' situé juste avant le séquenceur, qui mémorise l'instruction chargée.

[[File:Registre d'instruction.png|centre|vignette|upright=2|Registre d'instruction.]]

Le second problème est de gérer le flot des instructions/données entre le bus mémoire, le chemin de données et le séquenceur. Le processeur doit connecter l'interface mémoire soit au séquenceur, soit au chemin de données et cela complique le réseau d'interconnexion interne au processeur.

Une première solution utilise un bus unique qui relie l'interface mémoire, le séquenceur et le chemin de données. Pour charger une instruction, le séquenceur copie le ''program counter'' sur le bus d'adresse, attend que l'instruction lue soit disponible sur le bus de données, puis la copie dans le registre d'instruction. Le bus mémoire est alors libre et peut être utilisé pour lire ou écrire des données, si le besoin s'en fait sentir.

Il faut noter que l'usage d'un bus unique a un impact sur l'organisation interne du chemin de données. Par exemple, le chapitre précédent nous a montré comment implémenter un chemin de données basique, avec des multiplexeurs et démultiplexeurs. Et bien ces chemins de données ne marchent pas vraiment avec un bus interne unique. Il est possible de les adapter, mais au prix d'une complexité largement supérieure. Un bus interne unique marche mieux quand le banc de registre est mono-port. C'est pourquoi il a été utilisé sur d'anciennes architectures appelées des architectures à accumulateur et à pile, que nous verrons dans quelques chapitres, qui utilisaient un banc de registre mono-port.

[[File:Microarchitecture de l'interface mémoire d'une architecture von neumann.png|centre|vignette|upright=2|Microarchitecture de l'interface mémoire d'une architecture von neumann]]

Une autre solution utilise deux bus interne séparés : un connecté au bus d'adresse, l'autre au bus de données. Le ''program counter'' est alors connecté au bus interne d'adresse, le séquenceur est relié au bus interne de données. Notons que la technique marche bien si le ''program counter'' est dans le banc de registre : les interconnexions utilisées pour gérer l'adressage indirect permettent d'envoyer le ''program counter'' sur le bus d'adresse sans ajout de circuit.

Le tout peut être amélioré en remplaçant les deux bus par des multiplexeurs et démultiplexeurs. Le bus d'adresse est précédé par un multiplexeur, qui permet de faire le choix entre ''Program Counter'', adresse venant du chemin de données, ou adresse provenant du séquenceur (adressage absolu). De même, le bus de données est suivi par un démultiplexeur qui envoie la donnée/instruction lue soit au registre d'instruction, soit au chemin de données. Le tout se marie très bien avec les chemins de donnée vu dans le chapitre précédent. Au passage, il faut noter que cette solution nécessite un banc de registre multi-port.

[[File:Connexion du program counter sur les bus avec PC isolé.png|centre|vignette|upright=2|Connexion du program counter sur les bus avec PC isolé]]

===Le chargement des instructions de longueur variable===

Le chargement des instructions de longueur variable pose de nombreux problèmes. Le premier est que mettre à jour le ''program counter'' demande de connaitre la longueur de l'instruction chargée, pour l'ajouter au ''program counter''. Si la longueur d'une instruction est variable, on doit connaitre cette longueur d'une manière où d'une autre. La solution la plus simple indique la longueur de l'instruction dans une partie de l'opcode ou de la représentation en binaire de l'instruction. Mais les processeurs haute performance de nos PC utilisent d'autres solutions, qui n'encodent pas explicitement la taille de l'instruction.

Les processeurs récents utilisent un registre d'instruction de grande taille, capable de mémoriser l'instruction la plus longue du processeur. Par exemple, si un processeur supporte des instructions allant de 1 à 8 octets, comme les CPU x86, le registre d'instruction fera 8 octets. Le décodeur d'instruction vérifie à chaque cycle le contenu du registre d'instruction. Si une instruction est détectée dedans, son décodage commence, peu importe la taille de l'instruction. Une fois l'instruction exécutée, elle est retirée du registre d'instruction. Reste à alimenter le registre d'instruction, à charger des instructions dedans. Et pour cela deux solutions : soit on charge l'instruction en plusieurs fois, soit d'un seul coup.

La solution la plus simple charge les instructions par mots de 8, 16, 32, 64 bits. Ils sont accumulés dans le registre d'instruction jusqu'à détecter une instruction complète. La technique marche nettement mieux si les instructions sont très longues. Par exemple, les CPU x86 ont des instructions qui vont de 1 à 15 octets, ce qui fait qu'ils utilisent cette technique. Précisément, elle marche si les instructions les plus longues sont plus grandes que le bus mémoire.

Une autre solution charge un bloc de mots mémoire aussi grand que la plus grande instruction. Par exemple, si le processeur gère des instructions allant de 1 à 4 octets, il charge 4 octets d'un seul coup dans le registre d'instruction. Il va de soit que cette solution ne marche que si les instructions du processeur sont assez courtes, au plus aussi courtes que le bus mémoire. Ainsi, on est sûr de charger obligatoirement au moins une instruction complète, et peut-être même plusieurs. Le contenu du registre d'instruction est alors découpé en instructions au fil de l'eau. 

Utiliser un registre d'instruction large pose problème avec des instructions à cheval entre deux blocs. Il se peut qu'on n'ait pas une instruction complète lorsque l'on arrive à la fin du bloc, mais seulement un morceau. Le problème se manifeste peu importe que l'instruction soit chargée d'un seul coup ou bien en plusieurs fois.

[[File:Instructions non alignées.png|centre|vignette|upright=2|Instructions non alignées.]]

Dans ce cas, on doit décaler le morceau de bloc pour le mettre au bon endroit (au début du registre d'instruction), et charger le prochain bloc juste à côté. On a donc besoin d'un circuit qui décale tous les bits du registre d'instruction, couplé à un circuit qui décide où placer dans le registre d'instruction ce qui a été chargé, avec quelques circuits autour pour configurer les deux circuits précédents.

[[File:Décaleur d’instruction.png|centre|vignette|upright=2|Décaleur d’instruction.]]

Une autre solution se passe de registre d'instruction en utilisant à la place l'état interne du séquenceur. Là encore, elle charge l'instruction morceau par morceau, typiquement par blocs de 8, 16 ou 32 bits. Les morceaux ne sont pas accumulés dans le registre d'instruction, la solution utilise à la place l'état interne du séquenceur. Les mots mémoire de l'instruction sont chargés à chaque cycle, faisant passer le séquenceur d'un état interne à un autre à chaque mot mémoire. Tant qu'il n'a pas reçu tous les mots mémoire de l'instruction, chaque mot mémoire non terminal le fera passer d'un état interne à un autre, chaque état interne encodant les mots mémoire chargés auparavant. S'il tombe sur le dernier mot mémoire d'une instruction, il rentre dans un état de décodage.

==L'incrémentation du ''program counter''==

À chaque chargement, le ''program counter'' est mis à jour afin de pointer sur la prochaine instruction à charger. Sur la quasi-totalité des processeurs, les instructions sont placées dans l'ordre d’exécution dans la RAM. En faisant ainsi, on peut mettre à jour le ''program counter'' en lui ajoutant la longueur de l'instruction courante. Déterminer la longueur de l'instruction est simple quand les instructions ont toutes la même taille, mais certains processeurs ont des instructions de taille variable, ce qui complique le calcul. Dans ce qui va suivre, nous allons supposer que les instructions sont de taille fixe, ce qui fait que le ''program counter'' est toujours incrémenté de la même valeur.

Il existe deux méthodes principales pour incrémenter le ''program counter'' : soit le ''program counter'' a son propre additionneur, soit le ''program counter'' est mis à jour par l'ALU. Pour ce qui est de l'organisation des registres, soit le ''program counter'' est un registre séparé des autres, soit il est regroupé avec d'autres registres dans un banc de registre. En tout, cela donne quatre organisations possibles.
* Un ''program counter'' séparé relié à un incrémenteur séparé.
* Un ''program counter'' séparé des autres registres, incrémenté par l'ALU.
* Un ''program counter'' intégré au banc de registre, relié à un incrémenteur séparé.
* Un ''program counter'' intégré au banc de registre, incrémenté par l'ALU.

[[File:Calcul du program counter.png|centre|vignette|upright=2|les différentes méthodes de calcul du program counter.]]

Les processeurs haute performance modernes utilisent tous la première méthode. Les autres méthodes étaient surtout utilisées sur les processeurs 8 ou 16 bits, elles sont encore utilisées sur quelques microcontrôleurs de faible puissance. Nous auront l'occasion de donner des exemples quand nous parlerons des processeurs 8 bits anciens, dans le chapitre sur les architectures à accumulateur et affiliées.

===Le ''program counter'' mis à jour par l'ALU===

Sur certains processeurs, le calcul de l'adresse de la prochaine instruction est effectué par l'ALU. L'avantage de cette méthode est qu'elle économise un incrémenteur dédié au ''program counter''. Ce qui explique que cette méthode était utilisée sur les processeurs assez anciens, à une époque où un additionneur pouvait facilement prendre 10 à 20% des transistors disponibles. Le désavantage principal est une augmentation de la complexité du séquenceur, qui doit gérer la mise à jour du ''program counter''. De plus, la mise à jour du ''program counter'' ne peut pas se faire en même temps qu'une opération arithmétique, ce qui réduit les performances.

Si on incrémente le ''program counter'' avec l'ALU, il est intéressant de le placer dans le banc de registres. Un désavantage est qu'on perd un registre. Par exemple, avec un banc de registre de 16 registres, on ne peut adresser que 15 registres généraux. De plus ce n'est pas l'idéal pour le décodage des instructions et pour le séquenceur. Si le processeur dispose de plusieurs bancs de registres, le ''program counter'' est généralement placé dans le banc de registre dédié aux adresses. Sinon, il est placé avec les nombres entiers/adresses.

D'anciens processeurs incrémentaient le ''program counter'' avec l'ALU, mais utilisaient bien un registre séparé pour le ''program counter''. Cette méthode est relativement simple à implémenter : il suffit de connecter/déconnecter le ''program counter'' du bus interne suivant les besoins. Le ''program counter'' est déconnecté pendant l’exécution d'une instruction, il est connecté au bus interne pour l'incrémenter. C'est le séquenceur qui gère le tout. L'avantage de cette séparation est qu'elle est plus facile à gérer pour le séquenceur. De plus, on gagne un registre général/entier dans le banc de registre.

===Le compteur programme===

Dans la quasi-totalité des processeurs modernes, le ''program counter'' est un vulgaire compteur comme on en a vu dans les chapitres sur les circuits, ce qui fait qu'il passe automatiquement d'une adresse à la suivante. Dans ce qui suit, nous allons appeler ce registre compteur : le '''compteur ordinal'''. L'usage d'un compteur simplifie fortement la conception du séquenceur. Le séquenceur n'a pas à gérer la mise à jour du ''program counter'', sauf en cas de branchements. De plus, il est possible d'incrémenter le ''program counter'' pendant que l'unité de calcul effectue une opération arithmétique, ce qui améliore grandement les performances. Le seul désavantage est qu'elle demande d'ajouter un incrémenteur dédié au ''program counter''.

Sur les processeurs très anciens, les instructions faisaient toutes un seul mot mémoire et le compteur ordinal était un circuit incrémenteur des plus basique. Sur les processeurs modernes, le compteur est incrémenté par pas de 4 si les instructions sont codées sur 4 octets, 8 si les instructions sont codées sur 8 octets, etc. Concrètement, le compteur est un circuit incrémenteur auquel on aurait retiré quelques bits de poids faible. Par exemple, si les instructions sont codées sur 4 octets, on coupe les 2 derniers bits du compteur. Si les instructions sont codées sur 8 octets, on coupe les 3 derniers bits du compteur. Et ainsi de suite.

Il a existé quelques processeurs pour lesquelles le ''program counter'' était non pas un compteur binaire classique, mais un ''linear feedback shift register''. L'avantage est que le circuit d'incrémentation utilisait bien moins de portes logiques, l'économie était substantielle. Mais un défaut est que des instructions consécutives dans le programme n'étaient pas consécutives en mémoire. Il existait cependant une table de correspondance pour dire : la première instruction est à telle adresse, la seconde à telle autre, etc. Un exemple de processeur de ce type est le TMS 1000 de Texas Instrument, un des premiers microcontrôleur 4 bits datant des années 70.

Une amélioration de la solution précédente utilise un circuit incrémenteur partagé entre le ''program counter'' et d'autres registres. L'incrémenteur est utilisé pour incrémenter le ''program counter'', mais aussi pour effectuer d'autres calculs d'adresse. Par exemple, sur les architectures avec une pile d'adresse de retour, il est possible de partager l'incrémenteur/décrémenteur avec le pointeur de pile ( la technique ne marche pas avec une pile d'appel). Un autre exemple est celui des processeurs qui gèrent automatiquement le rafraichissement mémoire, grâce à, un compteur intégré dans le processeur. Il est possible de partager l'incrémenteur du ''program counter'' avec le compteur de rafraichissement mémoire, qui mémorise la prochaine adresse mémoire à rafraichir. Nous avions déjà abordé ce genre de partage dans le chapitre sur le chemin de données, dans l'annexe sur le pointeur de pile, mais nous verrons d'autres exemples dans le chapitre sur les architectures hybride accumulateur-registre 8/16 bits.

===Quand est mis à jour le ''program counter'' ?===

Le ''program counter'' est mis à jour quand il faut charger une nouvelle instruction. Reste qu'il faut savoir quand le mettre à jour. Incrémenter le ''program counter'' à intervalle régulier, par exemple à chaque cycle d’horloge, fonctionne sur les processeurs où toutes les instructions mettent le même temps pour s’exécuter. Mais de tels processeurs sont très rares. Sur la quasi-totalité des processeurs, les instructions ont une durée d’exécution variable, elles ne prennent pas le même nombre de cycle d'horloge pour s’exécuter. Le temps d’exécution d'une instruction varie selon l'instruction, certaines sont plus longues que d'autres. Tout cela amène un problème : comment incrémenter le ''program counter'' avec des instructions avec des temps d’exécution variables ?

La réponse est que la mise à jour du ''program counter'' démarre quand l'instruction précédente a terminée de s’exécuter, plus précisément un cycle avant. C'est un cycle avant pour que l'instruction chargée soit disponible au prochain cycle pour le décodeur. Pour cela, le séquenceur doit déterminer quand l'instruction est terminée et prévenir le ''program counter'' au bon moment. Il faut donc une interaction entre séquenceur et circuit de chargement. Le circuit de chargement contient une entrée Enable, qui autorise la mise à jour du ''program counter''. Le séquenceur met à 1 cette entrée pour prévenir au ''program counter'' qu'il doit être incrémenté au cycle suivant ou lors du cycle courant. Cela permet de gérer simplement le cas des instructions multicycles. 

[[File:Commande de la mise à jour du program counter.png|centre|vignette|upright=2|Commande de la mise à jour du program counter.]]

Toute la difficulté est alors reportée dans le séquenceur, qui doit déterminer la durée d'une instruction. Pour gérer la mise à jour du ''program counter'', le séquenceur doit déterminer la durée d'une instruction. Cela est simple pour les instructions arithmétiques et logiques, qui ont un nombre de cycles fixe, toujours le même. Une fois l'instruction identifiée par le séquenceur, il connait son nombre de cycles et peut programmer un compteur interne au séquenceur, qui compte le nombre de cycles de l'instruction, et fournit le signal Enable au ''program counter''. Mais cette technique ne marche pas vraiment pour les accès mémoire, dont la durée n'est pas connue à l'avance, surtout sur les processeurs avec des mémoires caches. Pour cela, le séquenceur détermine quand l'instruction mémoire est finie et prévient le ''program counter'' quand c'est le cas.

Il existe quelques processeurs pour lesquels le temps de calcul dépend des opérandes de l'instruction. On peut par exemple avoir une division qui prend 10 cycles avec certaines opérandes, mais 40 cycles avec d'autres opérandes. Mais ces processeurs sont rares et cela est surtout valable pour les opérations de multiplication/division, guère plus. Le problème est alors le même qu'avec les accès mémoire et la solution est la même : l'ALU prévient le séquenceur quand le résultat est disponible.

==Les branchements et le ''program counter''==

Un branchement consiste juste à écrire l'adresse de destination dans le ''program counter''. L'implémentation des branchements demande d'extraire l'adresse de destination et d'altérer le ''program counter'' quand un branchement est détecté. Pour cela, le décodeur d'instruction détecte si l'instruction exécutée est un branchement ou non, et il en déduit où trouver l'adresse de destination.

L'adresse de destination se trouve à un endroit qui dépend du mode d'adressage du branchement. Pour rappel, on distingue quatre modes d'adressage pour les branchements : direct, indirect, relatif et implicite. Pour les branchements directs, l'adresse est intégrée dans l'instruction de branchement elle-même et est extraite par le séquenceur. Pour les branchements indirects, l'adresse de destination est dans le banc de registre. Pour les branchements relatifs, il faut ajouter un décalage au ''program counter'', décalage extrait de l'instruction par le séquenceur. Enfin, les instructions de retour de fonction lisent l'adresse de destination depuis la pile. L'implémentation de ces quatre types de branchements est très différente.

L'altération du ''program counter'' dépend de si le ''program counter'' est dans un compteur séparé ou s'il est dans le banc de registre. Nous avons vu plus haut qu'il y a quatre cas différents, mais nous n'allons voir que deux cas : celui où le ''program counter'' est dans le banc de registre et est incrémenté par l'unité de calcul, celui avec un ''program counter'' séparé avec son propre incrémenteur. Les deux autres cas ne sont utilisés que sur des architectures à accumulateur ou à pile spécifiques, que nous n'avons pas encore vu à ce stade du cours et que nous verrons en temps voulu dans le chapitre sur ces architectures.

===L’implémentation des branchements avec un ''program counter'' intégré au banc de registres===

Le cas le plus simple est celui où le ''program counter'' est intégré au banc de registre, avec une incrémentation faite par l'unité de calcul. Charger une instruction revient alors à effectuer une instruction LOAD en adressage indirect, à deux différences près : le registre sélectionné est le ''program counter'', l’instruction est copiée dans le registre d'instruction et non dans le banc de registre. L'incrémentation du ''porgram counter'' est implémenté avec des micro-opérations qui agissent sur le chemin de données, au même titre que les branchements indirects, relatifs et directs.
* Les branchements indirects copient un registre dans le ''program counter'', ce qui revient simplement à faire une opération MOV entre deux registres, dont le ''program counter'' est la destination.
* L'opération inverse d'un branchement indirect, qui copie le ''program counter'' dans un registre général, est utile pour sauvegarder l'adresse de retour d'une fonction.
* Les branchements directs copient une adresse dans le ''program counter'', ce qui les rend équivalents à une opération MOV avec une constante immédiate, dont le ''program counter'' est la destination.
* Les branchements relatifs sont une opération arithmétique entre le ''program counter'' et un opérande en adressage immédiat.

En clair, à partir du moment où le chemin de données supporte les instructions MOV et l'addition, avec les modes d'adressage adéquat, il supporte les branchements. Aucune modification du chemin de données n'est nécessaire, le séquenceur gére le chargement d'une instruction avec les micro-instructions adéquates : une micro-opération ADD pour incrémenter le ''program counter'', une micro-opération LOAD pour le chargement de l'instruction.

Notons que sur certaines architectures, le ''program counter'' est adressable au même titre que les autres registres du banc de registre. Les instructions de branchement sont alors remplacées par des instructions MOV ou des instructions arithmétique équivalentes, comme décrit plus haut.

===L’implémentation des branchements avec un ''program counter'' séparé===

Étudions maintenant le cas où le ''program counter'' est dans un registre/compteur séparé. Rappelons que tout compteur digne de ce nom possède une entrée de réinitialisation, qui remet le compteur à zéro. De plus, on peut préciser à quelle valeur il doit être réinitialisé. Ici, la valeur à laquelle on veut réinitialiser le compteur n'est autre que l'adresse de destination du branchement. Implémenter un branchement est donc simple : l'entrée de réinitialisation est commandée par le circuit de détection des branchements, alors que la valeur de réinitialisation est envoyée sur l'entrée adéquate. En clair, nous partons du principe que le ''program counter'' est implémenté avec ce type de compteur :

[[File:Fonctionnement d'un compteur (décompteur), schématique.jpg|centre|vignette|upright=1.5|Fonctionnement d'un compteur (décompteur), schématique]]

Toute la difficulté est de présenter l'adresse de destination au ''program counter''. Pour les branchements directs, l'adresse de destination est fournie par le séquenceur. L'adresse de destination du branchement sort du séquenceur et est présentée au ''program counter'' sur l'entrée adéquate. Voici donc comment sont implémentés les branchements directs avec un ''program counter'' séparé du banc de registres. Le schéma ci-dessous marche peu importe que le ''program counter'' soit incrémenté par l'ALU ou par un additionneur dédié.

[[File:Unité de détection des branchements dans le décodeur.png|centre|vignette|upright=2|Unité de détection des branchements dans le décodeur]]

Les branchements relatifs sont ceux qui font sauter X instructions plus loin dans le programme. Leur implémentation demande d'ajouter une constante au ''program counter'', la constante étant fournie dans l’instruction. Là encore, deux solutions sont possibles : réutiliser l'ALU pour calculer l'adresse, ou utiliser un additionneur séparé. L'additionneur séparé peut être fusionné avec l'additionneur qui incrémente le ''program counter'' pour passer à l’instruction suivante.

[[File:Unité de chargement qui gère les branchements relatifs.png|centre|vignette|upright=2|Unité de chargement qui gère les branchements relatifs.]]

Pour les branchements indirects, il suffit de lire le registre voulu et d'envoyer le tout sur l'entrée adéquate du ''program counter''. Il faut alors rajouter un multiplexeur pour que l'entrée de réinitialisationr ecoive la bonne adresse de destination.

[[File:Unité de chargement qui gère les branchements directs.png|centre|vignette|upright=2|Unité de chargement qui gère les branchements directs et indirects.]]

Toute la difficulté de l'implémentation des branchements est de configurer les multiplexeurs, ce qui est réalisé par le séquenceur en fonction du mode d'adressage du branchement.

==Les optimisations du chargement des instructions==

Charger une instruction est techniquement une forme d'accès mémoire un peu particulier. En clair, charger une instruction prend au minimum un cycle d'horloge, et cela peut rapidement monter à 3-5 cycles, si ce n'est plus. L'exécution des instructions est alors fortement ralentit par la mémoire. Par exemple, imaginez que la mémoire mette 3 cycles d'horloges pour charger une instruction, alors qu'une instruction s’exécute en 1 cycle (si les opérandes sont dans les registres). La perte de performance liée au chargement des instructions est alors substantielle. Heureusement, il est possible de limiter la casse en utilisant des mémoires caches, ainsi que d'autres optimisations, que nous allons voir dans ce qui suit.

===Le tampon de préchargement===

La technique dite du '''préchargement''' est utilisée dans le cas où la mémoire a un temps d'accès important. Mais si la latence de la RAM est un problème, le débit ne l'est pas. Il est possible d'avoir une RAM lente, mais à fort débit. Par exemple, supposons que la mémoire puisse charger 4 instructions (de taille fixe) en 3 cycles. Le processeur peut alors charger 4 instructions en un seul accès mémoire, et les exécuter l'une après l'autre, une par cycle d'horloge. Les temps d'attente sont éliminés : le processeur peut décoder une nouvelle instruction à chaque cycle. Et quand la dernière instruction préchargée est exécutée, la mémoire est de nouveau libre, ce qui masque la latence des accès mémoire.

[[File:Tampon de préchargement d'instruction.png|vignette|Tampon de préchargement d'instruction]]

La seule contrainte est de mettre les instructions préchargées en attente. La solution pour cela est d'utiliser un registre d'instruction très large, capable de mémoriser plusieurs instructions à la fois. Ce registre est de plus connecté à un multiplexeur qui permet de sélectionner l'instruction adéquate dans ce registre. Ce multiplexeur est commandé par le ''program counter'' et quelques circuits annexes. Ce super-registre d'instruction est appelé un '''tampon de préchargement'''.

La méthode a une implémentation nettement plus simple avec des instructions de taille fixe, alignées en mémoire. La commande du multiplexeur de sélection de l'instruction est alors beaucoup plus simple : il suffit d'utiliser les bits de poids fort du ''program counter''. Par exemple, prenons le cas d'un registre d'instruction de 32 octets pour des instructions de 4 octets, soit 8 instructions. Le choix de l'instruction à sélectionner se fait en utilisant les 3 bits de poids faible du ''program counter''. 

Mais cette méthode ajoute de nouvelles contraintes d'alignement, similaires à celles vues dans le chapitre sur l'alignement et le boutisme, sauf que l'alignement porte ici sur des blocs d'instructions de même taille que le tampon de préchargement. Si on prend l'exemple d'un tampon de préchargement de 128 bits, les instructions devront être alignées par blocs de 128 bits. C'est à dire qu'idéalement, les fonctions et autres blocs de code isolés doivent commencer à des adresses multiples de 128, pour pouvoir charger un bloc d'instruction en une seule fois. Sans cela, les performances seront sous-optimales.

: Il arrive que le tampon de préchargement ait la même taille qu'une ligne de cache.

Lorsque l'on passe d'un bloc d'instruction à un autre, le tampon de préchargement est mis à jour. Par exemple, si on prend un tampon de préchargement de 4 instructions, on doit changer son contenu toutes les 4 instructions. La seule exception est l'exécution d'un branchement. En effet, lors d'un branchement, la destination du branchement n'est pas dans le tampon de préchargement et elle doit être chargée dedans (sauf si le branchement pointe vers une instruction très proche, ce qui est improbable). Pour cela, le tampon de préchargement est mis à jour précocement quand le processeur détecte un branchement.

Le même problème survient avec du code auto-modifiant. Un code auto-modifiant est un programme qui se modifie lui-même, en remplaçant certaines instructions par d'autres, en en retirant, en en ajoutant, lors de sa propre exécution. De tels programmes sont rares, mais la technique était utilisée dans quelques cas au tout début de l'informatique sur des ordinateurs rudimentaires. Ceux-ci avaient des modes d'adressages tellement limités que gérer des tableaux de taille variable demandait d'utiliser du code auto-modifiant pour écrire des boucles. Le problème survient quand des instructions sont modifiées immédiatement après avoir été préchargées. Les instructions dans le tampon de préchargement sont l'ancienne version, alors que la mémoire RAM contient les instructions modifiées. Gérer ce genre de cas demande de vider le tampon de préchargement si le cas arrive, mais ça ne vaut que très rarement le coup, aussi les ingénieurs ne s’embêtent pas à mettre ce correctif en place. Le code automodifiant est alors buggé.

===La ''prefetch input queue''===

La ''prefetch input queue'' est une optimisation matérielle qui a été utilisée sur les processeurs Intel assez ancien. Elle est apparue sur le 8086 et le 8088, des processeurs respectivement 8 et 16 bits. Elle été présente sur le 286 et le 386, mais était un peu améliorée. Elle est apparue sur ces processeurs à une époque où le processeur devenait plus rapide que la mémoire.

L'idée est là encore de précharger des instructions en avance. Sauf que cette fois-ci, on ne charge pas plusieurs instructions à la fois. Au contraire, les instructions sont préchargées séquentiellement, un octet à la fois. Le tampon de préchargement est remplacé par une mémoire FIFO appelée la '''''Prefetch Input Queue''''', terme abrévié en PIQ. Les instructions sont accumulées une par une dans la PIQ, elles en sortent une par une au fur et à mesure pour alimenter le décodeur d'instruction. La ''prefetch input queue'' est une sorte de cousine du tampon de préchargement. 

L'idée est que pendant que le processeur exécute une instruction, on précharge la suivante. Sans ''prefetch input queue'', le processeur chargeait une instruction, la décodait et l'exécutait, puis chargeait la suivante, et ainsi de suite. Avec la ''prefetch input queue'', pendant qu'une instruction est en cours de décodage/exécution, le processeur précharge l'instruction suivante. Si une instruction prend vraiment beaucoup de temps pour s'exécuter, le processeur peutr en profiter pour précharger l'instruction encore suivante, et ainsi de suite, jusqu'à une limite de 4/6 instructions (la limite dépend du processeur).

Les instructions préchargées dans la ''Prefetch input queue'' y attendent que le processeur les lise et les décode. Les instructions préchargées sont conservées dans leur ordre d'arrivée, afin qu'elles soient exécutées dans le bon ordre, ce qui fait que la ''Prefetch input queue'' est une mémoire de type FIFO. L'étape de décodage pioche l'instruction à décoder dans la ''Prefetch input queue'', cette instruction étant par définition la plus ancienne, puis la retire de la file.

La ''prefetch input queue'' permet de précharger l'instruction suivante à condition qu'aucun autre accès mémoire n'ait lieu. Si l'instruction en cours d'exécution effectue des accès mémoire, ceux-ci sont prioritaires sur tout le reste, le préchargement de l'instruction suivante est alors mis en pause ou inhibé. Par contre, si la mémoire n'est pas utilisée par l'instruction en cours d'exécution, le processeur lit l'instruction suivante en RAM et la copie dans la ''prefetch input queue''.

Le premier processeur commercial grand public à utiliser cette méthode était le 8086, un processeur d'Intel de jeu d'instruction x86. Il pouvait précharger à l'avance 6 octets d’instruction. L'Intel 8088 avait lui aussi une ''Prefetch input queue'', mais qui ne permettait que de précharger 4 instructions. La taille idéale de la FIFO dépend de nombreux paramètres. On pourrait croire que plus elle peut contenir d'instructions, mieux c'est, mais ce n'est pas le cas, pour des raisons que nous allons voir dans ce qui suit.

[[File:80186 arch.png|centre|vignette|700px|upright=2|Architecture du 8086, du 80186 et de ses variantes.]]

Les branchements posent des problèmes avec la ''Prefetch input queue'' : à cause d'eux, on peut charger à l'avance des instructions qui sont zappées par un branchement et ne sont pas censées être exécutées. Si un branchement est chargé, toutes les instructions préchargées après sont potentiellement invalides. Si le branchement est non-pris, les instructions chargées sont valides, elles sont censées s’exécuter. Mais si le branchement est pris, elles ont été chargées à tort et ne doivent pas s’exécuter. 

Pour éviter cela, la ''Prefetch input queue'' est vidée quand le processeur détecte un branchement. Cette détection ne peut se faire qu'une fois le branchement décodé : on ne sait pas si l'instruction est un branchement ou autre chose tant que le décodage n'a pas eu lieu, par définition. En clair, le décodeur invalide la ''Prefetch input queue'' quand il détecte un branchement. Les interruptions posent le même genre de problèmes. Il faut impérativement vider la ''Prefetch input queue'' quand une interruption survient, avant de la traiter.

Un autre défaut est que la ''Prefetch input queue'' se marie assez mal avec du code auto-modifiant. Un code auto-modifiant est un programme qui se modifie lui-même, en remplaçant certaines instructions par d'autres, en en retirant, en en ajoutant, lors de sa propre exécution. De tels programmes sont rares, mais la technique était utilisée dans quelques cas au tout début de l'informatique sur des ordinateurs rudimentaires. Ceux-ci avaient des modes d'adressages tellement limités que gérer des tableaux de taille variable demandait d'utiliser du code auto-modifiant pour écrire des boucles.

Le problème avec la ''Prefetch input queue'' survient quand des instructions sont modifiées immédiatement après avoir été préchargées. Les instructions dans la ''Prefetch input queue'' sont l'ancienne version, alors que la mémoire RAM contient les instructions modifiées. Gérer ce genre de cas est quelque peu complexe. Il faut en effet vider la ''Prefetch input queue'' si le cas arrive, ce qui demande d'identifier les écritures qui écrasent des instructions préchargées. C'est parfaitement possible, mais demande de transformer la ''Prefetch input queue'' en une mémoire hybride, à la fois mémoire associative et mémoire FIFO. Cela ne vaut que très rarement le coup, aussi les ingénieurs ne s’embêtent pas à mettre ce correctif en place, le code automodifiant est alors buggé.

===Le ''Zero-overhead looping''===

Nous avions vu dans le chapitre sur les instructions machines, qu'il existe des instructions qui permettent de grandement faciliter l'implémentation des boucles. Il s'agit de l'instruction REPEAT, utilisée sur certains processeurs de traitement de signal. Elle répète l'instruction suivante, voire une série d'instructions, un certain nombre de fois. Le nombre de répétitions est mémorisé dans un registre décrémenté à chaque itération de la boucle. Elle permet donc d'implémenter une boucle FOR facilement, sans recourir à des branchements ou des conditions.

Une technique en lien avec cette instruction permet de grandement améliorer les performances et la consommation d'énergie. L'idée est de mémoriser la boucle, les instructions à répéter, dans une petite mémoire cache située entre l'unité de chargement et le séquenceur. Le cache en question s'appelle un '''tampon de boucle''', ou encore un ''hardware loop buffer''. Grâce à lui, il n'y a pas besoin de charger les instructions à chaque fois qu'on les exécute, on les charge une bonne fois pour toute : c'est plus rapide. Bien sûr, il ne fonctionne que pour de petites boucles, mais il en est de même avec l'instruction REPEAT.

&lt;noinclude&gt;
{{NavChapitre | book=Fonctionnement d'un ordinateur
           | prev=Le chemin de données
           | prevText=Le chemin de données
           | next=L'unité de contrôle
           | nextText=L'unité de contrôle
}}
&lt;/noinclude&gt;</text>
      <sha1>rg33t8sc0vpy6t2r62t5ipkntsiwgoj</sha1>
    </revision>
    <revision>
      <id>744068</id>
      <parentid>744063</parentid>
      <timestamp>2025-06-03T19:01:23Z</timestamp>
      <contributor>
        <username>Mewtow</username>
        <id>31375</id>
      </contributor>
      <minor />
      <comment>/* La prefetch input queue */</comment>
      <origin>744068</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="40663" sha1="bz8z4zwhl1miqzft5fufs2869ag6hsq" xml:space="preserve">L'unité de contrôle s'occupe du chargement des instructions et de leur interprétation, leur décodage. Elle contient deux circuits : l''''unité de chargement''' qui charge l'instruction depuis la mémoire, et le '''séquenceur''' qui commande le chemin de données. Les deux circuits sont séparés, mais ils communiquent entre eux, notamment pour gérer les branchements. Dans ce chapitre, nous allons nous intéresser au chargement d'une instruction depuis la RAM/ROM, nous verrons l'étape de décodage de l'instruction au prochain chapitre.

==Le chargement d'une instruction==

[[File:Étape de chargement.png|vignette|upright=1|Étape de chargement.]]

L'étape de chargement (ou ''fetch'') doit faire deux choses : mettre à jour le ''program counter'' et lire l'instruction en mémoire RAM ou en ROM. Les deux étapes peuvent être faites en parallèle, dans des circuits séparés. Pendant que l'instruction est lue depuis la mémoire RAM/ROM, le ''program counter'' est incrémenté et/ou altéré par un branchement.

Pour lire l'instruction, on envoie le ''program counter'' sur le bus d'adresse et on récupère l'instruction sur le bus de données pour l'envoyer sur l'entrée du séquenceur. Et cela demande de connecter le séquenceur au bus mémoire, à travers l'interface mémoire. Et sur ce point, la situation est différente selon que l'on parler d'une architecture Harvard ou Von Neumann.

===Les interconnexions entre séquenceur et bus mémoire===

Sur les architectures Harvard, le séquenceur et le chemin de donnée utilisent des interfaces mémoire séparées. Le séquenceur est directement relié au bus mémoire de la ROM, alors que le chemin de données est connecté à la RAM.

[[File:Microarchitecture de l'interface mémoire d'une architecture Harvard.png|centre|vignette|upright=2|Microarchitecture de l'interface mémoire d'une architecture Harvard]]

Mais sur les architectures Von-Neumann et affiliées, le séquenceur et le chemin de donnée partagent la même interface mémoire. Et cela pose deux problèmes.

Le premier problème est que le bus mémoire doit être libéré une fois l'instruction chargée, pour un éventuel accès mémoire. Mais le séquenceur doit conserver une copie de l'instruction chargée, sans quoi il ne peut pas décoder l'instruction correctement. Par exemple, si l'instruction met plusieurs cycles à s'exécuter, le séquenceur doit conserver une copie de l'instruction durant ces plusieurs cycles. La solution à ce problème est un '''registre d'instruction''' situé juste avant le séquenceur, qui mémorise l'instruction chargée.

[[File:Registre d'instruction.png|centre|vignette|upright=2|Registre d'instruction.]]

Le second problème est de gérer le flot des instructions/données entre le bus mémoire, le chemin de données et le séquenceur. Le processeur doit connecter l'interface mémoire soit au séquenceur, soit au chemin de données et cela complique le réseau d'interconnexion interne au processeur.

Une première solution utilise un bus unique qui relie l'interface mémoire, le séquenceur et le chemin de données. Pour charger une instruction, le séquenceur copie le ''program counter'' sur le bus d'adresse, attend que l'instruction lue soit disponible sur le bus de données, puis la copie dans le registre d'instruction. Le bus mémoire est alors libre et peut être utilisé pour lire ou écrire des données, si le besoin s'en fait sentir.

Il faut noter que l'usage d'un bus unique a un impact sur l'organisation interne du chemin de données. Par exemple, le chapitre précédent nous a montré comment implémenter un chemin de données basique, avec des multiplexeurs et démultiplexeurs. Et bien ces chemins de données ne marchent pas vraiment avec un bus interne unique. Il est possible de les adapter, mais au prix d'une complexité largement supérieure. Un bus interne unique marche mieux quand le banc de registre est mono-port. C'est pourquoi il a été utilisé sur d'anciennes architectures appelées des architectures à accumulateur et à pile, que nous verrons dans quelques chapitres, qui utilisaient un banc de registre mono-port.

[[File:Microarchitecture de l'interface mémoire d'une architecture von neumann.png|centre|vignette|upright=2|Microarchitecture de l'interface mémoire d'une architecture von neumann]]

Une autre solution utilise deux bus interne séparés : un connecté au bus d'adresse, l'autre au bus de données. Le ''program counter'' est alors connecté au bus interne d'adresse, le séquenceur est relié au bus interne de données. Notons que la technique marche bien si le ''program counter'' est dans le banc de registre : les interconnexions utilisées pour gérer l'adressage indirect permettent d'envoyer le ''program counter'' sur le bus d'adresse sans ajout de circuit.

Le tout peut être amélioré en remplaçant les deux bus par des multiplexeurs et démultiplexeurs. Le bus d'adresse est précédé par un multiplexeur, qui permet de faire le choix entre ''Program Counter'', adresse venant du chemin de données, ou adresse provenant du séquenceur (adressage absolu). De même, le bus de données est suivi par un démultiplexeur qui envoie la donnée/instruction lue soit au registre d'instruction, soit au chemin de données. Le tout se marie très bien avec les chemins de donnée vu dans le chapitre précédent. Au passage, il faut noter que cette solution nécessite un banc de registre multi-port.

[[File:Connexion du program counter sur les bus avec PC isolé.png|centre|vignette|upright=2|Connexion du program counter sur les bus avec PC isolé]]

===Le chargement des instructions de longueur variable===

Le chargement des instructions de longueur variable pose de nombreux problèmes. Le premier est que mettre à jour le ''program counter'' demande de connaitre la longueur de l'instruction chargée, pour l'ajouter au ''program counter''. Si la longueur d'une instruction est variable, on doit connaitre cette longueur d'une manière où d'une autre. La solution la plus simple indique la longueur de l'instruction dans une partie de l'opcode ou de la représentation en binaire de l'instruction. Mais les processeurs haute performance de nos PC utilisent d'autres solutions, qui n'encodent pas explicitement la taille de l'instruction.

Les processeurs récents utilisent un registre d'instruction de grande taille, capable de mémoriser l'instruction la plus longue du processeur. Par exemple, si un processeur supporte des instructions allant de 1 à 8 octets, comme les CPU x86, le registre d'instruction fera 8 octets. Le décodeur d'instruction vérifie à chaque cycle le contenu du registre d'instruction. Si une instruction est détectée dedans, son décodage commence, peu importe la taille de l'instruction. Une fois l'instruction exécutée, elle est retirée du registre d'instruction. Reste à alimenter le registre d'instruction, à charger des instructions dedans. Et pour cela deux solutions : soit on charge l'instruction en plusieurs fois, soit d'un seul coup.

La solution la plus simple charge les instructions par mots de 8, 16, 32, 64 bits. Ils sont accumulés dans le registre d'instruction jusqu'à détecter une instruction complète. La technique marche nettement mieux si les instructions sont très longues. Par exemple, les CPU x86 ont des instructions qui vont de 1 à 15 octets, ce qui fait qu'ils utilisent cette technique. Précisément, elle marche si les instructions les plus longues sont plus grandes que le bus mémoire.

Une autre solution charge un bloc de mots mémoire aussi grand que la plus grande instruction. Par exemple, si le processeur gère des instructions allant de 1 à 4 octets, il charge 4 octets d'un seul coup dans le registre d'instruction. Il va de soit que cette solution ne marche que si les instructions du processeur sont assez courtes, au plus aussi courtes que le bus mémoire. Ainsi, on est sûr de charger obligatoirement au moins une instruction complète, et peut-être même plusieurs. Le contenu du registre d'instruction est alors découpé en instructions au fil de l'eau. 

Utiliser un registre d'instruction large pose problème avec des instructions à cheval entre deux blocs. Il se peut qu'on n'ait pas une instruction complète lorsque l'on arrive à la fin du bloc, mais seulement un morceau. Le problème se manifeste peu importe que l'instruction soit chargée d'un seul coup ou bien en plusieurs fois.

[[File:Instructions non alignées.png|centre|vignette|upright=2|Instructions non alignées.]]

Dans ce cas, on doit décaler le morceau de bloc pour le mettre au bon endroit (au début du registre d'instruction), et charger le prochain bloc juste à côté. On a donc besoin d'un circuit qui décale tous les bits du registre d'instruction, couplé à un circuit qui décide où placer dans le registre d'instruction ce qui a été chargé, avec quelques circuits autour pour configurer les deux circuits précédents.

[[File:Décaleur d’instruction.png|centre|vignette|upright=2|Décaleur d’instruction.]]

Une autre solution se passe de registre d'instruction en utilisant à la place l'état interne du séquenceur. Là encore, elle charge l'instruction morceau par morceau, typiquement par blocs de 8, 16 ou 32 bits. Les morceaux ne sont pas accumulés dans le registre d'instruction, la solution utilise à la place l'état interne du séquenceur. Les mots mémoire de l'instruction sont chargés à chaque cycle, faisant passer le séquenceur d'un état interne à un autre à chaque mot mémoire. Tant qu'il n'a pas reçu tous les mots mémoire de l'instruction, chaque mot mémoire non terminal le fera passer d'un état interne à un autre, chaque état interne encodant les mots mémoire chargés auparavant. S'il tombe sur le dernier mot mémoire d'une instruction, il rentre dans un état de décodage.

==L'incrémentation du ''program counter''==

À chaque chargement, le ''program counter'' est mis à jour afin de pointer sur la prochaine instruction à charger. Sur la quasi-totalité des processeurs, les instructions sont placées dans l'ordre d’exécution dans la RAM. En faisant ainsi, on peut mettre à jour le ''program counter'' en lui ajoutant la longueur de l'instruction courante. Déterminer la longueur de l'instruction est simple quand les instructions ont toutes la même taille, mais certains processeurs ont des instructions de taille variable, ce qui complique le calcul. Dans ce qui va suivre, nous allons supposer que les instructions sont de taille fixe, ce qui fait que le ''program counter'' est toujours incrémenté de la même valeur.

Il existe deux méthodes principales pour incrémenter le ''program counter'' : soit le ''program counter'' a son propre additionneur, soit le ''program counter'' est mis à jour par l'ALU. Pour ce qui est de l'organisation des registres, soit le ''program counter'' est un registre séparé des autres, soit il est regroupé avec d'autres registres dans un banc de registre. En tout, cela donne quatre organisations possibles.
* Un ''program counter'' séparé relié à un incrémenteur séparé.
* Un ''program counter'' séparé des autres registres, incrémenté par l'ALU.
* Un ''program counter'' intégré au banc de registre, relié à un incrémenteur séparé.
* Un ''program counter'' intégré au banc de registre, incrémenté par l'ALU.

[[File:Calcul du program counter.png|centre|vignette|upright=2|les différentes méthodes de calcul du program counter.]]

Les processeurs haute performance modernes utilisent tous la première méthode. Les autres méthodes étaient surtout utilisées sur les processeurs 8 ou 16 bits, elles sont encore utilisées sur quelques microcontrôleurs de faible puissance. Nous auront l'occasion de donner des exemples quand nous parlerons des processeurs 8 bits anciens, dans le chapitre sur les architectures à accumulateur et affiliées.

===Le ''program counter'' mis à jour par l'ALU===

Sur certains processeurs, le calcul de l'adresse de la prochaine instruction est effectué par l'ALU. L'avantage de cette méthode est qu'elle économise un incrémenteur dédié au ''program counter''. Ce qui explique que cette méthode était utilisée sur les processeurs assez anciens, à une époque où un additionneur pouvait facilement prendre 10 à 20% des transistors disponibles. Le désavantage principal est une augmentation de la complexité du séquenceur, qui doit gérer la mise à jour du ''program counter''. De plus, la mise à jour du ''program counter'' ne peut pas se faire en même temps qu'une opération arithmétique, ce qui réduit les performances.

Si on incrémente le ''program counter'' avec l'ALU, il est intéressant de le placer dans le banc de registres. Un désavantage est qu'on perd un registre. Par exemple, avec un banc de registre de 16 registres, on ne peut adresser que 15 registres généraux. De plus ce n'est pas l'idéal pour le décodage des instructions et pour le séquenceur. Si le processeur dispose de plusieurs bancs de registres, le ''program counter'' est généralement placé dans le banc de registre dédié aux adresses. Sinon, il est placé avec les nombres entiers/adresses.

D'anciens processeurs incrémentaient le ''program counter'' avec l'ALU, mais utilisaient bien un registre séparé pour le ''program counter''. Cette méthode est relativement simple à implémenter : il suffit de connecter/déconnecter le ''program counter'' du bus interne suivant les besoins. Le ''program counter'' est déconnecté pendant l’exécution d'une instruction, il est connecté au bus interne pour l'incrémenter. C'est le séquenceur qui gère le tout. L'avantage de cette séparation est qu'elle est plus facile à gérer pour le séquenceur. De plus, on gagne un registre général/entier dans le banc de registre.

===Le compteur programme===

Dans la quasi-totalité des processeurs modernes, le ''program counter'' est un vulgaire compteur comme on en a vu dans les chapitres sur les circuits, ce qui fait qu'il passe automatiquement d'une adresse à la suivante. Dans ce qui suit, nous allons appeler ce registre compteur : le '''compteur ordinal'''. L'usage d'un compteur simplifie fortement la conception du séquenceur. Le séquenceur n'a pas à gérer la mise à jour du ''program counter'', sauf en cas de branchements. De plus, il est possible d'incrémenter le ''program counter'' pendant que l'unité de calcul effectue une opération arithmétique, ce qui améliore grandement les performances. Le seul désavantage est qu'elle demande d'ajouter un incrémenteur dédié au ''program counter''.

Sur les processeurs très anciens, les instructions faisaient toutes un seul mot mémoire et le compteur ordinal était un circuit incrémenteur des plus basique. Sur les processeurs modernes, le compteur est incrémenté par pas de 4 si les instructions sont codées sur 4 octets, 8 si les instructions sont codées sur 8 octets, etc. Concrètement, le compteur est un circuit incrémenteur auquel on aurait retiré quelques bits de poids faible. Par exemple, si les instructions sont codées sur 4 octets, on coupe les 2 derniers bits du compteur. Si les instructions sont codées sur 8 octets, on coupe les 3 derniers bits du compteur. Et ainsi de suite.

Il a existé quelques processeurs pour lesquelles le ''program counter'' était non pas un compteur binaire classique, mais un ''linear feedback shift register''. L'avantage est que le circuit d'incrémentation utilisait bien moins de portes logiques, l'économie était substantielle. Mais un défaut est que des instructions consécutives dans le programme n'étaient pas consécutives en mémoire. Il existait cependant une table de correspondance pour dire : la première instruction est à telle adresse, la seconde à telle autre, etc. Un exemple de processeur de ce type est le TMS 1000 de Texas Instrument, un des premiers microcontrôleur 4 bits datant des années 70.

Une amélioration de la solution précédente utilise un circuit incrémenteur partagé entre le ''program counter'' et d'autres registres. L'incrémenteur est utilisé pour incrémenter le ''program counter'', mais aussi pour effectuer d'autres calculs d'adresse. Par exemple, sur les architectures avec une pile d'adresse de retour, il est possible de partager l'incrémenteur/décrémenteur avec le pointeur de pile ( la technique ne marche pas avec une pile d'appel). Un autre exemple est celui des processeurs qui gèrent automatiquement le rafraichissement mémoire, grâce à, un compteur intégré dans le processeur. Il est possible de partager l'incrémenteur du ''program counter'' avec le compteur de rafraichissement mémoire, qui mémorise la prochaine adresse mémoire à rafraichir. Nous avions déjà abordé ce genre de partage dans le chapitre sur le chemin de données, dans l'annexe sur le pointeur de pile, mais nous verrons d'autres exemples dans le chapitre sur les architectures hybride accumulateur-registre 8/16 bits.

===Quand est mis à jour le ''program counter'' ?===

Le ''program counter'' est mis à jour quand il faut charger une nouvelle instruction. Reste qu'il faut savoir quand le mettre à jour. Incrémenter le ''program counter'' à intervalle régulier, par exemple à chaque cycle d’horloge, fonctionne sur les processeurs où toutes les instructions mettent le même temps pour s’exécuter. Mais de tels processeurs sont très rares. Sur la quasi-totalité des processeurs, les instructions ont une durée d’exécution variable, elles ne prennent pas le même nombre de cycle d'horloge pour s’exécuter. Le temps d’exécution d'une instruction varie selon l'instruction, certaines sont plus longues que d'autres. Tout cela amène un problème : comment incrémenter le ''program counter'' avec des instructions avec des temps d’exécution variables ?

La réponse est que la mise à jour du ''program counter'' démarre quand l'instruction précédente a terminée de s’exécuter, plus précisément un cycle avant. C'est un cycle avant pour que l'instruction chargée soit disponible au prochain cycle pour le décodeur. Pour cela, le séquenceur doit déterminer quand l'instruction est terminée et prévenir le ''program counter'' au bon moment. Il faut donc une interaction entre séquenceur et circuit de chargement. Le circuit de chargement contient une entrée Enable, qui autorise la mise à jour du ''program counter''. Le séquenceur met à 1 cette entrée pour prévenir au ''program counter'' qu'il doit être incrémenté au cycle suivant ou lors du cycle courant. Cela permet de gérer simplement le cas des instructions multicycles. 

[[File:Commande de la mise à jour du program counter.png|centre|vignette|upright=2|Commande de la mise à jour du program counter.]]

Toute la difficulté est alors reportée dans le séquenceur, qui doit déterminer la durée d'une instruction. Pour gérer la mise à jour du ''program counter'', le séquenceur doit déterminer la durée d'une instruction. Cela est simple pour les instructions arithmétiques et logiques, qui ont un nombre de cycles fixe, toujours le même. Une fois l'instruction identifiée par le séquenceur, il connait son nombre de cycles et peut programmer un compteur interne au séquenceur, qui compte le nombre de cycles de l'instruction, et fournit le signal Enable au ''program counter''. Mais cette technique ne marche pas vraiment pour les accès mémoire, dont la durée n'est pas connue à l'avance, surtout sur les processeurs avec des mémoires caches. Pour cela, le séquenceur détermine quand l'instruction mémoire est finie et prévient le ''program counter'' quand c'est le cas.

Il existe quelques processeurs pour lesquels le temps de calcul dépend des opérandes de l'instruction. On peut par exemple avoir une division qui prend 10 cycles avec certaines opérandes, mais 40 cycles avec d'autres opérandes. Mais ces processeurs sont rares et cela est surtout valable pour les opérations de multiplication/division, guère plus. Le problème est alors le même qu'avec les accès mémoire et la solution est la même : l'ALU prévient le séquenceur quand le résultat est disponible.

==Les branchements et le ''program counter''==

Un branchement consiste juste à écrire l'adresse de destination dans le ''program counter''. L'implémentation des branchements demande d'extraire l'adresse de destination et d'altérer le ''program counter'' quand un branchement est détecté. Pour cela, le décodeur d'instruction détecte si l'instruction exécutée est un branchement ou non, et il en déduit où trouver l'adresse de destination.

L'adresse de destination se trouve à un endroit qui dépend du mode d'adressage du branchement. Pour rappel, on distingue quatre modes d'adressage pour les branchements : direct, indirect, relatif et implicite. Pour les branchements directs, l'adresse est intégrée dans l'instruction de branchement elle-même et est extraite par le séquenceur. Pour les branchements indirects, l'adresse de destination est dans le banc de registre. Pour les branchements relatifs, il faut ajouter un décalage au ''program counter'', décalage extrait de l'instruction par le séquenceur. Enfin, les instructions de retour de fonction lisent l'adresse de destination depuis la pile. L'implémentation de ces quatre types de branchements est très différente.

L'altération du ''program counter'' dépend de si le ''program counter'' est dans un compteur séparé ou s'il est dans le banc de registre. Nous avons vu plus haut qu'il y a quatre cas différents, mais nous n'allons voir que deux cas : celui où le ''program counter'' est dans le banc de registre et est incrémenté par l'unité de calcul, celui avec un ''program counter'' séparé avec son propre incrémenteur. Les deux autres cas ne sont utilisés que sur des architectures à accumulateur ou à pile spécifiques, que nous n'avons pas encore vu à ce stade du cours et que nous verrons en temps voulu dans le chapitre sur ces architectures.

===L’implémentation des branchements avec un ''program counter'' intégré au banc de registres===

Le cas le plus simple est celui où le ''program counter'' est intégré au banc de registre, avec une incrémentation faite par l'unité de calcul. Charger une instruction revient alors à effectuer une instruction LOAD en adressage indirect, à deux différences près : le registre sélectionné est le ''program counter'', l’instruction est copiée dans le registre d'instruction et non dans le banc de registre. L'incrémentation du ''porgram counter'' est implémenté avec des micro-opérations qui agissent sur le chemin de données, au même titre que les branchements indirects, relatifs et directs.
* Les branchements indirects copient un registre dans le ''program counter'', ce qui revient simplement à faire une opération MOV entre deux registres, dont le ''program counter'' est la destination.
* L'opération inverse d'un branchement indirect, qui copie le ''program counter'' dans un registre général, est utile pour sauvegarder l'adresse de retour d'une fonction.
* Les branchements directs copient une adresse dans le ''program counter'', ce qui les rend équivalents à une opération MOV avec une constante immédiate, dont le ''program counter'' est la destination.
* Les branchements relatifs sont une opération arithmétique entre le ''program counter'' et un opérande en adressage immédiat.

En clair, à partir du moment où le chemin de données supporte les instructions MOV et l'addition, avec les modes d'adressage adéquat, il supporte les branchements. Aucune modification du chemin de données n'est nécessaire, le séquenceur gére le chargement d'une instruction avec les micro-instructions adéquates : une micro-opération ADD pour incrémenter le ''program counter'', une micro-opération LOAD pour le chargement de l'instruction.

Notons que sur certaines architectures, le ''program counter'' est adressable au même titre que les autres registres du banc de registre. Les instructions de branchement sont alors remplacées par des instructions MOV ou des instructions arithmétique équivalentes, comme décrit plus haut.

===L’implémentation des branchements avec un ''program counter'' séparé===

Étudions maintenant le cas où le ''program counter'' est dans un registre/compteur séparé. Rappelons que tout compteur digne de ce nom possède une entrée de réinitialisation, qui remet le compteur à zéro. De plus, on peut préciser à quelle valeur il doit être réinitialisé. Ici, la valeur à laquelle on veut réinitialiser le compteur n'est autre que l'adresse de destination du branchement. Implémenter un branchement est donc simple : l'entrée de réinitialisation est commandée par le circuit de détection des branchements, alors que la valeur de réinitialisation est envoyée sur l'entrée adéquate. En clair, nous partons du principe que le ''program counter'' est implémenté avec ce type de compteur :

[[File:Fonctionnement d'un compteur (décompteur), schématique.jpg|centre|vignette|upright=1.5|Fonctionnement d'un compteur (décompteur), schématique]]

Toute la difficulté est de présenter l'adresse de destination au ''program counter''. Pour les branchements directs, l'adresse de destination est fournie par le séquenceur. L'adresse de destination du branchement sort du séquenceur et est présentée au ''program counter'' sur l'entrée adéquate. Voici donc comment sont implémentés les branchements directs avec un ''program counter'' séparé du banc de registres. Le schéma ci-dessous marche peu importe que le ''program counter'' soit incrémenté par l'ALU ou par un additionneur dédié.

[[File:Unité de détection des branchements dans le décodeur.png|centre|vignette|upright=2|Unité de détection des branchements dans le décodeur]]

Les branchements relatifs sont ceux qui font sauter X instructions plus loin dans le programme. Leur implémentation demande d'ajouter une constante au ''program counter'', la constante étant fournie dans l’instruction. Là encore, deux solutions sont possibles : réutiliser l'ALU pour calculer l'adresse, ou utiliser un additionneur séparé. L'additionneur séparé peut être fusionné avec l'additionneur qui incrémente le ''program counter'' pour passer à l’instruction suivante.

[[File:Unité de chargement qui gère les branchements relatifs.png|centre|vignette|upright=2|Unité de chargement qui gère les branchements relatifs.]]

Pour les branchements indirects, il suffit de lire le registre voulu et d'envoyer le tout sur l'entrée adéquate du ''program counter''. Il faut alors rajouter un multiplexeur pour que l'entrée de réinitialisationr ecoive la bonne adresse de destination.

[[File:Unité de chargement qui gère les branchements directs.png|centre|vignette|upright=2|Unité de chargement qui gère les branchements directs et indirects.]]

Toute la difficulté de l'implémentation des branchements est de configurer les multiplexeurs, ce qui est réalisé par le séquenceur en fonction du mode d'adressage du branchement.

==Les optimisations du chargement des instructions==

Charger une instruction est techniquement une forme d'accès mémoire un peu particulier. En clair, charger une instruction prend au minimum un cycle d'horloge, et cela peut rapidement monter à 3-5 cycles, si ce n'est plus. L'exécution des instructions est alors fortement ralentit par la mémoire. Par exemple, imaginez que la mémoire mette 3 cycles d'horloges pour charger une instruction, alors qu'une instruction s’exécute en 1 cycle (si les opérandes sont dans les registres). La perte de performance liée au chargement des instructions est alors substantielle. Heureusement, il est possible de limiter la casse en utilisant des mémoires caches, ainsi que d'autres optimisations, que nous allons voir dans ce qui suit.

===Le tampon de préchargement===

La technique dite du '''préchargement''' est utilisée dans le cas où la mémoire a un temps d'accès important. Mais si la latence de la RAM est un problème, le débit ne l'est pas. Il est possible d'avoir une RAM lente, mais à fort débit. Par exemple, supposons que la mémoire puisse charger 4 instructions (de taille fixe) en 3 cycles. Le processeur peut alors charger 4 instructions en un seul accès mémoire, et les exécuter l'une après l'autre, une par cycle d'horloge. Les temps d'attente sont éliminés : le processeur peut décoder une nouvelle instruction à chaque cycle. Et quand la dernière instruction préchargée est exécutée, la mémoire est de nouveau libre, ce qui masque la latence des accès mémoire.

[[File:Tampon de préchargement d'instruction.png|vignette|Tampon de préchargement d'instruction]]

La seule contrainte est de mettre les instructions préchargées en attente. La solution pour cela est d'utiliser un registre d'instruction très large, capable de mémoriser plusieurs instructions à la fois. Ce registre est de plus connecté à un multiplexeur qui permet de sélectionner l'instruction adéquate dans ce registre. Ce multiplexeur est commandé par le ''program counter'' et quelques circuits annexes. Ce super-registre d'instruction est appelé un '''tampon de préchargement'''.

La méthode a une implémentation nettement plus simple avec des instructions de taille fixe, alignées en mémoire. La commande du multiplexeur de sélection de l'instruction est alors beaucoup plus simple : il suffit d'utiliser les bits de poids fort du ''program counter''. Par exemple, prenons le cas d'un registre d'instruction de 32 octets pour des instructions de 4 octets, soit 8 instructions. Le choix de l'instruction à sélectionner se fait en utilisant les 3 bits de poids faible du ''program counter''. 

Mais cette méthode ajoute de nouvelles contraintes d'alignement, similaires à celles vues dans le chapitre sur l'alignement et le boutisme, sauf que l'alignement porte ici sur des blocs d'instructions de même taille que le tampon de préchargement. Si on prend l'exemple d'un tampon de préchargement de 128 bits, les instructions devront être alignées par blocs de 128 bits. C'est à dire qu'idéalement, les fonctions et autres blocs de code isolés doivent commencer à des adresses multiples de 128, pour pouvoir charger un bloc d'instruction en une seule fois. Sans cela, les performances seront sous-optimales.

: Il arrive que le tampon de préchargement ait la même taille qu'une ligne de cache.

Lorsque l'on passe d'un bloc d'instruction à un autre, le tampon de préchargement est mis à jour. Par exemple, si on prend un tampon de préchargement de 4 instructions, on doit changer son contenu toutes les 4 instructions. La seule exception est l'exécution d'un branchement. En effet, lors d'un branchement, la destination du branchement n'est pas dans le tampon de préchargement et elle doit être chargée dedans (sauf si le branchement pointe vers une instruction très proche, ce qui est improbable). Pour cela, le tampon de préchargement est mis à jour précocement quand le processeur détecte un branchement.

Le même problème survient avec du code auto-modifiant. Un code auto-modifiant est un programme qui se modifie lui-même, en remplaçant certaines instructions par d'autres, en en retirant, en en ajoutant, lors de sa propre exécution. De tels programmes sont rares, mais la technique était utilisée dans quelques cas au tout début de l'informatique sur des ordinateurs rudimentaires. Ceux-ci avaient des modes d'adressages tellement limités que gérer des tableaux de taille variable demandait d'utiliser du code auto-modifiant pour écrire des boucles. Le problème survient quand des instructions sont modifiées immédiatement après avoir été préchargées. Les instructions dans le tampon de préchargement sont l'ancienne version, alors que la mémoire RAM contient les instructions modifiées. Gérer ce genre de cas demande de vider le tampon de préchargement si le cas arrive, mais ça ne vaut que très rarement le coup, aussi les ingénieurs ne s’embêtent pas à mettre ce correctif en place. Le code automodifiant est alors buggé.

===La ''prefetch input queue''===

La ''prefetch input queue'' est une optimisation matérielle qui a été utilisée sur les processeurs Intel assez ancien. Elle est apparue sur le 8086 et le 8088, des processeurs respectivement 8 et 16 bits. Elle été présente sur le 286 et le 386, mais était un peu améliorée. Elle est apparue sur ces processeurs à une époque où le processeur devenait plus rapide que la mémoire.

L'idée est là encore de précharger des instructions en avance. Sauf que cette fois-ci, on ne charge pas plusieurs instructions à la fois. Au contraire, les instructions sont préchargées séquentiellement, un octet à la fois. Le tampon de préchargement est remplacé par une mémoire FIFO appelée la '''''Prefetch Input Queue''''', terme abrévié en PIQ. Les instructions sont accumulées une par une dans la PIQ, elles en sortent une par une au fur et à mesure pour alimenter le décodeur d'instruction. La ''prefetch input queue'' est une sorte de cousine du tampon de préchargement. 

L'idée est que pendant que le processeur exécute une instruction, on précharge la suivante. Sans ''prefetch input queue'', le processeur chargeait une instruction, la décodait et l'exécutait, puis chargeait la suivante, et ainsi de suite. Avec la ''prefetch input queue'', pendant qu'une instruction est en cours de décodage/exécution, le processeur précharge l'instruction suivante. Si une instruction prend vraiment beaucoup de temps pour s'exécuter, le processeur peutr en profiter pour précharger l'instruction encore suivante, et ainsi de suite, jusqu'à une limite de 4/6 instructions (la limite dépend du processeur).

Les instructions préchargées dans la ''Prefetch input queue'' y attendent que le processeur les lise et les décode. Les instructions préchargées sont conservées dans leur ordre d'arrivée, afin qu'elles soient exécutées dans le bon ordre, ce qui fait que la ''Prefetch input queue'' est une mémoire de type FIFO. L'étape de décodage pioche l'instruction à décoder dans la ''Prefetch input queue'', cette instruction étant par définition la plus ancienne, puis la retire de la file.

Sur le 8086 et le 8088, la plupart des instructions faisaient deux octets, alors que la mémoire RAM ne permettait que de charger un octet à la fois. Le décodeur devait attendre que les deux octets d'une instruction soient disponibles dans la ''Prefetch input queue''. Pour cela, un circuit appelé le ''loader'' fournissait deux signaux au décodeur d'instruction : l'un indiquant que le premier octet est déjà chargé, l'autre indiquant que le second octet est disponible. Le décodeur, quant à lui, envoyait le signal ''Run Next Instruction'' pour lire une instruction :  elle était alors dépilée de la ''Prefetch input queue''.

Le décodeur d'instruction pouvait aussi envoyer un signal ''Next-to-last (NXT)'' un cycle en avance, un cyucle avant que l'instruction en cours ne termine. Le résultat est que le ''loader'' réagissait en préchargeant l'instruction suivante. En clair, ce signal permettait de précharger l'instruction suivante avec un cycle d'avance, si celle-ci n'était pas déjà dans la ''Prefetch input queue''.

La ''prefetch input queue'' permet de précharger l'instruction suivante à condition qu'aucun autre accès mémoire n'ait lieu. Si l'instruction en cours d'exécution effectue des accès mémoire, ceux-ci sont prioritaires sur tout le reste, le préchargement de l'instruction suivante est alors mis en pause ou inhibé. Par contre, si la mémoire n'est pas utilisée par l'instruction en cours d'exécution, le processeur lit l'instruction suivante en RAM et la copie dans la ''prefetch input queue''.

Le premier processeur commercial grand public à utiliser cette méthode était le 8086, un processeur d'Intel de jeu d'instruction x86. Il pouvait précharger à l'avance 6 octets d’instruction. L'Intel 8088 avait lui aussi une ''Prefetch input queue'', mais qui ne permettait que de précharger 4 instructions. La taille idéale de la FIFO dépend de nombreux paramètres. On pourrait croire que plus elle peut contenir d'instructions, mieux c'est, mais ce n'est pas le cas, pour des raisons que nous allons voir dans ce qui suit.

[[File:80186 arch.png|centre|vignette|700px|upright=2|Architecture du 8086, du 80186 et de ses variantes.]]

Les branchements posent des problèmes avec la ''Prefetch input queue'' : à cause d'eux, on peut charger à l'avance des instructions qui sont zappées par un branchement et ne sont pas censées être exécutées. Si un branchement est chargé, toutes les instructions préchargées après sont potentiellement invalides. Si le branchement est non-pris, les instructions chargées sont valides, elles sont censées s’exécuter. Mais si le branchement est pris, elles ont été chargées à tort et ne doivent pas s’exécuter. 

Pour éviter cela, la ''Prefetch input queue'' est vidée quand le processeur détecte un branchement. Cette détection ne peut se faire qu'une fois le branchement décodé : on ne sait pas si l'instruction est un branchement ou autre chose tant que le décodage n'a pas eu lieu, par définition. En clair, le décodeur invalide la ''Prefetch input queue'' quand il détecte un branchement. Les interruptions posent le même genre de problèmes. Il faut impérativement vider la ''Prefetch input queue'' quand une interruption survient, avant de la traiter.

Un autre défaut est que la ''Prefetch input queue'' se marie assez mal avec du code auto-modifiant. Un code auto-modifiant est un programme qui se modifie lui-même, en remplaçant certaines instructions par d'autres, en en retirant, en en ajoutant, lors de sa propre exécution. De tels programmes sont rares, mais la technique était utilisée dans quelques cas au tout début de l'informatique sur des ordinateurs rudimentaires. Ceux-ci avaient des modes d'adressages tellement limités que gérer des tableaux de taille variable demandait d'utiliser du code auto-modifiant pour écrire des boucles.

Le problème avec la ''Prefetch input queue'' survient quand des instructions sont modifiées immédiatement après avoir été préchargées. Les instructions dans la ''Prefetch input queue'' sont l'ancienne version, alors que la mémoire RAM contient les instructions modifiées. Gérer ce genre de cas est quelque peu complexe. Il faut en effet vider la ''Prefetch input queue'' si le cas arrive, ce qui demande d'identifier les écritures qui écrasent des instructions préchargées. C'est parfaitement possible, mais demande de transformer la ''Prefetch input queue'' en une mémoire hybride, à la fois mémoire associative et mémoire FIFO. Cela ne vaut que très rarement le coup, aussi les ingénieurs ne s’embêtent pas à mettre ce correctif en place, le code automodifiant est alors buggé.

===Le ''Zero-overhead looping''===

Nous avions vu dans le chapitre sur les instructions machines, qu'il existe des instructions qui permettent de grandement faciliter l'implémentation des boucles. Il s'agit de l'instruction REPEAT, utilisée sur certains processeurs de traitement de signal. Elle répète l'instruction suivante, voire une série d'instructions, un certain nombre de fois. Le nombre de répétitions est mémorisé dans un registre décrémenté à chaque itération de la boucle. Elle permet donc d'implémenter une boucle FOR facilement, sans recourir à des branchements ou des conditions.

Une technique en lien avec cette instruction permet de grandement améliorer les performances et la consommation d'énergie. L'idée est de mémoriser la boucle, les instructions à répéter, dans une petite mémoire cache située entre l'unité de chargement et le séquenceur. Le cache en question s'appelle un '''tampon de boucle''', ou encore un ''hardware loop buffer''. Grâce à lui, il n'y a pas besoin de charger les instructions à chaque fois qu'on les exécute, on les charge une bonne fois pour toute : c'est plus rapide. Bien sûr, il ne fonctionne que pour de petites boucles, mais il en est de même avec l'instruction REPEAT.

&lt;noinclude&gt;
{{NavChapitre | book=Fonctionnement d'un ordinateur
           | prev=Le chemin de données
           | prevText=Le chemin de données
           | next=L'unité de contrôle
           | nextText=L'unité de contrôle
}}
&lt;/noinclude&gt;</text>
      <sha1>bz8z4zwhl1miqzft5fufs2869ag6hsq</sha1>
    </revision>
    <revision>
      <id>744069</id>
      <parentid>744068</parentid>
      <timestamp>2025-06-03T19:04:09Z</timestamp>
      <contributor>
        <username>Mewtow</username>
        <id>31375</id>
      </contributor>
      <minor />
      <comment>/* La prefetch input queue */</comment>
      <origin>744069</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="41147" sha1="qbcwwd91j8uy9n9sfrjwambv2rvttgs" xml:space="preserve">L'unité de contrôle s'occupe du chargement des instructions et de leur interprétation, leur décodage. Elle contient deux circuits : l''''unité de chargement''' qui charge l'instruction depuis la mémoire, et le '''séquenceur''' qui commande le chemin de données. Les deux circuits sont séparés, mais ils communiquent entre eux, notamment pour gérer les branchements. Dans ce chapitre, nous allons nous intéresser au chargement d'une instruction depuis la RAM/ROM, nous verrons l'étape de décodage de l'instruction au prochain chapitre.

==Le chargement d'une instruction==

[[File:Étape de chargement.png|vignette|upright=1|Étape de chargement.]]

L'étape de chargement (ou ''fetch'') doit faire deux choses : mettre à jour le ''program counter'' et lire l'instruction en mémoire RAM ou en ROM. Les deux étapes peuvent être faites en parallèle, dans des circuits séparés. Pendant que l'instruction est lue depuis la mémoire RAM/ROM, le ''program counter'' est incrémenté et/ou altéré par un branchement.

Pour lire l'instruction, on envoie le ''program counter'' sur le bus d'adresse et on récupère l'instruction sur le bus de données pour l'envoyer sur l'entrée du séquenceur. Et cela demande de connecter le séquenceur au bus mémoire, à travers l'interface mémoire. Et sur ce point, la situation est différente selon que l'on parler d'une architecture Harvard ou Von Neumann.

===Les interconnexions entre séquenceur et bus mémoire===

Sur les architectures Harvard, le séquenceur et le chemin de donnée utilisent des interfaces mémoire séparées. Le séquenceur est directement relié au bus mémoire de la ROM, alors que le chemin de données est connecté à la RAM.

[[File:Microarchitecture de l'interface mémoire d'une architecture Harvard.png|centre|vignette|upright=2|Microarchitecture de l'interface mémoire d'une architecture Harvard]]

Mais sur les architectures Von-Neumann et affiliées, le séquenceur et le chemin de donnée partagent la même interface mémoire. Et cela pose deux problèmes.

Le premier problème est que le bus mémoire doit être libéré une fois l'instruction chargée, pour un éventuel accès mémoire. Mais le séquenceur doit conserver une copie de l'instruction chargée, sans quoi il ne peut pas décoder l'instruction correctement. Par exemple, si l'instruction met plusieurs cycles à s'exécuter, le séquenceur doit conserver une copie de l'instruction durant ces plusieurs cycles. La solution à ce problème est un '''registre d'instruction''' situé juste avant le séquenceur, qui mémorise l'instruction chargée.

[[File:Registre d'instruction.png|centre|vignette|upright=2|Registre d'instruction.]]

Le second problème est de gérer le flot des instructions/données entre le bus mémoire, le chemin de données et le séquenceur. Le processeur doit connecter l'interface mémoire soit au séquenceur, soit au chemin de données et cela complique le réseau d'interconnexion interne au processeur.

Une première solution utilise un bus unique qui relie l'interface mémoire, le séquenceur et le chemin de données. Pour charger une instruction, le séquenceur copie le ''program counter'' sur le bus d'adresse, attend que l'instruction lue soit disponible sur le bus de données, puis la copie dans le registre d'instruction. Le bus mémoire est alors libre et peut être utilisé pour lire ou écrire des données, si le besoin s'en fait sentir.

Il faut noter que l'usage d'un bus unique a un impact sur l'organisation interne du chemin de données. Par exemple, le chapitre précédent nous a montré comment implémenter un chemin de données basique, avec des multiplexeurs et démultiplexeurs. Et bien ces chemins de données ne marchent pas vraiment avec un bus interne unique. Il est possible de les adapter, mais au prix d'une complexité largement supérieure. Un bus interne unique marche mieux quand le banc de registre est mono-port. C'est pourquoi il a été utilisé sur d'anciennes architectures appelées des architectures à accumulateur et à pile, que nous verrons dans quelques chapitres, qui utilisaient un banc de registre mono-port.

[[File:Microarchitecture de l'interface mémoire d'une architecture von neumann.png|centre|vignette|upright=2|Microarchitecture de l'interface mémoire d'une architecture von neumann]]

Une autre solution utilise deux bus interne séparés : un connecté au bus d'adresse, l'autre au bus de données. Le ''program counter'' est alors connecté au bus interne d'adresse, le séquenceur est relié au bus interne de données. Notons que la technique marche bien si le ''program counter'' est dans le banc de registre : les interconnexions utilisées pour gérer l'adressage indirect permettent d'envoyer le ''program counter'' sur le bus d'adresse sans ajout de circuit.

Le tout peut être amélioré en remplaçant les deux bus par des multiplexeurs et démultiplexeurs. Le bus d'adresse est précédé par un multiplexeur, qui permet de faire le choix entre ''Program Counter'', adresse venant du chemin de données, ou adresse provenant du séquenceur (adressage absolu). De même, le bus de données est suivi par un démultiplexeur qui envoie la donnée/instruction lue soit au registre d'instruction, soit au chemin de données. Le tout se marie très bien avec les chemins de donnée vu dans le chapitre précédent. Au passage, il faut noter que cette solution nécessite un banc de registre multi-port.

[[File:Connexion du program counter sur les bus avec PC isolé.png|centre|vignette|upright=2|Connexion du program counter sur les bus avec PC isolé]]

===Le chargement des instructions de longueur variable===

Le chargement des instructions de longueur variable pose de nombreux problèmes. Le premier est que mettre à jour le ''program counter'' demande de connaitre la longueur de l'instruction chargée, pour l'ajouter au ''program counter''. Si la longueur d'une instruction est variable, on doit connaitre cette longueur d'une manière où d'une autre. La solution la plus simple indique la longueur de l'instruction dans une partie de l'opcode ou de la représentation en binaire de l'instruction. Mais les processeurs haute performance de nos PC utilisent d'autres solutions, qui n'encodent pas explicitement la taille de l'instruction.

Les processeurs récents utilisent un registre d'instruction de grande taille, capable de mémoriser l'instruction la plus longue du processeur. Par exemple, si un processeur supporte des instructions allant de 1 à 8 octets, comme les CPU x86, le registre d'instruction fera 8 octets. Le décodeur d'instruction vérifie à chaque cycle le contenu du registre d'instruction. Si une instruction est détectée dedans, son décodage commence, peu importe la taille de l'instruction. Une fois l'instruction exécutée, elle est retirée du registre d'instruction. Reste à alimenter le registre d'instruction, à charger des instructions dedans. Et pour cela deux solutions : soit on charge l'instruction en plusieurs fois, soit d'un seul coup.

La solution la plus simple charge les instructions par mots de 8, 16, 32, 64 bits. Ils sont accumulés dans le registre d'instruction jusqu'à détecter une instruction complète. La technique marche nettement mieux si les instructions sont très longues. Par exemple, les CPU x86 ont des instructions qui vont de 1 à 15 octets, ce qui fait qu'ils utilisent cette technique. Précisément, elle marche si les instructions les plus longues sont plus grandes que le bus mémoire.

Une autre solution charge un bloc de mots mémoire aussi grand que la plus grande instruction. Par exemple, si le processeur gère des instructions allant de 1 à 4 octets, il charge 4 octets d'un seul coup dans le registre d'instruction. Il va de soit que cette solution ne marche que si les instructions du processeur sont assez courtes, au plus aussi courtes que le bus mémoire. Ainsi, on est sûr de charger obligatoirement au moins une instruction complète, et peut-être même plusieurs. Le contenu du registre d'instruction est alors découpé en instructions au fil de l'eau. 

Utiliser un registre d'instruction large pose problème avec des instructions à cheval entre deux blocs. Il se peut qu'on n'ait pas une instruction complète lorsque l'on arrive à la fin du bloc, mais seulement un morceau. Le problème se manifeste peu importe que l'instruction soit chargée d'un seul coup ou bien en plusieurs fois.

[[File:Instructions non alignées.png|centre|vignette|upright=2|Instructions non alignées.]]

Dans ce cas, on doit décaler le morceau de bloc pour le mettre au bon endroit (au début du registre d'instruction), et charger le prochain bloc juste à côté. On a donc besoin d'un circuit qui décale tous les bits du registre d'instruction, couplé à un circuit qui décide où placer dans le registre d'instruction ce qui a été chargé, avec quelques circuits autour pour configurer les deux circuits précédents.

[[File:Décaleur d’instruction.png|centre|vignette|upright=2|Décaleur d’instruction.]]

Une autre solution se passe de registre d'instruction en utilisant à la place l'état interne du séquenceur. Là encore, elle charge l'instruction morceau par morceau, typiquement par blocs de 8, 16 ou 32 bits. Les morceaux ne sont pas accumulés dans le registre d'instruction, la solution utilise à la place l'état interne du séquenceur. Les mots mémoire de l'instruction sont chargés à chaque cycle, faisant passer le séquenceur d'un état interne à un autre à chaque mot mémoire. Tant qu'il n'a pas reçu tous les mots mémoire de l'instruction, chaque mot mémoire non terminal le fera passer d'un état interne à un autre, chaque état interne encodant les mots mémoire chargés auparavant. S'il tombe sur le dernier mot mémoire d'une instruction, il rentre dans un état de décodage.

==L'incrémentation du ''program counter''==

À chaque chargement, le ''program counter'' est mis à jour afin de pointer sur la prochaine instruction à charger. Sur la quasi-totalité des processeurs, les instructions sont placées dans l'ordre d’exécution dans la RAM. En faisant ainsi, on peut mettre à jour le ''program counter'' en lui ajoutant la longueur de l'instruction courante. Déterminer la longueur de l'instruction est simple quand les instructions ont toutes la même taille, mais certains processeurs ont des instructions de taille variable, ce qui complique le calcul. Dans ce qui va suivre, nous allons supposer que les instructions sont de taille fixe, ce qui fait que le ''program counter'' est toujours incrémenté de la même valeur.

Il existe deux méthodes principales pour incrémenter le ''program counter'' : soit le ''program counter'' a son propre additionneur, soit le ''program counter'' est mis à jour par l'ALU. Pour ce qui est de l'organisation des registres, soit le ''program counter'' est un registre séparé des autres, soit il est regroupé avec d'autres registres dans un banc de registre. En tout, cela donne quatre organisations possibles.
* Un ''program counter'' séparé relié à un incrémenteur séparé.
* Un ''program counter'' séparé des autres registres, incrémenté par l'ALU.
* Un ''program counter'' intégré au banc de registre, relié à un incrémenteur séparé.
* Un ''program counter'' intégré au banc de registre, incrémenté par l'ALU.

[[File:Calcul du program counter.png|centre|vignette|upright=2|les différentes méthodes de calcul du program counter.]]

Les processeurs haute performance modernes utilisent tous la première méthode. Les autres méthodes étaient surtout utilisées sur les processeurs 8 ou 16 bits, elles sont encore utilisées sur quelques microcontrôleurs de faible puissance. Nous auront l'occasion de donner des exemples quand nous parlerons des processeurs 8 bits anciens, dans le chapitre sur les architectures à accumulateur et affiliées.

===Le ''program counter'' mis à jour par l'ALU===

Sur certains processeurs, le calcul de l'adresse de la prochaine instruction est effectué par l'ALU. L'avantage de cette méthode est qu'elle économise un incrémenteur dédié au ''program counter''. Ce qui explique que cette méthode était utilisée sur les processeurs assez anciens, à une époque où un additionneur pouvait facilement prendre 10 à 20% des transistors disponibles. Le désavantage principal est une augmentation de la complexité du séquenceur, qui doit gérer la mise à jour du ''program counter''. De plus, la mise à jour du ''program counter'' ne peut pas se faire en même temps qu'une opération arithmétique, ce qui réduit les performances.

Si on incrémente le ''program counter'' avec l'ALU, il est intéressant de le placer dans le banc de registres. Un désavantage est qu'on perd un registre. Par exemple, avec un banc de registre de 16 registres, on ne peut adresser que 15 registres généraux. De plus ce n'est pas l'idéal pour le décodage des instructions et pour le séquenceur. Si le processeur dispose de plusieurs bancs de registres, le ''program counter'' est généralement placé dans le banc de registre dédié aux adresses. Sinon, il est placé avec les nombres entiers/adresses.

D'anciens processeurs incrémentaient le ''program counter'' avec l'ALU, mais utilisaient bien un registre séparé pour le ''program counter''. Cette méthode est relativement simple à implémenter : il suffit de connecter/déconnecter le ''program counter'' du bus interne suivant les besoins. Le ''program counter'' est déconnecté pendant l’exécution d'une instruction, il est connecté au bus interne pour l'incrémenter. C'est le séquenceur qui gère le tout. L'avantage de cette séparation est qu'elle est plus facile à gérer pour le séquenceur. De plus, on gagne un registre général/entier dans le banc de registre.

===Le compteur programme===

Dans la quasi-totalité des processeurs modernes, le ''program counter'' est un vulgaire compteur comme on en a vu dans les chapitres sur les circuits, ce qui fait qu'il passe automatiquement d'une adresse à la suivante. Dans ce qui suit, nous allons appeler ce registre compteur : le '''compteur ordinal'''. L'usage d'un compteur simplifie fortement la conception du séquenceur. Le séquenceur n'a pas à gérer la mise à jour du ''program counter'', sauf en cas de branchements. De plus, il est possible d'incrémenter le ''program counter'' pendant que l'unité de calcul effectue une opération arithmétique, ce qui améliore grandement les performances. Le seul désavantage est qu'elle demande d'ajouter un incrémenteur dédié au ''program counter''.

Sur les processeurs très anciens, les instructions faisaient toutes un seul mot mémoire et le compteur ordinal était un circuit incrémenteur des plus basique. Sur les processeurs modernes, le compteur est incrémenté par pas de 4 si les instructions sont codées sur 4 octets, 8 si les instructions sont codées sur 8 octets, etc. Concrètement, le compteur est un circuit incrémenteur auquel on aurait retiré quelques bits de poids faible. Par exemple, si les instructions sont codées sur 4 octets, on coupe les 2 derniers bits du compteur. Si les instructions sont codées sur 8 octets, on coupe les 3 derniers bits du compteur. Et ainsi de suite.

Il a existé quelques processeurs pour lesquelles le ''program counter'' était non pas un compteur binaire classique, mais un ''linear feedback shift register''. L'avantage est que le circuit d'incrémentation utilisait bien moins de portes logiques, l'économie était substantielle. Mais un défaut est que des instructions consécutives dans le programme n'étaient pas consécutives en mémoire. Il existait cependant une table de correspondance pour dire : la première instruction est à telle adresse, la seconde à telle autre, etc. Un exemple de processeur de ce type est le TMS 1000 de Texas Instrument, un des premiers microcontrôleur 4 bits datant des années 70.

Une amélioration de la solution précédente utilise un circuit incrémenteur partagé entre le ''program counter'' et d'autres registres. L'incrémenteur est utilisé pour incrémenter le ''program counter'', mais aussi pour effectuer d'autres calculs d'adresse. Par exemple, sur les architectures avec une pile d'adresse de retour, il est possible de partager l'incrémenteur/décrémenteur avec le pointeur de pile ( la technique ne marche pas avec une pile d'appel). Un autre exemple est celui des processeurs qui gèrent automatiquement le rafraichissement mémoire, grâce à, un compteur intégré dans le processeur. Il est possible de partager l'incrémenteur du ''program counter'' avec le compteur de rafraichissement mémoire, qui mémorise la prochaine adresse mémoire à rafraichir. Nous avions déjà abordé ce genre de partage dans le chapitre sur le chemin de données, dans l'annexe sur le pointeur de pile, mais nous verrons d'autres exemples dans le chapitre sur les architectures hybride accumulateur-registre 8/16 bits.

===Quand est mis à jour le ''program counter'' ?===

Le ''program counter'' est mis à jour quand il faut charger une nouvelle instruction. Reste qu'il faut savoir quand le mettre à jour. Incrémenter le ''program counter'' à intervalle régulier, par exemple à chaque cycle d’horloge, fonctionne sur les processeurs où toutes les instructions mettent le même temps pour s’exécuter. Mais de tels processeurs sont très rares. Sur la quasi-totalité des processeurs, les instructions ont une durée d’exécution variable, elles ne prennent pas le même nombre de cycle d'horloge pour s’exécuter. Le temps d’exécution d'une instruction varie selon l'instruction, certaines sont plus longues que d'autres. Tout cela amène un problème : comment incrémenter le ''program counter'' avec des instructions avec des temps d’exécution variables ?

La réponse est que la mise à jour du ''program counter'' démarre quand l'instruction précédente a terminée de s’exécuter, plus précisément un cycle avant. C'est un cycle avant pour que l'instruction chargée soit disponible au prochain cycle pour le décodeur. Pour cela, le séquenceur doit déterminer quand l'instruction est terminée et prévenir le ''program counter'' au bon moment. Il faut donc une interaction entre séquenceur et circuit de chargement. Le circuit de chargement contient une entrée Enable, qui autorise la mise à jour du ''program counter''. Le séquenceur met à 1 cette entrée pour prévenir au ''program counter'' qu'il doit être incrémenté au cycle suivant ou lors du cycle courant. Cela permet de gérer simplement le cas des instructions multicycles. 

[[File:Commande de la mise à jour du program counter.png|centre|vignette|upright=2|Commande de la mise à jour du program counter.]]

Toute la difficulté est alors reportée dans le séquenceur, qui doit déterminer la durée d'une instruction. Pour gérer la mise à jour du ''program counter'', le séquenceur doit déterminer la durée d'une instruction. Cela est simple pour les instructions arithmétiques et logiques, qui ont un nombre de cycles fixe, toujours le même. Une fois l'instruction identifiée par le séquenceur, il connait son nombre de cycles et peut programmer un compteur interne au séquenceur, qui compte le nombre de cycles de l'instruction, et fournit le signal Enable au ''program counter''. Mais cette technique ne marche pas vraiment pour les accès mémoire, dont la durée n'est pas connue à l'avance, surtout sur les processeurs avec des mémoires caches. Pour cela, le séquenceur détermine quand l'instruction mémoire est finie et prévient le ''program counter'' quand c'est le cas.

Il existe quelques processeurs pour lesquels le temps de calcul dépend des opérandes de l'instruction. On peut par exemple avoir une division qui prend 10 cycles avec certaines opérandes, mais 40 cycles avec d'autres opérandes. Mais ces processeurs sont rares et cela est surtout valable pour les opérations de multiplication/division, guère plus. Le problème est alors le même qu'avec les accès mémoire et la solution est la même : l'ALU prévient le séquenceur quand le résultat est disponible.

==Les branchements et le ''program counter''==

Un branchement consiste juste à écrire l'adresse de destination dans le ''program counter''. L'implémentation des branchements demande d'extraire l'adresse de destination et d'altérer le ''program counter'' quand un branchement est détecté. Pour cela, le décodeur d'instruction détecte si l'instruction exécutée est un branchement ou non, et il en déduit où trouver l'adresse de destination.

L'adresse de destination se trouve à un endroit qui dépend du mode d'adressage du branchement. Pour rappel, on distingue quatre modes d'adressage pour les branchements : direct, indirect, relatif et implicite. Pour les branchements directs, l'adresse est intégrée dans l'instruction de branchement elle-même et est extraite par le séquenceur. Pour les branchements indirects, l'adresse de destination est dans le banc de registre. Pour les branchements relatifs, il faut ajouter un décalage au ''program counter'', décalage extrait de l'instruction par le séquenceur. Enfin, les instructions de retour de fonction lisent l'adresse de destination depuis la pile. L'implémentation de ces quatre types de branchements est très différente.

L'altération du ''program counter'' dépend de si le ''program counter'' est dans un compteur séparé ou s'il est dans le banc de registre. Nous avons vu plus haut qu'il y a quatre cas différents, mais nous n'allons voir que deux cas : celui où le ''program counter'' est dans le banc de registre et est incrémenté par l'unité de calcul, celui avec un ''program counter'' séparé avec son propre incrémenteur. Les deux autres cas ne sont utilisés que sur des architectures à accumulateur ou à pile spécifiques, que nous n'avons pas encore vu à ce stade du cours et que nous verrons en temps voulu dans le chapitre sur ces architectures.

===L’implémentation des branchements avec un ''program counter'' intégré au banc de registres===

Le cas le plus simple est celui où le ''program counter'' est intégré au banc de registre, avec une incrémentation faite par l'unité de calcul. Charger une instruction revient alors à effectuer une instruction LOAD en adressage indirect, à deux différences près : le registre sélectionné est le ''program counter'', l’instruction est copiée dans le registre d'instruction et non dans le banc de registre. L'incrémentation du ''porgram counter'' est implémenté avec des micro-opérations qui agissent sur le chemin de données, au même titre que les branchements indirects, relatifs et directs.
* Les branchements indirects copient un registre dans le ''program counter'', ce qui revient simplement à faire une opération MOV entre deux registres, dont le ''program counter'' est la destination.
* L'opération inverse d'un branchement indirect, qui copie le ''program counter'' dans un registre général, est utile pour sauvegarder l'adresse de retour d'une fonction.
* Les branchements directs copient une adresse dans le ''program counter'', ce qui les rend équivalents à une opération MOV avec une constante immédiate, dont le ''program counter'' est la destination.
* Les branchements relatifs sont une opération arithmétique entre le ''program counter'' et un opérande en adressage immédiat.

En clair, à partir du moment où le chemin de données supporte les instructions MOV et l'addition, avec les modes d'adressage adéquat, il supporte les branchements. Aucune modification du chemin de données n'est nécessaire, le séquenceur gére le chargement d'une instruction avec les micro-instructions adéquates : une micro-opération ADD pour incrémenter le ''program counter'', une micro-opération LOAD pour le chargement de l'instruction.

Notons que sur certaines architectures, le ''program counter'' est adressable au même titre que les autres registres du banc de registre. Les instructions de branchement sont alors remplacées par des instructions MOV ou des instructions arithmétique équivalentes, comme décrit plus haut.

===L’implémentation des branchements avec un ''program counter'' séparé===

Étudions maintenant le cas où le ''program counter'' est dans un registre/compteur séparé. Rappelons que tout compteur digne de ce nom possède une entrée de réinitialisation, qui remet le compteur à zéro. De plus, on peut préciser à quelle valeur il doit être réinitialisé. Ici, la valeur à laquelle on veut réinitialiser le compteur n'est autre que l'adresse de destination du branchement. Implémenter un branchement est donc simple : l'entrée de réinitialisation est commandée par le circuit de détection des branchements, alors que la valeur de réinitialisation est envoyée sur l'entrée adéquate. En clair, nous partons du principe que le ''program counter'' est implémenté avec ce type de compteur :

[[File:Fonctionnement d'un compteur (décompteur), schématique.jpg|centre|vignette|upright=1.5|Fonctionnement d'un compteur (décompteur), schématique]]

Toute la difficulté est de présenter l'adresse de destination au ''program counter''. Pour les branchements directs, l'adresse de destination est fournie par le séquenceur. L'adresse de destination du branchement sort du séquenceur et est présentée au ''program counter'' sur l'entrée adéquate. Voici donc comment sont implémentés les branchements directs avec un ''program counter'' séparé du banc de registres. Le schéma ci-dessous marche peu importe que le ''program counter'' soit incrémenté par l'ALU ou par un additionneur dédié.

[[File:Unité de détection des branchements dans le décodeur.png|centre|vignette|upright=2|Unité de détection des branchements dans le décodeur]]

Les branchements relatifs sont ceux qui font sauter X instructions plus loin dans le programme. Leur implémentation demande d'ajouter une constante au ''program counter'', la constante étant fournie dans l’instruction. Là encore, deux solutions sont possibles : réutiliser l'ALU pour calculer l'adresse, ou utiliser un additionneur séparé. L'additionneur séparé peut être fusionné avec l'additionneur qui incrémente le ''program counter'' pour passer à l’instruction suivante.

[[File:Unité de chargement qui gère les branchements relatifs.png|centre|vignette|upright=2|Unité de chargement qui gère les branchements relatifs.]]

Pour les branchements indirects, il suffit de lire le registre voulu et d'envoyer le tout sur l'entrée adéquate du ''program counter''. Il faut alors rajouter un multiplexeur pour que l'entrée de réinitialisationr ecoive la bonne adresse de destination.

[[File:Unité de chargement qui gère les branchements directs.png|centre|vignette|upright=2|Unité de chargement qui gère les branchements directs et indirects.]]

Toute la difficulté de l'implémentation des branchements est de configurer les multiplexeurs, ce qui est réalisé par le séquenceur en fonction du mode d'adressage du branchement.

==Les optimisations du chargement des instructions==

Charger une instruction est techniquement une forme d'accès mémoire un peu particulier. En clair, charger une instruction prend au minimum un cycle d'horloge, et cela peut rapidement monter à 3-5 cycles, si ce n'est plus. L'exécution des instructions est alors fortement ralentit par la mémoire. Par exemple, imaginez que la mémoire mette 3 cycles d'horloges pour charger une instruction, alors qu'une instruction s’exécute en 1 cycle (si les opérandes sont dans les registres). La perte de performance liée au chargement des instructions est alors substantielle. Heureusement, il est possible de limiter la casse en utilisant des mémoires caches, ainsi que d'autres optimisations, que nous allons voir dans ce qui suit.

===Le tampon de préchargement===

La technique dite du '''préchargement''' est utilisée dans le cas où la mémoire a un temps d'accès important. Mais si la latence de la RAM est un problème, le débit ne l'est pas. Il est possible d'avoir une RAM lente, mais à fort débit. Par exemple, supposons que la mémoire puisse charger 4 instructions (de taille fixe) en 3 cycles. Le processeur peut alors charger 4 instructions en un seul accès mémoire, et les exécuter l'une après l'autre, une par cycle d'horloge. Les temps d'attente sont éliminés : le processeur peut décoder une nouvelle instruction à chaque cycle. Et quand la dernière instruction préchargée est exécutée, la mémoire est de nouveau libre, ce qui masque la latence des accès mémoire.

[[File:Tampon de préchargement d'instruction.png|vignette|Tampon de préchargement d'instruction]]

La seule contrainte est de mettre les instructions préchargées en attente. La solution pour cela est d'utiliser un registre d'instruction très large, capable de mémoriser plusieurs instructions à la fois. Ce registre est de plus connecté à un multiplexeur qui permet de sélectionner l'instruction adéquate dans ce registre. Ce multiplexeur est commandé par le ''program counter'' et quelques circuits annexes. Ce super-registre d'instruction est appelé un '''tampon de préchargement'''.

La méthode a une implémentation nettement plus simple avec des instructions de taille fixe, alignées en mémoire. La commande du multiplexeur de sélection de l'instruction est alors beaucoup plus simple : il suffit d'utiliser les bits de poids fort du ''program counter''. Par exemple, prenons le cas d'un registre d'instruction de 32 octets pour des instructions de 4 octets, soit 8 instructions. Le choix de l'instruction à sélectionner se fait en utilisant les 3 bits de poids faible du ''program counter''. 

Mais cette méthode ajoute de nouvelles contraintes d'alignement, similaires à celles vues dans le chapitre sur l'alignement et le boutisme, sauf que l'alignement porte ici sur des blocs d'instructions de même taille que le tampon de préchargement. Si on prend l'exemple d'un tampon de préchargement de 128 bits, les instructions devront être alignées par blocs de 128 bits. C'est à dire qu'idéalement, les fonctions et autres blocs de code isolés doivent commencer à des adresses multiples de 128, pour pouvoir charger un bloc d'instruction en une seule fois. Sans cela, les performances seront sous-optimales.

: Il arrive que le tampon de préchargement ait la même taille qu'une ligne de cache.

Lorsque l'on passe d'un bloc d'instruction à un autre, le tampon de préchargement est mis à jour. Par exemple, si on prend un tampon de préchargement de 4 instructions, on doit changer son contenu toutes les 4 instructions. La seule exception est l'exécution d'un branchement. En effet, lors d'un branchement, la destination du branchement n'est pas dans le tampon de préchargement et elle doit être chargée dedans (sauf si le branchement pointe vers une instruction très proche, ce qui est improbable). Pour cela, le tampon de préchargement est mis à jour précocement quand le processeur détecte un branchement.

Le même problème survient avec du code auto-modifiant. Un code auto-modifiant est un programme qui se modifie lui-même, en remplaçant certaines instructions par d'autres, en en retirant, en en ajoutant, lors de sa propre exécution. De tels programmes sont rares, mais la technique était utilisée dans quelques cas au tout début de l'informatique sur des ordinateurs rudimentaires. Ceux-ci avaient des modes d'adressages tellement limités que gérer des tableaux de taille variable demandait d'utiliser du code auto-modifiant pour écrire des boucles. Le problème survient quand des instructions sont modifiées immédiatement après avoir été préchargées. Les instructions dans le tampon de préchargement sont l'ancienne version, alors que la mémoire RAM contient les instructions modifiées. Gérer ce genre de cas demande de vider le tampon de préchargement si le cas arrive, mais ça ne vaut que très rarement le coup, aussi les ingénieurs ne s’embêtent pas à mettre ce correctif en place. Le code automodifiant est alors buggé.

===La ''prefetch input queue''===

La ''prefetch input queue'' est une optimisation matérielle qui a été utilisée sur les processeurs Intel assez ancien. Elle est apparue sur le 8086 et le 8088, des processeurs respectivement 8 et 16 bits. Elle été présente sur le 286 et le 386, mais était un peu améliorée. Elle est apparue sur ces processeurs à une époque où le processeur devenait plus rapide que la mémoire.

L'idée est là encore de précharger des instructions en avance. Sauf que cette fois-ci, on ne charge pas plusieurs instructions à la fois. Au contraire, les instructions sont préchargées séquentiellement, un octet à la fois. Le tampon de préchargement est remplacé par une mémoire FIFO appelée la '''''Prefetch Input Queue''''', terme abrévié en PIQ. Les instructions sont accumulées une par une dans la PIQ, elles en sortent une par une au fur et à mesure pour alimenter le décodeur d'instruction. La ''prefetch input queue'' est une sorte de cousine du tampon de préchargement. 

L'idée est que pendant que le processeur exécute une instruction, on précharge la suivante. Sans ''prefetch input queue'', le processeur chargeait une instruction, la décodait et l'exécutait, puis chargeait la suivante, et ainsi de suite. Avec la ''prefetch input queue'', pendant qu'une instruction est en cours de décodage/exécution, le processeur précharge l'instruction suivante. Si une instruction prend vraiment beaucoup de temps pour s'exécuter, le processeur peutr en profiter pour précharger l'instruction encore suivante, et ainsi de suite, jusqu'à une limite de 4/6 instructions (la limite dépend du processeur).

Les instructions préchargées dans la ''Prefetch input queue'' y attendent que le processeur les lise et les décode. Les instructions préchargées sont conservées dans leur ordre d'arrivée, afin qu'elles soient exécutées dans le bon ordre, ce qui fait que la ''Prefetch input queue'' est une mémoire de type FIFO. L'étape de décodage pioche l'instruction à décoder dans la ''Prefetch input queue'', cette instruction étant par définition la plus ancienne, puis la retire de la file.

Sur le 8086 et le 8088, la plupart des instructions faisaient deux octets, alors que la mémoire RAM ne permettait que de charger un octet à la fois. Le décodeur devait attendre que les deux octets d'une instruction soient disponibles dans la ''Prefetch input queue''. Pour cela, un circuit appelé le ''loader'' fournissait deux signaux au décodeur d'instruction : l'un indiquant que le premier octet est déjà chargé, l'autre indiquant que le second octet est disponible. Le décodeur, quant à lui, envoyait le signal ''Run Next Instruction'' pour lire une instruction :  elle était alors dépilée de la ''Prefetch input queue''.

Le décodeur d'instruction pouvait aussi envoyer un signal ''Next-to-last (NXT)'' un cycle en avance, un cyucle avant que l'instruction en cours ne termine. Le résultat est que le ''loader'' réagissait en préchargeant l'instruction suivante. En clair, ce signal permettait de précharger l'instruction suivante avec un cycle d'avance, si celle-ci n'était pas déjà dans la ''Prefetch input queue''.

Il faut noter que les instructions x86 sont de longueur variables. Pour les gérer, le décodeur pouvait lire une instruction en plusieurs fois dans la ''Prefetch input queue''. Les deux premiers octets sont lus depuis la ''Prefetch input queue'', et sont alors décodés. Le décodeur détermine alors la taille de l'instruction. Si l'instruction fait exactement deux octets, elle est exécutée directement. Sinon, les octets manquants sont lus depuis la ''Prefetch input queue''.

La ''prefetch input queue'' permet de précharger l'instruction suivante à condition qu'aucun autre accès mémoire n'ait lieu. Si l'instruction en cours d'exécution effectue des accès mémoire, ceux-ci sont prioritaires sur tout le reste, le préchargement de l'instruction suivante est alors mis en pause ou inhibé. Par contre, si la mémoire n'est pas utilisée par l'instruction en cours d'exécution, le processeur lit l'instruction suivante en RAM et la copie dans la ''prefetch input queue''.

Le premier processeur commercial grand public à utiliser cette méthode était le 8086, un processeur d'Intel de jeu d'instruction x86. Il pouvait précharger à l'avance 6 octets d’instruction. L'Intel 8088 avait lui aussi une ''Prefetch input queue'', mais qui ne permettait que de précharger 4 instructions. La taille idéale de la FIFO dépend de nombreux paramètres. On pourrait croire que plus elle peut contenir d'instructions, mieux c'est, mais ce n'est pas le cas, pour des raisons que nous allons voir dans ce qui suit.

[[File:80186 arch.png|centre|vignette|700px|upright=2|Architecture du 8086, du 80186 et de ses variantes.]]

Les branchements posent des problèmes avec la ''Prefetch input queue'' : à cause d'eux, on peut charger à l'avance des instructions qui sont zappées par un branchement et ne sont pas censées être exécutées. Si un branchement est chargé, toutes les instructions préchargées après sont potentiellement invalides. Si le branchement est non-pris, les instructions chargées sont valides, elles sont censées s’exécuter. Mais si le branchement est pris, elles ont été chargées à tort et ne doivent pas s’exécuter. 

Pour éviter cela, la ''Prefetch input queue'' est vidée quand le processeur détecte un branchement. Cette détection ne peut se faire qu'une fois le branchement décodé : on ne sait pas si l'instruction est un branchement ou autre chose tant que le décodage n'a pas eu lieu, par définition. En clair, le décodeur invalide la ''Prefetch input queue'' quand il détecte un branchement. Les interruptions posent le même genre de problèmes. Il faut impérativement vider la ''Prefetch input queue'' quand une interruption survient, avant de la traiter.

Un autre défaut est que la ''Prefetch input queue'' se marie assez mal avec du code auto-modifiant. Un code auto-modifiant est un programme qui se modifie lui-même, en remplaçant certaines instructions par d'autres, en en retirant, en en ajoutant, lors de sa propre exécution. De tels programmes sont rares, mais la technique était utilisée dans quelques cas au tout début de l'informatique sur des ordinateurs rudimentaires. Ceux-ci avaient des modes d'adressages tellement limités que gérer des tableaux de taille variable demandait d'utiliser du code auto-modifiant pour écrire des boucles.

Le problème avec la ''Prefetch input queue'' survient quand des instructions sont modifiées immédiatement après avoir été préchargées. Les instructions dans la ''Prefetch input queue'' sont l'ancienne version, alors que la mémoire RAM contient les instructions modifiées. Gérer ce genre de cas est quelque peu complexe. Il faut en effet vider la ''Prefetch input queue'' si le cas arrive, ce qui demande d'identifier les écritures qui écrasent des instructions préchargées. C'est parfaitement possible, mais demande de transformer la ''Prefetch input queue'' en une mémoire hybride, à la fois mémoire associative et mémoire FIFO. Cela ne vaut que très rarement le coup, aussi les ingénieurs ne s’embêtent pas à mettre ce correctif en place, le code automodifiant est alors buggé.

===Le ''Zero-overhead looping''===

Nous avions vu dans le chapitre sur les instructions machines, qu'il existe des instructions qui permettent de grandement faciliter l'implémentation des boucles. Il s'agit de l'instruction REPEAT, utilisée sur certains processeurs de traitement de signal. Elle répète l'instruction suivante, voire une série d'instructions, un certain nombre de fois. Le nombre de répétitions est mémorisé dans un registre décrémenté à chaque itération de la boucle. Elle permet donc d'implémenter une boucle FOR facilement, sans recourir à des branchements ou des conditions.

Une technique en lien avec cette instruction permet de grandement améliorer les performances et la consommation d'énergie. L'idée est de mémoriser la boucle, les instructions à répéter, dans une petite mémoire cache située entre l'unité de chargement et le séquenceur. Le cache en question s'appelle un '''tampon de boucle''', ou encore un ''hardware loop buffer''. Grâce à lui, il n'y a pas besoin de charger les instructions à chaque fois qu'on les exécute, on les charge une bonne fois pour toute : c'est plus rapide. Bien sûr, il ne fonctionne que pour de petites boucles, mais il en est de même avec l'instruction REPEAT.

&lt;noinclude&gt;
{{NavChapitre | book=Fonctionnement d'un ordinateur
           | prev=Le chemin de données
           | prevText=Le chemin de données
           | next=L'unité de contrôle
           | nextText=L'unité de contrôle
}}
&lt;/noinclude&gt;</text>
      <sha1>qbcwwd91j8uy9n9sfrjwambv2rvttgs</sha1>
    </revision>
    <revision>
      <id>744070</id>
      <parentid>744069</parentid>
      <timestamp>2025-06-03T19:13:23Z</timestamp>
      <contributor>
        <username>Mewtow</username>
        <id>31375</id>
      </contributor>
      <minor />
      <comment>/* La prefetch input queue */</comment>
      <origin>744070</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="42545" sha1="p1h2hxtrwy3t8uqmrke8x0geosr75c2" xml:space="preserve">L'unité de contrôle s'occupe du chargement des instructions et de leur interprétation, leur décodage. Elle contient deux circuits : l''''unité de chargement''' qui charge l'instruction depuis la mémoire, et le '''séquenceur''' qui commande le chemin de données. Les deux circuits sont séparés, mais ils communiquent entre eux, notamment pour gérer les branchements. Dans ce chapitre, nous allons nous intéresser au chargement d'une instruction depuis la RAM/ROM, nous verrons l'étape de décodage de l'instruction au prochain chapitre.

==Le chargement d'une instruction==

[[File:Étape de chargement.png|vignette|upright=1|Étape de chargement.]]

L'étape de chargement (ou ''fetch'') doit faire deux choses : mettre à jour le ''program counter'' et lire l'instruction en mémoire RAM ou en ROM. Les deux étapes peuvent être faites en parallèle, dans des circuits séparés. Pendant que l'instruction est lue depuis la mémoire RAM/ROM, le ''program counter'' est incrémenté et/ou altéré par un branchement.

Pour lire l'instruction, on envoie le ''program counter'' sur le bus d'adresse et on récupère l'instruction sur le bus de données pour l'envoyer sur l'entrée du séquenceur. Et cela demande de connecter le séquenceur au bus mémoire, à travers l'interface mémoire. Et sur ce point, la situation est différente selon que l'on parler d'une architecture Harvard ou Von Neumann.

===Les interconnexions entre séquenceur et bus mémoire===

Sur les architectures Harvard, le séquenceur et le chemin de donnée utilisent des interfaces mémoire séparées. Le séquenceur est directement relié au bus mémoire de la ROM, alors que le chemin de données est connecté à la RAM.

[[File:Microarchitecture de l'interface mémoire d'une architecture Harvard.png|centre|vignette|upright=2|Microarchitecture de l'interface mémoire d'une architecture Harvard]]

Mais sur les architectures Von-Neumann et affiliées, le séquenceur et le chemin de donnée partagent la même interface mémoire. Et cela pose deux problèmes.

Le premier problème est que le bus mémoire doit être libéré une fois l'instruction chargée, pour un éventuel accès mémoire. Mais le séquenceur doit conserver une copie de l'instruction chargée, sans quoi il ne peut pas décoder l'instruction correctement. Par exemple, si l'instruction met plusieurs cycles à s'exécuter, le séquenceur doit conserver une copie de l'instruction durant ces plusieurs cycles. La solution à ce problème est un '''registre d'instruction''' situé juste avant le séquenceur, qui mémorise l'instruction chargée.

[[File:Registre d'instruction.png|centre|vignette|upright=2|Registre d'instruction.]]

Le second problème est de gérer le flot des instructions/données entre le bus mémoire, le chemin de données et le séquenceur. Le processeur doit connecter l'interface mémoire soit au séquenceur, soit au chemin de données et cela complique le réseau d'interconnexion interne au processeur.

Une première solution utilise un bus unique qui relie l'interface mémoire, le séquenceur et le chemin de données. Pour charger une instruction, le séquenceur copie le ''program counter'' sur le bus d'adresse, attend que l'instruction lue soit disponible sur le bus de données, puis la copie dans le registre d'instruction. Le bus mémoire est alors libre et peut être utilisé pour lire ou écrire des données, si le besoin s'en fait sentir.

Il faut noter que l'usage d'un bus unique a un impact sur l'organisation interne du chemin de données. Par exemple, le chapitre précédent nous a montré comment implémenter un chemin de données basique, avec des multiplexeurs et démultiplexeurs. Et bien ces chemins de données ne marchent pas vraiment avec un bus interne unique. Il est possible de les adapter, mais au prix d'une complexité largement supérieure. Un bus interne unique marche mieux quand le banc de registre est mono-port. C'est pourquoi il a été utilisé sur d'anciennes architectures appelées des architectures à accumulateur et à pile, que nous verrons dans quelques chapitres, qui utilisaient un banc de registre mono-port.

[[File:Microarchitecture de l'interface mémoire d'une architecture von neumann.png|centre|vignette|upright=2|Microarchitecture de l'interface mémoire d'une architecture von neumann]]

Une autre solution utilise deux bus interne séparés : un connecté au bus d'adresse, l'autre au bus de données. Le ''program counter'' est alors connecté au bus interne d'adresse, le séquenceur est relié au bus interne de données. Notons que la technique marche bien si le ''program counter'' est dans le banc de registre : les interconnexions utilisées pour gérer l'adressage indirect permettent d'envoyer le ''program counter'' sur le bus d'adresse sans ajout de circuit.

Le tout peut être amélioré en remplaçant les deux bus par des multiplexeurs et démultiplexeurs. Le bus d'adresse est précédé par un multiplexeur, qui permet de faire le choix entre ''Program Counter'', adresse venant du chemin de données, ou adresse provenant du séquenceur (adressage absolu). De même, le bus de données est suivi par un démultiplexeur qui envoie la donnée/instruction lue soit au registre d'instruction, soit au chemin de données. Le tout se marie très bien avec les chemins de donnée vu dans le chapitre précédent. Au passage, il faut noter que cette solution nécessite un banc de registre multi-port.

[[File:Connexion du program counter sur les bus avec PC isolé.png|centre|vignette|upright=2|Connexion du program counter sur les bus avec PC isolé]]

===Le chargement des instructions de longueur variable===

Le chargement des instructions de longueur variable pose de nombreux problèmes. Le premier est que mettre à jour le ''program counter'' demande de connaitre la longueur de l'instruction chargée, pour l'ajouter au ''program counter''. Si la longueur d'une instruction est variable, on doit connaitre cette longueur d'une manière où d'une autre. La solution la plus simple indique la longueur de l'instruction dans une partie de l'opcode ou de la représentation en binaire de l'instruction. Mais les processeurs haute performance de nos PC utilisent d'autres solutions, qui n'encodent pas explicitement la taille de l'instruction.

Les processeurs récents utilisent un registre d'instruction de grande taille, capable de mémoriser l'instruction la plus longue du processeur. Par exemple, si un processeur supporte des instructions allant de 1 à 8 octets, comme les CPU x86, le registre d'instruction fera 8 octets. Le décodeur d'instruction vérifie à chaque cycle le contenu du registre d'instruction. Si une instruction est détectée dedans, son décodage commence, peu importe la taille de l'instruction. Une fois l'instruction exécutée, elle est retirée du registre d'instruction. Reste à alimenter le registre d'instruction, à charger des instructions dedans. Et pour cela deux solutions : soit on charge l'instruction en plusieurs fois, soit d'un seul coup.

La solution la plus simple charge les instructions par mots de 8, 16, 32, 64 bits. Ils sont accumulés dans le registre d'instruction jusqu'à détecter une instruction complète. La technique marche nettement mieux si les instructions sont très longues. Par exemple, les CPU x86 ont des instructions qui vont de 1 à 15 octets, ce qui fait qu'ils utilisent cette technique. Précisément, elle marche si les instructions les plus longues sont plus grandes que le bus mémoire.

Une autre solution charge un bloc de mots mémoire aussi grand que la plus grande instruction. Par exemple, si le processeur gère des instructions allant de 1 à 4 octets, il charge 4 octets d'un seul coup dans le registre d'instruction. Il va de soit que cette solution ne marche que si les instructions du processeur sont assez courtes, au plus aussi courtes que le bus mémoire. Ainsi, on est sûr de charger obligatoirement au moins une instruction complète, et peut-être même plusieurs. Le contenu du registre d'instruction est alors découpé en instructions au fil de l'eau. 

Utiliser un registre d'instruction large pose problème avec des instructions à cheval entre deux blocs. Il se peut qu'on n'ait pas une instruction complète lorsque l'on arrive à la fin du bloc, mais seulement un morceau. Le problème se manifeste peu importe que l'instruction soit chargée d'un seul coup ou bien en plusieurs fois.

[[File:Instructions non alignées.png|centre|vignette|upright=2|Instructions non alignées.]]

Dans ce cas, on doit décaler le morceau de bloc pour le mettre au bon endroit (au début du registre d'instruction), et charger le prochain bloc juste à côté. On a donc besoin d'un circuit qui décale tous les bits du registre d'instruction, couplé à un circuit qui décide où placer dans le registre d'instruction ce qui a été chargé, avec quelques circuits autour pour configurer les deux circuits précédents.

[[File:Décaleur d’instruction.png|centre|vignette|upright=2|Décaleur d’instruction.]]

Une autre solution se passe de registre d'instruction en utilisant à la place l'état interne du séquenceur. Là encore, elle charge l'instruction morceau par morceau, typiquement par blocs de 8, 16 ou 32 bits. Les morceaux ne sont pas accumulés dans le registre d'instruction, la solution utilise à la place l'état interne du séquenceur. Les mots mémoire de l'instruction sont chargés à chaque cycle, faisant passer le séquenceur d'un état interne à un autre à chaque mot mémoire. Tant qu'il n'a pas reçu tous les mots mémoire de l'instruction, chaque mot mémoire non terminal le fera passer d'un état interne à un autre, chaque état interne encodant les mots mémoire chargés auparavant. S'il tombe sur le dernier mot mémoire d'une instruction, il rentre dans un état de décodage.

==L'incrémentation du ''program counter''==

À chaque chargement, le ''program counter'' est mis à jour afin de pointer sur la prochaine instruction à charger. Sur la quasi-totalité des processeurs, les instructions sont placées dans l'ordre d’exécution dans la RAM. En faisant ainsi, on peut mettre à jour le ''program counter'' en lui ajoutant la longueur de l'instruction courante. Déterminer la longueur de l'instruction est simple quand les instructions ont toutes la même taille, mais certains processeurs ont des instructions de taille variable, ce qui complique le calcul. Dans ce qui va suivre, nous allons supposer que les instructions sont de taille fixe, ce qui fait que le ''program counter'' est toujours incrémenté de la même valeur.

Il existe deux méthodes principales pour incrémenter le ''program counter'' : soit le ''program counter'' a son propre additionneur, soit le ''program counter'' est mis à jour par l'ALU. Pour ce qui est de l'organisation des registres, soit le ''program counter'' est un registre séparé des autres, soit il est regroupé avec d'autres registres dans un banc de registre. En tout, cela donne quatre organisations possibles.
* Un ''program counter'' séparé relié à un incrémenteur séparé.
* Un ''program counter'' séparé des autres registres, incrémenté par l'ALU.
* Un ''program counter'' intégré au banc de registre, relié à un incrémenteur séparé.
* Un ''program counter'' intégré au banc de registre, incrémenté par l'ALU.

[[File:Calcul du program counter.png|centre|vignette|upright=2|les différentes méthodes de calcul du program counter.]]

Les processeurs haute performance modernes utilisent tous la première méthode. Les autres méthodes étaient surtout utilisées sur les processeurs 8 ou 16 bits, elles sont encore utilisées sur quelques microcontrôleurs de faible puissance. Nous auront l'occasion de donner des exemples quand nous parlerons des processeurs 8 bits anciens, dans le chapitre sur les architectures à accumulateur et affiliées.

===Le ''program counter'' mis à jour par l'ALU===

Sur certains processeurs, le calcul de l'adresse de la prochaine instruction est effectué par l'ALU. L'avantage de cette méthode est qu'elle économise un incrémenteur dédié au ''program counter''. Ce qui explique que cette méthode était utilisée sur les processeurs assez anciens, à une époque où un additionneur pouvait facilement prendre 10 à 20% des transistors disponibles. Le désavantage principal est une augmentation de la complexité du séquenceur, qui doit gérer la mise à jour du ''program counter''. De plus, la mise à jour du ''program counter'' ne peut pas se faire en même temps qu'une opération arithmétique, ce qui réduit les performances.

Si on incrémente le ''program counter'' avec l'ALU, il est intéressant de le placer dans le banc de registres. Un désavantage est qu'on perd un registre. Par exemple, avec un banc de registre de 16 registres, on ne peut adresser que 15 registres généraux. De plus ce n'est pas l'idéal pour le décodage des instructions et pour le séquenceur. Si le processeur dispose de plusieurs bancs de registres, le ''program counter'' est généralement placé dans le banc de registre dédié aux adresses. Sinon, il est placé avec les nombres entiers/adresses.

D'anciens processeurs incrémentaient le ''program counter'' avec l'ALU, mais utilisaient bien un registre séparé pour le ''program counter''. Cette méthode est relativement simple à implémenter : il suffit de connecter/déconnecter le ''program counter'' du bus interne suivant les besoins. Le ''program counter'' est déconnecté pendant l’exécution d'une instruction, il est connecté au bus interne pour l'incrémenter. C'est le séquenceur qui gère le tout. L'avantage de cette séparation est qu'elle est plus facile à gérer pour le séquenceur. De plus, on gagne un registre général/entier dans le banc de registre.

===Le compteur programme===

Dans la quasi-totalité des processeurs modernes, le ''program counter'' est un vulgaire compteur comme on en a vu dans les chapitres sur les circuits, ce qui fait qu'il passe automatiquement d'une adresse à la suivante. Dans ce qui suit, nous allons appeler ce registre compteur : le '''compteur ordinal'''. L'usage d'un compteur simplifie fortement la conception du séquenceur. Le séquenceur n'a pas à gérer la mise à jour du ''program counter'', sauf en cas de branchements. De plus, il est possible d'incrémenter le ''program counter'' pendant que l'unité de calcul effectue une opération arithmétique, ce qui améliore grandement les performances. Le seul désavantage est qu'elle demande d'ajouter un incrémenteur dédié au ''program counter''.

Sur les processeurs très anciens, les instructions faisaient toutes un seul mot mémoire et le compteur ordinal était un circuit incrémenteur des plus basique. Sur les processeurs modernes, le compteur est incrémenté par pas de 4 si les instructions sont codées sur 4 octets, 8 si les instructions sont codées sur 8 octets, etc. Concrètement, le compteur est un circuit incrémenteur auquel on aurait retiré quelques bits de poids faible. Par exemple, si les instructions sont codées sur 4 octets, on coupe les 2 derniers bits du compteur. Si les instructions sont codées sur 8 octets, on coupe les 3 derniers bits du compteur. Et ainsi de suite.

Il a existé quelques processeurs pour lesquelles le ''program counter'' était non pas un compteur binaire classique, mais un ''linear feedback shift register''. L'avantage est que le circuit d'incrémentation utilisait bien moins de portes logiques, l'économie était substantielle. Mais un défaut est que des instructions consécutives dans le programme n'étaient pas consécutives en mémoire. Il existait cependant une table de correspondance pour dire : la première instruction est à telle adresse, la seconde à telle autre, etc. Un exemple de processeur de ce type est le TMS 1000 de Texas Instrument, un des premiers microcontrôleur 4 bits datant des années 70.

Une amélioration de la solution précédente utilise un circuit incrémenteur partagé entre le ''program counter'' et d'autres registres. L'incrémenteur est utilisé pour incrémenter le ''program counter'', mais aussi pour effectuer d'autres calculs d'adresse. Par exemple, sur les architectures avec une pile d'adresse de retour, il est possible de partager l'incrémenteur/décrémenteur avec le pointeur de pile ( la technique ne marche pas avec une pile d'appel). Un autre exemple est celui des processeurs qui gèrent automatiquement le rafraichissement mémoire, grâce à, un compteur intégré dans le processeur. Il est possible de partager l'incrémenteur du ''program counter'' avec le compteur de rafraichissement mémoire, qui mémorise la prochaine adresse mémoire à rafraichir. Nous avions déjà abordé ce genre de partage dans le chapitre sur le chemin de données, dans l'annexe sur le pointeur de pile, mais nous verrons d'autres exemples dans le chapitre sur les architectures hybride accumulateur-registre 8/16 bits.

===Quand est mis à jour le ''program counter'' ?===

Le ''program counter'' est mis à jour quand il faut charger une nouvelle instruction. Reste qu'il faut savoir quand le mettre à jour. Incrémenter le ''program counter'' à intervalle régulier, par exemple à chaque cycle d’horloge, fonctionne sur les processeurs où toutes les instructions mettent le même temps pour s’exécuter. Mais de tels processeurs sont très rares. Sur la quasi-totalité des processeurs, les instructions ont une durée d’exécution variable, elles ne prennent pas le même nombre de cycle d'horloge pour s’exécuter. Le temps d’exécution d'une instruction varie selon l'instruction, certaines sont plus longues que d'autres. Tout cela amène un problème : comment incrémenter le ''program counter'' avec des instructions avec des temps d’exécution variables ?

La réponse est que la mise à jour du ''program counter'' démarre quand l'instruction précédente a terminée de s’exécuter, plus précisément un cycle avant. C'est un cycle avant pour que l'instruction chargée soit disponible au prochain cycle pour le décodeur. Pour cela, le séquenceur doit déterminer quand l'instruction est terminée et prévenir le ''program counter'' au bon moment. Il faut donc une interaction entre séquenceur et circuit de chargement. Le circuit de chargement contient une entrée Enable, qui autorise la mise à jour du ''program counter''. Le séquenceur met à 1 cette entrée pour prévenir au ''program counter'' qu'il doit être incrémenté au cycle suivant ou lors du cycle courant. Cela permet de gérer simplement le cas des instructions multicycles. 

[[File:Commande de la mise à jour du program counter.png|centre|vignette|upright=2|Commande de la mise à jour du program counter.]]

Toute la difficulté est alors reportée dans le séquenceur, qui doit déterminer la durée d'une instruction. Pour gérer la mise à jour du ''program counter'', le séquenceur doit déterminer la durée d'une instruction. Cela est simple pour les instructions arithmétiques et logiques, qui ont un nombre de cycles fixe, toujours le même. Une fois l'instruction identifiée par le séquenceur, il connait son nombre de cycles et peut programmer un compteur interne au séquenceur, qui compte le nombre de cycles de l'instruction, et fournit le signal Enable au ''program counter''. Mais cette technique ne marche pas vraiment pour les accès mémoire, dont la durée n'est pas connue à l'avance, surtout sur les processeurs avec des mémoires caches. Pour cela, le séquenceur détermine quand l'instruction mémoire est finie et prévient le ''program counter'' quand c'est le cas.

Il existe quelques processeurs pour lesquels le temps de calcul dépend des opérandes de l'instruction. On peut par exemple avoir une division qui prend 10 cycles avec certaines opérandes, mais 40 cycles avec d'autres opérandes. Mais ces processeurs sont rares et cela est surtout valable pour les opérations de multiplication/division, guère plus. Le problème est alors le même qu'avec les accès mémoire et la solution est la même : l'ALU prévient le séquenceur quand le résultat est disponible.

==Les branchements et le ''program counter''==

Un branchement consiste juste à écrire l'adresse de destination dans le ''program counter''. L'implémentation des branchements demande d'extraire l'adresse de destination et d'altérer le ''program counter'' quand un branchement est détecté. Pour cela, le décodeur d'instruction détecte si l'instruction exécutée est un branchement ou non, et il en déduit où trouver l'adresse de destination.

L'adresse de destination se trouve à un endroit qui dépend du mode d'adressage du branchement. Pour rappel, on distingue quatre modes d'adressage pour les branchements : direct, indirect, relatif et implicite. Pour les branchements directs, l'adresse est intégrée dans l'instruction de branchement elle-même et est extraite par le séquenceur. Pour les branchements indirects, l'adresse de destination est dans le banc de registre. Pour les branchements relatifs, il faut ajouter un décalage au ''program counter'', décalage extrait de l'instruction par le séquenceur. Enfin, les instructions de retour de fonction lisent l'adresse de destination depuis la pile. L'implémentation de ces quatre types de branchements est très différente.

L'altération du ''program counter'' dépend de si le ''program counter'' est dans un compteur séparé ou s'il est dans le banc de registre. Nous avons vu plus haut qu'il y a quatre cas différents, mais nous n'allons voir que deux cas : celui où le ''program counter'' est dans le banc de registre et est incrémenté par l'unité de calcul, celui avec un ''program counter'' séparé avec son propre incrémenteur. Les deux autres cas ne sont utilisés que sur des architectures à accumulateur ou à pile spécifiques, que nous n'avons pas encore vu à ce stade du cours et que nous verrons en temps voulu dans le chapitre sur ces architectures.

===L’implémentation des branchements avec un ''program counter'' intégré au banc de registres===

Le cas le plus simple est celui où le ''program counter'' est intégré au banc de registre, avec une incrémentation faite par l'unité de calcul. Charger une instruction revient alors à effectuer une instruction LOAD en adressage indirect, à deux différences près : le registre sélectionné est le ''program counter'', l’instruction est copiée dans le registre d'instruction et non dans le banc de registre. L'incrémentation du ''porgram counter'' est implémenté avec des micro-opérations qui agissent sur le chemin de données, au même titre que les branchements indirects, relatifs et directs.
* Les branchements indirects copient un registre dans le ''program counter'', ce qui revient simplement à faire une opération MOV entre deux registres, dont le ''program counter'' est la destination.
* L'opération inverse d'un branchement indirect, qui copie le ''program counter'' dans un registre général, est utile pour sauvegarder l'adresse de retour d'une fonction.
* Les branchements directs copient une adresse dans le ''program counter'', ce qui les rend équivalents à une opération MOV avec une constante immédiate, dont le ''program counter'' est la destination.
* Les branchements relatifs sont une opération arithmétique entre le ''program counter'' et un opérande en adressage immédiat.

En clair, à partir du moment où le chemin de données supporte les instructions MOV et l'addition, avec les modes d'adressage adéquat, il supporte les branchements. Aucune modification du chemin de données n'est nécessaire, le séquenceur gére le chargement d'une instruction avec les micro-instructions adéquates : une micro-opération ADD pour incrémenter le ''program counter'', une micro-opération LOAD pour le chargement de l'instruction.

Notons que sur certaines architectures, le ''program counter'' est adressable au même titre que les autres registres du banc de registre. Les instructions de branchement sont alors remplacées par des instructions MOV ou des instructions arithmétique équivalentes, comme décrit plus haut.

===L’implémentation des branchements avec un ''program counter'' séparé===

Étudions maintenant le cas où le ''program counter'' est dans un registre/compteur séparé. Rappelons que tout compteur digne de ce nom possède une entrée de réinitialisation, qui remet le compteur à zéro. De plus, on peut préciser à quelle valeur il doit être réinitialisé. Ici, la valeur à laquelle on veut réinitialiser le compteur n'est autre que l'adresse de destination du branchement. Implémenter un branchement est donc simple : l'entrée de réinitialisation est commandée par le circuit de détection des branchements, alors que la valeur de réinitialisation est envoyée sur l'entrée adéquate. En clair, nous partons du principe que le ''program counter'' est implémenté avec ce type de compteur :

[[File:Fonctionnement d'un compteur (décompteur), schématique.jpg|centre|vignette|upright=1.5|Fonctionnement d'un compteur (décompteur), schématique]]

Toute la difficulté est de présenter l'adresse de destination au ''program counter''. Pour les branchements directs, l'adresse de destination est fournie par le séquenceur. L'adresse de destination du branchement sort du séquenceur et est présentée au ''program counter'' sur l'entrée adéquate. Voici donc comment sont implémentés les branchements directs avec un ''program counter'' séparé du banc de registres. Le schéma ci-dessous marche peu importe que le ''program counter'' soit incrémenté par l'ALU ou par un additionneur dédié.

[[File:Unité de détection des branchements dans le décodeur.png|centre|vignette|upright=2|Unité de détection des branchements dans le décodeur]]

Les branchements relatifs sont ceux qui font sauter X instructions plus loin dans le programme. Leur implémentation demande d'ajouter une constante au ''program counter'', la constante étant fournie dans l’instruction. Là encore, deux solutions sont possibles : réutiliser l'ALU pour calculer l'adresse, ou utiliser un additionneur séparé. L'additionneur séparé peut être fusionné avec l'additionneur qui incrémente le ''program counter'' pour passer à l’instruction suivante.

[[File:Unité de chargement qui gère les branchements relatifs.png|centre|vignette|upright=2|Unité de chargement qui gère les branchements relatifs.]]

Pour les branchements indirects, il suffit de lire le registre voulu et d'envoyer le tout sur l'entrée adéquate du ''program counter''. Il faut alors rajouter un multiplexeur pour que l'entrée de réinitialisationr ecoive la bonne adresse de destination.

[[File:Unité de chargement qui gère les branchements directs.png|centre|vignette|upright=2|Unité de chargement qui gère les branchements directs et indirects.]]

Toute la difficulté de l'implémentation des branchements est de configurer les multiplexeurs, ce qui est réalisé par le séquenceur en fonction du mode d'adressage du branchement.

==Les optimisations du chargement des instructions==

Charger une instruction est techniquement une forme d'accès mémoire un peu particulier. En clair, charger une instruction prend au minimum un cycle d'horloge, et cela peut rapidement monter à 3-5 cycles, si ce n'est plus. L'exécution des instructions est alors fortement ralentit par la mémoire. Par exemple, imaginez que la mémoire mette 3 cycles d'horloges pour charger une instruction, alors qu'une instruction s’exécute en 1 cycle (si les opérandes sont dans les registres). La perte de performance liée au chargement des instructions est alors substantielle. Heureusement, il est possible de limiter la casse en utilisant des mémoires caches, ainsi que d'autres optimisations, que nous allons voir dans ce qui suit.

===Le tampon de préchargement===

La technique dite du '''préchargement''' est utilisée dans le cas où la mémoire a un temps d'accès important. Mais si la latence de la RAM est un problème, le débit ne l'est pas. Il est possible d'avoir une RAM lente, mais à fort débit. Par exemple, supposons que la mémoire puisse charger 4 instructions (de taille fixe) en 3 cycles. Le processeur peut alors charger 4 instructions en un seul accès mémoire, et les exécuter l'une après l'autre, une par cycle d'horloge. Les temps d'attente sont éliminés : le processeur peut décoder une nouvelle instruction à chaque cycle. Et quand la dernière instruction préchargée est exécutée, la mémoire est de nouveau libre, ce qui masque la latence des accès mémoire.

[[File:Tampon de préchargement d'instruction.png|vignette|Tampon de préchargement d'instruction]]

La seule contrainte est de mettre les instructions préchargées en attente. La solution pour cela est d'utiliser un registre d'instruction très large, capable de mémoriser plusieurs instructions à la fois. Ce registre est de plus connecté à un multiplexeur qui permet de sélectionner l'instruction adéquate dans ce registre. Ce multiplexeur est commandé par le ''program counter'' et quelques circuits annexes. Ce super-registre d'instruction est appelé un '''tampon de préchargement'''.

La méthode a une implémentation nettement plus simple avec des instructions de taille fixe, alignées en mémoire. La commande du multiplexeur de sélection de l'instruction est alors beaucoup plus simple : il suffit d'utiliser les bits de poids fort du ''program counter''. Par exemple, prenons le cas d'un registre d'instruction de 32 octets pour des instructions de 4 octets, soit 8 instructions. Le choix de l'instruction à sélectionner se fait en utilisant les 3 bits de poids faible du ''program counter''. 

Mais cette méthode ajoute de nouvelles contraintes d'alignement, similaires à celles vues dans le chapitre sur l'alignement et le boutisme, sauf que l'alignement porte ici sur des blocs d'instructions de même taille que le tampon de préchargement. Si on prend l'exemple d'un tampon de préchargement de 128 bits, les instructions devront être alignées par blocs de 128 bits. C'est à dire qu'idéalement, les fonctions et autres blocs de code isolés doivent commencer à des adresses multiples de 128, pour pouvoir charger un bloc d'instruction en une seule fois. Sans cela, les performances seront sous-optimales.

: Il arrive que le tampon de préchargement ait la même taille qu'une ligne de cache.

Lorsque l'on passe d'un bloc d'instruction à un autre, le tampon de préchargement est mis à jour. Par exemple, si on prend un tampon de préchargement de 4 instructions, on doit changer son contenu toutes les 4 instructions. La seule exception est l'exécution d'un branchement. En effet, lors d'un branchement, la destination du branchement n'est pas dans le tampon de préchargement et elle doit être chargée dedans (sauf si le branchement pointe vers une instruction très proche, ce qui est improbable). Pour cela, le tampon de préchargement est mis à jour précocement quand le processeur détecte un branchement.

Le même problème survient avec du code auto-modifiant. Un code auto-modifiant est un programme qui se modifie lui-même, en remplaçant certaines instructions par d'autres, en en retirant, en en ajoutant, lors de sa propre exécution. De tels programmes sont rares, mais la technique était utilisée dans quelques cas au tout début de l'informatique sur des ordinateurs rudimentaires. Ceux-ci avaient des modes d'adressages tellement limités que gérer des tableaux de taille variable demandait d'utiliser du code auto-modifiant pour écrire des boucles. Le problème survient quand des instructions sont modifiées immédiatement après avoir été préchargées. Les instructions dans le tampon de préchargement sont l'ancienne version, alors que la mémoire RAM contient les instructions modifiées. Gérer ce genre de cas demande de vider le tampon de préchargement si le cas arrive, mais ça ne vaut que très rarement le coup, aussi les ingénieurs ne s’embêtent pas à mettre ce correctif en place. Le code automodifiant est alors buggé.

===La ''prefetch input queue''===

La ''prefetch input queue'' est une optimisation matérielle qui a été utilisée sur les processeurs Intel assez ancien. Elle est apparue sur le 8086 et le 8088, des processeurs respectivement 8 et 16 bits. Elle été présente sur le 286 et le 386, mais était un peu améliorée. Elle est apparue sur ces processeurs à une époque où le processeur devenait plus rapide que la mémoire.

L'idée est là encore de précharger des instructions en avance. Sauf que cette fois-ci, on ne charge pas plusieurs instructions à la fois. Au contraire, les instructions sont préchargées séquentiellement, un octet à la fois. Le tampon de préchargement est remplacé par une mémoire FIFO appelée la '''''Prefetch Input Queue''''', terme abrévié en PIQ. Les instructions sont accumulées une par une dans la PIQ, elles en sortent une par une au fur et à mesure pour alimenter le décodeur d'instruction. La ''prefetch input queue'' est une sorte de cousine du tampon de préchargement. 

L'idée est que pendant que le processeur exécute une instruction, on précharge la suivante. Sans ''prefetch input queue'', le processeur chargeait une instruction, la décodait et l'exécutait, puis chargeait la suivante, et ainsi de suite. Avec la ''prefetch input queue'', pendant qu'une instruction est en cours de décodage/exécution, le processeur précharge l'instruction suivante. Si une instruction prend vraiment beaucoup de temps pour s'exécuter, le processeur peutr en profiter pour précharger l'instruction encore suivante, et ainsi de suite, jusqu'à une limite de 4/6 instructions (la limite dépend du processeur).

Les instructions préchargées dans la ''Prefetch input queue'' y attendent que le processeur les lise et les décode. Les instructions préchargées sont conservées dans leur ordre d'arrivée, afin qu'elles soient exécutées dans le bon ordre, ce qui fait que la ''Prefetch input queue'' est une mémoire de type FIFO. L'étape de décodage pioche l'instruction à décoder dans la ''Prefetch input queue'', cette instruction étant par définition la plus ancienne, puis la retire de la file.

La ''prefetch input queue'' permet de précharger l'instruction suivante à condition qu'aucun autre accès mémoire n'ait lieu. Si l'instruction en cours d'exécution effectue des accès mémoire, ceux-ci sont prioritaires sur tout le reste, le préchargement de l'instruction suivante est alors mis en pause ou inhibé. Par contre, si la mémoire n'est pas utilisée par l'instruction en cours d'exécution, le processeur lit l'instruction suivante en RAM et la copie dans la ''prefetch input queue''. En conséquence, il arrive que la 'prefetch input queue'' n'ait pas préchargé l'instruction suivante, alors que le décodeur d'instruction est prêt pour la décoder. Dans ce cas, le décodeur doit attendre que l'instruction soit chargée.

Sur le 8086 et le 8088, la plupart des instructions faisaient deux octets, alors que la mémoire RAM ne permettait que de charger un octet à la fois. Le décodeur devait attendre que les deux octets d'une instruction soient disponibles dans la ''Prefetch input queue''. Pour cela, un circuit appelé le ''loader'' fournissait deux signaux au décodeur d'instruction : l'un indiquant que le premier octet est déjà chargé, l'autre indiquant que le second octet est disponible. Le décodeur, quant à lui, envoyait le signal ''Run Next Instruction'' pour lire une instruction :  elle était alors dépilée de la ''Prefetch input queue''.

Le décodeur d'instruction pouvait aussi envoyer un signal ''Next-to-last (NXT)'' un cycle en avance, un cucle avant que l'instruction en cours ne termine. Le résultat est que le ''loader'' réagissait en préchargeant l'instruction suivante. En clair, ce signal permettait de précharger l'instruction suivante avec un cycle d'avance, si celle-ci n'était pas déjà dans la ''Prefetch input queue''.

Il faut noter que les instructions x86 sont de longueur variables. Pour les gérer, le décodeur pouvait lire une instruction en plusieurs fois dans la ''Prefetch input queue''. Les deux premiers octets sont lus depuis la ''Prefetch input queue'', et sont alors décodés. Le décodeur détermine alors la taille de l'instruction. Si l'instruction fait exactement deux octets, elle est exécutée directement. Sinon, les octets manquants sont lus depuis la ''Prefetch input queue''. Pour cela, le décodeur dispose d'une micro-opération pour lire un octet depuis la ''Prefetch input queue''.

Il faut noter qu'une ''Prefetch input queue'' interagit assez mal avec le ''program counter''. En effet, la ''Prefetch input queue'' précharge les instructions séquentiellement. Pour savoir où elle en est rendue, elle mémorise l'adresse de la prochaine instruction à charger dans un registre dédié. Et pour ne pas faire doublon, ce registre remplace le ''program counter''. Après tout, le registre n'est qu'un ''program counter'' ayant pris une avance de quelques cycles d'horloge, qui a été incrémenté en avance. Et cela ne pose pas de problèmes, sauf dans le cas des branchements.

Le décodeur d'instruction dispose d'autres micro-opérations qui agissent sur la ''Prefetch input queue'', trois au total. La première stoppe le préchargement des instructions dans la ''Prefetch input queue''. La seconde vide la ''Prefetch input queue'', elle invalide les instructions préchargées. La troisième permet de reconstituer le ''program counter''.  Elles servent à gérer l'exécution des branchements, comme on le verra plus bas.

Le premier processeur commercial grand public à utiliser cette méthode était le 8086, un processeur d'Intel de jeu d'instruction x86. Il pouvait précharger à l'avance 6 octets d’instruction. L'Intel 8088 avait lui aussi une ''Prefetch input queue'', mais qui ne permettait que de précharger 4 instructions. La taille idéale de la FIFO dépend de nombreux paramètres. On pourrait croire que plus elle peut contenir d'instructions, mieux c'est, mais ce n'est pas le cas, pour des raisons que nous allons voir dans ce qui suit.

[[File:80186 arch.png|centre|vignette|700px|upright=2|Architecture du 8086, du 80186 et de ses variantes.]]

Les branchements posent des problèmes avec la ''Prefetch input queue'' : à cause d'eux, on peut charger à l'avance des instructions qui sont zappées par un branchement et ne sont pas censées être exécutées. Si un branchement est chargé, toutes les instructions préchargées après sont potentiellement invalides. Si le branchement est non-pris, les instructions chargées sont valides, elles sont censées s’exécuter. Mais si le branchement est pris, elles ont été chargées à tort et ne doivent pas s’exécuter. 

Pour éviter cela, la ''Prefetch input queue'' est vidée quand le processeur détecte un branchement. Cette détection ne peut se faire qu'une fois le branchement décodé : on ne sait pas si l'instruction est un branchement ou autre chose tant que le décodage n'a pas eu lieu, par définition. En clair, le décodeur invalide la ''Prefetch input queue'' quand il détecte un branchement. Les interruptions posent le même genre de problèmes. Il faut impérativement vider la ''Prefetch input queue'' quand une interruption survient, avant de la traiter.

Un autre défaut est que la ''Prefetch input queue'' se marie assez mal avec du code auto-modifiant. Un code auto-modifiant est un programme qui se modifie lui-même, en remplaçant certaines instructions par d'autres, en en retirant, en en ajoutant, lors de sa propre exécution. De tels programmes sont rares, mais la technique était utilisée dans quelques cas au tout début de l'informatique sur des ordinateurs rudimentaires. Ceux-ci avaient des modes d'adressages tellement limités que gérer des tableaux de taille variable demandait d'utiliser du code auto-modifiant pour écrire des boucles.

Le problème avec la ''Prefetch input queue'' survient quand des instructions sont modifiées immédiatement après avoir été préchargées. Les instructions dans la ''Prefetch input queue'' sont l'ancienne version, alors que la mémoire RAM contient les instructions modifiées. Gérer ce genre de cas est quelque peu complexe. Il faut en effet vider la ''Prefetch input queue'' si le cas arrive, ce qui demande d'identifier les écritures qui écrasent des instructions préchargées. C'est parfaitement possible, mais demande de transformer la ''Prefetch input queue'' en une mémoire hybride, à la fois mémoire associative et mémoire FIFO. Cela ne vaut que très rarement le coup, aussi les ingénieurs ne s’embêtent pas à mettre ce correctif en place, le code automodifiant est alors buggé.

===Le ''Zero-overhead looping''===

Nous avions vu dans le chapitre sur les instructions machines, qu'il existe des instructions qui permettent de grandement faciliter l'implémentation des boucles. Il s'agit de l'instruction REPEAT, utilisée sur certains processeurs de traitement de signal. Elle répète l'instruction suivante, voire une série d'instructions, un certain nombre de fois. Le nombre de répétitions est mémorisé dans un registre décrémenté à chaque itération de la boucle. Elle permet donc d'implémenter une boucle FOR facilement, sans recourir à des branchements ou des conditions.

Une technique en lien avec cette instruction permet de grandement améliorer les performances et la consommation d'énergie. L'idée est de mémoriser la boucle, les instructions à répéter, dans une petite mémoire cache située entre l'unité de chargement et le séquenceur. Le cache en question s'appelle un '''tampon de boucle''', ou encore un ''hardware loop buffer''. Grâce à lui, il n'y a pas besoin de charger les instructions à chaque fois qu'on les exécute, on les charge une bonne fois pour toute : c'est plus rapide. Bien sûr, il ne fonctionne que pour de petites boucles, mais il en est de même avec l'instruction REPEAT.

&lt;noinclude&gt;
{{NavChapitre | book=Fonctionnement d'un ordinateur
           | prev=Le chemin de données
           | prevText=Le chemin de données
           | next=L'unité de contrôle
           | nextText=L'unité de contrôle
}}
&lt;/noinclude&gt;</text>
      <sha1>p1h2hxtrwy3t8uqmrke8x0geosr75c2</sha1>
    </revision>
    <revision>
      <id>744075</id>
      <parentid>744070</parentid>
      <timestamp>2025-06-03T19:17:00Z</timestamp>
      <contributor>
        <username>Mewtow</username>
        <id>31375</id>
      </contributor>
      <minor />
      <comment>/* La prefetch input queue */</comment>
      <origin>744075</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="43103" sha1="dufpptlx4qwzxmdyxg14b0f40zra8p0" xml:space="preserve">L'unité de contrôle s'occupe du chargement des instructions et de leur interprétation, leur décodage. Elle contient deux circuits : l''''unité de chargement''' qui charge l'instruction depuis la mémoire, et le '''séquenceur''' qui commande le chemin de données. Les deux circuits sont séparés, mais ils communiquent entre eux, notamment pour gérer les branchements. Dans ce chapitre, nous allons nous intéresser au chargement d'une instruction depuis la RAM/ROM, nous verrons l'étape de décodage de l'instruction au prochain chapitre.

==Le chargement d'une instruction==

[[File:Étape de chargement.png|vignette|upright=1|Étape de chargement.]]

L'étape de chargement (ou ''fetch'') doit faire deux choses : mettre à jour le ''program counter'' et lire l'instruction en mémoire RAM ou en ROM. Les deux étapes peuvent être faites en parallèle, dans des circuits séparés. Pendant que l'instruction est lue depuis la mémoire RAM/ROM, le ''program counter'' est incrémenté et/ou altéré par un branchement.

Pour lire l'instruction, on envoie le ''program counter'' sur le bus d'adresse et on récupère l'instruction sur le bus de données pour l'envoyer sur l'entrée du séquenceur. Et cela demande de connecter le séquenceur au bus mémoire, à travers l'interface mémoire. Et sur ce point, la situation est différente selon que l'on parler d'une architecture Harvard ou Von Neumann.

===Les interconnexions entre séquenceur et bus mémoire===

Sur les architectures Harvard, le séquenceur et le chemin de donnée utilisent des interfaces mémoire séparées. Le séquenceur est directement relié au bus mémoire de la ROM, alors que le chemin de données est connecté à la RAM.

[[File:Microarchitecture de l'interface mémoire d'une architecture Harvard.png|centre|vignette|upright=2|Microarchitecture de l'interface mémoire d'une architecture Harvard]]

Mais sur les architectures Von-Neumann et affiliées, le séquenceur et le chemin de donnée partagent la même interface mémoire. Et cela pose deux problèmes.

Le premier problème est que le bus mémoire doit être libéré une fois l'instruction chargée, pour un éventuel accès mémoire. Mais le séquenceur doit conserver une copie de l'instruction chargée, sans quoi il ne peut pas décoder l'instruction correctement. Par exemple, si l'instruction met plusieurs cycles à s'exécuter, le séquenceur doit conserver une copie de l'instruction durant ces plusieurs cycles. La solution à ce problème est un '''registre d'instruction''' situé juste avant le séquenceur, qui mémorise l'instruction chargée.

[[File:Registre d'instruction.png|centre|vignette|upright=2|Registre d'instruction.]]

Le second problème est de gérer le flot des instructions/données entre le bus mémoire, le chemin de données et le séquenceur. Le processeur doit connecter l'interface mémoire soit au séquenceur, soit au chemin de données et cela complique le réseau d'interconnexion interne au processeur.

Une première solution utilise un bus unique qui relie l'interface mémoire, le séquenceur et le chemin de données. Pour charger une instruction, le séquenceur copie le ''program counter'' sur le bus d'adresse, attend que l'instruction lue soit disponible sur le bus de données, puis la copie dans le registre d'instruction. Le bus mémoire est alors libre et peut être utilisé pour lire ou écrire des données, si le besoin s'en fait sentir.

Il faut noter que l'usage d'un bus unique a un impact sur l'organisation interne du chemin de données. Par exemple, le chapitre précédent nous a montré comment implémenter un chemin de données basique, avec des multiplexeurs et démultiplexeurs. Et bien ces chemins de données ne marchent pas vraiment avec un bus interne unique. Il est possible de les adapter, mais au prix d'une complexité largement supérieure. Un bus interne unique marche mieux quand le banc de registre est mono-port. C'est pourquoi il a été utilisé sur d'anciennes architectures appelées des architectures à accumulateur et à pile, que nous verrons dans quelques chapitres, qui utilisaient un banc de registre mono-port.

[[File:Microarchitecture de l'interface mémoire d'une architecture von neumann.png|centre|vignette|upright=2|Microarchitecture de l'interface mémoire d'une architecture von neumann]]

Une autre solution utilise deux bus interne séparés : un connecté au bus d'adresse, l'autre au bus de données. Le ''program counter'' est alors connecté au bus interne d'adresse, le séquenceur est relié au bus interne de données. Notons que la technique marche bien si le ''program counter'' est dans le banc de registre : les interconnexions utilisées pour gérer l'adressage indirect permettent d'envoyer le ''program counter'' sur le bus d'adresse sans ajout de circuit.

Le tout peut être amélioré en remplaçant les deux bus par des multiplexeurs et démultiplexeurs. Le bus d'adresse est précédé par un multiplexeur, qui permet de faire le choix entre ''Program Counter'', adresse venant du chemin de données, ou adresse provenant du séquenceur (adressage absolu). De même, le bus de données est suivi par un démultiplexeur qui envoie la donnée/instruction lue soit au registre d'instruction, soit au chemin de données. Le tout se marie très bien avec les chemins de donnée vu dans le chapitre précédent. Au passage, il faut noter que cette solution nécessite un banc de registre multi-port.

[[File:Connexion du program counter sur les bus avec PC isolé.png|centre|vignette|upright=2|Connexion du program counter sur les bus avec PC isolé]]

===Le chargement des instructions de longueur variable===

Le chargement des instructions de longueur variable pose de nombreux problèmes. Le premier est que mettre à jour le ''program counter'' demande de connaitre la longueur de l'instruction chargée, pour l'ajouter au ''program counter''. Si la longueur d'une instruction est variable, on doit connaitre cette longueur d'une manière où d'une autre. La solution la plus simple indique la longueur de l'instruction dans une partie de l'opcode ou de la représentation en binaire de l'instruction. Mais les processeurs haute performance de nos PC utilisent d'autres solutions, qui n'encodent pas explicitement la taille de l'instruction.

Les processeurs récents utilisent un registre d'instruction de grande taille, capable de mémoriser l'instruction la plus longue du processeur. Par exemple, si un processeur supporte des instructions allant de 1 à 8 octets, comme les CPU x86, le registre d'instruction fera 8 octets. Le décodeur d'instruction vérifie à chaque cycle le contenu du registre d'instruction. Si une instruction est détectée dedans, son décodage commence, peu importe la taille de l'instruction. Une fois l'instruction exécutée, elle est retirée du registre d'instruction. Reste à alimenter le registre d'instruction, à charger des instructions dedans. Et pour cela deux solutions : soit on charge l'instruction en plusieurs fois, soit d'un seul coup.

La solution la plus simple charge les instructions par mots de 8, 16, 32, 64 bits. Ils sont accumulés dans le registre d'instruction jusqu'à détecter une instruction complète. La technique marche nettement mieux si les instructions sont très longues. Par exemple, les CPU x86 ont des instructions qui vont de 1 à 15 octets, ce qui fait qu'ils utilisent cette technique. Précisément, elle marche si les instructions les plus longues sont plus grandes que le bus mémoire.

Une autre solution charge un bloc de mots mémoire aussi grand que la plus grande instruction. Par exemple, si le processeur gère des instructions allant de 1 à 4 octets, il charge 4 octets d'un seul coup dans le registre d'instruction. Il va de soit que cette solution ne marche que si les instructions du processeur sont assez courtes, au plus aussi courtes que le bus mémoire. Ainsi, on est sûr de charger obligatoirement au moins une instruction complète, et peut-être même plusieurs. Le contenu du registre d'instruction est alors découpé en instructions au fil de l'eau. 

Utiliser un registre d'instruction large pose problème avec des instructions à cheval entre deux blocs. Il se peut qu'on n'ait pas une instruction complète lorsque l'on arrive à la fin du bloc, mais seulement un morceau. Le problème se manifeste peu importe que l'instruction soit chargée d'un seul coup ou bien en plusieurs fois.

[[File:Instructions non alignées.png|centre|vignette|upright=2|Instructions non alignées.]]

Dans ce cas, on doit décaler le morceau de bloc pour le mettre au bon endroit (au début du registre d'instruction), et charger le prochain bloc juste à côté. On a donc besoin d'un circuit qui décale tous les bits du registre d'instruction, couplé à un circuit qui décide où placer dans le registre d'instruction ce qui a été chargé, avec quelques circuits autour pour configurer les deux circuits précédents.

[[File:Décaleur d’instruction.png|centre|vignette|upright=2|Décaleur d’instruction.]]

Une autre solution se passe de registre d'instruction en utilisant à la place l'état interne du séquenceur. Là encore, elle charge l'instruction morceau par morceau, typiquement par blocs de 8, 16 ou 32 bits. Les morceaux ne sont pas accumulés dans le registre d'instruction, la solution utilise à la place l'état interne du séquenceur. Les mots mémoire de l'instruction sont chargés à chaque cycle, faisant passer le séquenceur d'un état interne à un autre à chaque mot mémoire. Tant qu'il n'a pas reçu tous les mots mémoire de l'instruction, chaque mot mémoire non terminal le fera passer d'un état interne à un autre, chaque état interne encodant les mots mémoire chargés auparavant. S'il tombe sur le dernier mot mémoire d'une instruction, il rentre dans un état de décodage.

==L'incrémentation du ''program counter''==

À chaque chargement, le ''program counter'' est mis à jour afin de pointer sur la prochaine instruction à charger. Sur la quasi-totalité des processeurs, les instructions sont placées dans l'ordre d’exécution dans la RAM. En faisant ainsi, on peut mettre à jour le ''program counter'' en lui ajoutant la longueur de l'instruction courante. Déterminer la longueur de l'instruction est simple quand les instructions ont toutes la même taille, mais certains processeurs ont des instructions de taille variable, ce qui complique le calcul. Dans ce qui va suivre, nous allons supposer que les instructions sont de taille fixe, ce qui fait que le ''program counter'' est toujours incrémenté de la même valeur.

Il existe deux méthodes principales pour incrémenter le ''program counter'' : soit le ''program counter'' a son propre additionneur, soit le ''program counter'' est mis à jour par l'ALU. Pour ce qui est de l'organisation des registres, soit le ''program counter'' est un registre séparé des autres, soit il est regroupé avec d'autres registres dans un banc de registre. En tout, cela donne quatre organisations possibles.
* Un ''program counter'' séparé relié à un incrémenteur séparé.
* Un ''program counter'' séparé des autres registres, incrémenté par l'ALU.
* Un ''program counter'' intégré au banc de registre, relié à un incrémenteur séparé.
* Un ''program counter'' intégré au banc de registre, incrémenté par l'ALU.

[[File:Calcul du program counter.png|centre|vignette|upright=2|les différentes méthodes de calcul du program counter.]]

Les processeurs haute performance modernes utilisent tous la première méthode. Les autres méthodes étaient surtout utilisées sur les processeurs 8 ou 16 bits, elles sont encore utilisées sur quelques microcontrôleurs de faible puissance. Nous auront l'occasion de donner des exemples quand nous parlerons des processeurs 8 bits anciens, dans le chapitre sur les architectures à accumulateur et affiliées.

===Le ''program counter'' mis à jour par l'ALU===

Sur certains processeurs, le calcul de l'adresse de la prochaine instruction est effectué par l'ALU. L'avantage de cette méthode est qu'elle économise un incrémenteur dédié au ''program counter''. Ce qui explique que cette méthode était utilisée sur les processeurs assez anciens, à une époque où un additionneur pouvait facilement prendre 10 à 20% des transistors disponibles. Le désavantage principal est une augmentation de la complexité du séquenceur, qui doit gérer la mise à jour du ''program counter''. De plus, la mise à jour du ''program counter'' ne peut pas se faire en même temps qu'une opération arithmétique, ce qui réduit les performances.

Si on incrémente le ''program counter'' avec l'ALU, il est intéressant de le placer dans le banc de registres. Un désavantage est qu'on perd un registre. Par exemple, avec un banc de registre de 16 registres, on ne peut adresser que 15 registres généraux. De plus ce n'est pas l'idéal pour le décodage des instructions et pour le séquenceur. Si le processeur dispose de plusieurs bancs de registres, le ''program counter'' est généralement placé dans le banc de registre dédié aux adresses. Sinon, il est placé avec les nombres entiers/adresses.

D'anciens processeurs incrémentaient le ''program counter'' avec l'ALU, mais utilisaient bien un registre séparé pour le ''program counter''. Cette méthode est relativement simple à implémenter : il suffit de connecter/déconnecter le ''program counter'' du bus interne suivant les besoins. Le ''program counter'' est déconnecté pendant l’exécution d'une instruction, il est connecté au bus interne pour l'incrémenter. C'est le séquenceur qui gère le tout. L'avantage de cette séparation est qu'elle est plus facile à gérer pour le séquenceur. De plus, on gagne un registre général/entier dans le banc de registre.

===Le compteur programme===

Dans la quasi-totalité des processeurs modernes, le ''program counter'' est un vulgaire compteur comme on en a vu dans les chapitres sur les circuits, ce qui fait qu'il passe automatiquement d'une adresse à la suivante. Dans ce qui suit, nous allons appeler ce registre compteur : le '''compteur ordinal'''. L'usage d'un compteur simplifie fortement la conception du séquenceur. Le séquenceur n'a pas à gérer la mise à jour du ''program counter'', sauf en cas de branchements. De plus, il est possible d'incrémenter le ''program counter'' pendant que l'unité de calcul effectue une opération arithmétique, ce qui améliore grandement les performances. Le seul désavantage est qu'elle demande d'ajouter un incrémenteur dédié au ''program counter''.

Sur les processeurs très anciens, les instructions faisaient toutes un seul mot mémoire et le compteur ordinal était un circuit incrémenteur des plus basique. Sur les processeurs modernes, le compteur est incrémenté par pas de 4 si les instructions sont codées sur 4 octets, 8 si les instructions sont codées sur 8 octets, etc. Concrètement, le compteur est un circuit incrémenteur auquel on aurait retiré quelques bits de poids faible. Par exemple, si les instructions sont codées sur 4 octets, on coupe les 2 derniers bits du compteur. Si les instructions sont codées sur 8 octets, on coupe les 3 derniers bits du compteur. Et ainsi de suite.

Il a existé quelques processeurs pour lesquelles le ''program counter'' était non pas un compteur binaire classique, mais un ''linear feedback shift register''. L'avantage est que le circuit d'incrémentation utilisait bien moins de portes logiques, l'économie était substantielle. Mais un défaut est que des instructions consécutives dans le programme n'étaient pas consécutives en mémoire. Il existait cependant une table de correspondance pour dire : la première instruction est à telle adresse, la seconde à telle autre, etc. Un exemple de processeur de ce type est le TMS 1000 de Texas Instrument, un des premiers microcontrôleur 4 bits datant des années 70.

Une amélioration de la solution précédente utilise un circuit incrémenteur partagé entre le ''program counter'' et d'autres registres. L'incrémenteur est utilisé pour incrémenter le ''program counter'', mais aussi pour effectuer d'autres calculs d'adresse. Par exemple, sur les architectures avec une pile d'adresse de retour, il est possible de partager l'incrémenteur/décrémenteur avec le pointeur de pile ( la technique ne marche pas avec une pile d'appel). Un autre exemple est celui des processeurs qui gèrent automatiquement le rafraichissement mémoire, grâce à, un compteur intégré dans le processeur. Il est possible de partager l'incrémenteur du ''program counter'' avec le compteur de rafraichissement mémoire, qui mémorise la prochaine adresse mémoire à rafraichir. Nous avions déjà abordé ce genre de partage dans le chapitre sur le chemin de données, dans l'annexe sur le pointeur de pile, mais nous verrons d'autres exemples dans le chapitre sur les architectures hybride accumulateur-registre 8/16 bits.

===Quand est mis à jour le ''program counter'' ?===

Le ''program counter'' est mis à jour quand il faut charger une nouvelle instruction. Reste qu'il faut savoir quand le mettre à jour. Incrémenter le ''program counter'' à intervalle régulier, par exemple à chaque cycle d’horloge, fonctionne sur les processeurs où toutes les instructions mettent le même temps pour s’exécuter. Mais de tels processeurs sont très rares. Sur la quasi-totalité des processeurs, les instructions ont une durée d’exécution variable, elles ne prennent pas le même nombre de cycle d'horloge pour s’exécuter. Le temps d’exécution d'une instruction varie selon l'instruction, certaines sont plus longues que d'autres. Tout cela amène un problème : comment incrémenter le ''program counter'' avec des instructions avec des temps d’exécution variables ?

La réponse est que la mise à jour du ''program counter'' démarre quand l'instruction précédente a terminée de s’exécuter, plus précisément un cycle avant. C'est un cycle avant pour que l'instruction chargée soit disponible au prochain cycle pour le décodeur. Pour cela, le séquenceur doit déterminer quand l'instruction est terminée et prévenir le ''program counter'' au bon moment. Il faut donc une interaction entre séquenceur et circuit de chargement. Le circuit de chargement contient une entrée Enable, qui autorise la mise à jour du ''program counter''. Le séquenceur met à 1 cette entrée pour prévenir au ''program counter'' qu'il doit être incrémenté au cycle suivant ou lors du cycle courant. Cela permet de gérer simplement le cas des instructions multicycles. 

[[File:Commande de la mise à jour du program counter.png|centre|vignette|upright=2|Commande de la mise à jour du program counter.]]

Toute la difficulté est alors reportée dans le séquenceur, qui doit déterminer la durée d'une instruction. Pour gérer la mise à jour du ''program counter'', le séquenceur doit déterminer la durée d'une instruction. Cela est simple pour les instructions arithmétiques et logiques, qui ont un nombre de cycles fixe, toujours le même. Une fois l'instruction identifiée par le séquenceur, il connait son nombre de cycles et peut programmer un compteur interne au séquenceur, qui compte le nombre de cycles de l'instruction, et fournit le signal Enable au ''program counter''. Mais cette technique ne marche pas vraiment pour les accès mémoire, dont la durée n'est pas connue à l'avance, surtout sur les processeurs avec des mémoires caches. Pour cela, le séquenceur détermine quand l'instruction mémoire est finie et prévient le ''program counter'' quand c'est le cas.

Il existe quelques processeurs pour lesquels le temps de calcul dépend des opérandes de l'instruction. On peut par exemple avoir une division qui prend 10 cycles avec certaines opérandes, mais 40 cycles avec d'autres opérandes. Mais ces processeurs sont rares et cela est surtout valable pour les opérations de multiplication/division, guère plus. Le problème est alors le même qu'avec les accès mémoire et la solution est la même : l'ALU prévient le séquenceur quand le résultat est disponible.

==Les branchements et le ''program counter''==

Un branchement consiste juste à écrire l'adresse de destination dans le ''program counter''. L'implémentation des branchements demande d'extraire l'adresse de destination et d'altérer le ''program counter'' quand un branchement est détecté. Pour cela, le décodeur d'instruction détecte si l'instruction exécutée est un branchement ou non, et il en déduit où trouver l'adresse de destination.

L'adresse de destination se trouve à un endroit qui dépend du mode d'adressage du branchement. Pour rappel, on distingue quatre modes d'adressage pour les branchements : direct, indirect, relatif et implicite. Pour les branchements directs, l'adresse est intégrée dans l'instruction de branchement elle-même et est extraite par le séquenceur. Pour les branchements indirects, l'adresse de destination est dans le banc de registre. Pour les branchements relatifs, il faut ajouter un décalage au ''program counter'', décalage extrait de l'instruction par le séquenceur. Enfin, les instructions de retour de fonction lisent l'adresse de destination depuis la pile. L'implémentation de ces quatre types de branchements est très différente.

L'altération du ''program counter'' dépend de si le ''program counter'' est dans un compteur séparé ou s'il est dans le banc de registre. Nous avons vu plus haut qu'il y a quatre cas différents, mais nous n'allons voir que deux cas : celui où le ''program counter'' est dans le banc de registre et est incrémenté par l'unité de calcul, celui avec un ''program counter'' séparé avec son propre incrémenteur. Les deux autres cas ne sont utilisés que sur des architectures à accumulateur ou à pile spécifiques, que nous n'avons pas encore vu à ce stade du cours et que nous verrons en temps voulu dans le chapitre sur ces architectures.

===L’implémentation des branchements avec un ''program counter'' intégré au banc de registres===

Le cas le plus simple est celui où le ''program counter'' est intégré au banc de registre, avec une incrémentation faite par l'unité de calcul. Charger une instruction revient alors à effectuer une instruction LOAD en adressage indirect, à deux différences près : le registre sélectionné est le ''program counter'', l’instruction est copiée dans le registre d'instruction et non dans le banc de registre. L'incrémentation du ''porgram counter'' est implémenté avec des micro-opérations qui agissent sur le chemin de données, au même titre que les branchements indirects, relatifs et directs.
* Les branchements indirects copient un registre dans le ''program counter'', ce qui revient simplement à faire une opération MOV entre deux registres, dont le ''program counter'' est la destination.
* L'opération inverse d'un branchement indirect, qui copie le ''program counter'' dans un registre général, est utile pour sauvegarder l'adresse de retour d'une fonction.
* Les branchements directs copient une adresse dans le ''program counter'', ce qui les rend équivalents à une opération MOV avec une constante immédiate, dont le ''program counter'' est la destination.
* Les branchements relatifs sont une opération arithmétique entre le ''program counter'' et un opérande en adressage immédiat.

En clair, à partir du moment où le chemin de données supporte les instructions MOV et l'addition, avec les modes d'adressage adéquat, il supporte les branchements. Aucune modification du chemin de données n'est nécessaire, le séquenceur gére le chargement d'une instruction avec les micro-instructions adéquates : une micro-opération ADD pour incrémenter le ''program counter'', une micro-opération LOAD pour le chargement de l'instruction.

Notons que sur certaines architectures, le ''program counter'' est adressable au même titre que les autres registres du banc de registre. Les instructions de branchement sont alors remplacées par des instructions MOV ou des instructions arithmétique équivalentes, comme décrit plus haut.

===L’implémentation des branchements avec un ''program counter'' séparé===

Étudions maintenant le cas où le ''program counter'' est dans un registre/compteur séparé. Rappelons que tout compteur digne de ce nom possède une entrée de réinitialisation, qui remet le compteur à zéro. De plus, on peut préciser à quelle valeur il doit être réinitialisé. Ici, la valeur à laquelle on veut réinitialiser le compteur n'est autre que l'adresse de destination du branchement. Implémenter un branchement est donc simple : l'entrée de réinitialisation est commandée par le circuit de détection des branchements, alors que la valeur de réinitialisation est envoyée sur l'entrée adéquate. En clair, nous partons du principe que le ''program counter'' est implémenté avec ce type de compteur :

[[File:Fonctionnement d'un compteur (décompteur), schématique.jpg|centre|vignette|upright=1.5|Fonctionnement d'un compteur (décompteur), schématique]]

Toute la difficulté est de présenter l'adresse de destination au ''program counter''. Pour les branchements directs, l'adresse de destination est fournie par le séquenceur. L'adresse de destination du branchement sort du séquenceur et est présentée au ''program counter'' sur l'entrée adéquate. Voici donc comment sont implémentés les branchements directs avec un ''program counter'' séparé du banc de registres. Le schéma ci-dessous marche peu importe que le ''program counter'' soit incrémenté par l'ALU ou par un additionneur dédié.

[[File:Unité de détection des branchements dans le décodeur.png|centre|vignette|upright=2|Unité de détection des branchements dans le décodeur]]

Les branchements relatifs sont ceux qui font sauter X instructions plus loin dans le programme. Leur implémentation demande d'ajouter une constante au ''program counter'', la constante étant fournie dans l’instruction. Là encore, deux solutions sont possibles : réutiliser l'ALU pour calculer l'adresse, ou utiliser un additionneur séparé. L'additionneur séparé peut être fusionné avec l'additionneur qui incrémente le ''program counter'' pour passer à l’instruction suivante.

[[File:Unité de chargement qui gère les branchements relatifs.png|centre|vignette|upright=2|Unité de chargement qui gère les branchements relatifs.]]

Pour les branchements indirects, il suffit de lire le registre voulu et d'envoyer le tout sur l'entrée adéquate du ''program counter''. Il faut alors rajouter un multiplexeur pour que l'entrée de réinitialisationr ecoive la bonne adresse de destination.

[[File:Unité de chargement qui gère les branchements directs.png|centre|vignette|upright=2|Unité de chargement qui gère les branchements directs et indirects.]]

Toute la difficulté de l'implémentation des branchements est de configurer les multiplexeurs, ce qui est réalisé par le séquenceur en fonction du mode d'adressage du branchement.

==Les optimisations du chargement des instructions==

Charger une instruction est techniquement une forme d'accès mémoire un peu particulier. En clair, charger une instruction prend au minimum un cycle d'horloge, et cela peut rapidement monter à 3-5 cycles, si ce n'est plus. L'exécution des instructions est alors fortement ralentit par la mémoire. Par exemple, imaginez que la mémoire mette 3 cycles d'horloges pour charger une instruction, alors qu'une instruction s’exécute en 1 cycle (si les opérandes sont dans les registres). La perte de performance liée au chargement des instructions est alors substantielle. Heureusement, il est possible de limiter la casse en utilisant des mémoires caches, ainsi que d'autres optimisations, que nous allons voir dans ce qui suit.

===Le tampon de préchargement===

La technique dite du '''préchargement''' est utilisée dans le cas où la mémoire a un temps d'accès important. Mais si la latence de la RAM est un problème, le débit ne l'est pas. Il est possible d'avoir une RAM lente, mais à fort débit. Par exemple, supposons que la mémoire puisse charger 4 instructions (de taille fixe) en 3 cycles. Le processeur peut alors charger 4 instructions en un seul accès mémoire, et les exécuter l'une après l'autre, une par cycle d'horloge. Les temps d'attente sont éliminés : le processeur peut décoder une nouvelle instruction à chaque cycle. Et quand la dernière instruction préchargée est exécutée, la mémoire est de nouveau libre, ce qui masque la latence des accès mémoire.

[[File:Tampon de préchargement d'instruction.png|vignette|Tampon de préchargement d'instruction]]

La seule contrainte est de mettre les instructions préchargées en attente. La solution pour cela est d'utiliser un registre d'instruction très large, capable de mémoriser plusieurs instructions à la fois. Ce registre est de plus connecté à un multiplexeur qui permet de sélectionner l'instruction adéquate dans ce registre. Ce multiplexeur est commandé par le ''program counter'' et quelques circuits annexes. Ce super-registre d'instruction est appelé un '''tampon de préchargement'''.

La méthode a une implémentation nettement plus simple avec des instructions de taille fixe, alignées en mémoire. La commande du multiplexeur de sélection de l'instruction est alors beaucoup plus simple : il suffit d'utiliser les bits de poids fort du ''program counter''. Par exemple, prenons le cas d'un registre d'instruction de 32 octets pour des instructions de 4 octets, soit 8 instructions. Le choix de l'instruction à sélectionner se fait en utilisant les 3 bits de poids faible du ''program counter''. 

Mais cette méthode ajoute de nouvelles contraintes d'alignement, similaires à celles vues dans le chapitre sur l'alignement et le boutisme, sauf que l'alignement porte ici sur des blocs d'instructions de même taille que le tampon de préchargement. Si on prend l'exemple d'un tampon de préchargement de 128 bits, les instructions devront être alignées par blocs de 128 bits. C'est à dire qu'idéalement, les fonctions et autres blocs de code isolés doivent commencer à des adresses multiples de 128, pour pouvoir charger un bloc d'instruction en une seule fois. Sans cela, les performances seront sous-optimales.

: Il arrive que le tampon de préchargement ait la même taille qu'une ligne de cache.

Lorsque l'on passe d'un bloc d'instruction à un autre, le tampon de préchargement est mis à jour. Par exemple, si on prend un tampon de préchargement de 4 instructions, on doit changer son contenu toutes les 4 instructions. La seule exception est l'exécution d'un branchement. En effet, lors d'un branchement, la destination du branchement n'est pas dans le tampon de préchargement et elle doit être chargée dedans (sauf si le branchement pointe vers une instruction très proche, ce qui est improbable). Pour cela, le tampon de préchargement est mis à jour précocement quand le processeur détecte un branchement.

Le même problème survient avec du code auto-modifiant. Un code auto-modifiant est un programme qui se modifie lui-même, en remplaçant certaines instructions par d'autres, en en retirant, en en ajoutant, lors de sa propre exécution. De tels programmes sont rares, mais la technique était utilisée dans quelques cas au tout début de l'informatique sur des ordinateurs rudimentaires. Ceux-ci avaient des modes d'adressages tellement limités que gérer des tableaux de taille variable demandait d'utiliser du code auto-modifiant pour écrire des boucles. Le problème survient quand des instructions sont modifiées immédiatement après avoir été préchargées. Les instructions dans le tampon de préchargement sont l'ancienne version, alors que la mémoire RAM contient les instructions modifiées. Gérer ce genre de cas demande de vider le tampon de préchargement si le cas arrive, mais ça ne vaut que très rarement le coup, aussi les ingénieurs ne s’embêtent pas à mettre ce correctif en place. Le code automodifiant est alors buggé.

===La ''prefetch input queue''===

La ''prefetch input queue'' est une optimisation matérielle qui a été utilisée sur les processeurs Intel assez ancien. Elle est apparue sur le 8086 et le 8088, des processeurs respectivement 8 et 16 bits. Elle été présente sur le 286 et le 386, mais était un peu améliorée. Elle est apparue sur ces processeurs à une époque où le processeur devenait plus rapide que la mémoire.

L'idée est là encore de précharger des instructions en avance. Sauf que cette fois-ci, on ne charge pas plusieurs instructions à la fois. Au contraire, les instructions sont préchargées séquentiellement, un octet à la fois. Le tampon de préchargement est remplacé par une mémoire FIFO appelée la '''''Prefetch Input Queue''''', terme abrévié en PIQ. Les instructions sont accumulées une par une dans la PIQ, elles en sortent une par une au fur et à mesure pour alimenter le décodeur d'instruction. La ''prefetch input queue'' est une sorte de cousine du tampon de préchargement. 

L'idée est que pendant que le processeur exécute une instruction, on précharge la suivante. Sans ''prefetch input queue'', le processeur chargeait une instruction, la décodait et l'exécutait, puis chargeait la suivante, et ainsi de suite. Avec la ''prefetch input queue'', pendant qu'une instruction est en cours de décodage/exécution, le processeur précharge l'instruction suivante. Si une instruction prend vraiment beaucoup de temps pour s'exécuter, le processeur peut en profiter pour précharger l'instruction encore suivante, et ainsi de suite, jusqu'à une limite de 4/6 instructions (la limite dépend du processeur).

Les instructions préchargées dans la ''Prefetch input queue'' y attendent que le processeur les lise et les décode. Les instructions préchargées sont conservées dans leur ordre d'arrivée, afin qu'elles soient exécutées dans le bon ordre, ce qui fait que la ''Prefetch input queue'' est une mémoire de type FIFO. L'étape de décodage pioche l'instruction à décoder dans la ''Prefetch input queue'', cette instruction étant par définition la plus ancienne, puis la retire de la file.

La ''prefetch input queue'' permet de précharger l'instruction suivante à condition qu'aucun autre accès mémoire n'ait lieu. Si l'instruction en cours d'exécution effectue des accès mémoire, ceux-ci sont prioritaires sur tout le reste, le préchargement de l'instruction suivante est alors mis en pause ou inhibé. Par contre, si la mémoire n'est pas utilisée par l'instruction en cours d'exécution, le processeur lit l'instruction suivante en RAM et la copie dans la ''prefetch input queue''. En conséquence, il arrive que la 'prefetch input queue'' n'ait pas préchargé l'instruction suivante, alors que le décodeur d'instruction est prêt pour la décoder. Dans ce cas, le décodeur doit attendre que l'instruction soit chargée.

La taille idéale de la FIFO dépend de nombreux paramètres. On pourrait croire que plus elle peut contenir d'instructions, mieux c'est, mais ce n'est pas le cas, pour des raisons que nous allons expliquer dans quelques paragraphes. Le premier processeur commercial grand public à utiliser une ''prefetch input queue'' était le 8086. Il pouvait précharger à l'avance 6 octets d’instruction. L'Intel 8088 avait lui aussi une ''Prefetch input queue'', mais qui ne permettait que de précharger 4 instructions.

Vous remarquerez que j'ai exprimé la capacité de la ''prefetch input queue'' en octets et non en instructions. La raison est que sur les processeurs x86, les instructions sont de taille variable. Les instructions de ces processeurs ont une taille qui varie entre deux octets et 6 octets. La ''prefetch input queue'' était optimisée pour lire des instructions de deux octets, avec quelques mécanismes pour gérer les instructions plus longues. Il faut dire que les instructions les plus courantes faisaient deux octets, respectivement un octet d'opcode et un octet Mod/RM pour préciser le mode d'adressage.

Si les instructions faisaient deux octets ou plus, La mémoire RAM ne permettait que de charger un octet à la fois. Le décodeur devait attendre que les deux octets d'une instruction soient disponibles dans la ''Prefetch input queue''. Pour cela, un circuit appelé le ''loader'' fournissait deux signaux au décodeur d'instruction : l'un indiquant que le premier octet est déjà chargé, l'autre indiquant que le second octet est disponible. Le décodeur, quant à lui, envoyait le signal ''Run Next Instruction'' pour lire une instruction :  elle était alors dépilée de la ''Prefetch input queue''.

Le décodeur d'instruction pouvait aussi envoyer un signal ''Next-to-last (NXT)'' un cycle en avance, un cucle avant que l'instruction en cours ne termine. Le résultat est que le ''loader'' réagissait en préchargeant l'instruction suivante. En clair, ce signal permettait de précharger l'instruction suivante avec un cycle d'avance, si celle-ci n'était pas déjà dans la ''Prefetch input queue''.

Il faut noter que les instructions x86 sont de longueur variables. Pour les gérer, le décodeur pouvait lire une instruction en plusieurs fois dans la ''Prefetch input queue''. Les deux premiers octets sont lus depuis la ''Prefetch input queue'', et sont alors décodés. Le décodeur détermine alors la taille de l'instruction. Si l'instruction fait exactement deux octets, elle est exécutée directement. Sinon, les octets manquants sont lus depuis la ''Prefetch input queue''. Pour cela, le décodeur dispose d'une micro-opération pour lire un octet depuis la ''Prefetch input queue''.

Il faut noter qu'une ''Prefetch input queue'' interagit assez mal avec le ''program counter''. En effet, la ''Prefetch input queue'' précharge les instructions séquentiellement. Pour savoir où elle en est rendue, elle mémorise l'adresse de la prochaine instruction à charger dans un registre dédié. Et pour ne pas faire doublon, ce registre remplace le ''program counter''. Après tout, le registre n'est qu'un ''program counter'' ayant pris une avance de quelques cycles d'horloge, qui a été incrémenté en avance. Et cela ne pose pas de problèmes, sauf dans le cas des branchements.

Le décodeur d'instruction dispose d'autres micro-opérations qui agissent sur la ''Prefetch input queue'', trois au total. La première stoppe le préchargement des instructions dans la ''Prefetch input queue''. La seconde vide la ''Prefetch input queue'', elle invalide les instructions préchargées. La troisième permet de reconstituer le ''program counter''.  Elles servent à gérer l'exécution des branchements, comme on le verra plus bas.

[[File:80186 arch.png|centre|vignette|700px|upright=2|Architecture du 8086, du 80186 et de ses variantes.]]

Les branchements posent des problèmes avec la ''Prefetch input queue'' : à cause d'eux, on peut charger à l'avance des instructions qui sont zappées par un branchement et ne sont pas censées être exécutées. Si un branchement est chargé, toutes les instructions préchargées après sont potentiellement invalides. Si le branchement est non-pris, les instructions chargées sont valides, elles sont censées s’exécuter. Mais si le branchement est pris, elles ont été chargées à tort et ne doivent pas s’exécuter. 

Pour éviter cela, la ''Prefetch input queue'' est vidée quand le processeur détecte un branchement. Cette détection ne peut se faire qu'une fois le branchement décodé : on ne sait pas si l'instruction est un branchement ou autre chose tant que le décodage n'a pas eu lieu, par définition. En clair, le décodeur invalide la ''Prefetch input queue'' quand il détecte un branchement. Les interruptions posent le même genre de problèmes. Il faut impérativement vider la ''Prefetch input queue'' quand une interruption survient, avant de la traiter.

Un autre défaut est que la ''Prefetch input queue'' se marie assez mal avec du code auto-modifiant. Un code auto-modifiant est un programme qui se modifie lui-même, en remplaçant certaines instructions par d'autres, en en retirant, en en ajoutant, lors de sa propre exécution. De tels programmes sont rares, mais la technique était utilisée dans quelques cas au tout début de l'informatique sur des ordinateurs rudimentaires. Ceux-ci avaient des modes d'adressages tellement limités que gérer des tableaux de taille variable demandait d'utiliser du code auto-modifiant pour écrire des boucles.

Le problème avec la ''Prefetch input queue'' survient quand des instructions sont modifiées immédiatement après avoir été préchargées. Les instructions dans la ''Prefetch input queue'' sont l'ancienne version, alors que la mémoire RAM contient les instructions modifiées. Gérer ce genre de cas est quelque peu complexe. Il faut en effet vider la ''Prefetch input queue'' si le cas arrive, ce qui demande d'identifier les écritures qui écrasent des instructions préchargées. C'est parfaitement possible, mais demande de transformer la ''Prefetch input queue'' en une mémoire hybride, à la fois mémoire associative et mémoire FIFO. Cela ne vaut que très rarement le coup, aussi les ingénieurs ne s’embêtent pas à mettre ce correctif en place, le code automodifiant est alors buggé.

===Le ''Zero-overhead looping''===

Nous avions vu dans le chapitre sur les instructions machines, qu'il existe des instructions qui permettent de grandement faciliter l'implémentation des boucles. Il s'agit de l'instruction REPEAT, utilisée sur certains processeurs de traitement de signal. Elle répète l'instruction suivante, voire une série d'instructions, un certain nombre de fois. Le nombre de répétitions est mémorisé dans un registre décrémenté à chaque itération de la boucle. Elle permet donc d'implémenter une boucle FOR facilement, sans recourir à des branchements ou des conditions.

Une technique en lien avec cette instruction permet de grandement améliorer les performances et la consommation d'énergie. L'idée est de mémoriser la boucle, les instructions à répéter, dans une petite mémoire cache située entre l'unité de chargement et le séquenceur. Le cache en question s'appelle un '''tampon de boucle''', ou encore un ''hardware loop buffer''. Grâce à lui, il n'y a pas besoin de charger les instructions à chaque fois qu'on les exécute, on les charge une bonne fois pour toute : c'est plus rapide. Bien sûr, il ne fonctionne que pour de petites boucles, mais il en est de même avec l'instruction REPEAT.

&lt;noinclude&gt;
{{NavChapitre | book=Fonctionnement d'un ordinateur
           | prev=Le chemin de données
           | prevText=Le chemin de données
           | next=L'unité de contrôle
           | nextText=L'unité de contrôle
}}
&lt;/noinclude&gt;</text>
      <sha1>dufpptlx4qwzxmdyxg14b0f40zra8p0</sha1>
    </revision>
    <revision>
      <id>744076</id>
      <parentid>744075</parentid>
      <timestamp>2025-06-03T19:19:26Z</timestamp>
      <contributor>
        <username>Mewtow</username>
        <id>31375</id>
      </contributor>
      <minor />
      <comment>/* La prefetch input queue */</comment>
      <origin>744076</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="43274" sha1="tgvje186cmr1rejul6t9jpuqpyw7vh6" xml:space="preserve">L'unité de contrôle s'occupe du chargement des instructions et de leur interprétation, leur décodage. Elle contient deux circuits : l''''unité de chargement''' qui charge l'instruction depuis la mémoire, et le '''séquenceur''' qui commande le chemin de données. Les deux circuits sont séparés, mais ils communiquent entre eux, notamment pour gérer les branchements. Dans ce chapitre, nous allons nous intéresser au chargement d'une instruction depuis la RAM/ROM, nous verrons l'étape de décodage de l'instruction au prochain chapitre.

==Le chargement d'une instruction==

[[File:Étape de chargement.png|vignette|upright=1|Étape de chargement.]]

L'étape de chargement (ou ''fetch'') doit faire deux choses : mettre à jour le ''program counter'' et lire l'instruction en mémoire RAM ou en ROM. Les deux étapes peuvent être faites en parallèle, dans des circuits séparés. Pendant que l'instruction est lue depuis la mémoire RAM/ROM, le ''program counter'' est incrémenté et/ou altéré par un branchement.

Pour lire l'instruction, on envoie le ''program counter'' sur le bus d'adresse et on récupère l'instruction sur le bus de données pour l'envoyer sur l'entrée du séquenceur. Et cela demande de connecter le séquenceur au bus mémoire, à travers l'interface mémoire. Et sur ce point, la situation est différente selon que l'on parler d'une architecture Harvard ou Von Neumann.

===Les interconnexions entre séquenceur et bus mémoire===

Sur les architectures Harvard, le séquenceur et le chemin de donnée utilisent des interfaces mémoire séparées. Le séquenceur est directement relié au bus mémoire de la ROM, alors que le chemin de données est connecté à la RAM.

[[File:Microarchitecture de l'interface mémoire d'une architecture Harvard.png|centre|vignette|upright=2|Microarchitecture de l'interface mémoire d'une architecture Harvard]]

Mais sur les architectures Von-Neumann et affiliées, le séquenceur et le chemin de donnée partagent la même interface mémoire. Et cela pose deux problèmes.

Le premier problème est que le bus mémoire doit être libéré une fois l'instruction chargée, pour un éventuel accès mémoire. Mais le séquenceur doit conserver une copie de l'instruction chargée, sans quoi il ne peut pas décoder l'instruction correctement. Par exemple, si l'instruction met plusieurs cycles à s'exécuter, le séquenceur doit conserver une copie de l'instruction durant ces plusieurs cycles. La solution à ce problème est un '''registre d'instruction''' situé juste avant le séquenceur, qui mémorise l'instruction chargée.

[[File:Registre d'instruction.png|centre|vignette|upright=2|Registre d'instruction.]]

Le second problème est de gérer le flot des instructions/données entre le bus mémoire, le chemin de données et le séquenceur. Le processeur doit connecter l'interface mémoire soit au séquenceur, soit au chemin de données et cela complique le réseau d'interconnexion interne au processeur.

Une première solution utilise un bus unique qui relie l'interface mémoire, le séquenceur et le chemin de données. Pour charger une instruction, le séquenceur copie le ''program counter'' sur le bus d'adresse, attend que l'instruction lue soit disponible sur le bus de données, puis la copie dans le registre d'instruction. Le bus mémoire est alors libre et peut être utilisé pour lire ou écrire des données, si le besoin s'en fait sentir.

Il faut noter que l'usage d'un bus unique a un impact sur l'organisation interne du chemin de données. Par exemple, le chapitre précédent nous a montré comment implémenter un chemin de données basique, avec des multiplexeurs et démultiplexeurs. Et bien ces chemins de données ne marchent pas vraiment avec un bus interne unique. Il est possible de les adapter, mais au prix d'une complexité largement supérieure. Un bus interne unique marche mieux quand le banc de registre est mono-port. C'est pourquoi il a été utilisé sur d'anciennes architectures appelées des architectures à accumulateur et à pile, que nous verrons dans quelques chapitres, qui utilisaient un banc de registre mono-port.

[[File:Microarchitecture de l'interface mémoire d'une architecture von neumann.png|centre|vignette|upright=2|Microarchitecture de l'interface mémoire d'une architecture von neumann]]

Une autre solution utilise deux bus interne séparés : un connecté au bus d'adresse, l'autre au bus de données. Le ''program counter'' est alors connecté au bus interne d'adresse, le séquenceur est relié au bus interne de données. Notons que la technique marche bien si le ''program counter'' est dans le banc de registre : les interconnexions utilisées pour gérer l'adressage indirect permettent d'envoyer le ''program counter'' sur le bus d'adresse sans ajout de circuit.

Le tout peut être amélioré en remplaçant les deux bus par des multiplexeurs et démultiplexeurs. Le bus d'adresse est précédé par un multiplexeur, qui permet de faire le choix entre ''Program Counter'', adresse venant du chemin de données, ou adresse provenant du séquenceur (adressage absolu). De même, le bus de données est suivi par un démultiplexeur qui envoie la donnée/instruction lue soit au registre d'instruction, soit au chemin de données. Le tout se marie très bien avec les chemins de donnée vu dans le chapitre précédent. Au passage, il faut noter que cette solution nécessite un banc de registre multi-port.

[[File:Connexion du program counter sur les bus avec PC isolé.png|centre|vignette|upright=2|Connexion du program counter sur les bus avec PC isolé]]

===Le chargement des instructions de longueur variable===

Le chargement des instructions de longueur variable pose de nombreux problèmes. Le premier est que mettre à jour le ''program counter'' demande de connaitre la longueur de l'instruction chargée, pour l'ajouter au ''program counter''. Si la longueur d'une instruction est variable, on doit connaitre cette longueur d'une manière où d'une autre. La solution la plus simple indique la longueur de l'instruction dans une partie de l'opcode ou de la représentation en binaire de l'instruction. Mais les processeurs haute performance de nos PC utilisent d'autres solutions, qui n'encodent pas explicitement la taille de l'instruction.

Les processeurs récents utilisent un registre d'instruction de grande taille, capable de mémoriser l'instruction la plus longue du processeur. Par exemple, si un processeur supporte des instructions allant de 1 à 8 octets, comme les CPU x86, le registre d'instruction fera 8 octets. Le décodeur d'instruction vérifie à chaque cycle le contenu du registre d'instruction. Si une instruction est détectée dedans, son décodage commence, peu importe la taille de l'instruction. Une fois l'instruction exécutée, elle est retirée du registre d'instruction. Reste à alimenter le registre d'instruction, à charger des instructions dedans. Et pour cela deux solutions : soit on charge l'instruction en plusieurs fois, soit d'un seul coup.

La solution la plus simple charge les instructions par mots de 8, 16, 32, 64 bits. Ils sont accumulés dans le registre d'instruction jusqu'à détecter une instruction complète. La technique marche nettement mieux si les instructions sont très longues. Par exemple, les CPU x86 ont des instructions qui vont de 1 à 15 octets, ce qui fait qu'ils utilisent cette technique. Précisément, elle marche si les instructions les plus longues sont plus grandes que le bus mémoire.

Une autre solution charge un bloc de mots mémoire aussi grand que la plus grande instruction. Par exemple, si le processeur gère des instructions allant de 1 à 4 octets, il charge 4 octets d'un seul coup dans le registre d'instruction. Il va de soit que cette solution ne marche que si les instructions du processeur sont assez courtes, au plus aussi courtes que le bus mémoire. Ainsi, on est sûr de charger obligatoirement au moins une instruction complète, et peut-être même plusieurs. Le contenu du registre d'instruction est alors découpé en instructions au fil de l'eau. 

Utiliser un registre d'instruction large pose problème avec des instructions à cheval entre deux blocs. Il se peut qu'on n'ait pas une instruction complète lorsque l'on arrive à la fin du bloc, mais seulement un morceau. Le problème se manifeste peu importe que l'instruction soit chargée d'un seul coup ou bien en plusieurs fois.

[[File:Instructions non alignées.png|centre|vignette|upright=2|Instructions non alignées.]]

Dans ce cas, on doit décaler le morceau de bloc pour le mettre au bon endroit (au début du registre d'instruction), et charger le prochain bloc juste à côté. On a donc besoin d'un circuit qui décale tous les bits du registre d'instruction, couplé à un circuit qui décide où placer dans le registre d'instruction ce qui a été chargé, avec quelques circuits autour pour configurer les deux circuits précédents.

[[File:Décaleur d’instruction.png|centre|vignette|upright=2|Décaleur d’instruction.]]

Une autre solution se passe de registre d'instruction en utilisant à la place l'état interne du séquenceur. Là encore, elle charge l'instruction morceau par morceau, typiquement par blocs de 8, 16 ou 32 bits. Les morceaux ne sont pas accumulés dans le registre d'instruction, la solution utilise à la place l'état interne du séquenceur. Les mots mémoire de l'instruction sont chargés à chaque cycle, faisant passer le séquenceur d'un état interne à un autre à chaque mot mémoire. Tant qu'il n'a pas reçu tous les mots mémoire de l'instruction, chaque mot mémoire non terminal le fera passer d'un état interne à un autre, chaque état interne encodant les mots mémoire chargés auparavant. S'il tombe sur le dernier mot mémoire d'une instruction, il rentre dans un état de décodage.

==L'incrémentation du ''program counter''==

À chaque chargement, le ''program counter'' est mis à jour afin de pointer sur la prochaine instruction à charger. Sur la quasi-totalité des processeurs, les instructions sont placées dans l'ordre d’exécution dans la RAM. En faisant ainsi, on peut mettre à jour le ''program counter'' en lui ajoutant la longueur de l'instruction courante. Déterminer la longueur de l'instruction est simple quand les instructions ont toutes la même taille, mais certains processeurs ont des instructions de taille variable, ce qui complique le calcul. Dans ce qui va suivre, nous allons supposer que les instructions sont de taille fixe, ce qui fait que le ''program counter'' est toujours incrémenté de la même valeur.

Il existe deux méthodes principales pour incrémenter le ''program counter'' : soit le ''program counter'' a son propre additionneur, soit le ''program counter'' est mis à jour par l'ALU. Pour ce qui est de l'organisation des registres, soit le ''program counter'' est un registre séparé des autres, soit il est regroupé avec d'autres registres dans un banc de registre. En tout, cela donne quatre organisations possibles.
* Un ''program counter'' séparé relié à un incrémenteur séparé.
* Un ''program counter'' séparé des autres registres, incrémenté par l'ALU.
* Un ''program counter'' intégré au banc de registre, relié à un incrémenteur séparé.
* Un ''program counter'' intégré au banc de registre, incrémenté par l'ALU.

[[File:Calcul du program counter.png|centre|vignette|upright=2|les différentes méthodes de calcul du program counter.]]

Les processeurs haute performance modernes utilisent tous la première méthode. Les autres méthodes étaient surtout utilisées sur les processeurs 8 ou 16 bits, elles sont encore utilisées sur quelques microcontrôleurs de faible puissance. Nous auront l'occasion de donner des exemples quand nous parlerons des processeurs 8 bits anciens, dans le chapitre sur les architectures à accumulateur et affiliées.

===Le ''program counter'' mis à jour par l'ALU===

Sur certains processeurs, le calcul de l'adresse de la prochaine instruction est effectué par l'ALU. L'avantage de cette méthode est qu'elle économise un incrémenteur dédié au ''program counter''. Ce qui explique que cette méthode était utilisée sur les processeurs assez anciens, à une époque où un additionneur pouvait facilement prendre 10 à 20% des transistors disponibles. Le désavantage principal est une augmentation de la complexité du séquenceur, qui doit gérer la mise à jour du ''program counter''. De plus, la mise à jour du ''program counter'' ne peut pas se faire en même temps qu'une opération arithmétique, ce qui réduit les performances.

Si on incrémente le ''program counter'' avec l'ALU, il est intéressant de le placer dans le banc de registres. Un désavantage est qu'on perd un registre. Par exemple, avec un banc de registre de 16 registres, on ne peut adresser que 15 registres généraux. De plus ce n'est pas l'idéal pour le décodage des instructions et pour le séquenceur. Si le processeur dispose de plusieurs bancs de registres, le ''program counter'' est généralement placé dans le banc de registre dédié aux adresses. Sinon, il est placé avec les nombres entiers/adresses.

D'anciens processeurs incrémentaient le ''program counter'' avec l'ALU, mais utilisaient bien un registre séparé pour le ''program counter''. Cette méthode est relativement simple à implémenter : il suffit de connecter/déconnecter le ''program counter'' du bus interne suivant les besoins. Le ''program counter'' est déconnecté pendant l’exécution d'une instruction, il est connecté au bus interne pour l'incrémenter. C'est le séquenceur qui gère le tout. L'avantage de cette séparation est qu'elle est plus facile à gérer pour le séquenceur. De plus, on gagne un registre général/entier dans le banc de registre.

===Le compteur programme===

Dans la quasi-totalité des processeurs modernes, le ''program counter'' est un vulgaire compteur comme on en a vu dans les chapitres sur les circuits, ce qui fait qu'il passe automatiquement d'une adresse à la suivante. Dans ce qui suit, nous allons appeler ce registre compteur : le '''compteur ordinal'''. L'usage d'un compteur simplifie fortement la conception du séquenceur. Le séquenceur n'a pas à gérer la mise à jour du ''program counter'', sauf en cas de branchements. De plus, il est possible d'incrémenter le ''program counter'' pendant que l'unité de calcul effectue une opération arithmétique, ce qui améliore grandement les performances. Le seul désavantage est qu'elle demande d'ajouter un incrémenteur dédié au ''program counter''.

Sur les processeurs très anciens, les instructions faisaient toutes un seul mot mémoire et le compteur ordinal était un circuit incrémenteur des plus basique. Sur les processeurs modernes, le compteur est incrémenté par pas de 4 si les instructions sont codées sur 4 octets, 8 si les instructions sont codées sur 8 octets, etc. Concrètement, le compteur est un circuit incrémenteur auquel on aurait retiré quelques bits de poids faible. Par exemple, si les instructions sont codées sur 4 octets, on coupe les 2 derniers bits du compteur. Si les instructions sont codées sur 8 octets, on coupe les 3 derniers bits du compteur. Et ainsi de suite.

Il a existé quelques processeurs pour lesquelles le ''program counter'' était non pas un compteur binaire classique, mais un ''linear feedback shift register''. L'avantage est que le circuit d'incrémentation utilisait bien moins de portes logiques, l'économie était substantielle. Mais un défaut est que des instructions consécutives dans le programme n'étaient pas consécutives en mémoire. Il existait cependant une table de correspondance pour dire : la première instruction est à telle adresse, la seconde à telle autre, etc. Un exemple de processeur de ce type est le TMS 1000 de Texas Instrument, un des premiers microcontrôleur 4 bits datant des années 70.

Une amélioration de la solution précédente utilise un circuit incrémenteur partagé entre le ''program counter'' et d'autres registres. L'incrémenteur est utilisé pour incrémenter le ''program counter'', mais aussi pour effectuer d'autres calculs d'adresse. Par exemple, sur les architectures avec une pile d'adresse de retour, il est possible de partager l'incrémenteur/décrémenteur avec le pointeur de pile ( la technique ne marche pas avec une pile d'appel). Un autre exemple est celui des processeurs qui gèrent automatiquement le rafraichissement mémoire, grâce à, un compteur intégré dans le processeur. Il est possible de partager l'incrémenteur du ''program counter'' avec le compteur de rafraichissement mémoire, qui mémorise la prochaine adresse mémoire à rafraichir. Nous avions déjà abordé ce genre de partage dans le chapitre sur le chemin de données, dans l'annexe sur le pointeur de pile, mais nous verrons d'autres exemples dans le chapitre sur les architectures hybride accumulateur-registre 8/16 bits.

===Quand est mis à jour le ''program counter'' ?===

Le ''program counter'' est mis à jour quand il faut charger une nouvelle instruction. Reste qu'il faut savoir quand le mettre à jour. Incrémenter le ''program counter'' à intervalle régulier, par exemple à chaque cycle d’horloge, fonctionne sur les processeurs où toutes les instructions mettent le même temps pour s’exécuter. Mais de tels processeurs sont très rares. Sur la quasi-totalité des processeurs, les instructions ont une durée d’exécution variable, elles ne prennent pas le même nombre de cycle d'horloge pour s’exécuter. Le temps d’exécution d'une instruction varie selon l'instruction, certaines sont plus longues que d'autres. Tout cela amène un problème : comment incrémenter le ''program counter'' avec des instructions avec des temps d’exécution variables ?

La réponse est que la mise à jour du ''program counter'' démarre quand l'instruction précédente a terminée de s’exécuter, plus précisément un cycle avant. C'est un cycle avant pour que l'instruction chargée soit disponible au prochain cycle pour le décodeur. Pour cela, le séquenceur doit déterminer quand l'instruction est terminée et prévenir le ''program counter'' au bon moment. Il faut donc une interaction entre séquenceur et circuit de chargement. Le circuit de chargement contient une entrée Enable, qui autorise la mise à jour du ''program counter''. Le séquenceur met à 1 cette entrée pour prévenir au ''program counter'' qu'il doit être incrémenté au cycle suivant ou lors du cycle courant. Cela permet de gérer simplement le cas des instructions multicycles. 

[[File:Commande de la mise à jour du program counter.png|centre|vignette|upright=2|Commande de la mise à jour du program counter.]]

Toute la difficulté est alors reportée dans le séquenceur, qui doit déterminer la durée d'une instruction. Pour gérer la mise à jour du ''program counter'', le séquenceur doit déterminer la durée d'une instruction. Cela est simple pour les instructions arithmétiques et logiques, qui ont un nombre de cycles fixe, toujours le même. Une fois l'instruction identifiée par le séquenceur, il connait son nombre de cycles et peut programmer un compteur interne au séquenceur, qui compte le nombre de cycles de l'instruction, et fournit le signal Enable au ''program counter''. Mais cette technique ne marche pas vraiment pour les accès mémoire, dont la durée n'est pas connue à l'avance, surtout sur les processeurs avec des mémoires caches. Pour cela, le séquenceur détermine quand l'instruction mémoire est finie et prévient le ''program counter'' quand c'est le cas.

Il existe quelques processeurs pour lesquels le temps de calcul dépend des opérandes de l'instruction. On peut par exemple avoir une division qui prend 10 cycles avec certaines opérandes, mais 40 cycles avec d'autres opérandes. Mais ces processeurs sont rares et cela est surtout valable pour les opérations de multiplication/division, guère plus. Le problème est alors le même qu'avec les accès mémoire et la solution est la même : l'ALU prévient le séquenceur quand le résultat est disponible.

==Les branchements et le ''program counter''==

Un branchement consiste juste à écrire l'adresse de destination dans le ''program counter''. L'implémentation des branchements demande d'extraire l'adresse de destination et d'altérer le ''program counter'' quand un branchement est détecté. Pour cela, le décodeur d'instruction détecte si l'instruction exécutée est un branchement ou non, et il en déduit où trouver l'adresse de destination.

L'adresse de destination se trouve à un endroit qui dépend du mode d'adressage du branchement. Pour rappel, on distingue quatre modes d'adressage pour les branchements : direct, indirect, relatif et implicite. Pour les branchements directs, l'adresse est intégrée dans l'instruction de branchement elle-même et est extraite par le séquenceur. Pour les branchements indirects, l'adresse de destination est dans le banc de registre. Pour les branchements relatifs, il faut ajouter un décalage au ''program counter'', décalage extrait de l'instruction par le séquenceur. Enfin, les instructions de retour de fonction lisent l'adresse de destination depuis la pile. L'implémentation de ces quatre types de branchements est très différente.

L'altération du ''program counter'' dépend de si le ''program counter'' est dans un compteur séparé ou s'il est dans le banc de registre. Nous avons vu plus haut qu'il y a quatre cas différents, mais nous n'allons voir que deux cas : celui où le ''program counter'' est dans le banc de registre et est incrémenté par l'unité de calcul, celui avec un ''program counter'' séparé avec son propre incrémenteur. Les deux autres cas ne sont utilisés que sur des architectures à accumulateur ou à pile spécifiques, que nous n'avons pas encore vu à ce stade du cours et que nous verrons en temps voulu dans le chapitre sur ces architectures.

===L’implémentation des branchements avec un ''program counter'' intégré au banc de registres===

Le cas le plus simple est celui où le ''program counter'' est intégré au banc de registre, avec une incrémentation faite par l'unité de calcul. Charger une instruction revient alors à effectuer une instruction LOAD en adressage indirect, à deux différences près : le registre sélectionné est le ''program counter'', l’instruction est copiée dans le registre d'instruction et non dans le banc de registre. L'incrémentation du ''porgram counter'' est implémenté avec des micro-opérations qui agissent sur le chemin de données, au même titre que les branchements indirects, relatifs et directs.
* Les branchements indirects copient un registre dans le ''program counter'', ce qui revient simplement à faire une opération MOV entre deux registres, dont le ''program counter'' est la destination.
* L'opération inverse d'un branchement indirect, qui copie le ''program counter'' dans un registre général, est utile pour sauvegarder l'adresse de retour d'une fonction.
* Les branchements directs copient une adresse dans le ''program counter'', ce qui les rend équivalents à une opération MOV avec une constante immédiate, dont le ''program counter'' est la destination.
* Les branchements relatifs sont une opération arithmétique entre le ''program counter'' et un opérande en adressage immédiat.

En clair, à partir du moment où le chemin de données supporte les instructions MOV et l'addition, avec les modes d'adressage adéquat, il supporte les branchements. Aucune modification du chemin de données n'est nécessaire, le séquenceur gére le chargement d'une instruction avec les micro-instructions adéquates : une micro-opération ADD pour incrémenter le ''program counter'', une micro-opération LOAD pour le chargement de l'instruction.

Notons que sur certaines architectures, le ''program counter'' est adressable au même titre que les autres registres du banc de registre. Les instructions de branchement sont alors remplacées par des instructions MOV ou des instructions arithmétique équivalentes, comme décrit plus haut.

===L’implémentation des branchements avec un ''program counter'' séparé===

Étudions maintenant le cas où le ''program counter'' est dans un registre/compteur séparé. Rappelons que tout compteur digne de ce nom possède une entrée de réinitialisation, qui remet le compteur à zéro. De plus, on peut préciser à quelle valeur il doit être réinitialisé. Ici, la valeur à laquelle on veut réinitialiser le compteur n'est autre que l'adresse de destination du branchement. Implémenter un branchement est donc simple : l'entrée de réinitialisation est commandée par le circuit de détection des branchements, alors que la valeur de réinitialisation est envoyée sur l'entrée adéquate. En clair, nous partons du principe que le ''program counter'' est implémenté avec ce type de compteur :

[[File:Fonctionnement d'un compteur (décompteur), schématique.jpg|centre|vignette|upright=1.5|Fonctionnement d'un compteur (décompteur), schématique]]

Toute la difficulté est de présenter l'adresse de destination au ''program counter''. Pour les branchements directs, l'adresse de destination est fournie par le séquenceur. L'adresse de destination du branchement sort du séquenceur et est présentée au ''program counter'' sur l'entrée adéquate. Voici donc comment sont implémentés les branchements directs avec un ''program counter'' séparé du banc de registres. Le schéma ci-dessous marche peu importe que le ''program counter'' soit incrémenté par l'ALU ou par un additionneur dédié.

[[File:Unité de détection des branchements dans le décodeur.png|centre|vignette|upright=2|Unité de détection des branchements dans le décodeur]]

Les branchements relatifs sont ceux qui font sauter X instructions plus loin dans le programme. Leur implémentation demande d'ajouter une constante au ''program counter'', la constante étant fournie dans l’instruction. Là encore, deux solutions sont possibles : réutiliser l'ALU pour calculer l'adresse, ou utiliser un additionneur séparé. L'additionneur séparé peut être fusionné avec l'additionneur qui incrémente le ''program counter'' pour passer à l’instruction suivante.

[[File:Unité de chargement qui gère les branchements relatifs.png|centre|vignette|upright=2|Unité de chargement qui gère les branchements relatifs.]]

Pour les branchements indirects, il suffit de lire le registre voulu et d'envoyer le tout sur l'entrée adéquate du ''program counter''. Il faut alors rajouter un multiplexeur pour que l'entrée de réinitialisationr ecoive la bonne adresse de destination.

[[File:Unité de chargement qui gère les branchements directs.png|centre|vignette|upright=2|Unité de chargement qui gère les branchements directs et indirects.]]

Toute la difficulté de l'implémentation des branchements est de configurer les multiplexeurs, ce qui est réalisé par le séquenceur en fonction du mode d'adressage du branchement.

==Les optimisations du chargement des instructions==

Charger une instruction est techniquement une forme d'accès mémoire un peu particulier. En clair, charger une instruction prend au minimum un cycle d'horloge, et cela peut rapidement monter à 3-5 cycles, si ce n'est plus. L'exécution des instructions est alors fortement ralentit par la mémoire. Par exemple, imaginez que la mémoire mette 3 cycles d'horloges pour charger une instruction, alors qu'une instruction s’exécute en 1 cycle (si les opérandes sont dans les registres). La perte de performance liée au chargement des instructions est alors substantielle. Heureusement, il est possible de limiter la casse en utilisant des mémoires caches, ainsi que d'autres optimisations, que nous allons voir dans ce qui suit.

===Le tampon de préchargement===

La technique dite du '''préchargement''' est utilisée dans le cas où la mémoire a un temps d'accès important. Mais si la latence de la RAM est un problème, le débit ne l'est pas. Il est possible d'avoir une RAM lente, mais à fort débit. Par exemple, supposons que la mémoire puisse charger 4 instructions (de taille fixe) en 3 cycles. Le processeur peut alors charger 4 instructions en un seul accès mémoire, et les exécuter l'une après l'autre, une par cycle d'horloge. Les temps d'attente sont éliminés : le processeur peut décoder une nouvelle instruction à chaque cycle. Et quand la dernière instruction préchargée est exécutée, la mémoire est de nouveau libre, ce qui masque la latence des accès mémoire.

[[File:Tampon de préchargement d'instruction.png|vignette|Tampon de préchargement d'instruction]]

La seule contrainte est de mettre les instructions préchargées en attente. La solution pour cela est d'utiliser un registre d'instruction très large, capable de mémoriser plusieurs instructions à la fois. Ce registre est de plus connecté à un multiplexeur qui permet de sélectionner l'instruction adéquate dans ce registre. Ce multiplexeur est commandé par le ''program counter'' et quelques circuits annexes. Ce super-registre d'instruction est appelé un '''tampon de préchargement'''.

La méthode a une implémentation nettement plus simple avec des instructions de taille fixe, alignées en mémoire. La commande du multiplexeur de sélection de l'instruction est alors beaucoup plus simple : il suffit d'utiliser les bits de poids fort du ''program counter''. Par exemple, prenons le cas d'un registre d'instruction de 32 octets pour des instructions de 4 octets, soit 8 instructions. Le choix de l'instruction à sélectionner se fait en utilisant les 3 bits de poids faible du ''program counter''. 

Mais cette méthode ajoute de nouvelles contraintes d'alignement, similaires à celles vues dans le chapitre sur l'alignement et le boutisme, sauf que l'alignement porte ici sur des blocs d'instructions de même taille que le tampon de préchargement. Si on prend l'exemple d'un tampon de préchargement de 128 bits, les instructions devront être alignées par blocs de 128 bits. C'est à dire qu'idéalement, les fonctions et autres blocs de code isolés doivent commencer à des adresses multiples de 128, pour pouvoir charger un bloc d'instruction en une seule fois. Sans cela, les performances seront sous-optimales.

: Il arrive que le tampon de préchargement ait la même taille qu'une ligne de cache.

Lorsque l'on passe d'un bloc d'instruction à un autre, le tampon de préchargement est mis à jour. Par exemple, si on prend un tampon de préchargement de 4 instructions, on doit changer son contenu toutes les 4 instructions. La seule exception est l'exécution d'un branchement. En effet, lors d'un branchement, la destination du branchement n'est pas dans le tampon de préchargement et elle doit être chargée dedans (sauf si le branchement pointe vers une instruction très proche, ce qui est improbable). Pour cela, le tampon de préchargement est mis à jour précocement quand le processeur détecte un branchement.

Le même problème survient avec du code auto-modifiant. Un code auto-modifiant est un programme qui se modifie lui-même, en remplaçant certaines instructions par d'autres, en en retirant, en en ajoutant, lors de sa propre exécution. De tels programmes sont rares, mais la technique était utilisée dans quelques cas au tout début de l'informatique sur des ordinateurs rudimentaires. Ceux-ci avaient des modes d'adressages tellement limités que gérer des tableaux de taille variable demandait d'utiliser du code auto-modifiant pour écrire des boucles. Le problème survient quand des instructions sont modifiées immédiatement après avoir été préchargées. Les instructions dans le tampon de préchargement sont l'ancienne version, alors que la mémoire RAM contient les instructions modifiées. Gérer ce genre de cas demande de vider le tampon de préchargement si le cas arrive, mais ça ne vaut que très rarement le coup, aussi les ingénieurs ne s’embêtent pas à mettre ce correctif en place. Le code automodifiant est alors buggé.

===La ''prefetch input queue''===

La ''prefetch input queue'' est une optimisation matérielle qui a été utilisée sur les processeurs Intel assez ancien. Elle est apparue sur le 8086 et le 8088, des processeurs respectivement 8 et 16 bits. Elle été présente sur le 286 et le 386, mais était un peu améliorée. Elle est apparue sur ces processeurs à une époque où le processeur devenait plus rapide que la mémoire.

L'idée est là encore de précharger des instructions en avance. Sauf que cette fois-ci, on ne charge pas plusieurs instructions à la fois. Au contraire, les instructions sont préchargées séquentiellement, un octet à la fois. Le tampon de préchargement est remplacé par une mémoire FIFO appelée la '''''Prefetch Input Queue''''', terme abrévié en PIQ. Les instructions sont accumulées une par une dans la PIQ, elles en sortent une par une au fur et à mesure pour alimenter le décodeur d'instruction. La ''prefetch input queue'' est une sorte de cousine du tampon de préchargement. 

L'idée est que pendant que le processeur exécute une instruction, on précharge la suivante. Sans ''prefetch input queue'', le processeur chargeait une instruction, la décodait et l'exécutait, puis chargeait la suivante, et ainsi de suite. Avec la ''prefetch input queue'', pendant qu'une instruction est en cours de décodage/exécution, le processeur précharge l'instruction suivante. Si une instruction prend vraiment beaucoup de temps pour s'exécuter, le processeur peut en profiter pour précharger l'instruction encore suivante, et ainsi de suite, jusqu'à une limite de 4/6 instructions (la limite dépend du processeur).

Les instructions préchargées dans la ''Prefetch input queue'' y attendent que le processeur les lise et les décode. Les instructions préchargées sont conservées dans leur ordre d'arrivée, afin qu'elles soient exécutées dans le bon ordre, ce qui fait que la ''Prefetch input queue'' est une mémoire de type FIFO. L'étape de décodage pioche l'instruction à décoder dans la ''Prefetch input queue'', cette instruction étant par définition la plus ancienne, puis la retire de la file.

La ''prefetch input queue'' permet de précharger l'instruction suivante à condition qu'aucun autre accès mémoire n'ait lieu. Si l'instruction en cours d'exécution effectue des accès mémoire, ceux-ci sont prioritaires sur tout le reste, le préchargement de l'instruction suivante est alors mis en pause ou inhibé. Par contre, si la mémoire n'est pas utilisée par l'instruction en cours d'exécution, le processeur lit l'instruction suivante en RAM et la copie dans la ''prefetch input queue''. En conséquence, il arrive que la 'prefetch input queue'' n'ait pas préchargé l'instruction suivante, alors que le décodeur d'instruction est prêt pour la décoder. Dans ce cas, le décodeur doit attendre que l'instruction soit chargée.

La taille idéale de la FIFO dépend de nombreux paramètres. On pourrait croire que plus elle peut contenir d'instructions, mieux c'est, mais ce n'est pas le cas, pour des raisons que nous allons expliquer dans quelques paragraphes. Le premier processeur commercial grand public à utiliser une ''prefetch input queue'' était le 8086. Il pouvait précharger à l'avance 6 octets d’instruction. L'Intel 8088 avait lui aussi une ''Prefetch input queue'', mais qui ne permettait que de précharger 4 instructions.

Vous remarquerez que j'ai exprimé la capacité de la ''prefetch input queue'' en octets et non en instructions. La raison est que sur les processeurs x86, les instructions sont de taille variable. Les instructions de ces processeurs ont une taille qui varie entre deux octets et 6 octets. La ''prefetch input queue'' était optimisée pour lire des instructions de deux octets, avec quelques mécanismes pour gérer les instructions plus longues. Il faut dire que les instructions les plus courantes faisaient deux octets, respectivement un octet d'opcode et un octet Mod/RM pour préciser le mode d'adressage.

Si les instructions faisaient deux octets ou plus, La mémoire RAM ne permettait que de charger un octet à la fois. Le décodeur devait attendre que les deux octets d'une instruction soient disponibles dans la ''Prefetch input queue''. Pour cela, un circuit appelé le ''loader'' fournissait deux signaux au décodeur d'instruction : l'un indiquant que le premier octet est déjà chargé, l'autre indiquant que le second octet est disponible.

Pour gérer les instructions de plus de deux octets, le décodeur pouvait lire une instruction en plusieurs fois dans la ''Prefetch input queue''. Les deux premiers octets sont lus depuis la ''Prefetch input queue'', et sont alors décodés. Le décodeur détermine alors la taille de l'instruction. Si l'instruction fait exactement deux octets, elle est exécutée directement. Sinon, les octets manquants sont lus depuis la ''Prefetch input queue''. Pour cela, le décodeur dispose d'une micro-opération pour lire un octet depuis la ''Prefetch input queue''.

Le ''loader'' ne faisait pas que fournir les deux signaux au décodeur d'instruction. Il recevait aussi des signaux de la part du décodeur d'instruction, afin de gérer les lectures dans la ''Prefetch input queue''. Le décodeur envoyait le signal ''Run Next Instruction'' pour lire une instruction :  elle était alors dépilée de la ''Prefetch input queue''. Le décodeur d'instruction pouvait aussi envoyer un signal ''Next-to-last (NXT)'' un cycle en avance, un cucle avant que l'instruction en cours ne termine. Le résultat est que le ''loader'' réagissait en préchargeant l'instruction suivante. En clair, ce signal permettait de précharger l'instruction suivante avec un cycle d'avance, si celle-ci n'était pas déjà dans la ''Prefetch input queue''.

Il faut noter qu'une ''Prefetch input queue'' interagit assez mal avec le ''program counter''. En effet, la ''Prefetch input queue'' précharge les instructions séquentiellement. Pour savoir où elle en est rendue, elle mémorise l'adresse de la prochaine instruction à charger dans un registre dédié. Et pour ne pas faire doublon, ce registre remplace le ''program counter''. Après tout, le registre n'est qu'un ''program counter'' ayant pris une avance de quelques cycles d'horloge, qui a été incrémenté en avance. Et cela ne pose pas de problèmes, sauf dans le cas des branchements.

Le décodeur d'instruction dispose d'autres micro-opérations qui agissent sur la ''Prefetch input queue'', trois au total. La première stoppe le préchargement des instructions dans la ''Prefetch input queue''. La seconde vide la ''Prefetch input queue'', elle invalide les instructions préchargées. La troisième permet de reconstituer le ''program counter''.  Elles servent à gérer l'exécution des branchements, comme on le verra plus bas.

[[File:80186 arch.png|centre|vignette|700px|upright=2|Architecture du 8086, du 80186 et de ses variantes.]]

Les branchements posent des problèmes avec la ''Prefetch input queue'' : à cause d'eux, on peut charger à l'avance des instructions qui sont zappées par un branchement et ne sont pas censées être exécutées. Si un branchement est chargé, toutes les instructions préchargées après sont potentiellement invalides. Si le branchement est non-pris, les instructions chargées sont valides, elles sont censées s’exécuter. Mais si le branchement est pris, elles ont été chargées à tort et ne doivent pas s’exécuter. 

Pour éviter cela, la ''Prefetch input queue'' est vidée quand le processeur détecte un branchement. Cette détection ne peut se faire qu'une fois le branchement décodé : on ne sait pas si l'instruction est un branchement ou autre chose tant que le décodage n'a pas eu lieu, par définition. En clair, le décodeur invalide la ''Prefetch input queue'' quand il détecte un branchement. Les interruptions posent le même genre de problèmes. Il faut impérativement vider la ''Prefetch input queue'' quand une interruption survient, avant de la traiter.

Un autre défaut est que la ''Prefetch input queue'' se marie assez mal avec du code auto-modifiant. Un code auto-modifiant est un programme qui se modifie lui-même, en remplaçant certaines instructions par d'autres, en en retirant, en en ajoutant, lors de sa propre exécution. De tels programmes sont rares, mais la technique était utilisée dans quelques cas au tout début de l'informatique sur des ordinateurs rudimentaires. Ceux-ci avaient des modes d'adressages tellement limités que gérer des tableaux de taille variable demandait d'utiliser du code auto-modifiant pour écrire des boucles.

Le problème avec la ''Prefetch input queue'' survient quand des instructions sont modifiées immédiatement après avoir été préchargées. Les instructions dans la ''Prefetch input queue'' sont l'ancienne version, alors que la mémoire RAM contient les instructions modifiées. Gérer ce genre de cas est quelque peu complexe. Il faut en effet vider la ''Prefetch input queue'' si le cas arrive, ce qui demande d'identifier les écritures qui écrasent des instructions préchargées. C'est parfaitement possible, mais demande de transformer la ''Prefetch input queue'' en une mémoire hybride, à la fois mémoire associative et mémoire FIFO. Cela ne vaut que très rarement le coup, aussi les ingénieurs ne s’embêtent pas à mettre ce correctif en place, le code automodifiant est alors buggé.

===Le ''Zero-overhead looping''===

Nous avions vu dans le chapitre sur les instructions machines, qu'il existe des instructions qui permettent de grandement faciliter l'implémentation des boucles. Il s'agit de l'instruction REPEAT, utilisée sur certains processeurs de traitement de signal. Elle répète l'instruction suivante, voire une série d'instructions, un certain nombre de fois. Le nombre de répétitions est mémorisé dans un registre décrémenté à chaque itération de la boucle. Elle permet donc d'implémenter une boucle FOR facilement, sans recourir à des branchements ou des conditions.

Une technique en lien avec cette instruction permet de grandement améliorer les performances et la consommation d'énergie. L'idée est de mémoriser la boucle, les instructions à répéter, dans une petite mémoire cache située entre l'unité de chargement et le séquenceur. Le cache en question s'appelle un '''tampon de boucle''', ou encore un ''hardware loop buffer''. Grâce à lui, il n'y a pas besoin de charger les instructions à chaque fois qu'on les exécute, on les charge une bonne fois pour toute : c'est plus rapide. Bien sûr, il ne fonctionne que pour de petites boucles, mais il en est de même avec l'instruction REPEAT.

&lt;noinclude&gt;
{{NavChapitre | book=Fonctionnement d'un ordinateur
           | prev=Le chemin de données
           | prevText=Le chemin de données
           | next=L'unité de contrôle
           | nextText=L'unité de contrôle
}}
&lt;/noinclude&gt;</text>
      <sha1>tgvje186cmr1rejul6t9jpuqpyw7vh6</sha1>
    </revision>
    <revision>
      <id>744077</id>
      <parentid>744076</parentid>
      <timestamp>2025-06-03T19:26:48Z</timestamp>
      <contributor>
        <username>Mewtow</username>
        <id>31375</id>
      </contributor>
      <minor />
      <comment>/* La prefetch input queue */</comment>
      <origin>744077</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="43680" sha1="saagvh0xivfhorbpv85z2alml5rn3mb" xml:space="preserve">L'unité de contrôle s'occupe du chargement des instructions et de leur interprétation, leur décodage. Elle contient deux circuits : l''''unité de chargement''' qui charge l'instruction depuis la mémoire, et le '''séquenceur''' qui commande le chemin de données. Les deux circuits sont séparés, mais ils communiquent entre eux, notamment pour gérer les branchements. Dans ce chapitre, nous allons nous intéresser au chargement d'une instruction depuis la RAM/ROM, nous verrons l'étape de décodage de l'instruction au prochain chapitre.

==Le chargement d'une instruction==

[[File:Étape de chargement.png|vignette|upright=1|Étape de chargement.]]

L'étape de chargement (ou ''fetch'') doit faire deux choses : mettre à jour le ''program counter'' et lire l'instruction en mémoire RAM ou en ROM. Les deux étapes peuvent être faites en parallèle, dans des circuits séparés. Pendant que l'instruction est lue depuis la mémoire RAM/ROM, le ''program counter'' est incrémenté et/ou altéré par un branchement.

Pour lire l'instruction, on envoie le ''program counter'' sur le bus d'adresse et on récupère l'instruction sur le bus de données pour l'envoyer sur l'entrée du séquenceur. Et cela demande de connecter le séquenceur au bus mémoire, à travers l'interface mémoire. Et sur ce point, la situation est différente selon que l'on parler d'une architecture Harvard ou Von Neumann.

===Les interconnexions entre séquenceur et bus mémoire===

Sur les architectures Harvard, le séquenceur et le chemin de donnée utilisent des interfaces mémoire séparées. Le séquenceur est directement relié au bus mémoire de la ROM, alors que le chemin de données est connecté à la RAM.

[[File:Microarchitecture de l'interface mémoire d'une architecture Harvard.png|centre|vignette|upright=2|Microarchitecture de l'interface mémoire d'une architecture Harvard]]

Mais sur les architectures Von-Neumann et affiliées, le séquenceur et le chemin de donnée partagent la même interface mémoire. Et cela pose deux problèmes.

Le premier problème est que le bus mémoire doit être libéré une fois l'instruction chargée, pour un éventuel accès mémoire. Mais le séquenceur doit conserver une copie de l'instruction chargée, sans quoi il ne peut pas décoder l'instruction correctement. Par exemple, si l'instruction met plusieurs cycles à s'exécuter, le séquenceur doit conserver une copie de l'instruction durant ces plusieurs cycles. La solution à ce problème est un '''registre d'instruction''' situé juste avant le séquenceur, qui mémorise l'instruction chargée.

[[File:Registre d'instruction.png|centre|vignette|upright=2|Registre d'instruction.]]

Le second problème est de gérer le flot des instructions/données entre le bus mémoire, le chemin de données et le séquenceur. Le processeur doit connecter l'interface mémoire soit au séquenceur, soit au chemin de données et cela complique le réseau d'interconnexion interne au processeur.

Une première solution utilise un bus unique qui relie l'interface mémoire, le séquenceur et le chemin de données. Pour charger une instruction, le séquenceur copie le ''program counter'' sur le bus d'adresse, attend que l'instruction lue soit disponible sur le bus de données, puis la copie dans le registre d'instruction. Le bus mémoire est alors libre et peut être utilisé pour lire ou écrire des données, si le besoin s'en fait sentir.

Il faut noter que l'usage d'un bus unique a un impact sur l'organisation interne du chemin de données. Par exemple, le chapitre précédent nous a montré comment implémenter un chemin de données basique, avec des multiplexeurs et démultiplexeurs. Et bien ces chemins de données ne marchent pas vraiment avec un bus interne unique. Il est possible de les adapter, mais au prix d'une complexité largement supérieure. Un bus interne unique marche mieux quand le banc de registre est mono-port. C'est pourquoi il a été utilisé sur d'anciennes architectures appelées des architectures à accumulateur et à pile, que nous verrons dans quelques chapitres, qui utilisaient un banc de registre mono-port.

[[File:Microarchitecture de l'interface mémoire d'une architecture von neumann.png|centre|vignette|upright=2|Microarchitecture de l'interface mémoire d'une architecture von neumann]]

Une autre solution utilise deux bus interne séparés : un connecté au bus d'adresse, l'autre au bus de données. Le ''program counter'' est alors connecté au bus interne d'adresse, le séquenceur est relié au bus interne de données. Notons que la technique marche bien si le ''program counter'' est dans le banc de registre : les interconnexions utilisées pour gérer l'adressage indirect permettent d'envoyer le ''program counter'' sur le bus d'adresse sans ajout de circuit.

Le tout peut être amélioré en remplaçant les deux bus par des multiplexeurs et démultiplexeurs. Le bus d'adresse est précédé par un multiplexeur, qui permet de faire le choix entre ''Program Counter'', adresse venant du chemin de données, ou adresse provenant du séquenceur (adressage absolu). De même, le bus de données est suivi par un démultiplexeur qui envoie la donnée/instruction lue soit au registre d'instruction, soit au chemin de données. Le tout se marie très bien avec les chemins de donnée vu dans le chapitre précédent. Au passage, il faut noter que cette solution nécessite un banc de registre multi-port.

[[File:Connexion du program counter sur les bus avec PC isolé.png|centre|vignette|upright=2|Connexion du program counter sur les bus avec PC isolé]]

===Le chargement des instructions de longueur variable===

Le chargement des instructions de longueur variable pose de nombreux problèmes. Le premier est que mettre à jour le ''program counter'' demande de connaitre la longueur de l'instruction chargée, pour l'ajouter au ''program counter''. Si la longueur d'une instruction est variable, on doit connaitre cette longueur d'une manière où d'une autre. La solution la plus simple indique la longueur de l'instruction dans une partie de l'opcode ou de la représentation en binaire de l'instruction. Mais les processeurs haute performance de nos PC utilisent d'autres solutions, qui n'encodent pas explicitement la taille de l'instruction.

Les processeurs récents utilisent un registre d'instruction de grande taille, capable de mémoriser l'instruction la plus longue du processeur. Par exemple, si un processeur supporte des instructions allant de 1 à 8 octets, comme les CPU x86, le registre d'instruction fera 8 octets. Le décodeur d'instruction vérifie à chaque cycle le contenu du registre d'instruction. Si une instruction est détectée dedans, son décodage commence, peu importe la taille de l'instruction. Une fois l'instruction exécutée, elle est retirée du registre d'instruction. Reste à alimenter le registre d'instruction, à charger des instructions dedans. Et pour cela deux solutions : soit on charge l'instruction en plusieurs fois, soit d'un seul coup.

La solution la plus simple charge les instructions par mots de 8, 16, 32, 64 bits. Ils sont accumulés dans le registre d'instruction jusqu'à détecter une instruction complète. La technique marche nettement mieux si les instructions sont très longues. Par exemple, les CPU x86 ont des instructions qui vont de 1 à 15 octets, ce qui fait qu'ils utilisent cette technique. Précisément, elle marche si les instructions les plus longues sont plus grandes que le bus mémoire.

Une autre solution charge un bloc de mots mémoire aussi grand que la plus grande instruction. Par exemple, si le processeur gère des instructions allant de 1 à 4 octets, il charge 4 octets d'un seul coup dans le registre d'instruction. Il va de soit que cette solution ne marche que si les instructions du processeur sont assez courtes, au plus aussi courtes que le bus mémoire. Ainsi, on est sûr de charger obligatoirement au moins une instruction complète, et peut-être même plusieurs. Le contenu du registre d'instruction est alors découpé en instructions au fil de l'eau. 

Utiliser un registre d'instruction large pose problème avec des instructions à cheval entre deux blocs. Il se peut qu'on n'ait pas une instruction complète lorsque l'on arrive à la fin du bloc, mais seulement un morceau. Le problème se manifeste peu importe que l'instruction soit chargée d'un seul coup ou bien en plusieurs fois.

[[File:Instructions non alignées.png|centre|vignette|upright=2|Instructions non alignées.]]

Dans ce cas, on doit décaler le morceau de bloc pour le mettre au bon endroit (au début du registre d'instruction), et charger le prochain bloc juste à côté. On a donc besoin d'un circuit qui décale tous les bits du registre d'instruction, couplé à un circuit qui décide où placer dans le registre d'instruction ce qui a été chargé, avec quelques circuits autour pour configurer les deux circuits précédents.

[[File:Décaleur d’instruction.png|centre|vignette|upright=2|Décaleur d’instruction.]]

Une autre solution se passe de registre d'instruction en utilisant à la place l'état interne du séquenceur. Là encore, elle charge l'instruction morceau par morceau, typiquement par blocs de 8, 16 ou 32 bits. Les morceaux ne sont pas accumulés dans le registre d'instruction, la solution utilise à la place l'état interne du séquenceur. Les mots mémoire de l'instruction sont chargés à chaque cycle, faisant passer le séquenceur d'un état interne à un autre à chaque mot mémoire. Tant qu'il n'a pas reçu tous les mots mémoire de l'instruction, chaque mot mémoire non terminal le fera passer d'un état interne à un autre, chaque état interne encodant les mots mémoire chargés auparavant. S'il tombe sur le dernier mot mémoire d'une instruction, il rentre dans un état de décodage.

==L'incrémentation du ''program counter''==

À chaque chargement, le ''program counter'' est mis à jour afin de pointer sur la prochaine instruction à charger. Sur la quasi-totalité des processeurs, les instructions sont placées dans l'ordre d’exécution dans la RAM. En faisant ainsi, on peut mettre à jour le ''program counter'' en lui ajoutant la longueur de l'instruction courante. Déterminer la longueur de l'instruction est simple quand les instructions ont toutes la même taille, mais certains processeurs ont des instructions de taille variable, ce qui complique le calcul. Dans ce qui va suivre, nous allons supposer que les instructions sont de taille fixe, ce qui fait que le ''program counter'' est toujours incrémenté de la même valeur.

Il existe deux méthodes principales pour incrémenter le ''program counter'' : soit le ''program counter'' a son propre additionneur, soit le ''program counter'' est mis à jour par l'ALU. Pour ce qui est de l'organisation des registres, soit le ''program counter'' est un registre séparé des autres, soit il est regroupé avec d'autres registres dans un banc de registre. En tout, cela donne quatre organisations possibles.
* Un ''program counter'' séparé relié à un incrémenteur séparé.
* Un ''program counter'' séparé des autres registres, incrémenté par l'ALU.
* Un ''program counter'' intégré au banc de registre, relié à un incrémenteur séparé.
* Un ''program counter'' intégré au banc de registre, incrémenté par l'ALU.

[[File:Calcul du program counter.png|centre|vignette|upright=2|les différentes méthodes de calcul du program counter.]]

Les processeurs haute performance modernes utilisent tous la première méthode. Les autres méthodes étaient surtout utilisées sur les processeurs 8 ou 16 bits, elles sont encore utilisées sur quelques microcontrôleurs de faible puissance. Nous auront l'occasion de donner des exemples quand nous parlerons des processeurs 8 bits anciens, dans le chapitre sur les architectures à accumulateur et affiliées.

===Le ''program counter'' mis à jour par l'ALU===

Sur certains processeurs, le calcul de l'adresse de la prochaine instruction est effectué par l'ALU. L'avantage de cette méthode est qu'elle économise un incrémenteur dédié au ''program counter''. Ce qui explique que cette méthode était utilisée sur les processeurs assez anciens, à une époque où un additionneur pouvait facilement prendre 10 à 20% des transistors disponibles. Le désavantage principal est une augmentation de la complexité du séquenceur, qui doit gérer la mise à jour du ''program counter''. De plus, la mise à jour du ''program counter'' ne peut pas se faire en même temps qu'une opération arithmétique, ce qui réduit les performances.

Si on incrémente le ''program counter'' avec l'ALU, il est intéressant de le placer dans le banc de registres. Un désavantage est qu'on perd un registre. Par exemple, avec un banc de registre de 16 registres, on ne peut adresser que 15 registres généraux. De plus ce n'est pas l'idéal pour le décodage des instructions et pour le séquenceur. Si le processeur dispose de plusieurs bancs de registres, le ''program counter'' est généralement placé dans le banc de registre dédié aux adresses. Sinon, il est placé avec les nombres entiers/adresses.

D'anciens processeurs incrémentaient le ''program counter'' avec l'ALU, mais utilisaient bien un registre séparé pour le ''program counter''. Cette méthode est relativement simple à implémenter : il suffit de connecter/déconnecter le ''program counter'' du bus interne suivant les besoins. Le ''program counter'' est déconnecté pendant l’exécution d'une instruction, il est connecté au bus interne pour l'incrémenter. C'est le séquenceur qui gère le tout. L'avantage de cette séparation est qu'elle est plus facile à gérer pour le séquenceur. De plus, on gagne un registre général/entier dans le banc de registre.

===Le compteur programme===

Dans la quasi-totalité des processeurs modernes, le ''program counter'' est un vulgaire compteur comme on en a vu dans les chapitres sur les circuits, ce qui fait qu'il passe automatiquement d'une adresse à la suivante. Dans ce qui suit, nous allons appeler ce registre compteur : le '''compteur ordinal'''. L'usage d'un compteur simplifie fortement la conception du séquenceur. Le séquenceur n'a pas à gérer la mise à jour du ''program counter'', sauf en cas de branchements. De plus, il est possible d'incrémenter le ''program counter'' pendant que l'unité de calcul effectue une opération arithmétique, ce qui améliore grandement les performances. Le seul désavantage est qu'elle demande d'ajouter un incrémenteur dédié au ''program counter''.

Sur les processeurs très anciens, les instructions faisaient toutes un seul mot mémoire et le compteur ordinal était un circuit incrémenteur des plus basique. Sur les processeurs modernes, le compteur est incrémenté par pas de 4 si les instructions sont codées sur 4 octets, 8 si les instructions sont codées sur 8 octets, etc. Concrètement, le compteur est un circuit incrémenteur auquel on aurait retiré quelques bits de poids faible. Par exemple, si les instructions sont codées sur 4 octets, on coupe les 2 derniers bits du compteur. Si les instructions sont codées sur 8 octets, on coupe les 3 derniers bits du compteur. Et ainsi de suite.

Il a existé quelques processeurs pour lesquelles le ''program counter'' était non pas un compteur binaire classique, mais un ''linear feedback shift register''. L'avantage est que le circuit d'incrémentation utilisait bien moins de portes logiques, l'économie était substantielle. Mais un défaut est que des instructions consécutives dans le programme n'étaient pas consécutives en mémoire. Il existait cependant une table de correspondance pour dire : la première instruction est à telle adresse, la seconde à telle autre, etc. Un exemple de processeur de ce type est le TMS 1000 de Texas Instrument, un des premiers microcontrôleur 4 bits datant des années 70.

Une amélioration de la solution précédente utilise un circuit incrémenteur partagé entre le ''program counter'' et d'autres registres. L'incrémenteur est utilisé pour incrémenter le ''program counter'', mais aussi pour effectuer d'autres calculs d'adresse. Par exemple, sur les architectures avec une pile d'adresse de retour, il est possible de partager l'incrémenteur/décrémenteur avec le pointeur de pile ( la technique ne marche pas avec une pile d'appel). Un autre exemple est celui des processeurs qui gèrent automatiquement le rafraichissement mémoire, grâce à, un compteur intégré dans le processeur. Il est possible de partager l'incrémenteur du ''program counter'' avec le compteur de rafraichissement mémoire, qui mémorise la prochaine adresse mémoire à rafraichir. Nous avions déjà abordé ce genre de partage dans le chapitre sur le chemin de données, dans l'annexe sur le pointeur de pile, mais nous verrons d'autres exemples dans le chapitre sur les architectures hybride accumulateur-registre 8/16 bits.

===Quand est mis à jour le ''program counter'' ?===

Le ''program counter'' est mis à jour quand il faut charger une nouvelle instruction. Reste qu'il faut savoir quand le mettre à jour. Incrémenter le ''program counter'' à intervalle régulier, par exemple à chaque cycle d’horloge, fonctionne sur les processeurs où toutes les instructions mettent le même temps pour s’exécuter. Mais de tels processeurs sont très rares. Sur la quasi-totalité des processeurs, les instructions ont une durée d’exécution variable, elles ne prennent pas le même nombre de cycle d'horloge pour s’exécuter. Le temps d’exécution d'une instruction varie selon l'instruction, certaines sont plus longues que d'autres. Tout cela amène un problème : comment incrémenter le ''program counter'' avec des instructions avec des temps d’exécution variables ?

La réponse est que la mise à jour du ''program counter'' démarre quand l'instruction précédente a terminée de s’exécuter, plus précisément un cycle avant. C'est un cycle avant pour que l'instruction chargée soit disponible au prochain cycle pour le décodeur. Pour cela, le séquenceur doit déterminer quand l'instruction est terminée et prévenir le ''program counter'' au bon moment. Il faut donc une interaction entre séquenceur et circuit de chargement. Le circuit de chargement contient une entrée Enable, qui autorise la mise à jour du ''program counter''. Le séquenceur met à 1 cette entrée pour prévenir au ''program counter'' qu'il doit être incrémenté au cycle suivant ou lors du cycle courant. Cela permet de gérer simplement le cas des instructions multicycles. 

[[File:Commande de la mise à jour du program counter.png|centre|vignette|upright=2|Commande de la mise à jour du program counter.]]

Toute la difficulté est alors reportée dans le séquenceur, qui doit déterminer la durée d'une instruction. Pour gérer la mise à jour du ''program counter'', le séquenceur doit déterminer la durée d'une instruction. Cela est simple pour les instructions arithmétiques et logiques, qui ont un nombre de cycles fixe, toujours le même. Une fois l'instruction identifiée par le séquenceur, il connait son nombre de cycles et peut programmer un compteur interne au séquenceur, qui compte le nombre de cycles de l'instruction, et fournit le signal Enable au ''program counter''. Mais cette technique ne marche pas vraiment pour les accès mémoire, dont la durée n'est pas connue à l'avance, surtout sur les processeurs avec des mémoires caches. Pour cela, le séquenceur détermine quand l'instruction mémoire est finie et prévient le ''program counter'' quand c'est le cas.

Il existe quelques processeurs pour lesquels le temps de calcul dépend des opérandes de l'instruction. On peut par exemple avoir une division qui prend 10 cycles avec certaines opérandes, mais 40 cycles avec d'autres opérandes. Mais ces processeurs sont rares et cela est surtout valable pour les opérations de multiplication/division, guère plus. Le problème est alors le même qu'avec les accès mémoire et la solution est la même : l'ALU prévient le séquenceur quand le résultat est disponible.

==Les branchements et le ''program counter''==

Un branchement consiste juste à écrire l'adresse de destination dans le ''program counter''. L'implémentation des branchements demande d'extraire l'adresse de destination et d'altérer le ''program counter'' quand un branchement est détecté. Pour cela, le décodeur d'instruction détecte si l'instruction exécutée est un branchement ou non, et il en déduit où trouver l'adresse de destination.

L'adresse de destination se trouve à un endroit qui dépend du mode d'adressage du branchement. Pour rappel, on distingue quatre modes d'adressage pour les branchements : direct, indirect, relatif et implicite. Pour les branchements directs, l'adresse est intégrée dans l'instruction de branchement elle-même et est extraite par le séquenceur. Pour les branchements indirects, l'adresse de destination est dans le banc de registre. Pour les branchements relatifs, il faut ajouter un décalage au ''program counter'', décalage extrait de l'instruction par le séquenceur. Enfin, les instructions de retour de fonction lisent l'adresse de destination depuis la pile. L'implémentation de ces quatre types de branchements est très différente.

L'altération du ''program counter'' dépend de si le ''program counter'' est dans un compteur séparé ou s'il est dans le banc de registre. Nous avons vu plus haut qu'il y a quatre cas différents, mais nous n'allons voir que deux cas : celui où le ''program counter'' est dans le banc de registre et est incrémenté par l'unité de calcul, celui avec un ''program counter'' séparé avec son propre incrémenteur. Les deux autres cas ne sont utilisés que sur des architectures à accumulateur ou à pile spécifiques, que nous n'avons pas encore vu à ce stade du cours et que nous verrons en temps voulu dans le chapitre sur ces architectures.

===L’implémentation des branchements avec un ''program counter'' intégré au banc de registres===

Le cas le plus simple est celui où le ''program counter'' est intégré au banc de registre, avec une incrémentation faite par l'unité de calcul. Charger une instruction revient alors à effectuer une instruction LOAD en adressage indirect, à deux différences près : le registre sélectionné est le ''program counter'', l’instruction est copiée dans le registre d'instruction et non dans le banc de registre. L'incrémentation du ''porgram counter'' est implémenté avec des micro-opérations qui agissent sur le chemin de données, au même titre que les branchements indirects, relatifs et directs.
* Les branchements indirects copient un registre dans le ''program counter'', ce qui revient simplement à faire une opération MOV entre deux registres, dont le ''program counter'' est la destination.
* L'opération inverse d'un branchement indirect, qui copie le ''program counter'' dans un registre général, est utile pour sauvegarder l'adresse de retour d'une fonction.
* Les branchements directs copient une adresse dans le ''program counter'', ce qui les rend équivalents à une opération MOV avec une constante immédiate, dont le ''program counter'' est la destination.
* Les branchements relatifs sont une opération arithmétique entre le ''program counter'' et un opérande en adressage immédiat.

En clair, à partir du moment où le chemin de données supporte les instructions MOV et l'addition, avec les modes d'adressage adéquat, il supporte les branchements. Aucune modification du chemin de données n'est nécessaire, le séquenceur gére le chargement d'une instruction avec les micro-instructions adéquates : une micro-opération ADD pour incrémenter le ''program counter'', une micro-opération LOAD pour le chargement de l'instruction.

Notons que sur certaines architectures, le ''program counter'' est adressable au même titre que les autres registres du banc de registre. Les instructions de branchement sont alors remplacées par des instructions MOV ou des instructions arithmétique équivalentes, comme décrit plus haut.

===L’implémentation des branchements avec un ''program counter'' séparé===

Étudions maintenant le cas où le ''program counter'' est dans un registre/compteur séparé. Rappelons que tout compteur digne de ce nom possède une entrée de réinitialisation, qui remet le compteur à zéro. De plus, on peut préciser à quelle valeur il doit être réinitialisé. Ici, la valeur à laquelle on veut réinitialiser le compteur n'est autre que l'adresse de destination du branchement. Implémenter un branchement est donc simple : l'entrée de réinitialisation est commandée par le circuit de détection des branchements, alors que la valeur de réinitialisation est envoyée sur l'entrée adéquate. En clair, nous partons du principe que le ''program counter'' est implémenté avec ce type de compteur :

[[File:Fonctionnement d'un compteur (décompteur), schématique.jpg|centre|vignette|upright=1.5|Fonctionnement d'un compteur (décompteur), schématique]]

Toute la difficulté est de présenter l'adresse de destination au ''program counter''. Pour les branchements directs, l'adresse de destination est fournie par le séquenceur. L'adresse de destination du branchement sort du séquenceur et est présentée au ''program counter'' sur l'entrée adéquate. Voici donc comment sont implémentés les branchements directs avec un ''program counter'' séparé du banc de registres. Le schéma ci-dessous marche peu importe que le ''program counter'' soit incrémenté par l'ALU ou par un additionneur dédié.

[[File:Unité de détection des branchements dans le décodeur.png|centre|vignette|upright=2|Unité de détection des branchements dans le décodeur]]

Les branchements relatifs sont ceux qui font sauter X instructions plus loin dans le programme. Leur implémentation demande d'ajouter une constante au ''program counter'', la constante étant fournie dans l’instruction. Là encore, deux solutions sont possibles : réutiliser l'ALU pour calculer l'adresse, ou utiliser un additionneur séparé. L'additionneur séparé peut être fusionné avec l'additionneur qui incrémente le ''program counter'' pour passer à l’instruction suivante.

[[File:Unité de chargement qui gère les branchements relatifs.png|centre|vignette|upright=2|Unité de chargement qui gère les branchements relatifs.]]

Pour les branchements indirects, il suffit de lire le registre voulu et d'envoyer le tout sur l'entrée adéquate du ''program counter''. Il faut alors rajouter un multiplexeur pour que l'entrée de réinitialisationr ecoive la bonne adresse de destination.

[[File:Unité de chargement qui gère les branchements directs.png|centre|vignette|upright=2|Unité de chargement qui gère les branchements directs et indirects.]]

Toute la difficulté de l'implémentation des branchements est de configurer les multiplexeurs, ce qui est réalisé par le séquenceur en fonction du mode d'adressage du branchement.

==Les optimisations du chargement des instructions==

Charger une instruction est techniquement une forme d'accès mémoire un peu particulier. En clair, charger une instruction prend au minimum un cycle d'horloge, et cela peut rapidement monter à 3-5 cycles, si ce n'est plus. L'exécution des instructions est alors fortement ralentit par la mémoire. Par exemple, imaginez que la mémoire mette 3 cycles d'horloges pour charger une instruction, alors qu'une instruction s’exécute en 1 cycle (si les opérandes sont dans les registres). La perte de performance liée au chargement des instructions est alors substantielle. Heureusement, il est possible de limiter la casse en utilisant des mémoires caches, ainsi que d'autres optimisations, que nous allons voir dans ce qui suit.

===Le tampon de préchargement===

La technique dite du '''préchargement''' est utilisée dans le cas où la mémoire a un temps d'accès important. Mais si la latence de la RAM est un problème, le débit ne l'est pas. Il est possible d'avoir une RAM lente, mais à fort débit. Par exemple, supposons que la mémoire puisse charger 4 instructions (de taille fixe) en 3 cycles. Le processeur peut alors charger 4 instructions en un seul accès mémoire, et les exécuter l'une après l'autre, une par cycle d'horloge. Les temps d'attente sont éliminés : le processeur peut décoder une nouvelle instruction à chaque cycle. Et quand la dernière instruction préchargée est exécutée, la mémoire est de nouveau libre, ce qui masque la latence des accès mémoire.

[[File:Tampon de préchargement d'instruction.png|vignette|Tampon de préchargement d'instruction]]

La seule contrainte est de mettre les instructions préchargées en attente. La solution pour cela est d'utiliser un registre d'instruction très large, capable de mémoriser plusieurs instructions à la fois. Ce registre est de plus connecté à un multiplexeur qui permet de sélectionner l'instruction adéquate dans ce registre. Ce multiplexeur est commandé par le ''program counter'' et quelques circuits annexes. Ce super-registre d'instruction est appelé un '''tampon de préchargement'''.

La méthode a une implémentation nettement plus simple avec des instructions de taille fixe, alignées en mémoire. La commande du multiplexeur de sélection de l'instruction est alors beaucoup plus simple : il suffit d'utiliser les bits de poids fort du ''program counter''. Par exemple, prenons le cas d'un registre d'instruction de 32 octets pour des instructions de 4 octets, soit 8 instructions. Le choix de l'instruction à sélectionner se fait en utilisant les 3 bits de poids faible du ''program counter''. 

Mais cette méthode ajoute de nouvelles contraintes d'alignement, similaires à celles vues dans le chapitre sur l'alignement et le boutisme, sauf que l'alignement porte ici sur des blocs d'instructions de même taille que le tampon de préchargement. Si on prend l'exemple d'un tampon de préchargement de 128 bits, les instructions devront être alignées par blocs de 128 bits. C'est à dire qu'idéalement, les fonctions et autres blocs de code isolés doivent commencer à des adresses multiples de 128, pour pouvoir charger un bloc d'instruction en une seule fois. Sans cela, les performances seront sous-optimales.

: Il arrive que le tampon de préchargement ait la même taille qu'une ligne de cache.

Lorsque l'on passe d'un bloc d'instruction à un autre, le tampon de préchargement est mis à jour. Par exemple, si on prend un tampon de préchargement de 4 instructions, on doit changer son contenu toutes les 4 instructions. La seule exception est l'exécution d'un branchement. En effet, lors d'un branchement, la destination du branchement n'est pas dans le tampon de préchargement et elle doit être chargée dedans (sauf si le branchement pointe vers une instruction très proche, ce qui est improbable). Pour cela, le tampon de préchargement est mis à jour précocement quand le processeur détecte un branchement.

Le même problème survient avec du code auto-modifiant. Un code auto-modifiant est un programme qui se modifie lui-même, en remplaçant certaines instructions par d'autres, en en retirant, en en ajoutant, lors de sa propre exécution. De tels programmes sont rares, mais la technique était utilisée dans quelques cas au tout début de l'informatique sur des ordinateurs rudimentaires. Ceux-ci avaient des modes d'adressages tellement limités que gérer des tableaux de taille variable demandait d'utiliser du code auto-modifiant pour écrire des boucles. Le problème survient quand des instructions sont modifiées immédiatement après avoir été préchargées. Les instructions dans le tampon de préchargement sont l'ancienne version, alors que la mémoire RAM contient les instructions modifiées. Gérer ce genre de cas demande de vider le tampon de préchargement si le cas arrive, mais ça ne vaut que très rarement le coup, aussi les ingénieurs ne s’embêtent pas à mettre ce correctif en place. Le code automodifiant est alors buggé.

===La ''prefetch input queue''===

La ''prefetch input queue'' est une sorte de cousine du tampon de préchargement, qui a été utilisée sur les processeurs Intel assez ancien. Elle est apparue sur le 8086 et le 8088, des processeurs respectivement 8 et 16 bits. Elle été présente sur le 286 et le 386, mais était un peu améliorée. Elle est apparue sur ces processeurs à une époque où le processeur devenait plus rapide que la mémoire.

L'idée est là encore de précharger des instructions en avance. Sauf que cette fois-ci, on ne charge pas plusieurs instructions à la fois. Au contraire, les instructions sont préchargées séquentiellement, un octet à la fois. En conséquence, le tampon de préchargement est remplacé par une mémoire FIFO appelée la '''''Prefetch Input Queue''''', terme abrévié en PIQ. Les instructions sont accumulées une par une dans la PIQ, elles en sortent une par une au fur et à mesure pour alimenter le décodeur d'instruction.

L'idée est que pendant que le processeur exécute une instruction, on précharge la suivante. Sans ''prefetch input queue'', le processeur chargeait une instruction, la décodait et l'exécutait, puis chargeait la suivante, et ainsi de suite. Avec la ''prefetch input queue'', pendant qu'une instruction est en cours de décodage/exécution, le processeur précharge l'instruction suivante. Si une instruction prend vraiment beaucoup de temps pour s'exécuter, le processeur peut en profiter pour précharger l'instruction encore suivante, et ainsi de suite, jusqu'à une limite de 4/6 instructions (la limite dépend du processeur).

La ''prefetch input queue'' permet de précharger l'instruction suivante à condition qu'aucun autre accès mémoire n'ait lieu. Si l'instruction en cours d'exécution effectue des accès mémoire, ceux-ci sont prioritaires sur tout le reste, le préchargement de l'instruction suivante est alors mis en pause ou inhibé. Par contre, si la mémoire n'est pas utilisée par l'instruction en cours d'exécution, le processeur lit l'instruction suivante en RAM et la copie dans la ''prefetch input queue''. En conséquence, il arrive que la 'prefetch input queue'' n'ait pas préchargé l'instruction suivante, alors que le décodeur d'instruction est prêt pour la décoder. Dans ce cas, le décodeur doit attendre que l'instruction soit chargée.

Les instructions préchargées dans la ''Prefetch input queue'' y attendent que le processeur les lise et les décode. Les instructions préchargées sont conservées dans leur ordre d'arrivée, afin qu'elles soient exécutées dans le bon ordre, ce qui fait que la ''Prefetch input queue'' est une mémoire de type FIFO. L'étape de décodage pioche l'instruction à décoder dans la ''Prefetch input queue'', cette instruction étant par définition la plus ancienne, puis la retire de la file.

Le premier processeur commercial grand public à utiliser une ''prefetch input queue'' était le 8086. Il pouvait précharger à l'avance 6 octets d’instruction. L'Intel 8088 avait lui aussi une ''Prefetch input queue'', mais qui ne permettait que de précharger 4 instructions. La taille idéale de la FIFO dépend de nombreux paramètres. On pourrait croire que plus elle peut contenir d'instructions, mieux c'est, mais ce n'est pas le cas, pour des raisons que nous allons expliquer dans quelques paragraphes.

Vous remarquerez que j'ai exprimé la capacité de la ''prefetch input queue'' en octets et non en instructions. La raison est que sur les processeurs x86, les instructions sont de taille variable. Les instructions de ces processeurs ont une taille qui varie entre deux octets et 6 octets. La ''prefetch input queue'' était optimisée pour lire des instructions de deux octets, avec quelques mécanismes pour gérer les instructions plus longues. Il faut dire que les instructions les plus courantes faisaient deux octets, respectivement un octet d'opcode et un octet Mod/RM pour préciser le mode d'adressage.

Si les instructions faisaient deux octets ou plus, La mémoire RAM ne permettait que de charger un octet à la fois. Le décodeur devait attendre que les deux octets d'une instruction soient disponibles dans la ''Prefetch input queue''. Pour cela, un circuit appelé le ''loader'' fournissait deux signaux au décodeur d'instruction : l'un indiquant que le premier octet est déjà chargé, l'autre indiquant que le second octet est disponible.

Le ''loader'' recevait aussi des signaux de la part du décodeur d'instruction, afin de gérer les lectures dans la ''Prefetch input queue''. Le décodeur envoyait le signal ''Run Next Instruction'' pour lire une instruction :  elle était alors dépilée de la ''Prefetch input queue''. Le décodeur d'instruction pouvait aussi envoyer un signal ''Next-to-last (NXT)'' un cycle en avance, un cucle avant que l'instruction en cours ne termine. Le résultat est que le ''loader'' réagissait en préchargeant l'instruction suivante. En clair, ce signal permettait de précharger l'instruction suivante avec un cycle d'avance, si celle-ci n'était pas déjà dans la ''Prefetch input queue''.

Pour gérer les instructions de plus de deux octets, le décodeur pouvait lire une instruction en plusieurs fois dans la ''Prefetch input queue''. Les deux premiers octets sont lus depuis la ''Prefetch input queue'', et sont alors décodés. Le décodeur détermine alors la taille de l'instruction. Si l'instruction fait exactement deux octets, elle est exécutée directement. Sinon, les octets manquants sont lus depuis la ''Prefetch input queue''. Pour cela, le décodeur dispose d'une micro-opération pour lire un octet depuis la ''Prefetch input queue''.

[[File:80186 arch.png|centre|vignette|700px|upright=2|Architecture du 8086, du 80186 et de ses variantes.]]

Les branchements posent des problèmes avec la ''Prefetch input queue'' : à cause d'eux, on peut charger à l'avance des instructions qui sont zappées par un branchement et ne sont pas censées être exécutées. Si un branchement est chargé, toutes les instructions préchargées après sont potentiellement invalides. Si le branchement est non-pris, les instructions chargées sont valides, elles sont censées s’exécuter. Mais si le branchement est pris, elles ont été chargées à tort et ne doivent pas s’exécuter. 

Pour éviter cela, la ''Prefetch input queue'' est vidée quand le processeur détecte un branchement. Pour cela, le décodeur d'instruction dispose d'une micro-opération qui vide la ''Prefetch input queue'', elle invalide les instructions préchargées.  Cette détection ne peut se faire qu'une fois le branchement décodé, qu'une fois que l'on sait que l'instruction décodée est un branchement. En clair, le décodeur invalide la ''Prefetch input queue'' quand il détecte un branchement. Les interruptions posent le même genre de problèmes. Il faut impérativement vider la ''Prefetch input queue'' quand une interruption survient, avant de la traiter.

Il faut noter qu'une ''Prefetch input queue'' interagit assez mal avec le ''program counter''. En effet, la ''Prefetch input queue'' précharge les instructions séquentiellement. Pour savoir où elle en est rendue, elle mémorise l'adresse de la prochaine instruction à charger dans un registre dédié. Et pour ne pas faire doublon, ce registre remplace le ''program counter''. Après tout, le registre n'est qu'un ''program counter'' ayant pris une avance de quelques cycles d'horloge, qui a été incrémenté en avance. Il serait possible d'utiliser un ''program counter'' en plus du registre de préchargement, mais ce n'est pas la solution qui a été utilisée. Les processeurs Intel anciens ont préféré n'utiliser qu'un seul registre de préchargement en remplacement du ''program counter''.

Et cela ne pose pas de problèmes, sauf dans le cas des branchements. Par exemple, certains branchements relatifs demandent de connaitre la véritable valeur du ''program counter'', pas celle calculée en avance. D'autres situations demandent de connaitre exactement la valeur du ''program counter'', celle sans préchargement. Pour cela, le décodeur d'instruction dispose d'une instruction pour reconstituer le ''program counter'', à savoir corriger le ''program coutner'' et éliminer l'effet du préchargement.

Un autre défaut est que la ''Prefetch input queue'' se marie assez mal avec du code auto-modifiant. Un code auto-modifiant est un programme qui se modifie lui-même, en remplaçant certaines instructions par d'autres, en en retirant, en en ajoutant, lors de sa propre exécution. De tels programmes sont rares, mais la technique était utilisée dans quelques cas au tout début de l'informatique sur des ordinateurs rudimentaires. Ceux-ci avaient des modes d'adressages tellement limités que gérer des tableaux de taille variable demandait d'utiliser du code auto-modifiant pour écrire des boucles.

Le problème avec la ''Prefetch input queue'' survient quand des instructions sont modifiées immédiatement après avoir été préchargées. Les instructions dans la ''Prefetch input queue'' sont l'ancienne version, alors que la mémoire RAM contient les instructions modifiées. Gérer ce genre de cas est quelque peu complexe. Il faut en effet vider la ''Prefetch input queue'' si le cas arrive, ce qui demande d'identifier les écritures qui écrasent des instructions préchargées. C'est parfaitement possible, mais demande de transformer la ''Prefetch input queue'' en une mémoire hybride, à la fois mémoire associative et mémoire FIFO. Cela ne vaut que très rarement le coup, aussi les ingénieurs ne s’embêtent pas à mettre ce correctif en place, le code automodifiant est alors buggé.

Le décodeur d'instruction dispose aussi d'une micro-opération qui stoppe le préchargement des instructions dans la ''Prefetch input queue''.

===Le ''Zero-overhead looping''===

Nous avions vu dans le chapitre sur les instructions machines, qu'il existe des instructions qui permettent de grandement faciliter l'implémentation des boucles. Il s'agit de l'instruction REPEAT, utilisée sur certains processeurs de traitement de signal. Elle répète l'instruction suivante, voire une série d'instructions, un certain nombre de fois. Le nombre de répétitions est mémorisé dans un registre décrémenté à chaque itération de la boucle. Elle permet donc d'implémenter une boucle FOR facilement, sans recourir à des branchements ou des conditions.

Une technique en lien avec cette instruction permet de grandement améliorer les performances et la consommation d'énergie. L'idée est de mémoriser la boucle, les instructions à répéter, dans une petite mémoire cache située entre l'unité de chargement et le séquenceur. Le cache en question s'appelle un '''tampon de boucle''', ou encore un ''hardware loop buffer''. Grâce à lui, il n'y a pas besoin de charger les instructions à chaque fois qu'on les exécute, on les charge une bonne fois pour toute : c'est plus rapide. Bien sûr, il ne fonctionne que pour de petites boucles, mais il en est de même avec l'instruction REPEAT.

&lt;noinclude&gt;
{{NavChapitre | book=Fonctionnement d'un ordinateur
           | prev=Le chemin de données
           | prevText=Le chemin de données
           | next=L'unité de contrôle
           | nextText=L'unité de contrôle
}}
&lt;/noinclude&gt;</text>
      <sha1>saagvh0xivfhorbpv85z2alml5rn3mb</sha1>
    </revision>
    <revision>
      <id>744078</id>
      <parentid>744077</parentid>
      <timestamp>2025-06-03T19:32:43Z</timestamp>
      <contributor>
        <username>Mewtow</username>
        <id>31375</id>
      </contributor>
      <minor />
      <comment>/* La prefetch input queue */</comment>
      <origin>744078</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="44479" sha1="snop5my30q4kn3h68r5nbtdge1eynd5" xml:space="preserve">L'unité de contrôle s'occupe du chargement des instructions et de leur interprétation, leur décodage. Elle contient deux circuits : l''''unité de chargement''' qui charge l'instruction depuis la mémoire, et le '''séquenceur''' qui commande le chemin de données. Les deux circuits sont séparés, mais ils communiquent entre eux, notamment pour gérer les branchements. Dans ce chapitre, nous allons nous intéresser au chargement d'une instruction depuis la RAM/ROM, nous verrons l'étape de décodage de l'instruction au prochain chapitre.

==Le chargement d'une instruction==

[[File:Étape de chargement.png|vignette|upright=1|Étape de chargement.]]

L'étape de chargement (ou ''fetch'') doit faire deux choses : mettre à jour le ''program counter'' et lire l'instruction en mémoire RAM ou en ROM. Les deux étapes peuvent être faites en parallèle, dans des circuits séparés. Pendant que l'instruction est lue depuis la mémoire RAM/ROM, le ''program counter'' est incrémenté et/ou altéré par un branchement.

Pour lire l'instruction, on envoie le ''program counter'' sur le bus d'adresse et on récupère l'instruction sur le bus de données pour l'envoyer sur l'entrée du séquenceur. Et cela demande de connecter le séquenceur au bus mémoire, à travers l'interface mémoire. Et sur ce point, la situation est différente selon que l'on parler d'une architecture Harvard ou Von Neumann.

===Les interconnexions entre séquenceur et bus mémoire===

Sur les architectures Harvard, le séquenceur et le chemin de donnée utilisent des interfaces mémoire séparées. Le séquenceur est directement relié au bus mémoire de la ROM, alors que le chemin de données est connecté à la RAM.

[[File:Microarchitecture de l'interface mémoire d'une architecture Harvard.png|centre|vignette|upright=2|Microarchitecture de l'interface mémoire d'une architecture Harvard]]

Mais sur les architectures Von-Neumann et affiliées, le séquenceur et le chemin de donnée partagent la même interface mémoire. Et cela pose deux problèmes.

Le premier problème est que le bus mémoire doit être libéré une fois l'instruction chargée, pour un éventuel accès mémoire. Mais le séquenceur doit conserver une copie de l'instruction chargée, sans quoi il ne peut pas décoder l'instruction correctement. Par exemple, si l'instruction met plusieurs cycles à s'exécuter, le séquenceur doit conserver une copie de l'instruction durant ces plusieurs cycles. La solution à ce problème est un '''registre d'instruction''' situé juste avant le séquenceur, qui mémorise l'instruction chargée.

[[File:Registre d'instruction.png|centre|vignette|upright=2|Registre d'instruction.]]

Le second problème est de gérer le flot des instructions/données entre le bus mémoire, le chemin de données et le séquenceur. Le processeur doit connecter l'interface mémoire soit au séquenceur, soit au chemin de données et cela complique le réseau d'interconnexion interne au processeur.

Une première solution utilise un bus unique qui relie l'interface mémoire, le séquenceur et le chemin de données. Pour charger une instruction, le séquenceur copie le ''program counter'' sur le bus d'adresse, attend que l'instruction lue soit disponible sur le bus de données, puis la copie dans le registre d'instruction. Le bus mémoire est alors libre et peut être utilisé pour lire ou écrire des données, si le besoin s'en fait sentir.

Il faut noter que l'usage d'un bus unique a un impact sur l'organisation interne du chemin de données. Par exemple, le chapitre précédent nous a montré comment implémenter un chemin de données basique, avec des multiplexeurs et démultiplexeurs. Et bien ces chemins de données ne marchent pas vraiment avec un bus interne unique. Il est possible de les adapter, mais au prix d'une complexité largement supérieure. Un bus interne unique marche mieux quand le banc de registre est mono-port. C'est pourquoi il a été utilisé sur d'anciennes architectures appelées des architectures à accumulateur et à pile, que nous verrons dans quelques chapitres, qui utilisaient un banc de registre mono-port.

[[File:Microarchitecture de l'interface mémoire d'une architecture von neumann.png|centre|vignette|upright=2|Microarchitecture de l'interface mémoire d'une architecture von neumann]]

Une autre solution utilise deux bus interne séparés : un connecté au bus d'adresse, l'autre au bus de données. Le ''program counter'' est alors connecté au bus interne d'adresse, le séquenceur est relié au bus interne de données. Notons que la technique marche bien si le ''program counter'' est dans le banc de registre : les interconnexions utilisées pour gérer l'adressage indirect permettent d'envoyer le ''program counter'' sur le bus d'adresse sans ajout de circuit.

Le tout peut être amélioré en remplaçant les deux bus par des multiplexeurs et démultiplexeurs. Le bus d'adresse est précédé par un multiplexeur, qui permet de faire le choix entre ''Program Counter'', adresse venant du chemin de données, ou adresse provenant du séquenceur (adressage absolu). De même, le bus de données est suivi par un démultiplexeur qui envoie la donnée/instruction lue soit au registre d'instruction, soit au chemin de données. Le tout se marie très bien avec les chemins de donnée vu dans le chapitre précédent. Au passage, il faut noter que cette solution nécessite un banc de registre multi-port.

[[File:Connexion du program counter sur les bus avec PC isolé.png|centre|vignette|upright=2|Connexion du program counter sur les bus avec PC isolé]]

===Le chargement des instructions de longueur variable===

Le chargement des instructions de longueur variable pose de nombreux problèmes. Le premier est que mettre à jour le ''program counter'' demande de connaitre la longueur de l'instruction chargée, pour l'ajouter au ''program counter''. Si la longueur d'une instruction est variable, on doit connaitre cette longueur d'une manière où d'une autre. La solution la plus simple indique la longueur de l'instruction dans une partie de l'opcode ou de la représentation en binaire de l'instruction. Mais les processeurs haute performance de nos PC utilisent d'autres solutions, qui n'encodent pas explicitement la taille de l'instruction.

Les processeurs récents utilisent un registre d'instruction de grande taille, capable de mémoriser l'instruction la plus longue du processeur. Par exemple, si un processeur supporte des instructions allant de 1 à 8 octets, comme les CPU x86, le registre d'instruction fera 8 octets. Le décodeur d'instruction vérifie à chaque cycle le contenu du registre d'instruction. Si une instruction est détectée dedans, son décodage commence, peu importe la taille de l'instruction. Une fois l'instruction exécutée, elle est retirée du registre d'instruction. Reste à alimenter le registre d'instruction, à charger des instructions dedans. Et pour cela deux solutions : soit on charge l'instruction en plusieurs fois, soit d'un seul coup.

La solution la plus simple charge les instructions par mots de 8, 16, 32, 64 bits. Ils sont accumulés dans le registre d'instruction jusqu'à détecter une instruction complète. La technique marche nettement mieux si les instructions sont très longues. Par exemple, les CPU x86 ont des instructions qui vont de 1 à 15 octets, ce qui fait qu'ils utilisent cette technique. Précisément, elle marche si les instructions les plus longues sont plus grandes que le bus mémoire.

Une autre solution charge un bloc de mots mémoire aussi grand que la plus grande instruction. Par exemple, si le processeur gère des instructions allant de 1 à 4 octets, il charge 4 octets d'un seul coup dans le registre d'instruction. Il va de soit que cette solution ne marche que si les instructions du processeur sont assez courtes, au plus aussi courtes que le bus mémoire. Ainsi, on est sûr de charger obligatoirement au moins une instruction complète, et peut-être même plusieurs. Le contenu du registre d'instruction est alors découpé en instructions au fil de l'eau. 

Utiliser un registre d'instruction large pose problème avec des instructions à cheval entre deux blocs. Il se peut qu'on n'ait pas une instruction complète lorsque l'on arrive à la fin du bloc, mais seulement un morceau. Le problème se manifeste peu importe que l'instruction soit chargée d'un seul coup ou bien en plusieurs fois.

[[File:Instructions non alignées.png|centre|vignette|upright=2|Instructions non alignées.]]

Dans ce cas, on doit décaler le morceau de bloc pour le mettre au bon endroit (au début du registre d'instruction), et charger le prochain bloc juste à côté. On a donc besoin d'un circuit qui décale tous les bits du registre d'instruction, couplé à un circuit qui décide où placer dans le registre d'instruction ce qui a été chargé, avec quelques circuits autour pour configurer les deux circuits précédents.

[[File:Décaleur d’instruction.png|centre|vignette|upright=2|Décaleur d’instruction.]]

Une autre solution se passe de registre d'instruction en utilisant à la place l'état interne du séquenceur. Là encore, elle charge l'instruction morceau par morceau, typiquement par blocs de 8, 16 ou 32 bits. Les morceaux ne sont pas accumulés dans le registre d'instruction, la solution utilise à la place l'état interne du séquenceur. Les mots mémoire de l'instruction sont chargés à chaque cycle, faisant passer le séquenceur d'un état interne à un autre à chaque mot mémoire. Tant qu'il n'a pas reçu tous les mots mémoire de l'instruction, chaque mot mémoire non terminal le fera passer d'un état interne à un autre, chaque état interne encodant les mots mémoire chargés auparavant. S'il tombe sur le dernier mot mémoire d'une instruction, il rentre dans un état de décodage.

==L'incrémentation du ''program counter''==

À chaque chargement, le ''program counter'' est mis à jour afin de pointer sur la prochaine instruction à charger. Sur la quasi-totalité des processeurs, les instructions sont placées dans l'ordre d’exécution dans la RAM. En faisant ainsi, on peut mettre à jour le ''program counter'' en lui ajoutant la longueur de l'instruction courante. Déterminer la longueur de l'instruction est simple quand les instructions ont toutes la même taille, mais certains processeurs ont des instructions de taille variable, ce qui complique le calcul. Dans ce qui va suivre, nous allons supposer que les instructions sont de taille fixe, ce qui fait que le ''program counter'' est toujours incrémenté de la même valeur.

Il existe deux méthodes principales pour incrémenter le ''program counter'' : soit le ''program counter'' a son propre additionneur, soit le ''program counter'' est mis à jour par l'ALU. Pour ce qui est de l'organisation des registres, soit le ''program counter'' est un registre séparé des autres, soit il est regroupé avec d'autres registres dans un banc de registre. En tout, cela donne quatre organisations possibles.
* Un ''program counter'' séparé relié à un incrémenteur séparé.
* Un ''program counter'' séparé des autres registres, incrémenté par l'ALU.
* Un ''program counter'' intégré au banc de registre, relié à un incrémenteur séparé.
* Un ''program counter'' intégré au banc de registre, incrémenté par l'ALU.

[[File:Calcul du program counter.png|centre|vignette|upright=2|les différentes méthodes de calcul du program counter.]]

Les processeurs haute performance modernes utilisent tous la première méthode. Les autres méthodes étaient surtout utilisées sur les processeurs 8 ou 16 bits, elles sont encore utilisées sur quelques microcontrôleurs de faible puissance. Nous auront l'occasion de donner des exemples quand nous parlerons des processeurs 8 bits anciens, dans le chapitre sur les architectures à accumulateur et affiliées.

===Le ''program counter'' mis à jour par l'ALU===

Sur certains processeurs, le calcul de l'adresse de la prochaine instruction est effectué par l'ALU. L'avantage de cette méthode est qu'elle économise un incrémenteur dédié au ''program counter''. Ce qui explique que cette méthode était utilisée sur les processeurs assez anciens, à une époque où un additionneur pouvait facilement prendre 10 à 20% des transistors disponibles. Le désavantage principal est une augmentation de la complexité du séquenceur, qui doit gérer la mise à jour du ''program counter''. De plus, la mise à jour du ''program counter'' ne peut pas se faire en même temps qu'une opération arithmétique, ce qui réduit les performances.

Si on incrémente le ''program counter'' avec l'ALU, il est intéressant de le placer dans le banc de registres. Un désavantage est qu'on perd un registre. Par exemple, avec un banc de registre de 16 registres, on ne peut adresser que 15 registres généraux. De plus ce n'est pas l'idéal pour le décodage des instructions et pour le séquenceur. Si le processeur dispose de plusieurs bancs de registres, le ''program counter'' est généralement placé dans le banc de registre dédié aux adresses. Sinon, il est placé avec les nombres entiers/adresses.

D'anciens processeurs incrémentaient le ''program counter'' avec l'ALU, mais utilisaient bien un registre séparé pour le ''program counter''. Cette méthode est relativement simple à implémenter : il suffit de connecter/déconnecter le ''program counter'' du bus interne suivant les besoins. Le ''program counter'' est déconnecté pendant l’exécution d'une instruction, il est connecté au bus interne pour l'incrémenter. C'est le séquenceur qui gère le tout. L'avantage de cette séparation est qu'elle est plus facile à gérer pour le séquenceur. De plus, on gagne un registre général/entier dans le banc de registre.

===Le compteur programme===

Dans la quasi-totalité des processeurs modernes, le ''program counter'' est un vulgaire compteur comme on en a vu dans les chapitres sur les circuits, ce qui fait qu'il passe automatiquement d'une adresse à la suivante. Dans ce qui suit, nous allons appeler ce registre compteur : le '''compteur ordinal'''. L'usage d'un compteur simplifie fortement la conception du séquenceur. Le séquenceur n'a pas à gérer la mise à jour du ''program counter'', sauf en cas de branchements. De plus, il est possible d'incrémenter le ''program counter'' pendant que l'unité de calcul effectue une opération arithmétique, ce qui améliore grandement les performances. Le seul désavantage est qu'elle demande d'ajouter un incrémenteur dédié au ''program counter''.

Sur les processeurs très anciens, les instructions faisaient toutes un seul mot mémoire et le compteur ordinal était un circuit incrémenteur des plus basique. Sur les processeurs modernes, le compteur est incrémenté par pas de 4 si les instructions sont codées sur 4 octets, 8 si les instructions sont codées sur 8 octets, etc. Concrètement, le compteur est un circuit incrémenteur auquel on aurait retiré quelques bits de poids faible. Par exemple, si les instructions sont codées sur 4 octets, on coupe les 2 derniers bits du compteur. Si les instructions sont codées sur 8 octets, on coupe les 3 derniers bits du compteur. Et ainsi de suite.

Il a existé quelques processeurs pour lesquelles le ''program counter'' était non pas un compteur binaire classique, mais un ''linear feedback shift register''. L'avantage est que le circuit d'incrémentation utilisait bien moins de portes logiques, l'économie était substantielle. Mais un défaut est que des instructions consécutives dans le programme n'étaient pas consécutives en mémoire. Il existait cependant une table de correspondance pour dire : la première instruction est à telle adresse, la seconde à telle autre, etc. Un exemple de processeur de ce type est le TMS 1000 de Texas Instrument, un des premiers microcontrôleur 4 bits datant des années 70.

Une amélioration de la solution précédente utilise un circuit incrémenteur partagé entre le ''program counter'' et d'autres registres. L'incrémenteur est utilisé pour incrémenter le ''program counter'', mais aussi pour effectuer d'autres calculs d'adresse. Par exemple, sur les architectures avec une pile d'adresse de retour, il est possible de partager l'incrémenteur/décrémenteur avec le pointeur de pile ( la technique ne marche pas avec une pile d'appel). Un autre exemple est celui des processeurs qui gèrent automatiquement le rafraichissement mémoire, grâce à, un compteur intégré dans le processeur. Il est possible de partager l'incrémenteur du ''program counter'' avec le compteur de rafraichissement mémoire, qui mémorise la prochaine adresse mémoire à rafraichir. Nous avions déjà abordé ce genre de partage dans le chapitre sur le chemin de données, dans l'annexe sur le pointeur de pile, mais nous verrons d'autres exemples dans le chapitre sur les architectures hybride accumulateur-registre 8/16 bits.

===Quand est mis à jour le ''program counter'' ?===

Le ''program counter'' est mis à jour quand il faut charger une nouvelle instruction. Reste qu'il faut savoir quand le mettre à jour. Incrémenter le ''program counter'' à intervalle régulier, par exemple à chaque cycle d’horloge, fonctionne sur les processeurs où toutes les instructions mettent le même temps pour s’exécuter. Mais de tels processeurs sont très rares. Sur la quasi-totalité des processeurs, les instructions ont une durée d’exécution variable, elles ne prennent pas le même nombre de cycle d'horloge pour s’exécuter. Le temps d’exécution d'une instruction varie selon l'instruction, certaines sont plus longues que d'autres. Tout cela amène un problème : comment incrémenter le ''program counter'' avec des instructions avec des temps d’exécution variables ?

La réponse est que la mise à jour du ''program counter'' démarre quand l'instruction précédente a terminée de s’exécuter, plus précisément un cycle avant. C'est un cycle avant pour que l'instruction chargée soit disponible au prochain cycle pour le décodeur. Pour cela, le séquenceur doit déterminer quand l'instruction est terminée et prévenir le ''program counter'' au bon moment. Il faut donc une interaction entre séquenceur et circuit de chargement. Le circuit de chargement contient une entrée Enable, qui autorise la mise à jour du ''program counter''. Le séquenceur met à 1 cette entrée pour prévenir au ''program counter'' qu'il doit être incrémenté au cycle suivant ou lors du cycle courant. Cela permet de gérer simplement le cas des instructions multicycles. 

[[File:Commande de la mise à jour du program counter.png|centre|vignette|upright=2|Commande de la mise à jour du program counter.]]

Toute la difficulté est alors reportée dans le séquenceur, qui doit déterminer la durée d'une instruction. Pour gérer la mise à jour du ''program counter'', le séquenceur doit déterminer la durée d'une instruction. Cela est simple pour les instructions arithmétiques et logiques, qui ont un nombre de cycles fixe, toujours le même. Une fois l'instruction identifiée par le séquenceur, il connait son nombre de cycles et peut programmer un compteur interne au séquenceur, qui compte le nombre de cycles de l'instruction, et fournit le signal Enable au ''program counter''. Mais cette technique ne marche pas vraiment pour les accès mémoire, dont la durée n'est pas connue à l'avance, surtout sur les processeurs avec des mémoires caches. Pour cela, le séquenceur détermine quand l'instruction mémoire est finie et prévient le ''program counter'' quand c'est le cas.

Il existe quelques processeurs pour lesquels le temps de calcul dépend des opérandes de l'instruction. On peut par exemple avoir une division qui prend 10 cycles avec certaines opérandes, mais 40 cycles avec d'autres opérandes. Mais ces processeurs sont rares et cela est surtout valable pour les opérations de multiplication/division, guère plus. Le problème est alors le même qu'avec les accès mémoire et la solution est la même : l'ALU prévient le séquenceur quand le résultat est disponible.

==Les branchements et le ''program counter''==

Un branchement consiste juste à écrire l'adresse de destination dans le ''program counter''. L'implémentation des branchements demande d'extraire l'adresse de destination et d'altérer le ''program counter'' quand un branchement est détecté. Pour cela, le décodeur d'instruction détecte si l'instruction exécutée est un branchement ou non, et il en déduit où trouver l'adresse de destination.

L'adresse de destination se trouve à un endroit qui dépend du mode d'adressage du branchement. Pour rappel, on distingue quatre modes d'adressage pour les branchements : direct, indirect, relatif et implicite. Pour les branchements directs, l'adresse est intégrée dans l'instruction de branchement elle-même et est extraite par le séquenceur. Pour les branchements indirects, l'adresse de destination est dans le banc de registre. Pour les branchements relatifs, il faut ajouter un décalage au ''program counter'', décalage extrait de l'instruction par le séquenceur. Enfin, les instructions de retour de fonction lisent l'adresse de destination depuis la pile. L'implémentation de ces quatre types de branchements est très différente.

L'altération du ''program counter'' dépend de si le ''program counter'' est dans un compteur séparé ou s'il est dans le banc de registre. Nous avons vu plus haut qu'il y a quatre cas différents, mais nous n'allons voir que deux cas : celui où le ''program counter'' est dans le banc de registre et est incrémenté par l'unité de calcul, celui avec un ''program counter'' séparé avec son propre incrémenteur. Les deux autres cas ne sont utilisés que sur des architectures à accumulateur ou à pile spécifiques, que nous n'avons pas encore vu à ce stade du cours et que nous verrons en temps voulu dans le chapitre sur ces architectures.

===L’implémentation des branchements avec un ''program counter'' intégré au banc de registres===

Le cas le plus simple est celui où le ''program counter'' est intégré au banc de registre, avec une incrémentation faite par l'unité de calcul. Charger une instruction revient alors à effectuer une instruction LOAD en adressage indirect, à deux différences près : le registre sélectionné est le ''program counter'', l’instruction est copiée dans le registre d'instruction et non dans le banc de registre. L'incrémentation du ''porgram counter'' est implémenté avec des micro-opérations qui agissent sur le chemin de données, au même titre que les branchements indirects, relatifs et directs.
* Les branchements indirects copient un registre dans le ''program counter'', ce qui revient simplement à faire une opération MOV entre deux registres, dont le ''program counter'' est la destination.
* L'opération inverse d'un branchement indirect, qui copie le ''program counter'' dans un registre général, est utile pour sauvegarder l'adresse de retour d'une fonction.
* Les branchements directs copient une adresse dans le ''program counter'', ce qui les rend équivalents à une opération MOV avec une constante immédiate, dont le ''program counter'' est la destination.
* Les branchements relatifs sont une opération arithmétique entre le ''program counter'' et un opérande en adressage immédiat.

En clair, à partir du moment où le chemin de données supporte les instructions MOV et l'addition, avec les modes d'adressage adéquat, il supporte les branchements. Aucune modification du chemin de données n'est nécessaire, le séquenceur gére le chargement d'une instruction avec les micro-instructions adéquates : une micro-opération ADD pour incrémenter le ''program counter'', une micro-opération LOAD pour le chargement de l'instruction.

Notons que sur certaines architectures, le ''program counter'' est adressable au même titre que les autres registres du banc de registre. Les instructions de branchement sont alors remplacées par des instructions MOV ou des instructions arithmétique équivalentes, comme décrit plus haut.

===L’implémentation des branchements avec un ''program counter'' séparé===

Étudions maintenant le cas où le ''program counter'' est dans un registre/compteur séparé. Rappelons que tout compteur digne de ce nom possède une entrée de réinitialisation, qui remet le compteur à zéro. De plus, on peut préciser à quelle valeur il doit être réinitialisé. Ici, la valeur à laquelle on veut réinitialiser le compteur n'est autre que l'adresse de destination du branchement. Implémenter un branchement est donc simple : l'entrée de réinitialisation est commandée par le circuit de détection des branchements, alors que la valeur de réinitialisation est envoyée sur l'entrée adéquate. En clair, nous partons du principe que le ''program counter'' est implémenté avec ce type de compteur :

[[File:Fonctionnement d'un compteur (décompteur), schématique.jpg|centre|vignette|upright=1.5|Fonctionnement d'un compteur (décompteur), schématique]]

Toute la difficulté est de présenter l'adresse de destination au ''program counter''. Pour les branchements directs, l'adresse de destination est fournie par le séquenceur. L'adresse de destination du branchement sort du séquenceur et est présentée au ''program counter'' sur l'entrée adéquate. Voici donc comment sont implémentés les branchements directs avec un ''program counter'' séparé du banc de registres. Le schéma ci-dessous marche peu importe que le ''program counter'' soit incrémenté par l'ALU ou par un additionneur dédié.

[[File:Unité de détection des branchements dans le décodeur.png|centre|vignette|upright=2|Unité de détection des branchements dans le décodeur]]

Les branchements relatifs sont ceux qui font sauter X instructions plus loin dans le programme. Leur implémentation demande d'ajouter une constante au ''program counter'', la constante étant fournie dans l’instruction. Là encore, deux solutions sont possibles : réutiliser l'ALU pour calculer l'adresse, ou utiliser un additionneur séparé. L'additionneur séparé peut être fusionné avec l'additionneur qui incrémente le ''program counter'' pour passer à l’instruction suivante.

[[File:Unité de chargement qui gère les branchements relatifs.png|centre|vignette|upright=2|Unité de chargement qui gère les branchements relatifs.]]

Pour les branchements indirects, il suffit de lire le registre voulu et d'envoyer le tout sur l'entrée adéquate du ''program counter''. Il faut alors rajouter un multiplexeur pour que l'entrée de réinitialisationr ecoive la bonne adresse de destination.

[[File:Unité de chargement qui gère les branchements directs.png|centre|vignette|upright=2|Unité de chargement qui gère les branchements directs et indirects.]]

Toute la difficulté de l'implémentation des branchements est de configurer les multiplexeurs, ce qui est réalisé par le séquenceur en fonction du mode d'adressage du branchement.

==Les optimisations du chargement des instructions==

Charger une instruction est techniquement une forme d'accès mémoire un peu particulier. En clair, charger une instruction prend au minimum un cycle d'horloge, et cela peut rapidement monter à 3-5 cycles, si ce n'est plus. L'exécution des instructions est alors fortement ralentit par la mémoire. Par exemple, imaginez que la mémoire mette 3 cycles d'horloges pour charger une instruction, alors qu'une instruction s’exécute en 1 cycle (si les opérandes sont dans les registres). La perte de performance liée au chargement des instructions est alors substantielle. Heureusement, il est possible de limiter la casse en utilisant des mémoires caches, ainsi que d'autres optimisations, que nous allons voir dans ce qui suit.

===Le tampon de préchargement===

La technique dite du '''préchargement''' est utilisée dans le cas où la mémoire a un temps d'accès important. Mais si la latence de la RAM est un problème, le débit ne l'est pas. Il est possible d'avoir une RAM lente, mais à fort débit. Par exemple, supposons que la mémoire puisse charger 4 instructions (de taille fixe) en 3 cycles. Le processeur peut alors charger 4 instructions en un seul accès mémoire, et les exécuter l'une après l'autre, une par cycle d'horloge. Les temps d'attente sont éliminés : le processeur peut décoder une nouvelle instruction à chaque cycle. Et quand la dernière instruction préchargée est exécutée, la mémoire est de nouveau libre, ce qui masque la latence des accès mémoire.

[[File:Tampon de préchargement d'instruction.png|vignette|Tampon de préchargement d'instruction]]

La seule contrainte est de mettre les instructions préchargées en attente. La solution pour cela est d'utiliser un registre d'instruction très large, capable de mémoriser plusieurs instructions à la fois. Ce registre est de plus connecté à un multiplexeur qui permet de sélectionner l'instruction adéquate dans ce registre. Ce multiplexeur est commandé par le ''program counter'' et quelques circuits annexes. Ce super-registre d'instruction est appelé un '''tampon de préchargement'''.

La méthode a une implémentation nettement plus simple avec des instructions de taille fixe, alignées en mémoire. La commande du multiplexeur de sélection de l'instruction est alors beaucoup plus simple : il suffit d'utiliser les bits de poids fort du ''program counter''. Par exemple, prenons le cas d'un registre d'instruction de 32 octets pour des instructions de 4 octets, soit 8 instructions. Le choix de l'instruction à sélectionner se fait en utilisant les 3 bits de poids faible du ''program counter''. 

Mais cette méthode ajoute de nouvelles contraintes d'alignement, similaires à celles vues dans le chapitre sur l'alignement et le boutisme, sauf que l'alignement porte ici sur des blocs d'instructions de même taille que le tampon de préchargement. Si on prend l'exemple d'un tampon de préchargement de 128 bits, les instructions devront être alignées par blocs de 128 bits. C'est à dire qu'idéalement, les fonctions et autres blocs de code isolés doivent commencer à des adresses multiples de 128, pour pouvoir charger un bloc d'instruction en une seule fois. Sans cela, les performances seront sous-optimales.

: Il arrive que le tampon de préchargement ait la même taille qu'une ligne de cache.

Lorsque l'on passe d'un bloc d'instruction à un autre, le tampon de préchargement est mis à jour. Par exemple, si on prend un tampon de préchargement de 4 instructions, on doit changer son contenu toutes les 4 instructions. La seule exception est l'exécution d'un branchement. En effet, lors d'un branchement, la destination du branchement n'est pas dans le tampon de préchargement et elle doit être chargée dedans (sauf si le branchement pointe vers une instruction très proche, ce qui est improbable). Pour cela, le tampon de préchargement est mis à jour précocement quand le processeur détecte un branchement.

Le même problème survient avec du code auto-modifiant. Un code auto-modifiant est un programme qui se modifie lui-même, en remplaçant certaines instructions par d'autres, en en retirant, en en ajoutant, lors de sa propre exécution. De tels programmes sont rares, mais la technique était utilisée dans quelques cas au tout début de l'informatique sur des ordinateurs rudimentaires. Ceux-ci avaient des modes d'adressages tellement limités que gérer des tableaux de taille variable demandait d'utiliser du code auto-modifiant pour écrire des boucles. Le problème survient quand des instructions sont modifiées immédiatement après avoir été préchargées. Les instructions dans le tampon de préchargement sont l'ancienne version, alors que la mémoire RAM contient les instructions modifiées. Gérer ce genre de cas demande de vider le tampon de préchargement si le cas arrive, mais ça ne vaut que très rarement le coup, aussi les ingénieurs ne s’embêtent pas à mettre ce correctif en place. Le code automodifiant est alors buggé.

===La ''prefetch input queue''===

La ''prefetch input queue'' est une sorte de cousine du tampon de préchargement, qui a été utilisée sur les processeurs Intel assez ancien. Elle est apparue sur le 8086 et le 8088, des processeurs respectivement 8 et 16 bits. Elle été présente sur le 286 et le 386, mais était un peu améliorée. Elle est apparue sur ces processeurs à une époque où le processeur devenait plus rapide que la mémoire.

L'idée est là encore de précharger des instructions en avance. Sauf que cette fois-ci, on ne charge pas plusieurs instructions à la fois. Au contraire, les instructions sont préchargées séquentiellement, un octet à la fois. En conséquence, le tampon de préchargement est remplacé par une mémoire FIFO appelée la '''''Prefetch Input Queue''''', terme abrévié en PIQ. Les instructions sont accumulées une par une dans la PIQ, elles en sortent une par une au fur et à mesure pour alimenter le décodeur d'instruction.

L'idée est que pendant que le processeur exécute une instruction, on précharge la suivante. Sans ''prefetch input queue'', le processeur chargeait une instruction, la décodait et l'exécutait, puis chargeait la suivante, et ainsi de suite. Avec la ''prefetch input queue'', pendant qu'une instruction est en cours de décodage/exécution, le processeur précharge l'instruction suivante. Si une instruction prend vraiment beaucoup de temps pour s'exécuter, le processeur peut en profiter pour précharger l'instruction encore suivante, et ainsi de suite, jusqu'à une limite de 4/6 instructions (la limite dépend du processeur).

La ''prefetch input queue'' permet de précharger l'instruction suivante à condition qu'aucun autre accès mémoire n'ait lieu. Si l'instruction en cours d'exécution effectue des accès mémoire, ceux-ci sont prioritaires sur tout le reste, le préchargement de l'instruction suivante est alors mis en pause ou inhibé. Par contre, si la mémoire n'est pas utilisée par l'instruction en cours d'exécution, le processeur lit l'instruction suivante en RAM et la copie dans la ''prefetch input queue''. En conséquence, il arrive que la 'prefetch input queue'' n'ait pas préchargé l'instruction suivante, alors que le décodeur d'instruction est prêt pour la décoder. Dans ce cas, le décodeur doit attendre que l'instruction soit chargée.

Les instructions préchargées dans la ''Prefetch input queue'' y attendent que le processeur les lise et les décode. Les instructions préchargées sont conservées dans leur ordre d'arrivée, afin qu'elles soient exécutées dans le bon ordre, ce qui fait que la ''Prefetch input queue'' est une mémoire de type FIFO. L'étape de décodage pioche l'instruction à décoder dans la ''Prefetch input queue'', cette instruction étant par définition la plus ancienne, puis la retire de la file.

Le premier processeur commercial grand public à utiliser une ''prefetch input queue'' était le 8086. Il pouvait précharger à l'avance 6 octets d’instruction. L'Intel 8088 avait lui aussi une ''Prefetch input queue'', mais qui ne permettait que de précharger 4 instructions. La taille idéale de la FIFO dépend de nombreux paramètres. On pourrait croire que plus elle peut contenir d'instructions, mieux c'est, mais ce n'est pas le cas, pour des raisons que nous allons expliquer dans quelques paragraphes.

Vous remarquerez que j'ai exprimé la capacité de la ''prefetch input queue'' en octets et non en instructions. La raison est que sur les processeurs x86, les instructions sont de taille variable. Les instructions de ces processeurs ont une taille qui varie entre deux octets et 6 octets. La ''prefetch input queue'' était optimisée pour lire des instructions de deux octets, avec quelques mécanismes pour gérer les instructions plus longues. Il faut dire que les instructions les plus courantes faisaient deux octets, respectivement un octet d'opcode et un octet Mod/RM pour préciser le mode d'adressage.

Si les instructions faisaient deux octets ou plus, La mémoire RAM ne permettait que de charger un octet à la fois. Le décodeur devait attendre que les deux octets d'une instruction soient disponibles dans la ''Prefetch input queue''. Pour cela, un circuit appelé le ''loader'' fournissait deux signaux au décodeur d'instruction : l'un indiquant que le premier octet est déjà chargé, l'autre indiquant que le second octet est disponible.

Le ''loader'' recevait aussi des signaux de la part du décodeur d'instruction, afin de gérer les lectures dans la ''Prefetch input queue''. Le décodeur envoyait le signal ''Run Next Instruction'' pour lire une instruction :  elle était alors dépilée de la ''Prefetch input queue''. Le décodeur d'instruction pouvait aussi envoyer un signal ''Next-to-last (NXT)'' un cycle en avance, un cucle avant que l'instruction en cours ne termine. Le résultat est que le ''loader'' réagissait en préchargeant l'instruction suivante. En clair, ce signal permettait de précharger l'instruction suivante avec un cycle d'avance, si celle-ci n'était pas déjà dans la ''Prefetch input queue''.

Pour gérer les instructions de plus de deux octets, le décodeur pouvait lire une instruction en plusieurs fois dans la ''Prefetch input queue''. Les deux premiers octets sont lus depuis la ''Prefetch input queue'', et sont alors décodés. Le décodeur détermine alors la taille de l'instruction. Si l'instruction fait exactement deux octets, elle est exécutée directement. Sinon, les octets manquants sont lus depuis la ''Prefetch input queue''. Pour cela, le décodeur dispose d'une micro-opération pour lire un octet depuis la ''Prefetch input queue''.

[[File:80186 arch.png|centre|vignette|700px|upright=2|Architecture du 8086, du 80186 et de ses variantes.]]

Les branchements posent des problèmes avec la ''Prefetch input queue'' : à cause d'eux, on peut charger à l'avance des instructions qui sont zappées par un branchement et ne sont pas censées être exécutées. Si un branchement est chargé, toutes les instructions préchargées après sont potentiellement invalides. Si le branchement est non-pris, les instructions chargées sont valides, elles sont censées s’exécuter. Mais si le branchement est pris, elles ont été chargées à tort et ne doivent pas s’exécuter. 

Pour éviter cela, la ''Prefetch input queue'' est vidée quand le processeur détecte un branchement. Pour cela, le décodeur d'instruction dispose d'une micro-opération qui vide la ''Prefetch input queue'', elle invalide les instructions préchargées.  Cette détection ne peut se faire qu'une fois le branchement décodé, qu'une fois que l'on sait que l'instruction décodée est un branchement. En clair, le décodeur invalide la ''Prefetch input queue'' quand il détecte un branchement. Les interruptions posent le même genre de problèmes. Il faut impérativement vider la ''Prefetch input queue'' quand une interruption survient, avant de la traiter.

Il faut noter qu'une ''Prefetch input queue'' interagit assez mal avec le ''program counter''. En effet, la ''Prefetch input queue'' précharge les instructions séquentiellement. Pour savoir où elle en est rendue, elle mémorise l'adresse de la prochaine instruction à charger dans un '''registre de préchargement''' dédié. Il serait possible d'utiliser un ''program counter'' en plus du registre de préchargement, mais ce n'est pas la solution qui a été utilisée. Les processeurs Intel anciens ont préféré n'utiliser qu'un seul registre de préchargement en remplacement du ''program counter''. Après tout, le registre de préchargement n'est qu'un ''program counter'' ayant pris une avance de quelques cycles d'horloge, qui a été incrémenté en avance.

Et cela ne pose pas de problèmes, sauf avec certains branchements. Par exemple, certains branchements relatifs demandent de connaitre la véritable valeur du ''program counter'', pas celle calculée en avance. Idem avec les instructions d'appel de fonction, qui demandent de sauvegarder l'adresse de retour exacte, donc le vrai ''program counter''. De telles situations demandent de connaitre la valeur réelle du ''program counter'', celle sans préchargement. Pour cela, le décodeur d'instruction dispose d'une instruction pour reconstituer le ''program counter'', à savoir corriger le ''program coutner'' et éliminer l'effet du préchargement.

La micro-opération de correction se contente de soustraire le nombre d'octets préchargés au registre de préchargement. Le nombre d'octets préchargés est déduit à partir des deux pointeurs intégré à la FIFO, qui indiquent la position du premier et du dernier octet préchargé. Le bit qui indique si la FIFO est vide était aussi utilisé. Les deux pointeurs sont lus depuis la FIFO, et sont envoyés à un circuit qui détermine le nombre d'octets préchargés. Sur le 8086, ce circuit était implémenté non pas par un circuit combinatoire, mais par une mémoire ROM équivalente. La petite taille de la FIFO faisait que les pointeurs étaient très petits et la ROM l'était aussi.

Un autre défaut est que la ''Prefetch input queue'' se marie assez mal avec du code auto-modifiant. Un code auto-modifiant est un programme qui se modifie lui-même, en remplaçant certaines instructions par d'autres, en en retirant, en en ajoutant, lors de sa propre exécution. De tels programmes sont rares, mais la technique était utilisée dans quelques cas au tout début de l'informatique sur des ordinateurs rudimentaires. Ceux-ci avaient des modes d'adressages tellement limités que gérer des tableaux de taille variable demandait d'utiliser du code auto-modifiant pour écrire des boucles.

Le problème avec la ''Prefetch input queue'' survient quand des instructions sont modifiées immédiatement après avoir été préchargées. Les instructions dans la ''Prefetch input queue'' sont l'ancienne version, alors que la mémoire RAM contient les instructions modifiées. Gérer ce genre de cas est quelque peu complexe. Il faut en effet vider la ''Prefetch input queue'' si le cas arrive, ce qui demande d'identifier les écritures qui écrasent des instructions préchargées. C'est parfaitement possible, mais demande de transformer la ''Prefetch input queue'' en une mémoire hybride, à la fois mémoire associative et mémoire FIFO. Cela ne vaut que très rarement le coup, aussi les ingénieurs ne s’embêtent pas à mettre ce correctif en place, le code automodifiant est alors buggé.

Le décodeur d'instruction dispose aussi d'une micro-opération qui stoppe le préchargement des instructions dans la ''Prefetch input queue''.

===Le ''Zero-overhead looping''===

Nous avions vu dans le chapitre sur les instructions machines, qu'il existe des instructions qui permettent de grandement faciliter l'implémentation des boucles. Il s'agit de l'instruction REPEAT, utilisée sur certains processeurs de traitement de signal. Elle répète l'instruction suivante, voire une série d'instructions, un certain nombre de fois. Le nombre de répétitions est mémorisé dans un registre décrémenté à chaque itération de la boucle. Elle permet donc d'implémenter une boucle FOR facilement, sans recourir à des branchements ou des conditions.

Une technique en lien avec cette instruction permet de grandement améliorer les performances et la consommation d'énergie. L'idée est de mémoriser la boucle, les instructions à répéter, dans une petite mémoire cache située entre l'unité de chargement et le séquenceur. Le cache en question s'appelle un '''tampon de boucle''', ou encore un ''hardware loop buffer''. Grâce à lui, il n'y a pas besoin de charger les instructions à chaque fois qu'on les exécute, on les charge une bonne fois pour toute : c'est plus rapide. Bien sûr, il ne fonctionne que pour de petites boucles, mais il en est de même avec l'instruction REPEAT.

&lt;noinclude&gt;
{{NavChapitre | book=Fonctionnement d'un ordinateur
           | prev=Le chemin de données
           | prevText=Le chemin de données
           | next=L'unité de contrôle
           | nextText=L'unité de contrôle
}}
&lt;/noinclude&gt;</text>
      <sha1>snop5my30q4kn3h68r5nbtdge1eynd5</sha1>
    </revision>
    <revision>
      <id>744079</id>
      <parentid>744078</parentid>
      <timestamp>2025-06-03T19:33:33Z</timestamp>
      <contributor>
        <username>Mewtow</username>
        <id>31375</id>
      </contributor>
      <minor />
      <comment>/* La prefetch input queue */</comment>
      <origin>744079</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="44479" sha1="e31iqpu86acm6q7l03adnq2aohvuayd" xml:space="preserve">L'unité de contrôle s'occupe du chargement des instructions et de leur interprétation, leur décodage. Elle contient deux circuits : l''''unité de chargement''' qui charge l'instruction depuis la mémoire, et le '''séquenceur''' qui commande le chemin de données. Les deux circuits sont séparés, mais ils communiquent entre eux, notamment pour gérer les branchements. Dans ce chapitre, nous allons nous intéresser au chargement d'une instruction depuis la RAM/ROM, nous verrons l'étape de décodage de l'instruction au prochain chapitre.

==Le chargement d'une instruction==

[[File:Étape de chargement.png|vignette|upright=1|Étape de chargement.]]

L'étape de chargement (ou ''fetch'') doit faire deux choses : mettre à jour le ''program counter'' et lire l'instruction en mémoire RAM ou en ROM. Les deux étapes peuvent être faites en parallèle, dans des circuits séparés. Pendant que l'instruction est lue depuis la mémoire RAM/ROM, le ''program counter'' est incrémenté et/ou altéré par un branchement.

Pour lire l'instruction, on envoie le ''program counter'' sur le bus d'adresse et on récupère l'instruction sur le bus de données pour l'envoyer sur l'entrée du séquenceur. Et cela demande de connecter le séquenceur au bus mémoire, à travers l'interface mémoire. Et sur ce point, la situation est différente selon que l'on parler d'une architecture Harvard ou Von Neumann.

===Les interconnexions entre séquenceur et bus mémoire===

Sur les architectures Harvard, le séquenceur et le chemin de donnée utilisent des interfaces mémoire séparées. Le séquenceur est directement relié au bus mémoire de la ROM, alors que le chemin de données est connecté à la RAM.

[[File:Microarchitecture de l'interface mémoire d'une architecture Harvard.png|centre|vignette|upright=2|Microarchitecture de l'interface mémoire d'une architecture Harvard]]

Mais sur les architectures Von-Neumann et affiliées, le séquenceur et le chemin de donnée partagent la même interface mémoire. Et cela pose deux problèmes.

Le premier problème est que le bus mémoire doit être libéré une fois l'instruction chargée, pour un éventuel accès mémoire. Mais le séquenceur doit conserver une copie de l'instruction chargée, sans quoi il ne peut pas décoder l'instruction correctement. Par exemple, si l'instruction met plusieurs cycles à s'exécuter, le séquenceur doit conserver une copie de l'instruction durant ces plusieurs cycles. La solution à ce problème est un '''registre d'instruction''' situé juste avant le séquenceur, qui mémorise l'instruction chargée.

[[File:Registre d'instruction.png|centre|vignette|upright=2|Registre d'instruction.]]

Le second problème est de gérer le flot des instructions/données entre le bus mémoire, le chemin de données et le séquenceur. Le processeur doit connecter l'interface mémoire soit au séquenceur, soit au chemin de données et cela complique le réseau d'interconnexion interne au processeur.

Une première solution utilise un bus unique qui relie l'interface mémoire, le séquenceur et le chemin de données. Pour charger une instruction, le séquenceur copie le ''program counter'' sur le bus d'adresse, attend que l'instruction lue soit disponible sur le bus de données, puis la copie dans le registre d'instruction. Le bus mémoire est alors libre et peut être utilisé pour lire ou écrire des données, si le besoin s'en fait sentir.

Il faut noter que l'usage d'un bus unique a un impact sur l'organisation interne du chemin de données. Par exemple, le chapitre précédent nous a montré comment implémenter un chemin de données basique, avec des multiplexeurs et démultiplexeurs. Et bien ces chemins de données ne marchent pas vraiment avec un bus interne unique. Il est possible de les adapter, mais au prix d'une complexité largement supérieure. Un bus interne unique marche mieux quand le banc de registre est mono-port. C'est pourquoi il a été utilisé sur d'anciennes architectures appelées des architectures à accumulateur et à pile, que nous verrons dans quelques chapitres, qui utilisaient un banc de registre mono-port.

[[File:Microarchitecture de l'interface mémoire d'une architecture von neumann.png|centre|vignette|upright=2|Microarchitecture de l'interface mémoire d'une architecture von neumann]]

Une autre solution utilise deux bus interne séparés : un connecté au bus d'adresse, l'autre au bus de données. Le ''program counter'' est alors connecté au bus interne d'adresse, le séquenceur est relié au bus interne de données. Notons que la technique marche bien si le ''program counter'' est dans le banc de registre : les interconnexions utilisées pour gérer l'adressage indirect permettent d'envoyer le ''program counter'' sur le bus d'adresse sans ajout de circuit.

Le tout peut être amélioré en remplaçant les deux bus par des multiplexeurs et démultiplexeurs. Le bus d'adresse est précédé par un multiplexeur, qui permet de faire le choix entre ''Program Counter'', adresse venant du chemin de données, ou adresse provenant du séquenceur (adressage absolu). De même, le bus de données est suivi par un démultiplexeur qui envoie la donnée/instruction lue soit au registre d'instruction, soit au chemin de données. Le tout se marie très bien avec les chemins de donnée vu dans le chapitre précédent. Au passage, il faut noter que cette solution nécessite un banc de registre multi-port.

[[File:Connexion du program counter sur les bus avec PC isolé.png|centre|vignette|upright=2|Connexion du program counter sur les bus avec PC isolé]]

===Le chargement des instructions de longueur variable===

Le chargement des instructions de longueur variable pose de nombreux problèmes. Le premier est que mettre à jour le ''program counter'' demande de connaitre la longueur de l'instruction chargée, pour l'ajouter au ''program counter''. Si la longueur d'une instruction est variable, on doit connaitre cette longueur d'une manière où d'une autre. La solution la plus simple indique la longueur de l'instruction dans une partie de l'opcode ou de la représentation en binaire de l'instruction. Mais les processeurs haute performance de nos PC utilisent d'autres solutions, qui n'encodent pas explicitement la taille de l'instruction.

Les processeurs récents utilisent un registre d'instruction de grande taille, capable de mémoriser l'instruction la plus longue du processeur. Par exemple, si un processeur supporte des instructions allant de 1 à 8 octets, comme les CPU x86, le registre d'instruction fera 8 octets. Le décodeur d'instruction vérifie à chaque cycle le contenu du registre d'instruction. Si une instruction est détectée dedans, son décodage commence, peu importe la taille de l'instruction. Une fois l'instruction exécutée, elle est retirée du registre d'instruction. Reste à alimenter le registre d'instruction, à charger des instructions dedans. Et pour cela deux solutions : soit on charge l'instruction en plusieurs fois, soit d'un seul coup.

La solution la plus simple charge les instructions par mots de 8, 16, 32, 64 bits. Ils sont accumulés dans le registre d'instruction jusqu'à détecter une instruction complète. La technique marche nettement mieux si les instructions sont très longues. Par exemple, les CPU x86 ont des instructions qui vont de 1 à 15 octets, ce qui fait qu'ils utilisent cette technique. Précisément, elle marche si les instructions les plus longues sont plus grandes que le bus mémoire.

Une autre solution charge un bloc de mots mémoire aussi grand que la plus grande instruction. Par exemple, si le processeur gère des instructions allant de 1 à 4 octets, il charge 4 octets d'un seul coup dans le registre d'instruction. Il va de soit que cette solution ne marche que si les instructions du processeur sont assez courtes, au plus aussi courtes que le bus mémoire. Ainsi, on est sûr de charger obligatoirement au moins une instruction complète, et peut-être même plusieurs. Le contenu du registre d'instruction est alors découpé en instructions au fil de l'eau. 

Utiliser un registre d'instruction large pose problème avec des instructions à cheval entre deux blocs. Il se peut qu'on n'ait pas une instruction complète lorsque l'on arrive à la fin du bloc, mais seulement un morceau. Le problème se manifeste peu importe que l'instruction soit chargée d'un seul coup ou bien en plusieurs fois.

[[File:Instructions non alignées.png|centre|vignette|upright=2|Instructions non alignées.]]

Dans ce cas, on doit décaler le morceau de bloc pour le mettre au bon endroit (au début du registre d'instruction), et charger le prochain bloc juste à côté. On a donc besoin d'un circuit qui décale tous les bits du registre d'instruction, couplé à un circuit qui décide où placer dans le registre d'instruction ce qui a été chargé, avec quelques circuits autour pour configurer les deux circuits précédents.

[[File:Décaleur d’instruction.png|centre|vignette|upright=2|Décaleur d’instruction.]]

Une autre solution se passe de registre d'instruction en utilisant à la place l'état interne du séquenceur. Là encore, elle charge l'instruction morceau par morceau, typiquement par blocs de 8, 16 ou 32 bits. Les morceaux ne sont pas accumulés dans le registre d'instruction, la solution utilise à la place l'état interne du séquenceur. Les mots mémoire de l'instruction sont chargés à chaque cycle, faisant passer le séquenceur d'un état interne à un autre à chaque mot mémoire. Tant qu'il n'a pas reçu tous les mots mémoire de l'instruction, chaque mot mémoire non terminal le fera passer d'un état interne à un autre, chaque état interne encodant les mots mémoire chargés auparavant. S'il tombe sur le dernier mot mémoire d'une instruction, il rentre dans un état de décodage.

==L'incrémentation du ''program counter''==

À chaque chargement, le ''program counter'' est mis à jour afin de pointer sur la prochaine instruction à charger. Sur la quasi-totalité des processeurs, les instructions sont placées dans l'ordre d’exécution dans la RAM. En faisant ainsi, on peut mettre à jour le ''program counter'' en lui ajoutant la longueur de l'instruction courante. Déterminer la longueur de l'instruction est simple quand les instructions ont toutes la même taille, mais certains processeurs ont des instructions de taille variable, ce qui complique le calcul. Dans ce qui va suivre, nous allons supposer que les instructions sont de taille fixe, ce qui fait que le ''program counter'' est toujours incrémenté de la même valeur.

Il existe deux méthodes principales pour incrémenter le ''program counter'' : soit le ''program counter'' a son propre additionneur, soit le ''program counter'' est mis à jour par l'ALU. Pour ce qui est de l'organisation des registres, soit le ''program counter'' est un registre séparé des autres, soit il est regroupé avec d'autres registres dans un banc de registre. En tout, cela donne quatre organisations possibles.
* Un ''program counter'' séparé relié à un incrémenteur séparé.
* Un ''program counter'' séparé des autres registres, incrémenté par l'ALU.
* Un ''program counter'' intégré au banc de registre, relié à un incrémenteur séparé.
* Un ''program counter'' intégré au banc de registre, incrémenté par l'ALU.

[[File:Calcul du program counter.png|centre|vignette|upright=2|les différentes méthodes de calcul du program counter.]]

Les processeurs haute performance modernes utilisent tous la première méthode. Les autres méthodes étaient surtout utilisées sur les processeurs 8 ou 16 bits, elles sont encore utilisées sur quelques microcontrôleurs de faible puissance. Nous auront l'occasion de donner des exemples quand nous parlerons des processeurs 8 bits anciens, dans le chapitre sur les architectures à accumulateur et affiliées.

===Le ''program counter'' mis à jour par l'ALU===

Sur certains processeurs, le calcul de l'adresse de la prochaine instruction est effectué par l'ALU. L'avantage de cette méthode est qu'elle économise un incrémenteur dédié au ''program counter''. Ce qui explique que cette méthode était utilisée sur les processeurs assez anciens, à une époque où un additionneur pouvait facilement prendre 10 à 20% des transistors disponibles. Le désavantage principal est une augmentation de la complexité du séquenceur, qui doit gérer la mise à jour du ''program counter''. De plus, la mise à jour du ''program counter'' ne peut pas se faire en même temps qu'une opération arithmétique, ce qui réduit les performances.

Si on incrémente le ''program counter'' avec l'ALU, il est intéressant de le placer dans le banc de registres. Un désavantage est qu'on perd un registre. Par exemple, avec un banc de registre de 16 registres, on ne peut adresser que 15 registres généraux. De plus ce n'est pas l'idéal pour le décodage des instructions et pour le séquenceur. Si le processeur dispose de plusieurs bancs de registres, le ''program counter'' est généralement placé dans le banc de registre dédié aux adresses. Sinon, il est placé avec les nombres entiers/adresses.

D'anciens processeurs incrémentaient le ''program counter'' avec l'ALU, mais utilisaient bien un registre séparé pour le ''program counter''. Cette méthode est relativement simple à implémenter : il suffit de connecter/déconnecter le ''program counter'' du bus interne suivant les besoins. Le ''program counter'' est déconnecté pendant l’exécution d'une instruction, il est connecté au bus interne pour l'incrémenter. C'est le séquenceur qui gère le tout. L'avantage de cette séparation est qu'elle est plus facile à gérer pour le séquenceur. De plus, on gagne un registre général/entier dans le banc de registre.

===Le compteur programme===

Dans la quasi-totalité des processeurs modernes, le ''program counter'' est un vulgaire compteur comme on en a vu dans les chapitres sur les circuits, ce qui fait qu'il passe automatiquement d'une adresse à la suivante. Dans ce qui suit, nous allons appeler ce registre compteur : le '''compteur ordinal'''. L'usage d'un compteur simplifie fortement la conception du séquenceur. Le séquenceur n'a pas à gérer la mise à jour du ''program counter'', sauf en cas de branchements. De plus, il est possible d'incrémenter le ''program counter'' pendant que l'unité de calcul effectue une opération arithmétique, ce qui améliore grandement les performances. Le seul désavantage est qu'elle demande d'ajouter un incrémenteur dédié au ''program counter''.

Sur les processeurs très anciens, les instructions faisaient toutes un seul mot mémoire et le compteur ordinal était un circuit incrémenteur des plus basique. Sur les processeurs modernes, le compteur est incrémenté par pas de 4 si les instructions sont codées sur 4 octets, 8 si les instructions sont codées sur 8 octets, etc. Concrètement, le compteur est un circuit incrémenteur auquel on aurait retiré quelques bits de poids faible. Par exemple, si les instructions sont codées sur 4 octets, on coupe les 2 derniers bits du compteur. Si les instructions sont codées sur 8 octets, on coupe les 3 derniers bits du compteur. Et ainsi de suite.

Il a existé quelques processeurs pour lesquelles le ''program counter'' était non pas un compteur binaire classique, mais un ''linear feedback shift register''. L'avantage est que le circuit d'incrémentation utilisait bien moins de portes logiques, l'économie était substantielle. Mais un défaut est que des instructions consécutives dans le programme n'étaient pas consécutives en mémoire. Il existait cependant une table de correspondance pour dire : la première instruction est à telle adresse, la seconde à telle autre, etc. Un exemple de processeur de ce type est le TMS 1000 de Texas Instrument, un des premiers microcontrôleur 4 bits datant des années 70.

Une amélioration de la solution précédente utilise un circuit incrémenteur partagé entre le ''program counter'' et d'autres registres. L'incrémenteur est utilisé pour incrémenter le ''program counter'', mais aussi pour effectuer d'autres calculs d'adresse. Par exemple, sur les architectures avec une pile d'adresse de retour, il est possible de partager l'incrémenteur/décrémenteur avec le pointeur de pile ( la technique ne marche pas avec une pile d'appel). Un autre exemple est celui des processeurs qui gèrent automatiquement le rafraichissement mémoire, grâce à, un compteur intégré dans le processeur. Il est possible de partager l'incrémenteur du ''program counter'' avec le compteur de rafraichissement mémoire, qui mémorise la prochaine adresse mémoire à rafraichir. Nous avions déjà abordé ce genre de partage dans le chapitre sur le chemin de données, dans l'annexe sur le pointeur de pile, mais nous verrons d'autres exemples dans le chapitre sur les architectures hybride accumulateur-registre 8/16 bits.

===Quand est mis à jour le ''program counter'' ?===

Le ''program counter'' est mis à jour quand il faut charger une nouvelle instruction. Reste qu'il faut savoir quand le mettre à jour. Incrémenter le ''program counter'' à intervalle régulier, par exemple à chaque cycle d’horloge, fonctionne sur les processeurs où toutes les instructions mettent le même temps pour s’exécuter. Mais de tels processeurs sont très rares. Sur la quasi-totalité des processeurs, les instructions ont une durée d’exécution variable, elles ne prennent pas le même nombre de cycle d'horloge pour s’exécuter. Le temps d’exécution d'une instruction varie selon l'instruction, certaines sont plus longues que d'autres. Tout cela amène un problème : comment incrémenter le ''program counter'' avec des instructions avec des temps d’exécution variables ?

La réponse est que la mise à jour du ''program counter'' démarre quand l'instruction précédente a terminée de s’exécuter, plus précisément un cycle avant. C'est un cycle avant pour que l'instruction chargée soit disponible au prochain cycle pour le décodeur. Pour cela, le séquenceur doit déterminer quand l'instruction est terminée et prévenir le ''program counter'' au bon moment. Il faut donc une interaction entre séquenceur et circuit de chargement. Le circuit de chargement contient une entrée Enable, qui autorise la mise à jour du ''program counter''. Le séquenceur met à 1 cette entrée pour prévenir au ''program counter'' qu'il doit être incrémenté au cycle suivant ou lors du cycle courant. Cela permet de gérer simplement le cas des instructions multicycles. 

[[File:Commande de la mise à jour du program counter.png|centre|vignette|upright=2|Commande de la mise à jour du program counter.]]

Toute la difficulté est alors reportée dans le séquenceur, qui doit déterminer la durée d'une instruction. Pour gérer la mise à jour du ''program counter'', le séquenceur doit déterminer la durée d'une instruction. Cela est simple pour les instructions arithmétiques et logiques, qui ont un nombre de cycles fixe, toujours le même. Une fois l'instruction identifiée par le séquenceur, il connait son nombre de cycles et peut programmer un compteur interne au séquenceur, qui compte le nombre de cycles de l'instruction, et fournit le signal Enable au ''program counter''. Mais cette technique ne marche pas vraiment pour les accès mémoire, dont la durée n'est pas connue à l'avance, surtout sur les processeurs avec des mémoires caches. Pour cela, le séquenceur détermine quand l'instruction mémoire est finie et prévient le ''program counter'' quand c'est le cas.

Il existe quelques processeurs pour lesquels le temps de calcul dépend des opérandes de l'instruction. On peut par exemple avoir une division qui prend 10 cycles avec certaines opérandes, mais 40 cycles avec d'autres opérandes. Mais ces processeurs sont rares et cela est surtout valable pour les opérations de multiplication/division, guère plus. Le problème est alors le même qu'avec les accès mémoire et la solution est la même : l'ALU prévient le séquenceur quand le résultat est disponible.

==Les branchements et le ''program counter''==

Un branchement consiste juste à écrire l'adresse de destination dans le ''program counter''. L'implémentation des branchements demande d'extraire l'adresse de destination et d'altérer le ''program counter'' quand un branchement est détecté. Pour cela, le décodeur d'instruction détecte si l'instruction exécutée est un branchement ou non, et il en déduit où trouver l'adresse de destination.

L'adresse de destination se trouve à un endroit qui dépend du mode d'adressage du branchement. Pour rappel, on distingue quatre modes d'adressage pour les branchements : direct, indirect, relatif et implicite. Pour les branchements directs, l'adresse est intégrée dans l'instruction de branchement elle-même et est extraite par le séquenceur. Pour les branchements indirects, l'adresse de destination est dans le banc de registre. Pour les branchements relatifs, il faut ajouter un décalage au ''program counter'', décalage extrait de l'instruction par le séquenceur. Enfin, les instructions de retour de fonction lisent l'adresse de destination depuis la pile. L'implémentation de ces quatre types de branchements est très différente.

L'altération du ''program counter'' dépend de si le ''program counter'' est dans un compteur séparé ou s'il est dans le banc de registre. Nous avons vu plus haut qu'il y a quatre cas différents, mais nous n'allons voir que deux cas : celui où le ''program counter'' est dans le banc de registre et est incrémenté par l'unité de calcul, celui avec un ''program counter'' séparé avec son propre incrémenteur. Les deux autres cas ne sont utilisés que sur des architectures à accumulateur ou à pile spécifiques, que nous n'avons pas encore vu à ce stade du cours et que nous verrons en temps voulu dans le chapitre sur ces architectures.

===L’implémentation des branchements avec un ''program counter'' intégré au banc de registres===

Le cas le plus simple est celui où le ''program counter'' est intégré au banc de registre, avec une incrémentation faite par l'unité de calcul. Charger une instruction revient alors à effectuer une instruction LOAD en adressage indirect, à deux différences près : le registre sélectionné est le ''program counter'', l’instruction est copiée dans le registre d'instruction et non dans le banc de registre. L'incrémentation du ''porgram counter'' est implémenté avec des micro-opérations qui agissent sur le chemin de données, au même titre que les branchements indirects, relatifs et directs.
* Les branchements indirects copient un registre dans le ''program counter'', ce qui revient simplement à faire une opération MOV entre deux registres, dont le ''program counter'' est la destination.
* L'opération inverse d'un branchement indirect, qui copie le ''program counter'' dans un registre général, est utile pour sauvegarder l'adresse de retour d'une fonction.
* Les branchements directs copient une adresse dans le ''program counter'', ce qui les rend équivalents à une opération MOV avec une constante immédiate, dont le ''program counter'' est la destination.
* Les branchements relatifs sont une opération arithmétique entre le ''program counter'' et un opérande en adressage immédiat.

En clair, à partir du moment où le chemin de données supporte les instructions MOV et l'addition, avec les modes d'adressage adéquat, il supporte les branchements. Aucune modification du chemin de données n'est nécessaire, le séquenceur gére le chargement d'une instruction avec les micro-instructions adéquates : une micro-opération ADD pour incrémenter le ''program counter'', une micro-opération LOAD pour le chargement de l'instruction.

Notons que sur certaines architectures, le ''program counter'' est adressable au même titre que les autres registres du banc de registre. Les instructions de branchement sont alors remplacées par des instructions MOV ou des instructions arithmétique équivalentes, comme décrit plus haut.

===L’implémentation des branchements avec un ''program counter'' séparé===

Étudions maintenant le cas où le ''program counter'' est dans un registre/compteur séparé. Rappelons que tout compteur digne de ce nom possède une entrée de réinitialisation, qui remet le compteur à zéro. De plus, on peut préciser à quelle valeur il doit être réinitialisé. Ici, la valeur à laquelle on veut réinitialiser le compteur n'est autre que l'adresse de destination du branchement. Implémenter un branchement est donc simple : l'entrée de réinitialisation est commandée par le circuit de détection des branchements, alors que la valeur de réinitialisation est envoyée sur l'entrée adéquate. En clair, nous partons du principe que le ''program counter'' est implémenté avec ce type de compteur :

[[File:Fonctionnement d'un compteur (décompteur), schématique.jpg|centre|vignette|upright=1.5|Fonctionnement d'un compteur (décompteur), schématique]]

Toute la difficulté est de présenter l'adresse de destination au ''program counter''. Pour les branchements directs, l'adresse de destination est fournie par le séquenceur. L'adresse de destination du branchement sort du séquenceur et est présentée au ''program counter'' sur l'entrée adéquate. Voici donc comment sont implémentés les branchements directs avec un ''program counter'' séparé du banc de registres. Le schéma ci-dessous marche peu importe que le ''program counter'' soit incrémenté par l'ALU ou par un additionneur dédié.

[[File:Unité de détection des branchements dans le décodeur.png|centre|vignette|upright=2|Unité de détection des branchements dans le décodeur]]

Les branchements relatifs sont ceux qui font sauter X instructions plus loin dans le programme. Leur implémentation demande d'ajouter une constante au ''program counter'', la constante étant fournie dans l’instruction. Là encore, deux solutions sont possibles : réutiliser l'ALU pour calculer l'adresse, ou utiliser un additionneur séparé. L'additionneur séparé peut être fusionné avec l'additionneur qui incrémente le ''program counter'' pour passer à l’instruction suivante.

[[File:Unité de chargement qui gère les branchements relatifs.png|centre|vignette|upright=2|Unité de chargement qui gère les branchements relatifs.]]

Pour les branchements indirects, il suffit de lire le registre voulu et d'envoyer le tout sur l'entrée adéquate du ''program counter''. Il faut alors rajouter un multiplexeur pour que l'entrée de réinitialisationr ecoive la bonne adresse de destination.

[[File:Unité de chargement qui gère les branchements directs.png|centre|vignette|upright=2|Unité de chargement qui gère les branchements directs et indirects.]]

Toute la difficulté de l'implémentation des branchements est de configurer les multiplexeurs, ce qui est réalisé par le séquenceur en fonction du mode d'adressage du branchement.

==Les optimisations du chargement des instructions==

Charger une instruction est techniquement une forme d'accès mémoire un peu particulier. En clair, charger une instruction prend au minimum un cycle d'horloge, et cela peut rapidement monter à 3-5 cycles, si ce n'est plus. L'exécution des instructions est alors fortement ralentit par la mémoire. Par exemple, imaginez que la mémoire mette 3 cycles d'horloges pour charger une instruction, alors qu'une instruction s’exécute en 1 cycle (si les opérandes sont dans les registres). La perte de performance liée au chargement des instructions est alors substantielle. Heureusement, il est possible de limiter la casse en utilisant des mémoires caches, ainsi que d'autres optimisations, que nous allons voir dans ce qui suit.

===Le tampon de préchargement===

La technique dite du '''préchargement''' est utilisée dans le cas où la mémoire a un temps d'accès important. Mais si la latence de la RAM est un problème, le débit ne l'est pas. Il est possible d'avoir une RAM lente, mais à fort débit. Par exemple, supposons que la mémoire puisse charger 4 instructions (de taille fixe) en 3 cycles. Le processeur peut alors charger 4 instructions en un seul accès mémoire, et les exécuter l'une après l'autre, une par cycle d'horloge. Les temps d'attente sont éliminés : le processeur peut décoder une nouvelle instruction à chaque cycle. Et quand la dernière instruction préchargée est exécutée, la mémoire est de nouveau libre, ce qui masque la latence des accès mémoire.

[[File:Tampon de préchargement d'instruction.png|vignette|Tampon de préchargement d'instruction]]

La seule contrainte est de mettre les instructions préchargées en attente. La solution pour cela est d'utiliser un registre d'instruction très large, capable de mémoriser plusieurs instructions à la fois. Ce registre est de plus connecté à un multiplexeur qui permet de sélectionner l'instruction adéquate dans ce registre. Ce multiplexeur est commandé par le ''program counter'' et quelques circuits annexes. Ce super-registre d'instruction est appelé un '''tampon de préchargement'''.

La méthode a une implémentation nettement plus simple avec des instructions de taille fixe, alignées en mémoire. La commande du multiplexeur de sélection de l'instruction est alors beaucoup plus simple : il suffit d'utiliser les bits de poids fort du ''program counter''. Par exemple, prenons le cas d'un registre d'instruction de 32 octets pour des instructions de 4 octets, soit 8 instructions. Le choix de l'instruction à sélectionner se fait en utilisant les 3 bits de poids faible du ''program counter''. 

Mais cette méthode ajoute de nouvelles contraintes d'alignement, similaires à celles vues dans le chapitre sur l'alignement et le boutisme, sauf que l'alignement porte ici sur des blocs d'instructions de même taille que le tampon de préchargement. Si on prend l'exemple d'un tampon de préchargement de 128 bits, les instructions devront être alignées par blocs de 128 bits. C'est à dire qu'idéalement, les fonctions et autres blocs de code isolés doivent commencer à des adresses multiples de 128, pour pouvoir charger un bloc d'instruction en une seule fois. Sans cela, les performances seront sous-optimales.

: Il arrive que le tampon de préchargement ait la même taille qu'une ligne de cache.

Lorsque l'on passe d'un bloc d'instruction à un autre, le tampon de préchargement est mis à jour. Par exemple, si on prend un tampon de préchargement de 4 instructions, on doit changer son contenu toutes les 4 instructions. La seule exception est l'exécution d'un branchement. En effet, lors d'un branchement, la destination du branchement n'est pas dans le tampon de préchargement et elle doit être chargée dedans (sauf si le branchement pointe vers une instruction très proche, ce qui est improbable). Pour cela, le tampon de préchargement est mis à jour précocement quand le processeur détecte un branchement.

Le même problème survient avec du code auto-modifiant. Un code auto-modifiant est un programme qui se modifie lui-même, en remplaçant certaines instructions par d'autres, en en retirant, en en ajoutant, lors de sa propre exécution. De tels programmes sont rares, mais la technique était utilisée dans quelques cas au tout début de l'informatique sur des ordinateurs rudimentaires. Ceux-ci avaient des modes d'adressages tellement limités que gérer des tableaux de taille variable demandait d'utiliser du code auto-modifiant pour écrire des boucles. Le problème survient quand des instructions sont modifiées immédiatement après avoir été préchargées. Les instructions dans le tampon de préchargement sont l'ancienne version, alors que la mémoire RAM contient les instructions modifiées. Gérer ce genre de cas demande de vider le tampon de préchargement si le cas arrive, mais ça ne vaut que très rarement le coup, aussi les ingénieurs ne s’embêtent pas à mettre ce correctif en place. Le code automodifiant est alors buggé.

===La ''prefetch input queue''===

La ''prefetch input queue'' est une sorte de cousine du tampon de préchargement, qui a été utilisée sur les processeurs Intel assez ancien. Elle est apparue sur le 8086 et le 8088, des processeurs respectivement 8 et 16 bits. Elle été présente sur le 286 et le 386, mais était un peu améliorée. Elle est apparue sur ces processeurs à une époque où le processeur devenait plus rapide que la mémoire.

L'idée est là encore de précharger des instructions en avance. Sauf que cette fois-ci, on ne charge pas plusieurs instructions à la fois. Au contraire, les instructions sont préchargées séquentiellement, un octet à la fois. En conséquence, le tampon de préchargement est remplacé par une mémoire FIFO appelée la '''''Prefetch Input Queue''''', terme abrévié en PIQ. Les instructions sont accumulées une par une dans la PIQ, elles en sortent une par une au fur et à mesure pour alimenter le décodeur d'instruction.

L'idée est que pendant que le processeur exécute une instruction, on précharge la suivante. Sans ''prefetch input queue'', le processeur chargeait une instruction, la décodait et l'exécutait, puis chargeait la suivante, et ainsi de suite. Avec la ''prefetch input queue'', pendant qu'une instruction est en cours de décodage/exécution, le processeur précharge l'instruction suivante. Si une instruction prend vraiment beaucoup de temps pour s'exécuter, le processeur peut en profiter pour précharger l'instruction encore suivante, et ainsi de suite, jusqu'à une limite de 4/6 instructions (la limite dépend du processeur).

La ''prefetch input queue'' permet de précharger l'instruction suivante à condition qu'aucun autre accès mémoire n'ait lieu. Si l'instruction en cours d'exécution effectue des accès mémoire, ceux-ci sont prioritaires sur tout le reste, le préchargement de l'instruction suivante est alors mis en pause ou inhibé. Par contre, si la mémoire n'est pas utilisée par l'instruction en cours d'exécution, le processeur lit l'instruction suivante en RAM et la copie dans la ''prefetch input queue''. En conséquence, il arrive que la 'prefetch input queue'' n'ait pas préchargé l'instruction suivante, alors que le décodeur d'instruction est prêt pour la décoder. Dans ce cas, le décodeur doit attendre que l'instruction soit chargée.

Les instructions préchargées dans la ''Prefetch input queue'' y attendent que le processeur les lise et les décode. Les instructions préchargées sont conservées dans leur ordre d'arrivée, afin qu'elles soient exécutées dans le bon ordre, ce qui fait que la ''Prefetch input queue'' est une mémoire de type FIFO. L'étape de décodage pioche l'instruction à décoder dans la ''Prefetch input queue'', cette instruction étant par définition la plus ancienne, puis la retire de la file.

Le premier processeur commercial grand public à utiliser une ''prefetch input queue'' était le 8086. Il pouvait précharger à l'avance 6 octets d’instruction. L'Intel 8088 avait lui aussi une ''Prefetch input queue'', mais qui ne permettait que de précharger 4 instructions. La taille idéale de la FIFO dépend de nombreux paramètres. On pourrait croire que plus elle peut contenir d'instructions, mieux c'est, mais ce n'est pas le cas, pour des raisons que nous allons expliquer dans quelques paragraphes.

[[File:80186 arch.png|centre|vignette|700px|upright=2|Architecture du 8086, du 80186 et de ses variantes.]]

Vous remarquerez que j'ai exprimé la capacité de la ''prefetch input queue'' en octets et non en instructions. La raison est que sur les processeurs x86, les instructions sont de taille variable. Les instructions de ces processeurs ont une taille qui varie entre deux octets et 6 octets. La ''prefetch input queue'' était optimisée pour lire des instructions de deux octets, avec quelques mécanismes pour gérer les instructions plus longues. Il faut dire que les instructions les plus courantes faisaient deux octets, respectivement un octet d'opcode et un octet Mod/RM pour préciser le mode d'adressage.

Si les instructions faisaient deux octets ou plus, La mémoire RAM ne permettait que de charger un octet à la fois. Le décodeur devait attendre que les deux octets d'une instruction soient disponibles dans la ''Prefetch input queue''. Pour cela, un circuit appelé le ''loader'' fournissait deux signaux au décodeur d'instruction : l'un indiquant que le premier octet est déjà chargé, l'autre indiquant que le second octet est disponible.

Le ''loader'' recevait aussi des signaux de la part du décodeur d'instruction, afin de gérer les lectures dans la ''Prefetch input queue''. Le décodeur envoyait le signal ''Run Next Instruction'' pour lire une instruction :  elle était alors dépilée de la ''Prefetch input queue''. Le décodeur d'instruction pouvait aussi envoyer un signal ''Next-to-last (NXT)'' un cycle en avance, un cucle avant que l'instruction en cours ne termine. Le résultat est que le ''loader'' réagissait en préchargeant l'instruction suivante. En clair, ce signal permettait de précharger l'instruction suivante avec un cycle d'avance, si celle-ci n'était pas déjà dans la ''Prefetch input queue''.

Pour gérer les instructions de plus de deux octets, le décodeur pouvait lire une instruction en plusieurs fois dans la ''Prefetch input queue''. Les deux premiers octets sont lus depuis la ''Prefetch input queue'', et sont alors décodés. Le décodeur détermine alors la taille de l'instruction. Si l'instruction fait exactement deux octets, elle est exécutée directement. Sinon, les octets manquants sont lus depuis la ''Prefetch input queue''. Pour cela, le décodeur dispose d'une micro-opération pour lire un octet depuis la ''Prefetch input queue''.

Les branchements posent des problèmes avec la ''Prefetch input queue'' : à cause d'eux, on peut charger à l'avance des instructions qui sont zappées par un branchement et ne sont pas censées être exécutées. Si un branchement est chargé, toutes les instructions préchargées après sont potentiellement invalides. Si le branchement est non-pris, les instructions chargées sont valides, elles sont censées s’exécuter. Mais si le branchement est pris, elles ont été chargées à tort et ne doivent pas s’exécuter. 

Pour éviter cela, la ''Prefetch input queue'' est vidée quand le processeur détecte un branchement. Pour cela, le décodeur d'instruction dispose d'une micro-opération qui vide la ''Prefetch input queue'', elle invalide les instructions préchargées.  Cette détection ne peut se faire qu'une fois le branchement décodé, qu'une fois que l'on sait que l'instruction décodée est un branchement. En clair, le décodeur invalide la ''Prefetch input queue'' quand il détecte un branchement. Les interruptions posent le même genre de problèmes. Il faut impérativement vider la ''Prefetch input queue'' quand une interruption survient, avant de la traiter.

Il faut noter qu'une ''Prefetch input queue'' interagit assez mal avec le ''program counter''. En effet, la ''Prefetch input queue'' précharge les instructions séquentiellement. Pour savoir où elle en est rendue, elle mémorise l'adresse de la prochaine instruction à charger dans un '''registre de préchargement''' dédié. Il serait possible d'utiliser un ''program counter'' en plus du registre de préchargement, mais ce n'est pas la solution qui a été utilisée. Les processeurs Intel anciens ont préféré n'utiliser qu'un seul registre de préchargement en remplacement du ''program counter''. Après tout, le registre de préchargement n'est qu'un ''program counter'' ayant pris une avance de quelques cycles d'horloge, qui a été incrémenté en avance.

Et cela ne pose pas de problèmes, sauf avec certains branchements. Par exemple, certains branchements relatifs demandent de connaitre la véritable valeur du ''program counter'', pas celle calculée en avance. Idem avec les instructions d'appel de fonction, qui demandent de sauvegarder l'adresse de retour exacte, donc le vrai ''program counter''. De telles situations demandent de connaitre la valeur réelle du ''program counter'', celle sans préchargement. Pour cela, le décodeur d'instruction dispose d'une instruction pour reconstituer le ''program counter'', à savoir corriger le ''program coutner'' et éliminer l'effet du préchargement.

La micro-opération de correction se contente de soustraire le nombre d'octets préchargés au registre de préchargement. Le nombre d'octets préchargés est déduit à partir des deux pointeurs intégré à la FIFO, qui indiquent la position du premier et du dernier octet préchargé. Le bit qui indique si la FIFO est vide était aussi utilisé. Les deux pointeurs sont lus depuis la FIFO, et sont envoyés à un circuit qui détermine le nombre d'octets préchargés. Sur le 8086, ce circuit était implémenté non pas par un circuit combinatoire, mais par une mémoire ROM équivalente. La petite taille de la FIFO faisait que les pointeurs étaient très petits et la ROM l'était aussi.

Un autre défaut est que la ''Prefetch input queue'' se marie assez mal avec du code auto-modifiant. Un code auto-modifiant est un programme qui se modifie lui-même, en remplaçant certaines instructions par d'autres, en en retirant, en en ajoutant, lors de sa propre exécution. De tels programmes sont rares, mais la technique était utilisée dans quelques cas au tout début de l'informatique sur des ordinateurs rudimentaires. Ceux-ci avaient des modes d'adressages tellement limités que gérer des tableaux de taille variable demandait d'utiliser du code auto-modifiant pour écrire des boucles.

Le problème avec la ''Prefetch input queue'' survient quand des instructions sont modifiées immédiatement après avoir été préchargées. Les instructions dans la ''Prefetch input queue'' sont l'ancienne version, alors que la mémoire RAM contient les instructions modifiées. Gérer ce genre de cas est quelque peu complexe. Il faut en effet vider la ''Prefetch input queue'' si le cas arrive, ce qui demande d'identifier les écritures qui écrasent des instructions préchargées. C'est parfaitement possible, mais demande de transformer la ''Prefetch input queue'' en une mémoire hybride, à la fois mémoire associative et mémoire FIFO. Cela ne vaut que très rarement le coup, aussi les ingénieurs ne s’embêtent pas à mettre ce correctif en place, le code automodifiant est alors buggé.

Le décodeur d'instruction dispose aussi d'une micro-opération qui stoppe le préchargement des instructions dans la ''Prefetch input queue''.

===Le ''Zero-overhead looping''===

Nous avions vu dans le chapitre sur les instructions machines, qu'il existe des instructions qui permettent de grandement faciliter l'implémentation des boucles. Il s'agit de l'instruction REPEAT, utilisée sur certains processeurs de traitement de signal. Elle répète l'instruction suivante, voire une série d'instructions, un certain nombre de fois. Le nombre de répétitions est mémorisé dans un registre décrémenté à chaque itération de la boucle. Elle permet donc d'implémenter une boucle FOR facilement, sans recourir à des branchements ou des conditions.

Une technique en lien avec cette instruction permet de grandement améliorer les performances et la consommation d'énergie. L'idée est de mémoriser la boucle, les instructions à répéter, dans une petite mémoire cache située entre l'unité de chargement et le séquenceur. Le cache en question s'appelle un '''tampon de boucle''', ou encore un ''hardware loop buffer''. Grâce à lui, il n'y a pas besoin de charger les instructions à chaque fois qu'on les exécute, on les charge une bonne fois pour toute : c'est plus rapide. Bien sûr, il ne fonctionne que pour de petites boucles, mais il en est de même avec l'instruction REPEAT.

&lt;noinclude&gt;
{{NavChapitre | book=Fonctionnement d'un ordinateur
           | prev=Le chemin de données
           | prevText=Le chemin de données
           | next=L'unité de contrôle
           | nextText=L'unité de contrôle
}}
&lt;/noinclude&gt;</text>
      <sha1>e31iqpu86acm6q7l03adnq2aohvuayd</sha1>
    </revision>
    <revision>
      <id>744080</id>
      <parentid>744079</parentid>
      <timestamp>2025-06-03T19:35:42Z</timestamp>
      <contributor>
        <username>Mewtow</username>
        <id>31375</id>
      </contributor>
      <minor />
      <comment>/* La prefetch input queue */</comment>
      <origin>744080</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="44618" sha1="8p8poj6b7qnolqapwfx4nijpg8iirw0" xml:space="preserve">L'unité de contrôle s'occupe du chargement des instructions et de leur interprétation, leur décodage. Elle contient deux circuits : l''''unité de chargement''' qui charge l'instruction depuis la mémoire, et le '''séquenceur''' qui commande le chemin de données. Les deux circuits sont séparés, mais ils communiquent entre eux, notamment pour gérer les branchements. Dans ce chapitre, nous allons nous intéresser au chargement d'une instruction depuis la RAM/ROM, nous verrons l'étape de décodage de l'instruction au prochain chapitre.

==Le chargement d'une instruction==

[[File:Étape de chargement.png|vignette|upright=1|Étape de chargement.]]

L'étape de chargement (ou ''fetch'') doit faire deux choses : mettre à jour le ''program counter'' et lire l'instruction en mémoire RAM ou en ROM. Les deux étapes peuvent être faites en parallèle, dans des circuits séparés. Pendant que l'instruction est lue depuis la mémoire RAM/ROM, le ''program counter'' est incrémenté et/ou altéré par un branchement.

Pour lire l'instruction, on envoie le ''program counter'' sur le bus d'adresse et on récupère l'instruction sur le bus de données pour l'envoyer sur l'entrée du séquenceur. Et cela demande de connecter le séquenceur au bus mémoire, à travers l'interface mémoire. Et sur ce point, la situation est différente selon que l'on parler d'une architecture Harvard ou Von Neumann.

===Les interconnexions entre séquenceur et bus mémoire===

Sur les architectures Harvard, le séquenceur et le chemin de donnée utilisent des interfaces mémoire séparées. Le séquenceur est directement relié au bus mémoire de la ROM, alors que le chemin de données est connecté à la RAM.

[[File:Microarchitecture de l'interface mémoire d'une architecture Harvard.png|centre|vignette|upright=2|Microarchitecture de l'interface mémoire d'une architecture Harvard]]

Mais sur les architectures Von-Neumann et affiliées, le séquenceur et le chemin de donnée partagent la même interface mémoire. Et cela pose deux problèmes.

Le premier problème est que le bus mémoire doit être libéré une fois l'instruction chargée, pour un éventuel accès mémoire. Mais le séquenceur doit conserver une copie de l'instruction chargée, sans quoi il ne peut pas décoder l'instruction correctement. Par exemple, si l'instruction met plusieurs cycles à s'exécuter, le séquenceur doit conserver une copie de l'instruction durant ces plusieurs cycles. La solution à ce problème est un '''registre d'instruction''' situé juste avant le séquenceur, qui mémorise l'instruction chargée.

[[File:Registre d'instruction.png|centre|vignette|upright=2|Registre d'instruction.]]

Le second problème est de gérer le flot des instructions/données entre le bus mémoire, le chemin de données et le séquenceur. Le processeur doit connecter l'interface mémoire soit au séquenceur, soit au chemin de données et cela complique le réseau d'interconnexion interne au processeur.

Une première solution utilise un bus unique qui relie l'interface mémoire, le séquenceur et le chemin de données. Pour charger une instruction, le séquenceur copie le ''program counter'' sur le bus d'adresse, attend que l'instruction lue soit disponible sur le bus de données, puis la copie dans le registre d'instruction. Le bus mémoire est alors libre et peut être utilisé pour lire ou écrire des données, si le besoin s'en fait sentir.

Il faut noter que l'usage d'un bus unique a un impact sur l'organisation interne du chemin de données. Par exemple, le chapitre précédent nous a montré comment implémenter un chemin de données basique, avec des multiplexeurs et démultiplexeurs. Et bien ces chemins de données ne marchent pas vraiment avec un bus interne unique. Il est possible de les adapter, mais au prix d'une complexité largement supérieure. Un bus interne unique marche mieux quand le banc de registre est mono-port. C'est pourquoi il a été utilisé sur d'anciennes architectures appelées des architectures à accumulateur et à pile, que nous verrons dans quelques chapitres, qui utilisaient un banc de registre mono-port.

[[File:Microarchitecture de l'interface mémoire d'une architecture von neumann.png|centre|vignette|upright=2|Microarchitecture de l'interface mémoire d'une architecture von neumann]]

Une autre solution utilise deux bus interne séparés : un connecté au bus d'adresse, l'autre au bus de données. Le ''program counter'' est alors connecté au bus interne d'adresse, le séquenceur est relié au bus interne de données. Notons que la technique marche bien si le ''program counter'' est dans le banc de registre : les interconnexions utilisées pour gérer l'adressage indirect permettent d'envoyer le ''program counter'' sur le bus d'adresse sans ajout de circuit.

Le tout peut être amélioré en remplaçant les deux bus par des multiplexeurs et démultiplexeurs. Le bus d'adresse est précédé par un multiplexeur, qui permet de faire le choix entre ''Program Counter'', adresse venant du chemin de données, ou adresse provenant du séquenceur (adressage absolu). De même, le bus de données est suivi par un démultiplexeur qui envoie la donnée/instruction lue soit au registre d'instruction, soit au chemin de données. Le tout se marie très bien avec les chemins de donnée vu dans le chapitre précédent. Au passage, il faut noter que cette solution nécessite un banc de registre multi-port.

[[File:Connexion du program counter sur les bus avec PC isolé.png|centre|vignette|upright=2|Connexion du program counter sur les bus avec PC isolé]]

===Le chargement des instructions de longueur variable===

Le chargement des instructions de longueur variable pose de nombreux problèmes. Le premier est que mettre à jour le ''program counter'' demande de connaitre la longueur de l'instruction chargée, pour l'ajouter au ''program counter''. Si la longueur d'une instruction est variable, on doit connaitre cette longueur d'une manière où d'une autre. La solution la plus simple indique la longueur de l'instruction dans une partie de l'opcode ou de la représentation en binaire de l'instruction. Mais les processeurs haute performance de nos PC utilisent d'autres solutions, qui n'encodent pas explicitement la taille de l'instruction.

Les processeurs récents utilisent un registre d'instruction de grande taille, capable de mémoriser l'instruction la plus longue du processeur. Par exemple, si un processeur supporte des instructions allant de 1 à 8 octets, comme les CPU x86, le registre d'instruction fera 8 octets. Le décodeur d'instruction vérifie à chaque cycle le contenu du registre d'instruction. Si une instruction est détectée dedans, son décodage commence, peu importe la taille de l'instruction. Une fois l'instruction exécutée, elle est retirée du registre d'instruction. Reste à alimenter le registre d'instruction, à charger des instructions dedans. Et pour cela deux solutions : soit on charge l'instruction en plusieurs fois, soit d'un seul coup.

La solution la plus simple charge les instructions par mots de 8, 16, 32, 64 bits. Ils sont accumulés dans le registre d'instruction jusqu'à détecter une instruction complète. La technique marche nettement mieux si les instructions sont très longues. Par exemple, les CPU x86 ont des instructions qui vont de 1 à 15 octets, ce qui fait qu'ils utilisent cette technique. Précisément, elle marche si les instructions les plus longues sont plus grandes que le bus mémoire.

Une autre solution charge un bloc de mots mémoire aussi grand que la plus grande instruction. Par exemple, si le processeur gère des instructions allant de 1 à 4 octets, il charge 4 octets d'un seul coup dans le registre d'instruction. Il va de soit que cette solution ne marche que si les instructions du processeur sont assez courtes, au plus aussi courtes que le bus mémoire. Ainsi, on est sûr de charger obligatoirement au moins une instruction complète, et peut-être même plusieurs. Le contenu du registre d'instruction est alors découpé en instructions au fil de l'eau. 

Utiliser un registre d'instruction large pose problème avec des instructions à cheval entre deux blocs. Il se peut qu'on n'ait pas une instruction complète lorsque l'on arrive à la fin du bloc, mais seulement un morceau. Le problème se manifeste peu importe que l'instruction soit chargée d'un seul coup ou bien en plusieurs fois.

[[File:Instructions non alignées.png|centre|vignette|upright=2|Instructions non alignées.]]

Dans ce cas, on doit décaler le morceau de bloc pour le mettre au bon endroit (au début du registre d'instruction), et charger le prochain bloc juste à côté. On a donc besoin d'un circuit qui décale tous les bits du registre d'instruction, couplé à un circuit qui décide où placer dans le registre d'instruction ce qui a été chargé, avec quelques circuits autour pour configurer les deux circuits précédents.

[[File:Décaleur d’instruction.png|centre|vignette|upright=2|Décaleur d’instruction.]]

Une autre solution se passe de registre d'instruction en utilisant à la place l'état interne du séquenceur. Là encore, elle charge l'instruction morceau par morceau, typiquement par blocs de 8, 16 ou 32 bits. Les morceaux ne sont pas accumulés dans le registre d'instruction, la solution utilise à la place l'état interne du séquenceur. Les mots mémoire de l'instruction sont chargés à chaque cycle, faisant passer le séquenceur d'un état interne à un autre à chaque mot mémoire. Tant qu'il n'a pas reçu tous les mots mémoire de l'instruction, chaque mot mémoire non terminal le fera passer d'un état interne à un autre, chaque état interne encodant les mots mémoire chargés auparavant. S'il tombe sur le dernier mot mémoire d'une instruction, il rentre dans un état de décodage.

==L'incrémentation du ''program counter''==

À chaque chargement, le ''program counter'' est mis à jour afin de pointer sur la prochaine instruction à charger. Sur la quasi-totalité des processeurs, les instructions sont placées dans l'ordre d’exécution dans la RAM. En faisant ainsi, on peut mettre à jour le ''program counter'' en lui ajoutant la longueur de l'instruction courante. Déterminer la longueur de l'instruction est simple quand les instructions ont toutes la même taille, mais certains processeurs ont des instructions de taille variable, ce qui complique le calcul. Dans ce qui va suivre, nous allons supposer que les instructions sont de taille fixe, ce qui fait que le ''program counter'' est toujours incrémenté de la même valeur.

Il existe deux méthodes principales pour incrémenter le ''program counter'' : soit le ''program counter'' a son propre additionneur, soit le ''program counter'' est mis à jour par l'ALU. Pour ce qui est de l'organisation des registres, soit le ''program counter'' est un registre séparé des autres, soit il est regroupé avec d'autres registres dans un banc de registre. En tout, cela donne quatre organisations possibles.
* Un ''program counter'' séparé relié à un incrémenteur séparé.
* Un ''program counter'' séparé des autres registres, incrémenté par l'ALU.
* Un ''program counter'' intégré au banc de registre, relié à un incrémenteur séparé.
* Un ''program counter'' intégré au banc de registre, incrémenté par l'ALU.

[[File:Calcul du program counter.png|centre|vignette|upright=2|les différentes méthodes de calcul du program counter.]]

Les processeurs haute performance modernes utilisent tous la première méthode. Les autres méthodes étaient surtout utilisées sur les processeurs 8 ou 16 bits, elles sont encore utilisées sur quelques microcontrôleurs de faible puissance. Nous auront l'occasion de donner des exemples quand nous parlerons des processeurs 8 bits anciens, dans le chapitre sur les architectures à accumulateur et affiliées.

===Le ''program counter'' mis à jour par l'ALU===

Sur certains processeurs, le calcul de l'adresse de la prochaine instruction est effectué par l'ALU. L'avantage de cette méthode est qu'elle économise un incrémenteur dédié au ''program counter''. Ce qui explique que cette méthode était utilisée sur les processeurs assez anciens, à une époque où un additionneur pouvait facilement prendre 10 à 20% des transistors disponibles. Le désavantage principal est une augmentation de la complexité du séquenceur, qui doit gérer la mise à jour du ''program counter''. De plus, la mise à jour du ''program counter'' ne peut pas se faire en même temps qu'une opération arithmétique, ce qui réduit les performances.

Si on incrémente le ''program counter'' avec l'ALU, il est intéressant de le placer dans le banc de registres. Un désavantage est qu'on perd un registre. Par exemple, avec un banc de registre de 16 registres, on ne peut adresser que 15 registres généraux. De plus ce n'est pas l'idéal pour le décodage des instructions et pour le séquenceur. Si le processeur dispose de plusieurs bancs de registres, le ''program counter'' est généralement placé dans le banc de registre dédié aux adresses. Sinon, il est placé avec les nombres entiers/adresses.

D'anciens processeurs incrémentaient le ''program counter'' avec l'ALU, mais utilisaient bien un registre séparé pour le ''program counter''. Cette méthode est relativement simple à implémenter : il suffit de connecter/déconnecter le ''program counter'' du bus interne suivant les besoins. Le ''program counter'' est déconnecté pendant l’exécution d'une instruction, il est connecté au bus interne pour l'incrémenter. C'est le séquenceur qui gère le tout. L'avantage de cette séparation est qu'elle est plus facile à gérer pour le séquenceur. De plus, on gagne un registre général/entier dans le banc de registre.

===Le compteur programme===

Dans la quasi-totalité des processeurs modernes, le ''program counter'' est un vulgaire compteur comme on en a vu dans les chapitres sur les circuits, ce qui fait qu'il passe automatiquement d'une adresse à la suivante. Dans ce qui suit, nous allons appeler ce registre compteur : le '''compteur ordinal'''. L'usage d'un compteur simplifie fortement la conception du séquenceur. Le séquenceur n'a pas à gérer la mise à jour du ''program counter'', sauf en cas de branchements. De plus, il est possible d'incrémenter le ''program counter'' pendant que l'unité de calcul effectue une opération arithmétique, ce qui améliore grandement les performances. Le seul désavantage est qu'elle demande d'ajouter un incrémenteur dédié au ''program counter''.

Sur les processeurs très anciens, les instructions faisaient toutes un seul mot mémoire et le compteur ordinal était un circuit incrémenteur des plus basique. Sur les processeurs modernes, le compteur est incrémenté par pas de 4 si les instructions sont codées sur 4 octets, 8 si les instructions sont codées sur 8 octets, etc. Concrètement, le compteur est un circuit incrémenteur auquel on aurait retiré quelques bits de poids faible. Par exemple, si les instructions sont codées sur 4 octets, on coupe les 2 derniers bits du compteur. Si les instructions sont codées sur 8 octets, on coupe les 3 derniers bits du compteur. Et ainsi de suite.

Il a existé quelques processeurs pour lesquelles le ''program counter'' était non pas un compteur binaire classique, mais un ''linear feedback shift register''. L'avantage est que le circuit d'incrémentation utilisait bien moins de portes logiques, l'économie était substantielle. Mais un défaut est que des instructions consécutives dans le programme n'étaient pas consécutives en mémoire. Il existait cependant une table de correspondance pour dire : la première instruction est à telle adresse, la seconde à telle autre, etc. Un exemple de processeur de ce type est le TMS 1000 de Texas Instrument, un des premiers microcontrôleur 4 bits datant des années 70.

Une amélioration de la solution précédente utilise un circuit incrémenteur partagé entre le ''program counter'' et d'autres registres. L'incrémenteur est utilisé pour incrémenter le ''program counter'', mais aussi pour effectuer d'autres calculs d'adresse. Par exemple, sur les architectures avec une pile d'adresse de retour, il est possible de partager l'incrémenteur/décrémenteur avec le pointeur de pile ( la technique ne marche pas avec une pile d'appel). Un autre exemple est celui des processeurs qui gèrent automatiquement le rafraichissement mémoire, grâce à, un compteur intégré dans le processeur. Il est possible de partager l'incrémenteur du ''program counter'' avec le compteur de rafraichissement mémoire, qui mémorise la prochaine adresse mémoire à rafraichir. Nous avions déjà abordé ce genre de partage dans le chapitre sur le chemin de données, dans l'annexe sur le pointeur de pile, mais nous verrons d'autres exemples dans le chapitre sur les architectures hybride accumulateur-registre 8/16 bits.

===Quand est mis à jour le ''program counter'' ?===

Le ''program counter'' est mis à jour quand il faut charger une nouvelle instruction. Reste qu'il faut savoir quand le mettre à jour. Incrémenter le ''program counter'' à intervalle régulier, par exemple à chaque cycle d’horloge, fonctionne sur les processeurs où toutes les instructions mettent le même temps pour s’exécuter. Mais de tels processeurs sont très rares. Sur la quasi-totalité des processeurs, les instructions ont une durée d’exécution variable, elles ne prennent pas le même nombre de cycle d'horloge pour s’exécuter. Le temps d’exécution d'une instruction varie selon l'instruction, certaines sont plus longues que d'autres. Tout cela amène un problème : comment incrémenter le ''program counter'' avec des instructions avec des temps d’exécution variables ?

La réponse est que la mise à jour du ''program counter'' démarre quand l'instruction précédente a terminée de s’exécuter, plus précisément un cycle avant. C'est un cycle avant pour que l'instruction chargée soit disponible au prochain cycle pour le décodeur. Pour cela, le séquenceur doit déterminer quand l'instruction est terminée et prévenir le ''program counter'' au bon moment. Il faut donc une interaction entre séquenceur et circuit de chargement. Le circuit de chargement contient une entrée Enable, qui autorise la mise à jour du ''program counter''. Le séquenceur met à 1 cette entrée pour prévenir au ''program counter'' qu'il doit être incrémenté au cycle suivant ou lors du cycle courant. Cela permet de gérer simplement le cas des instructions multicycles. 

[[File:Commande de la mise à jour du program counter.png|centre|vignette|upright=2|Commande de la mise à jour du program counter.]]

Toute la difficulté est alors reportée dans le séquenceur, qui doit déterminer la durée d'une instruction. Pour gérer la mise à jour du ''program counter'', le séquenceur doit déterminer la durée d'une instruction. Cela est simple pour les instructions arithmétiques et logiques, qui ont un nombre de cycles fixe, toujours le même. Une fois l'instruction identifiée par le séquenceur, il connait son nombre de cycles et peut programmer un compteur interne au séquenceur, qui compte le nombre de cycles de l'instruction, et fournit le signal Enable au ''program counter''. Mais cette technique ne marche pas vraiment pour les accès mémoire, dont la durée n'est pas connue à l'avance, surtout sur les processeurs avec des mémoires caches. Pour cela, le séquenceur détermine quand l'instruction mémoire est finie et prévient le ''program counter'' quand c'est le cas.

Il existe quelques processeurs pour lesquels le temps de calcul dépend des opérandes de l'instruction. On peut par exemple avoir une division qui prend 10 cycles avec certaines opérandes, mais 40 cycles avec d'autres opérandes. Mais ces processeurs sont rares et cela est surtout valable pour les opérations de multiplication/division, guère plus. Le problème est alors le même qu'avec les accès mémoire et la solution est la même : l'ALU prévient le séquenceur quand le résultat est disponible.

==Les branchements et le ''program counter''==

Un branchement consiste juste à écrire l'adresse de destination dans le ''program counter''. L'implémentation des branchements demande d'extraire l'adresse de destination et d'altérer le ''program counter'' quand un branchement est détecté. Pour cela, le décodeur d'instruction détecte si l'instruction exécutée est un branchement ou non, et il en déduit où trouver l'adresse de destination.

L'adresse de destination se trouve à un endroit qui dépend du mode d'adressage du branchement. Pour rappel, on distingue quatre modes d'adressage pour les branchements : direct, indirect, relatif et implicite. Pour les branchements directs, l'adresse est intégrée dans l'instruction de branchement elle-même et est extraite par le séquenceur. Pour les branchements indirects, l'adresse de destination est dans le banc de registre. Pour les branchements relatifs, il faut ajouter un décalage au ''program counter'', décalage extrait de l'instruction par le séquenceur. Enfin, les instructions de retour de fonction lisent l'adresse de destination depuis la pile. L'implémentation de ces quatre types de branchements est très différente.

L'altération du ''program counter'' dépend de si le ''program counter'' est dans un compteur séparé ou s'il est dans le banc de registre. Nous avons vu plus haut qu'il y a quatre cas différents, mais nous n'allons voir que deux cas : celui où le ''program counter'' est dans le banc de registre et est incrémenté par l'unité de calcul, celui avec un ''program counter'' séparé avec son propre incrémenteur. Les deux autres cas ne sont utilisés que sur des architectures à accumulateur ou à pile spécifiques, que nous n'avons pas encore vu à ce stade du cours et que nous verrons en temps voulu dans le chapitre sur ces architectures.

===L’implémentation des branchements avec un ''program counter'' intégré au banc de registres===

Le cas le plus simple est celui où le ''program counter'' est intégré au banc de registre, avec une incrémentation faite par l'unité de calcul. Charger une instruction revient alors à effectuer une instruction LOAD en adressage indirect, à deux différences près : le registre sélectionné est le ''program counter'', l’instruction est copiée dans le registre d'instruction et non dans le banc de registre. L'incrémentation du ''porgram counter'' est implémenté avec des micro-opérations qui agissent sur le chemin de données, au même titre que les branchements indirects, relatifs et directs.
* Les branchements indirects copient un registre dans le ''program counter'', ce qui revient simplement à faire une opération MOV entre deux registres, dont le ''program counter'' est la destination.
* L'opération inverse d'un branchement indirect, qui copie le ''program counter'' dans un registre général, est utile pour sauvegarder l'adresse de retour d'une fonction.
* Les branchements directs copient une adresse dans le ''program counter'', ce qui les rend équivalents à une opération MOV avec une constante immédiate, dont le ''program counter'' est la destination.
* Les branchements relatifs sont une opération arithmétique entre le ''program counter'' et un opérande en adressage immédiat.

En clair, à partir du moment où le chemin de données supporte les instructions MOV et l'addition, avec les modes d'adressage adéquat, il supporte les branchements. Aucune modification du chemin de données n'est nécessaire, le séquenceur gére le chargement d'une instruction avec les micro-instructions adéquates : une micro-opération ADD pour incrémenter le ''program counter'', une micro-opération LOAD pour le chargement de l'instruction.

Notons que sur certaines architectures, le ''program counter'' est adressable au même titre que les autres registres du banc de registre. Les instructions de branchement sont alors remplacées par des instructions MOV ou des instructions arithmétique équivalentes, comme décrit plus haut.

===L’implémentation des branchements avec un ''program counter'' séparé===

Étudions maintenant le cas où le ''program counter'' est dans un registre/compteur séparé. Rappelons que tout compteur digne de ce nom possède une entrée de réinitialisation, qui remet le compteur à zéro. De plus, on peut préciser à quelle valeur il doit être réinitialisé. Ici, la valeur à laquelle on veut réinitialiser le compteur n'est autre que l'adresse de destination du branchement. Implémenter un branchement est donc simple : l'entrée de réinitialisation est commandée par le circuit de détection des branchements, alors que la valeur de réinitialisation est envoyée sur l'entrée adéquate. En clair, nous partons du principe que le ''program counter'' est implémenté avec ce type de compteur :

[[File:Fonctionnement d'un compteur (décompteur), schématique.jpg|centre|vignette|upright=1.5|Fonctionnement d'un compteur (décompteur), schématique]]

Toute la difficulté est de présenter l'adresse de destination au ''program counter''. Pour les branchements directs, l'adresse de destination est fournie par le séquenceur. L'adresse de destination du branchement sort du séquenceur et est présentée au ''program counter'' sur l'entrée adéquate. Voici donc comment sont implémentés les branchements directs avec un ''program counter'' séparé du banc de registres. Le schéma ci-dessous marche peu importe que le ''program counter'' soit incrémenté par l'ALU ou par un additionneur dédié.

[[File:Unité de détection des branchements dans le décodeur.png|centre|vignette|upright=2|Unité de détection des branchements dans le décodeur]]

Les branchements relatifs sont ceux qui font sauter X instructions plus loin dans le programme. Leur implémentation demande d'ajouter une constante au ''program counter'', la constante étant fournie dans l’instruction. Là encore, deux solutions sont possibles : réutiliser l'ALU pour calculer l'adresse, ou utiliser un additionneur séparé. L'additionneur séparé peut être fusionné avec l'additionneur qui incrémente le ''program counter'' pour passer à l’instruction suivante.

[[File:Unité de chargement qui gère les branchements relatifs.png|centre|vignette|upright=2|Unité de chargement qui gère les branchements relatifs.]]

Pour les branchements indirects, il suffit de lire le registre voulu et d'envoyer le tout sur l'entrée adéquate du ''program counter''. Il faut alors rajouter un multiplexeur pour que l'entrée de réinitialisationr ecoive la bonne adresse de destination.

[[File:Unité de chargement qui gère les branchements directs.png|centre|vignette|upright=2|Unité de chargement qui gère les branchements directs et indirects.]]

Toute la difficulté de l'implémentation des branchements est de configurer les multiplexeurs, ce qui est réalisé par le séquenceur en fonction du mode d'adressage du branchement.

==Les optimisations du chargement des instructions==

Charger une instruction est techniquement une forme d'accès mémoire un peu particulier. En clair, charger une instruction prend au minimum un cycle d'horloge, et cela peut rapidement monter à 3-5 cycles, si ce n'est plus. L'exécution des instructions est alors fortement ralentit par la mémoire. Par exemple, imaginez que la mémoire mette 3 cycles d'horloges pour charger une instruction, alors qu'une instruction s’exécute en 1 cycle (si les opérandes sont dans les registres). La perte de performance liée au chargement des instructions est alors substantielle. Heureusement, il est possible de limiter la casse en utilisant des mémoires caches, ainsi que d'autres optimisations, que nous allons voir dans ce qui suit.

===Le tampon de préchargement===

La technique dite du '''préchargement''' est utilisée dans le cas où la mémoire a un temps d'accès important. Mais si la latence de la RAM est un problème, le débit ne l'est pas. Il est possible d'avoir une RAM lente, mais à fort débit. Par exemple, supposons que la mémoire puisse charger 4 instructions (de taille fixe) en 3 cycles. Le processeur peut alors charger 4 instructions en un seul accès mémoire, et les exécuter l'une après l'autre, une par cycle d'horloge. Les temps d'attente sont éliminés : le processeur peut décoder une nouvelle instruction à chaque cycle. Et quand la dernière instruction préchargée est exécutée, la mémoire est de nouveau libre, ce qui masque la latence des accès mémoire.

[[File:Tampon de préchargement d'instruction.png|vignette|Tampon de préchargement d'instruction]]

La seule contrainte est de mettre les instructions préchargées en attente. La solution pour cela est d'utiliser un registre d'instruction très large, capable de mémoriser plusieurs instructions à la fois. Ce registre est de plus connecté à un multiplexeur qui permet de sélectionner l'instruction adéquate dans ce registre. Ce multiplexeur est commandé par le ''program counter'' et quelques circuits annexes. Ce super-registre d'instruction est appelé un '''tampon de préchargement'''.

La méthode a une implémentation nettement plus simple avec des instructions de taille fixe, alignées en mémoire. La commande du multiplexeur de sélection de l'instruction est alors beaucoup plus simple : il suffit d'utiliser les bits de poids fort du ''program counter''. Par exemple, prenons le cas d'un registre d'instruction de 32 octets pour des instructions de 4 octets, soit 8 instructions. Le choix de l'instruction à sélectionner se fait en utilisant les 3 bits de poids faible du ''program counter''. 

Mais cette méthode ajoute de nouvelles contraintes d'alignement, similaires à celles vues dans le chapitre sur l'alignement et le boutisme, sauf que l'alignement porte ici sur des blocs d'instructions de même taille que le tampon de préchargement. Si on prend l'exemple d'un tampon de préchargement de 128 bits, les instructions devront être alignées par blocs de 128 bits. C'est à dire qu'idéalement, les fonctions et autres blocs de code isolés doivent commencer à des adresses multiples de 128, pour pouvoir charger un bloc d'instruction en une seule fois. Sans cela, les performances seront sous-optimales.

: Il arrive que le tampon de préchargement ait la même taille qu'une ligne de cache.

Lorsque l'on passe d'un bloc d'instruction à un autre, le tampon de préchargement est mis à jour. Par exemple, si on prend un tampon de préchargement de 4 instructions, on doit changer son contenu toutes les 4 instructions. La seule exception est l'exécution d'un branchement. En effet, lors d'un branchement, la destination du branchement n'est pas dans le tampon de préchargement et elle doit être chargée dedans (sauf si le branchement pointe vers une instruction très proche, ce qui est improbable). Pour cela, le tampon de préchargement est mis à jour précocement quand le processeur détecte un branchement.

Le même problème survient avec du code auto-modifiant. Un code auto-modifiant est un programme qui se modifie lui-même, en remplaçant certaines instructions par d'autres, en en retirant, en en ajoutant, lors de sa propre exécution. De tels programmes sont rares, mais la technique était utilisée dans quelques cas au tout début de l'informatique sur des ordinateurs rudimentaires. Ceux-ci avaient des modes d'adressages tellement limités que gérer des tableaux de taille variable demandait d'utiliser du code auto-modifiant pour écrire des boucles. Le problème survient quand des instructions sont modifiées immédiatement après avoir été préchargées. Les instructions dans le tampon de préchargement sont l'ancienne version, alors que la mémoire RAM contient les instructions modifiées. Gérer ce genre de cas demande de vider le tampon de préchargement si le cas arrive, mais ça ne vaut que très rarement le coup, aussi les ingénieurs ne s’embêtent pas à mettre ce correctif en place. Le code automodifiant est alors buggé.

===La ''prefetch input queue''===

La ''prefetch input queue'' est une sorte de cousine du tampon de préchargement, qui a été utilisée sur les processeurs Intel assez ancien. Elle est apparue sur le 8086 et le 8088, des processeurs respectivement 8 et 16 bits. Elle été présente sur le 286 et le 386, mais était un peu améliorée. Elle est apparue sur ces processeurs à une époque où le processeur devenait plus rapide que la mémoire.

L'idée est là encore de précharger des instructions en avance. Sauf que cette fois-ci, on ne charge pas plusieurs instructions à la fois. Au contraire, les instructions sont préchargées séquentiellement, un octet à la fois. En conséquence, le tampon de préchargement est remplacé par une mémoire FIFO appelée la '''''Prefetch Input Queue''''', terme abrévié en PIQ. Les instructions sont accumulées une par une dans la PIQ, elles en sortent une par une au fur et à mesure pour alimenter le décodeur d'instruction.

L'idée est que pendant que le processeur exécute une instruction, on précharge la suivante. Sans ''prefetch input queue'', le processeur chargeait une instruction, la décodait et l'exécutait, puis chargeait la suivante, et ainsi de suite. Avec la ''prefetch input queue'', pendant qu'une instruction est en cours de décodage/exécution, le processeur précharge l'instruction suivante. Si une instruction prend vraiment beaucoup de temps pour s'exécuter, le processeur peut en profiter pour précharger l'instruction encore suivante, et ainsi de suite, jusqu'à une limite de 4/6 instructions (la limite dépend du processeur).

La ''prefetch input queue'' permet de précharger l'instruction suivante à condition qu'aucun autre accès mémoire n'ait lieu. Si l'instruction en cours d'exécution effectue des accès mémoire, ceux-ci sont prioritaires sur tout le reste, le préchargement de l'instruction suivante est alors mis en pause ou inhibé. Par contre, si la mémoire n'est pas utilisée par l'instruction en cours d'exécution, le processeur lit l'instruction suivante en RAM et la copie dans la ''prefetch input queue''. En conséquence, il arrive que la 'prefetch input queue'' n'ait pas préchargé l'instruction suivante, alors que le décodeur d'instruction est prêt pour la décoder. Dans ce cas, le décodeur doit attendre que l'instruction soit chargée.

Les instructions préchargées dans la ''Prefetch input queue'' y attendent que le processeur les lise et les décode. Les instructions préchargées sont conservées dans leur ordre d'arrivée, afin qu'elles soient exécutées dans le bon ordre, ce qui fait que la ''Prefetch input queue'' est une mémoire de type FIFO. L'étape de décodage pioche l'instruction à décoder dans la ''Prefetch input queue'', cette instruction étant par définition la plus ancienne, puis la retire de la file.

Le premier processeur commercial grand public à utiliser une ''prefetch input queue'' était le 8086. Il pouvait précharger à l'avance 6 octets d’instruction. L'Intel 8088 avait lui aussi une ''Prefetch input queue'', mais qui ne permettait que de précharger 4 instructions. La taille idéale de la FIFO dépend de nombreux paramètres. On pourrait croire que plus elle peut contenir d'instructions, mieux c'est, mais ce n'est pas le cas, pour des raisons que nous allons expliquer dans quelques paragraphes.

[[File:80186 arch.png|centre|vignette|700px|upright=2|Architecture du 8086, du 80186 et de ses variantes.]]

Vous remarquerez que j'ai exprimé la capacité de la ''prefetch input queue'' en octets et non en instructions. La raison est que sur les processeurs x86, les instructions sont de taille variable. Les instructions de ces processeurs ont une taille qui varie entre deux octets et 6 octets. La ''prefetch input queue'' était optimisée pour lire des instructions de deux octets, avec quelques mécanismes pour gérer les instructions plus longues. Il faut dire que les instructions les plus courantes faisaient deux octets, respectivement un octet d'opcode et un octet Mod/RM pour préciser le mode d'adressage.

Le bus de données du 8086 faisait 16 bits, ce qui fait qu'il était possible de charger une instruction courte en un cycle. Par contre, sur le 8088, un processeur 8 bits, le bus de donnée ne permettait que de lire un octet à la fois. Dans les deux cas, le décodeur devait attendre que les deux octets d'une instruction soient disponibles dans la ''Prefetch input queue''. Pour cela, un circuit appelé le ''loader'' fournissait deux signaux au décodeur d'instruction : l'un indiquant que le premier octet est déjà chargé, l'autre indiquant que le second octet est disponible.

Le ''loader'' recevait aussi des signaux de la part du décodeur d'instruction, afin de gérer les lectures dans la ''Prefetch input queue''. Le décodeur envoyait le signal ''Run Next Instruction'' pour lire une instruction :  elle était alors dépilée de la ''Prefetch input queue''. Le décodeur d'instruction pouvait aussi envoyer un signal ''Next-to-last (NXT)'' un cycle en avance, un cucle avant que l'instruction en cours ne termine. Le résultat est que le ''loader'' réagissait en préchargeant l'instruction suivante. En clair, ce signal permettait de précharger l'instruction suivante avec un cycle d'avance, si celle-ci n'était pas déjà dans la ''Prefetch input queue''.

Pour gérer les instructions de plus de deux octets, le décodeur pouvait lire une instruction en plusieurs fois dans la ''Prefetch input queue''. Les deux premiers octets sont lus depuis la ''Prefetch input queue'', et sont alors décodés. Le décodeur détermine alors la taille de l'instruction. Si l'instruction fait exactement deux octets, elle est exécutée directement. Sinon, les octets manquants sont lus depuis la ''Prefetch input queue''. Pour cela, le décodeur dispose d'une micro-opération pour lire un octet depuis la ''Prefetch input queue''.

Les branchements posent des problèmes avec la ''Prefetch input queue'' : à cause d'eux, on peut charger à l'avance des instructions qui sont zappées par un branchement et ne sont pas censées être exécutées. Si un branchement est chargé, toutes les instructions préchargées après sont potentiellement invalides. Si le branchement est non-pris, les instructions chargées sont valides, elles sont censées s’exécuter. Mais si le branchement est pris, elles ont été chargées à tort et ne doivent pas s’exécuter. 

Pour éviter cela, la ''Prefetch input queue'' est vidée quand le processeur détecte un branchement. Pour cela, le décodeur d'instruction dispose d'une micro-opération qui vide la ''Prefetch input queue'', elle invalide les instructions préchargées.  Cette détection ne peut se faire qu'une fois le branchement décodé, qu'une fois que l'on sait que l'instruction décodée est un branchement. En clair, le décodeur invalide la ''Prefetch input queue'' quand il détecte un branchement. Les interruptions posent le même genre de problèmes. Il faut impérativement vider la ''Prefetch input queue'' quand une interruption survient, avant de la traiter.

Il faut noter qu'une ''Prefetch input queue'' interagit assez mal avec le ''program counter''. En effet, la ''Prefetch input queue'' précharge les instructions séquentiellement. Pour savoir où elle en est rendue, elle mémorise l'adresse de la prochaine instruction à charger dans un '''registre de préchargement''' dédié. Il serait possible d'utiliser un ''program counter'' en plus du registre de préchargement, mais ce n'est pas la solution qui a été utilisée. Les processeurs Intel anciens ont préféré n'utiliser qu'un seul registre de préchargement en remplacement du ''program counter''. Après tout, le registre de préchargement n'est qu'un ''program counter'' ayant pris une avance de quelques cycles d'horloge, qui a été incrémenté en avance.

Et cela ne pose pas de problèmes, sauf avec certains branchements. Par exemple, certains branchements relatifs demandent de connaitre la véritable valeur du ''program counter'', pas celle calculée en avance. Idem avec les instructions d'appel de fonction, qui demandent de sauvegarder l'adresse de retour exacte, donc le vrai ''program counter''. De telles situations demandent de connaitre la valeur réelle du ''program counter'', celle sans préchargement. Pour cela, le décodeur d'instruction dispose d'une instruction pour reconstituer le ''program counter'', à savoir corriger le ''program coutner'' et éliminer l'effet du préchargement.

La micro-opération de correction se contente de soustraire le nombre d'octets préchargés au registre de préchargement. Le nombre d'octets préchargés est déduit à partir des deux pointeurs intégré à la FIFO, qui indiquent la position du premier et du dernier octet préchargé. Le bit qui indique si la FIFO est vide était aussi utilisé. Les deux pointeurs sont lus depuis la FIFO, et sont envoyés à un circuit qui détermine le nombre d'octets préchargés. Sur le 8086, ce circuit était implémenté non pas par un circuit combinatoire, mais par une mémoire ROM équivalente. La petite taille de la FIFO faisait que les pointeurs étaient très petits et la ROM l'était aussi.

Un autre défaut est que la ''Prefetch input queue'' se marie assez mal avec du code auto-modifiant. Un code auto-modifiant est un programme qui se modifie lui-même, en remplaçant certaines instructions par d'autres, en en retirant, en en ajoutant, lors de sa propre exécution. De tels programmes sont rares, mais la technique était utilisée dans quelques cas au tout début de l'informatique sur des ordinateurs rudimentaires. Ceux-ci avaient des modes d'adressages tellement limités que gérer des tableaux de taille variable demandait d'utiliser du code auto-modifiant pour écrire des boucles.

Le problème avec la ''Prefetch input queue'' survient quand des instructions sont modifiées immédiatement après avoir été préchargées. Les instructions dans la ''Prefetch input queue'' sont l'ancienne version, alors que la mémoire RAM contient les instructions modifiées. Gérer ce genre de cas est quelque peu complexe. Il faut en effet vider la ''Prefetch input queue'' si le cas arrive, ce qui demande d'identifier les écritures qui écrasent des instructions préchargées. C'est parfaitement possible, mais demande de transformer la ''Prefetch input queue'' en une mémoire hybride, à la fois mémoire associative et mémoire FIFO. Cela ne vaut que très rarement le coup, aussi les ingénieurs ne s’embêtent pas à mettre ce correctif en place, le code automodifiant est alors buggé.

Le décodeur d'instruction dispose aussi d'une micro-opération qui stoppe le préchargement des instructions dans la ''Prefetch input queue''.

===Le ''Zero-overhead looping''===

Nous avions vu dans le chapitre sur les instructions machines, qu'il existe des instructions qui permettent de grandement faciliter l'implémentation des boucles. Il s'agit de l'instruction REPEAT, utilisée sur certains processeurs de traitement de signal. Elle répète l'instruction suivante, voire une série d'instructions, un certain nombre de fois. Le nombre de répétitions est mémorisé dans un registre décrémenté à chaque itération de la boucle. Elle permet donc d'implémenter une boucle FOR facilement, sans recourir à des branchements ou des conditions.

Une technique en lien avec cette instruction permet de grandement améliorer les performances et la consommation d'énergie. L'idée est de mémoriser la boucle, les instructions à répéter, dans une petite mémoire cache située entre l'unité de chargement et le séquenceur. Le cache en question s'appelle un '''tampon de boucle''', ou encore un ''hardware loop buffer''. Grâce à lui, il n'y a pas besoin de charger les instructions à chaque fois qu'on les exécute, on les charge une bonne fois pour toute : c'est plus rapide. Bien sûr, il ne fonctionne que pour de petites boucles, mais il en est de même avec l'instruction REPEAT.

&lt;noinclude&gt;
{{NavChapitre | book=Fonctionnement d'un ordinateur
           | prev=Le chemin de données
           | prevText=Le chemin de données
           | next=L'unité de contrôle
           | nextText=L'unité de contrôle
}}
&lt;/noinclude&gt;</text>
      <sha1>8p8poj6b7qnolqapwfx4nijpg8iirw0</sha1>
    </revision>
    <revision>
      <id>744082</id>
      <parentid>744080</parentid>
      <timestamp>2025-06-03T19:42:16Z</timestamp>
      <contributor>
        <username>Mewtow</username>
        <id>31375</id>
      </contributor>
      <minor />
      <comment>/* La prefetch input queue */</comment>
      <origin>744082</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="45561" sha1="qa5rniqtk29ctw095nzv0r4bt1szk60" xml:space="preserve">L'unité de contrôle s'occupe du chargement des instructions et de leur interprétation, leur décodage. Elle contient deux circuits : l''''unité de chargement''' qui charge l'instruction depuis la mémoire, et le '''séquenceur''' qui commande le chemin de données. Les deux circuits sont séparés, mais ils communiquent entre eux, notamment pour gérer les branchements. Dans ce chapitre, nous allons nous intéresser au chargement d'une instruction depuis la RAM/ROM, nous verrons l'étape de décodage de l'instruction au prochain chapitre.

==Le chargement d'une instruction==

[[File:Étape de chargement.png|vignette|upright=1|Étape de chargement.]]

L'étape de chargement (ou ''fetch'') doit faire deux choses : mettre à jour le ''program counter'' et lire l'instruction en mémoire RAM ou en ROM. Les deux étapes peuvent être faites en parallèle, dans des circuits séparés. Pendant que l'instruction est lue depuis la mémoire RAM/ROM, le ''program counter'' est incrémenté et/ou altéré par un branchement.

Pour lire l'instruction, on envoie le ''program counter'' sur le bus d'adresse et on récupère l'instruction sur le bus de données pour l'envoyer sur l'entrée du séquenceur. Et cela demande de connecter le séquenceur au bus mémoire, à travers l'interface mémoire. Et sur ce point, la situation est différente selon que l'on parler d'une architecture Harvard ou Von Neumann.

===Les interconnexions entre séquenceur et bus mémoire===

Sur les architectures Harvard, le séquenceur et le chemin de donnée utilisent des interfaces mémoire séparées. Le séquenceur est directement relié au bus mémoire de la ROM, alors que le chemin de données est connecté à la RAM.

[[File:Microarchitecture de l'interface mémoire d'une architecture Harvard.png|centre|vignette|upright=2|Microarchitecture de l'interface mémoire d'une architecture Harvard]]

Mais sur les architectures Von-Neumann et affiliées, le séquenceur et le chemin de donnée partagent la même interface mémoire. Et cela pose deux problèmes.

Le premier problème est que le bus mémoire doit être libéré une fois l'instruction chargée, pour un éventuel accès mémoire. Mais le séquenceur doit conserver une copie de l'instruction chargée, sans quoi il ne peut pas décoder l'instruction correctement. Par exemple, si l'instruction met plusieurs cycles à s'exécuter, le séquenceur doit conserver une copie de l'instruction durant ces plusieurs cycles. La solution à ce problème est un '''registre d'instruction''' situé juste avant le séquenceur, qui mémorise l'instruction chargée.

[[File:Registre d'instruction.png|centre|vignette|upright=2|Registre d'instruction.]]

Le second problème est de gérer le flot des instructions/données entre le bus mémoire, le chemin de données et le séquenceur. Le processeur doit connecter l'interface mémoire soit au séquenceur, soit au chemin de données et cela complique le réseau d'interconnexion interne au processeur.

Une première solution utilise un bus unique qui relie l'interface mémoire, le séquenceur et le chemin de données. Pour charger une instruction, le séquenceur copie le ''program counter'' sur le bus d'adresse, attend que l'instruction lue soit disponible sur le bus de données, puis la copie dans le registre d'instruction. Le bus mémoire est alors libre et peut être utilisé pour lire ou écrire des données, si le besoin s'en fait sentir.

Il faut noter que l'usage d'un bus unique a un impact sur l'organisation interne du chemin de données. Par exemple, le chapitre précédent nous a montré comment implémenter un chemin de données basique, avec des multiplexeurs et démultiplexeurs. Et bien ces chemins de données ne marchent pas vraiment avec un bus interne unique. Il est possible de les adapter, mais au prix d'une complexité largement supérieure. Un bus interne unique marche mieux quand le banc de registre est mono-port. C'est pourquoi il a été utilisé sur d'anciennes architectures appelées des architectures à accumulateur et à pile, que nous verrons dans quelques chapitres, qui utilisaient un banc de registre mono-port.

[[File:Microarchitecture de l'interface mémoire d'une architecture von neumann.png|centre|vignette|upright=2|Microarchitecture de l'interface mémoire d'une architecture von neumann]]

Une autre solution utilise deux bus interne séparés : un connecté au bus d'adresse, l'autre au bus de données. Le ''program counter'' est alors connecté au bus interne d'adresse, le séquenceur est relié au bus interne de données. Notons que la technique marche bien si le ''program counter'' est dans le banc de registre : les interconnexions utilisées pour gérer l'adressage indirect permettent d'envoyer le ''program counter'' sur le bus d'adresse sans ajout de circuit.

Le tout peut être amélioré en remplaçant les deux bus par des multiplexeurs et démultiplexeurs. Le bus d'adresse est précédé par un multiplexeur, qui permet de faire le choix entre ''Program Counter'', adresse venant du chemin de données, ou adresse provenant du séquenceur (adressage absolu). De même, le bus de données est suivi par un démultiplexeur qui envoie la donnée/instruction lue soit au registre d'instruction, soit au chemin de données. Le tout se marie très bien avec les chemins de donnée vu dans le chapitre précédent. Au passage, il faut noter que cette solution nécessite un banc de registre multi-port.

[[File:Connexion du program counter sur les bus avec PC isolé.png|centre|vignette|upright=2|Connexion du program counter sur les bus avec PC isolé]]

===Le chargement des instructions de longueur variable===

Le chargement des instructions de longueur variable pose de nombreux problèmes. Le premier est que mettre à jour le ''program counter'' demande de connaitre la longueur de l'instruction chargée, pour l'ajouter au ''program counter''. Si la longueur d'une instruction est variable, on doit connaitre cette longueur d'une manière où d'une autre. La solution la plus simple indique la longueur de l'instruction dans une partie de l'opcode ou de la représentation en binaire de l'instruction. Mais les processeurs haute performance de nos PC utilisent d'autres solutions, qui n'encodent pas explicitement la taille de l'instruction.

Les processeurs récents utilisent un registre d'instruction de grande taille, capable de mémoriser l'instruction la plus longue du processeur. Par exemple, si un processeur supporte des instructions allant de 1 à 8 octets, comme les CPU x86, le registre d'instruction fera 8 octets. Le décodeur d'instruction vérifie à chaque cycle le contenu du registre d'instruction. Si une instruction est détectée dedans, son décodage commence, peu importe la taille de l'instruction. Une fois l'instruction exécutée, elle est retirée du registre d'instruction. Reste à alimenter le registre d'instruction, à charger des instructions dedans. Et pour cela deux solutions : soit on charge l'instruction en plusieurs fois, soit d'un seul coup.

La solution la plus simple charge les instructions par mots de 8, 16, 32, 64 bits. Ils sont accumulés dans le registre d'instruction jusqu'à détecter une instruction complète. La technique marche nettement mieux si les instructions sont très longues. Par exemple, les CPU x86 ont des instructions qui vont de 1 à 15 octets, ce qui fait qu'ils utilisent cette technique. Précisément, elle marche si les instructions les plus longues sont plus grandes que le bus mémoire.

Une autre solution charge un bloc de mots mémoire aussi grand que la plus grande instruction. Par exemple, si le processeur gère des instructions allant de 1 à 4 octets, il charge 4 octets d'un seul coup dans le registre d'instruction. Il va de soit que cette solution ne marche que si les instructions du processeur sont assez courtes, au plus aussi courtes que le bus mémoire. Ainsi, on est sûr de charger obligatoirement au moins une instruction complète, et peut-être même plusieurs. Le contenu du registre d'instruction est alors découpé en instructions au fil de l'eau. 

Utiliser un registre d'instruction large pose problème avec des instructions à cheval entre deux blocs. Il se peut qu'on n'ait pas une instruction complète lorsque l'on arrive à la fin du bloc, mais seulement un morceau. Le problème se manifeste peu importe que l'instruction soit chargée d'un seul coup ou bien en plusieurs fois.

[[File:Instructions non alignées.png|centre|vignette|upright=2|Instructions non alignées.]]

Dans ce cas, on doit décaler le morceau de bloc pour le mettre au bon endroit (au début du registre d'instruction), et charger le prochain bloc juste à côté. On a donc besoin d'un circuit qui décale tous les bits du registre d'instruction, couplé à un circuit qui décide où placer dans le registre d'instruction ce qui a été chargé, avec quelques circuits autour pour configurer les deux circuits précédents.

[[File:Décaleur d’instruction.png|centre|vignette|upright=2|Décaleur d’instruction.]]

Une autre solution se passe de registre d'instruction en utilisant à la place l'état interne du séquenceur. Là encore, elle charge l'instruction morceau par morceau, typiquement par blocs de 8, 16 ou 32 bits. Les morceaux ne sont pas accumulés dans le registre d'instruction, la solution utilise à la place l'état interne du séquenceur. Les mots mémoire de l'instruction sont chargés à chaque cycle, faisant passer le séquenceur d'un état interne à un autre à chaque mot mémoire. Tant qu'il n'a pas reçu tous les mots mémoire de l'instruction, chaque mot mémoire non terminal le fera passer d'un état interne à un autre, chaque état interne encodant les mots mémoire chargés auparavant. S'il tombe sur le dernier mot mémoire d'une instruction, il rentre dans un état de décodage.

==L'incrémentation du ''program counter''==

À chaque chargement, le ''program counter'' est mis à jour afin de pointer sur la prochaine instruction à charger. Sur la quasi-totalité des processeurs, les instructions sont placées dans l'ordre d’exécution dans la RAM. En faisant ainsi, on peut mettre à jour le ''program counter'' en lui ajoutant la longueur de l'instruction courante. Déterminer la longueur de l'instruction est simple quand les instructions ont toutes la même taille, mais certains processeurs ont des instructions de taille variable, ce qui complique le calcul. Dans ce qui va suivre, nous allons supposer que les instructions sont de taille fixe, ce qui fait que le ''program counter'' est toujours incrémenté de la même valeur.

Il existe deux méthodes principales pour incrémenter le ''program counter'' : soit le ''program counter'' a son propre additionneur, soit le ''program counter'' est mis à jour par l'ALU. Pour ce qui est de l'organisation des registres, soit le ''program counter'' est un registre séparé des autres, soit il est regroupé avec d'autres registres dans un banc de registre. En tout, cela donne quatre organisations possibles.
* Un ''program counter'' séparé relié à un incrémenteur séparé.
* Un ''program counter'' séparé des autres registres, incrémenté par l'ALU.
* Un ''program counter'' intégré au banc de registre, relié à un incrémenteur séparé.
* Un ''program counter'' intégré au banc de registre, incrémenté par l'ALU.

[[File:Calcul du program counter.png|centre|vignette|upright=2|les différentes méthodes de calcul du program counter.]]

Les processeurs haute performance modernes utilisent tous la première méthode. Les autres méthodes étaient surtout utilisées sur les processeurs 8 ou 16 bits, elles sont encore utilisées sur quelques microcontrôleurs de faible puissance. Nous auront l'occasion de donner des exemples quand nous parlerons des processeurs 8 bits anciens, dans le chapitre sur les architectures à accumulateur et affiliées.

===Le ''program counter'' mis à jour par l'ALU===

Sur certains processeurs, le calcul de l'adresse de la prochaine instruction est effectué par l'ALU. L'avantage de cette méthode est qu'elle économise un incrémenteur dédié au ''program counter''. Ce qui explique que cette méthode était utilisée sur les processeurs assez anciens, à une époque où un additionneur pouvait facilement prendre 10 à 20% des transistors disponibles. Le désavantage principal est une augmentation de la complexité du séquenceur, qui doit gérer la mise à jour du ''program counter''. De plus, la mise à jour du ''program counter'' ne peut pas se faire en même temps qu'une opération arithmétique, ce qui réduit les performances.

Si on incrémente le ''program counter'' avec l'ALU, il est intéressant de le placer dans le banc de registres. Un désavantage est qu'on perd un registre. Par exemple, avec un banc de registre de 16 registres, on ne peut adresser que 15 registres généraux. De plus ce n'est pas l'idéal pour le décodage des instructions et pour le séquenceur. Si le processeur dispose de plusieurs bancs de registres, le ''program counter'' est généralement placé dans le banc de registre dédié aux adresses. Sinon, il est placé avec les nombres entiers/adresses.

D'anciens processeurs incrémentaient le ''program counter'' avec l'ALU, mais utilisaient bien un registre séparé pour le ''program counter''. Cette méthode est relativement simple à implémenter : il suffit de connecter/déconnecter le ''program counter'' du bus interne suivant les besoins. Le ''program counter'' est déconnecté pendant l’exécution d'une instruction, il est connecté au bus interne pour l'incrémenter. C'est le séquenceur qui gère le tout. L'avantage de cette séparation est qu'elle est plus facile à gérer pour le séquenceur. De plus, on gagne un registre général/entier dans le banc de registre.

===Le compteur programme===

Dans la quasi-totalité des processeurs modernes, le ''program counter'' est un vulgaire compteur comme on en a vu dans les chapitres sur les circuits, ce qui fait qu'il passe automatiquement d'une adresse à la suivante. Dans ce qui suit, nous allons appeler ce registre compteur : le '''compteur ordinal'''. L'usage d'un compteur simplifie fortement la conception du séquenceur. Le séquenceur n'a pas à gérer la mise à jour du ''program counter'', sauf en cas de branchements. De plus, il est possible d'incrémenter le ''program counter'' pendant que l'unité de calcul effectue une opération arithmétique, ce qui améliore grandement les performances. Le seul désavantage est qu'elle demande d'ajouter un incrémenteur dédié au ''program counter''.

Sur les processeurs très anciens, les instructions faisaient toutes un seul mot mémoire et le compteur ordinal était un circuit incrémenteur des plus basique. Sur les processeurs modernes, le compteur est incrémenté par pas de 4 si les instructions sont codées sur 4 octets, 8 si les instructions sont codées sur 8 octets, etc. Concrètement, le compteur est un circuit incrémenteur auquel on aurait retiré quelques bits de poids faible. Par exemple, si les instructions sont codées sur 4 octets, on coupe les 2 derniers bits du compteur. Si les instructions sont codées sur 8 octets, on coupe les 3 derniers bits du compteur. Et ainsi de suite.

Il a existé quelques processeurs pour lesquelles le ''program counter'' était non pas un compteur binaire classique, mais un ''linear feedback shift register''. L'avantage est que le circuit d'incrémentation utilisait bien moins de portes logiques, l'économie était substantielle. Mais un défaut est que des instructions consécutives dans le programme n'étaient pas consécutives en mémoire. Il existait cependant une table de correspondance pour dire : la première instruction est à telle adresse, la seconde à telle autre, etc. Un exemple de processeur de ce type est le TMS 1000 de Texas Instrument, un des premiers microcontrôleur 4 bits datant des années 70.

Une amélioration de la solution précédente utilise un circuit incrémenteur partagé entre le ''program counter'' et d'autres registres. L'incrémenteur est utilisé pour incrémenter le ''program counter'', mais aussi pour effectuer d'autres calculs d'adresse. Par exemple, sur les architectures avec une pile d'adresse de retour, il est possible de partager l'incrémenteur/décrémenteur avec le pointeur de pile ( la technique ne marche pas avec une pile d'appel). Un autre exemple est celui des processeurs qui gèrent automatiquement le rafraichissement mémoire, grâce à, un compteur intégré dans le processeur. Il est possible de partager l'incrémenteur du ''program counter'' avec le compteur de rafraichissement mémoire, qui mémorise la prochaine adresse mémoire à rafraichir. Nous avions déjà abordé ce genre de partage dans le chapitre sur le chemin de données, dans l'annexe sur le pointeur de pile, mais nous verrons d'autres exemples dans le chapitre sur les architectures hybride accumulateur-registre 8/16 bits.

===Quand est mis à jour le ''program counter'' ?===

Le ''program counter'' est mis à jour quand il faut charger une nouvelle instruction. Reste qu'il faut savoir quand le mettre à jour. Incrémenter le ''program counter'' à intervalle régulier, par exemple à chaque cycle d’horloge, fonctionne sur les processeurs où toutes les instructions mettent le même temps pour s’exécuter. Mais de tels processeurs sont très rares. Sur la quasi-totalité des processeurs, les instructions ont une durée d’exécution variable, elles ne prennent pas le même nombre de cycle d'horloge pour s’exécuter. Le temps d’exécution d'une instruction varie selon l'instruction, certaines sont plus longues que d'autres. Tout cela amène un problème : comment incrémenter le ''program counter'' avec des instructions avec des temps d’exécution variables ?

La réponse est que la mise à jour du ''program counter'' démarre quand l'instruction précédente a terminée de s’exécuter, plus précisément un cycle avant. C'est un cycle avant pour que l'instruction chargée soit disponible au prochain cycle pour le décodeur. Pour cela, le séquenceur doit déterminer quand l'instruction est terminée et prévenir le ''program counter'' au bon moment. Il faut donc une interaction entre séquenceur et circuit de chargement. Le circuit de chargement contient une entrée Enable, qui autorise la mise à jour du ''program counter''. Le séquenceur met à 1 cette entrée pour prévenir au ''program counter'' qu'il doit être incrémenté au cycle suivant ou lors du cycle courant. Cela permet de gérer simplement le cas des instructions multicycles. 

[[File:Commande de la mise à jour du program counter.png|centre|vignette|upright=2|Commande de la mise à jour du program counter.]]

Toute la difficulté est alors reportée dans le séquenceur, qui doit déterminer la durée d'une instruction. Pour gérer la mise à jour du ''program counter'', le séquenceur doit déterminer la durée d'une instruction. Cela est simple pour les instructions arithmétiques et logiques, qui ont un nombre de cycles fixe, toujours le même. Une fois l'instruction identifiée par le séquenceur, il connait son nombre de cycles et peut programmer un compteur interne au séquenceur, qui compte le nombre de cycles de l'instruction, et fournit le signal Enable au ''program counter''. Mais cette technique ne marche pas vraiment pour les accès mémoire, dont la durée n'est pas connue à l'avance, surtout sur les processeurs avec des mémoires caches. Pour cela, le séquenceur détermine quand l'instruction mémoire est finie et prévient le ''program counter'' quand c'est le cas.

Il existe quelques processeurs pour lesquels le temps de calcul dépend des opérandes de l'instruction. On peut par exemple avoir une division qui prend 10 cycles avec certaines opérandes, mais 40 cycles avec d'autres opérandes. Mais ces processeurs sont rares et cela est surtout valable pour les opérations de multiplication/division, guère plus. Le problème est alors le même qu'avec les accès mémoire et la solution est la même : l'ALU prévient le séquenceur quand le résultat est disponible.

==Les branchements et le ''program counter''==

Un branchement consiste juste à écrire l'adresse de destination dans le ''program counter''. L'implémentation des branchements demande d'extraire l'adresse de destination et d'altérer le ''program counter'' quand un branchement est détecté. Pour cela, le décodeur d'instruction détecte si l'instruction exécutée est un branchement ou non, et il en déduit où trouver l'adresse de destination.

L'adresse de destination se trouve à un endroit qui dépend du mode d'adressage du branchement. Pour rappel, on distingue quatre modes d'adressage pour les branchements : direct, indirect, relatif et implicite. Pour les branchements directs, l'adresse est intégrée dans l'instruction de branchement elle-même et est extraite par le séquenceur. Pour les branchements indirects, l'adresse de destination est dans le banc de registre. Pour les branchements relatifs, il faut ajouter un décalage au ''program counter'', décalage extrait de l'instruction par le séquenceur. Enfin, les instructions de retour de fonction lisent l'adresse de destination depuis la pile. L'implémentation de ces quatre types de branchements est très différente.

L'altération du ''program counter'' dépend de si le ''program counter'' est dans un compteur séparé ou s'il est dans le banc de registre. Nous avons vu plus haut qu'il y a quatre cas différents, mais nous n'allons voir que deux cas : celui où le ''program counter'' est dans le banc de registre et est incrémenté par l'unité de calcul, celui avec un ''program counter'' séparé avec son propre incrémenteur. Les deux autres cas ne sont utilisés que sur des architectures à accumulateur ou à pile spécifiques, que nous n'avons pas encore vu à ce stade du cours et que nous verrons en temps voulu dans le chapitre sur ces architectures.

===L’implémentation des branchements avec un ''program counter'' intégré au banc de registres===

Le cas le plus simple est celui où le ''program counter'' est intégré au banc de registre, avec une incrémentation faite par l'unité de calcul. Charger une instruction revient alors à effectuer une instruction LOAD en adressage indirect, à deux différences près : le registre sélectionné est le ''program counter'', l’instruction est copiée dans le registre d'instruction et non dans le banc de registre. L'incrémentation du ''porgram counter'' est implémenté avec des micro-opérations qui agissent sur le chemin de données, au même titre que les branchements indirects, relatifs et directs.
* Les branchements indirects copient un registre dans le ''program counter'', ce qui revient simplement à faire une opération MOV entre deux registres, dont le ''program counter'' est la destination.
* L'opération inverse d'un branchement indirect, qui copie le ''program counter'' dans un registre général, est utile pour sauvegarder l'adresse de retour d'une fonction.
* Les branchements directs copient une adresse dans le ''program counter'', ce qui les rend équivalents à une opération MOV avec une constante immédiate, dont le ''program counter'' est la destination.
* Les branchements relatifs sont une opération arithmétique entre le ''program counter'' et un opérande en adressage immédiat.

En clair, à partir du moment où le chemin de données supporte les instructions MOV et l'addition, avec les modes d'adressage adéquat, il supporte les branchements. Aucune modification du chemin de données n'est nécessaire, le séquenceur gére le chargement d'une instruction avec les micro-instructions adéquates : une micro-opération ADD pour incrémenter le ''program counter'', une micro-opération LOAD pour le chargement de l'instruction.

Notons que sur certaines architectures, le ''program counter'' est adressable au même titre que les autres registres du banc de registre. Les instructions de branchement sont alors remplacées par des instructions MOV ou des instructions arithmétique équivalentes, comme décrit plus haut.

===L’implémentation des branchements avec un ''program counter'' séparé===

Étudions maintenant le cas où le ''program counter'' est dans un registre/compteur séparé. Rappelons que tout compteur digne de ce nom possède une entrée de réinitialisation, qui remet le compteur à zéro. De plus, on peut préciser à quelle valeur il doit être réinitialisé. Ici, la valeur à laquelle on veut réinitialiser le compteur n'est autre que l'adresse de destination du branchement. Implémenter un branchement est donc simple : l'entrée de réinitialisation est commandée par le circuit de détection des branchements, alors que la valeur de réinitialisation est envoyée sur l'entrée adéquate. En clair, nous partons du principe que le ''program counter'' est implémenté avec ce type de compteur :

[[File:Fonctionnement d'un compteur (décompteur), schématique.jpg|centre|vignette|upright=1.5|Fonctionnement d'un compteur (décompteur), schématique]]

Toute la difficulté est de présenter l'adresse de destination au ''program counter''. Pour les branchements directs, l'adresse de destination est fournie par le séquenceur. L'adresse de destination du branchement sort du séquenceur et est présentée au ''program counter'' sur l'entrée adéquate. Voici donc comment sont implémentés les branchements directs avec un ''program counter'' séparé du banc de registres. Le schéma ci-dessous marche peu importe que le ''program counter'' soit incrémenté par l'ALU ou par un additionneur dédié.

[[File:Unité de détection des branchements dans le décodeur.png|centre|vignette|upright=2|Unité de détection des branchements dans le décodeur]]

Les branchements relatifs sont ceux qui font sauter X instructions plus loin dans le programme. Leur implémentation demande d'ajouter une constante au ''program counter'', la constante étant fournie dans l’instruction. Là encore, deux solutions sont possibles : réutiliser l'ALU pour calculer l'adresse, ou utiliser un additionneur séparé. L'additionneur séparé peut être fusionné avec l'additionneur qui incrémente le ''program counter'' pour passer à l’instruction suivante.

[[File:Unité de chargement qui gère les branchements relatifs.png|centre|vignette|upright=2|Unité de chargement qui gère les branchements relatifs.]]

Pour les branchements indirects, il suffit de lire le registre voulu et d'envoyer le tout sur l'entrée adéquate du ''program counter''. Il faut alors rajouter un multiplexeur pour que l'entrée de réinitialisationr ecoive la bonne adresse de destination.

[[File:Unité de chargement qui gère les branchements directs.png|centre|vignette|upright=2|Unité de chargement qui gère les branchements directs et indirects.]]

Toute la difficulté de l'implémentation des branchements est de configurer les multiplexeurs, ce qui est réalisé par le séquenceur en fonction du mode d'adressage du branchement.

==Les optimisations du chargement des instructions==

Charger une instruction est techniquement une forme d'accès mémoire un peu particulier. En clair, charger une instruction prend au minimum un cycle d'horloge, et cela peut rapidement monter à 3-5 cycles, si ce n'est plus. L'exécution des instructions est alors fortement ralentit par la mémoire. Par exemple, imaginez que la mémoire mette 3 cycles d'horloges pour charger une instruction, alors qu'une instruction s’exécute en 1 cycle (si les opérandes sont dans les registres). La perte de performance liée au chargement des instructions est alors substantielle. Heureusement, il est possible de limiter la casse en utilisant des mémoires caches, ainsi que d'autres optimisations, que nous allons voir dans ce qui suit.

===Le tampon de préchargement===

La technique dite du '''préchargement''' est utilisée dans le cas où la mémoire a un temps d'accès important. Mais si la latence de la RAM est un problème, le débit ne l'est pas. Il est possible d'avoir une RAM lente, mais à fort débit. Par exemple, supposons que la mémoire puisse charger 4 instructions (de taille fixe) en 3 cycles. Le processeur peut alors charger 4 instructions en un seul accès mémoire, et les exécuter l'une après l'autre, une par cycle d'horloge. Les temps d'attente sont éliminés : le processeur peut décoder une nouvelle instruction à chaque cycle. Et quand la dernière instruction préchargée est exécutée, la mémoire est de nouveau libre, ce qui masque la latence des accès mémoire.

[[File:Tampon de préchargement d'instruction.png|vignette|Tampon de préchargement d'instruction]]

La seule contrainte est de mettre les instructions préchargées en attente. La solution pour cela est d'utiliser un registre d'instruction très large, capable de mémoriser plusieurs instructions à la fois. Ce registre est de plus connecté à un multiplexeur qui permet de sélectionner l'instruction adéquate dans ce registre. Ce multiplexeur est commandé par le ''program counter'' et quelques circuits annexes. Ce super-registre d'instruction est appelé un '''tampon de préchargement'''.

La méthode a une implémentation nettement plus simple avec des instructions de taille fixe, alignées en mémoire. La commande du multiplexeur de sélection de l'instruction est alors beaucoup plus simple : il suffit d'utiliser les bits de poids fort du ''program counter''. Par exemple, prenons le cas d'un registre d'instruction de 32 octets pour des instructions de 4 octets, soit 8 instructions. Le choix de l'instruction à sélectionner se fait en utilisant les 3 bits de poids faible du ''program counter''. 

Mais cette méthode ajoute de nouvelles contraintes d'alignement, similaires à celles vues dans le chapitre sur l'alignement et le boutisme, sauf que l'alignement porte ici sur des blocs d'instructions de même taille que le tampon de préchargement. Si on prend l'exemple d'un tampon de préchargement de 128 bits, les instructions devront être alignées par blocs de 128 bits. C'est à dire qu'idéalement, les fonctions et autres blocs de code isolés doivent commencer à des adresses multiples de 128, pour pouvoir charger un bloc d'instruction en une seule fois. Sans cela, les performances seront sous-optimales.

: Il arrive que le tampon de préchargement ait la même taille qu'une ligne de cache.

Lorsque l'on passe d'un bloc d'instruction à un autre, le tampon de préchargement est mis à jour. Par exemple, si on prend un tampon de préchargement de 4 instructions, on doit changer son contenu toutes les 4 instructions. La seule exception est l'exécution d'un branchement. En effet, lors d'un branchement, la destination du branchement n'est pas dans le tampon de préchargement et elle doit être chargée dedans (sauf si le branchement pointe vers une instruction très proche, ce qui est improbable). Pour cela, le tampon de préchargement est mis à jour précocement quand le processeur détecte un branchement.

Le même problème survient avec du code auto-modifiant. Un code auto-modifiant est un programme qui se modifie lui-même, en remplaçant certaines instructions par d'autres, en en retirant, en en ajoutant, lors de sa propre exécution. De tels programmes sont rares, mais la technique était utilisée dans quelques cas au tout début de l'informatique sur des ordinateurs rudimentaires. Ceux-ci avaient des modes d'adressages tellement limités que gérer des tableaux de taille variable demandait d'utiliser du code auto-modifiant pour écrire des boucles. Le problème survient quand des instructions sont modifiées immédiatement après avoir été préchargées. Les instructions dans le tampon de préchargement sont l'ancienne version, alors que la mémoire RAM contient les instructions modifiées. Gérer ce genre de cas demande de vider le tampon de préchargement si le cas arrive, mais ça ne vaut que très rarement le coup, aussi les ingénieurs ne s’embêtent pas à mettre ce correctif en place. Le code automodifiant est alors buggé.

===La ''prefetch input queue''===

La ''prefetch input queue'' est une sorte de cousine du tampon de préchargement, qui a été utilisée sur les processeurs Intel assez ancien. Elle est apparue sur le 8086 et le 8088, des processeurs respectivement 8 et 16 bits. Elle été présente sur le 286 et le 386, mais était un peu améliorée. Elle est apparue sur ces processeurs à une époque où le processeur devenait plus rapide que la mémoire.

L'idée est là encore de précharger des instructions en avance. Sauf que cette fois-ci, on ne charge pas plusieurs instructions à la fois. Au contraire, les instructions sont préchargées séquentiellement, un octet à la fois. En conséquence, le tampon de préchargement est remplacé par une mémoire FIFO appelée la '''''Prefetch Input Queue''''', terme abrévié en PIQ. Les instructions sont accumulées une par une dans la PIQ, elles en sortent une par une au fur et à mesure pour alimenter le décodeur d'instruction.

L'idée est que pendant que le processeur exécute une instruction, on précharge la suivante. Sans ''prefetch input queue'', le processeur chargeait une instruction, la décodait et l'exécutait, puis chargeait la suivante, et ainsi de suite. Avec la ''prefetch input queue'', pendant qu'une instruction est en cours de décodage/exécution, le processeur précharge l'instruction suivante. Si une instruction prend vraiment beaucoup de temps pour s'exécuter, le processeur peut en profiter pour précharger l'instruction encore suivante, et ainsi de suite, jusqu'à une limite de 4/6 instructions (la limite dépend du processeur).

La ''prefetch input queue'' permet de précharger l'instruction suivante à condition qu'aucun autre accès mémoire n'ait lieu. Si l'instruction en cours d'exécution effectue des accès mémoire, ceux-ci sont prioritaires sur tout le reste, le préchargement de l'instruction suivante est alors mis en pause ou inhibé. Par contre, si la mémoire n'est pas utilisée par l'instruction en cours d'exécution, le processeur lit l'instruction suivante en RAM et la copie dans la ''prefetch input queue''. En conséquence, il arrive que la 'prefetch input queue'' n'ait pas préchargé l'instruction suivante, alors que le décodeur d'instruction est prêt pour la décoder. Dans ce cas, le décodeur doit attendre que l'instruction soit chargée.

Les instructions préchargées dans la ''Prefetch input queue'' y attendent que le processeur les lise et les décode. Les instructions préchargées sont conservées dans leur ordre d'arrivée, afin qu'elles soient exécutées dans le bon ordre, ce qui fait que la ''Prefetch input queue'' est une mémoire de type FIFO. L'étape de décodage pioche l'instruction à décoder dans la ''Prefetch input queue'', cette instruction étant par définition la plus ancienne, puis la retire de la file.

Le premier processeur commercial grand public à utiliser une ''prefetch input queue'' était le 8086. Il pouvait précharger à l'avance 6 octets d’instruction. L'Intel 8088 avait lui aussi une ''Prefetch input queue'', mais qui ne permettait que de précharger 4 instructions. La taille idéale de la FIFO dépend de nombreux paramètres. On pourrait croire que plus elle peut contenir d'instructions, mieux c'est, mais ce n'est pas le cas, pour des raisons que nous allons expliquer dans quelques paragraphes.

[[File:80186 arch.png|centre|vignette|700px|upright=2|Architecture du 8086, du 80186 et de ses variantes.]]

Vous remarquerez que j'ai exprimé la capacité de la ''prefetch input queue'' en octets et non en instructions. La raison est que sur les processeurs x86, les instructions sont de taille variable. Les instructions de ces processeurs ont une taille qui varie entre deux octets et 6 octets. La ''prefetch input queue'' était optimisée pour lire des instructions de deux octets, avec quelques mécanismes pour gérer les instructions plus longues. Il faut dire que les instructions les plus courantes faisaient deux octets, respectivement un octet d'opcode et un octet Mod/RM pour préciser le mode d'adressage.

Le bus de données du 8086 faisait 16 bits, ce qui fait qu'il était possible de charger une instruction courte en un cycle. Par contre, sur le 8088, un processeur 8 bits, le bus de donnée ne permettait que de lire un octet à la fois. Dans les deux cas, le décodeur devait attendre que les deux octets d'une instruction soient disponibles dans la ''Prefetch input queue''. Pour cela, un circuit appelé le ''loader'' fournissait deux signaux au décodeur d'instruction : l'un indiquant que le premier octet est déjà chargé, l'autre indiquant que le second octet est disponible.

Le ''loader'' recevait aussi des signaux de la part du décodeur d'instruction, afin de gérer les lectures dans la ''Prefetch input queue''. Le décodeur envoyait le signal ''Run Next Instruction'' pour lire une instruction :  elle était alors dépilée de la ''Prefetch input queue''. Le décodeur d'instruction pouvait aussi envoyer un signal ''Next-to-last (NXT)'' un cycle en avance, un cucle avant que l'instruction en cours ne termine. Le résultat est que le ''loader'' réagissait en préchargeant l'instruction suivante. En clair, ce signal permettait de précharger l'instruction suivante avec un cycle d'avance, si celle-ci n'était pas déjà dans la ''Prefetch input queue''.

Pour gérer les instructions de plus de deux octets, le décodeur pouvait lire une instruction en plusieurs fois dans la ''Prefetch input queue''. Les deux premiers octets sont lus depuis la ''Prefetch input queue'', et sont alors décodés. Le décodeur détermine alors la taille de l'instruction. Si l'instruction fait exactement deux octets, elle est exécutée directement. Sinon, les octets manquants sont lus depuis la ''Prefetch input queue''. Pour cela, le décodeur dispose d'une micro-opération pour lire un octet depuis la ''Prefetch input queue''.

Les branchements posent des problèmes avec la ''Prefetch input queue'' : à cause d'eux, on peut charger à l'avance des instructions qui sont zappées par un branchement et ne sont pas censées être exécutées. Si un branchement est chargé, toutes les instructions préchargées après sont potentiellement invalides. Si le branchement est non-pris, les instructions chargées sont valides, elles sont censées s’exécuter. Mais si le branchement est pris, elles ont été chargées à tort et ne doivent pas s’exécuter. 

Pour éviter cela, la ''Prefetch input queue'' est vidée quand le processeur détecte un branchement. Pour cela, le décodeur d'instruction dispose d'une micro-opération qui vide la ''Prefetch input queue'', elle invalide les instructions préchargées.  Cette détection ne peut se faire qu'une fois le branchement décodé, qu'une fois que l'on sait que l'instruction décodée est un branchement. En clair, le décodeur invalide la ''Prefetch input queue'' quand il détecte un branchement. Les interruptions posent le même genre de problèmes. Il faut impérativement vider la ''Prefetch input queue'' quand une interruption survient, avant de la traiter.

Il faut noter qu'une ''Prefetch input queue'' interagit assez mal avec le ''program counter''. En effet, la ''Prefetch input queue'' précharge les instructions séquentiellement. Pour savoir où elle en est rendue, elle mémorise l'adresse de la prochaine instruction à charger dans un '''registre de préchargement''' dédié. Il serait possible d'utiliser un ''program counter'' en plus du registre de préchargement, mais ce n'est pas la solution qui a été utilisée. Les processeurs Intel anciens ont préféré n'utiliser qu'un seul registre de préchargement en remplacement du ''program counter''. Après tout, le registre de préchargement n'est qu'un ''program counter'' ayant pris une avance de quelques cycles d'horloge, qui a été incrémenté en avance.

Et cela ne pose pas de problèmes, sauf avec certains branchements. Par exemple, certains branchements relatifs demandent de connaitre la véritable valeur du ''program counter'', pas celle calculée en avance. Idem avec les instructions d'appel de fonction, qui demandent de sauvegarder l'adresse de retour exacte, donc le vrai ''program counter''. De telles situations demandent de connaitre la valeur réelle du ''program counter'', celle sans préchargement. Pour cela, le décodeur d'instruction dispose d'une instruction pour reconstituer le ''program counter'', à savoir corriger le ''program coutner'' et éliminer l'effet du préchargement.

La micro-opération de correction se contente de soustraire le nombre d'octets préchargés au registre de préchargement. Le nombre d'octets préchargés est déduit à partir des deux pointeurs intégré à la FIFO, qui indiquent la position du premier et du dernier octet préchargé. Le bit qui indique si la FIFO est vide était aussi utilisé. Les deux pointeurs sont lus depuis la FIFO, et sont envoyés à un circuit qui détermine le nombre d'octets préchargés. Sur le 8086, ce circuit était implémenté non pas par un circuit combinatoire, mais par une mémoire ROM équivalente. La petite taille de la FIFO faisait que les pointeurs étaient très petits et la ROM l'était aussi.

Un autre défaut est que la ''Prefetch input queue'' se marie assez mal avec du code auto-modifiant. Un code auto-modifiant est un programme qui se modifie lui-même, en remplaçant certaines instructions par d'autres, en en retirant, en en ajoutant, lors de sa propre exécution. De tels programmes sont rares, mais la technique était utilisée dans quelques cas au tout début de l'informatique sur des ordinateurs rudimentaires. Ceux-ci avaient des modes d'adressages tellement limités que gérer des tableaux de taille variable demandait d'utiliser du code auto-modifiant pour écrire des boucles.

Le problème avec la ''Prefetch input queue'' survient quand des instructions sont modifiées immédiatement après avoir été préchargées. Les instructions dans la ''Prefetch input queue'' sont l'ancienne version, alors que la mémoire RAM contient les instructions modifiées. Gérer ce genre de cas est quelque peu complexe. Il faut en effet vider la ''Prefetch input queue'' si le cas arrive, ce qui demande d'identifier les écritures qui écrasent des instructions préchargées. C'est parfaitement possible, mais demande de transformer la ''Prefetch input queue'' en une mémoire hybride, à la fois mémoire associative et mémoire FIFO. Cela ne vaut que très rarement le coup, aussi les ingénieurs ne s’embêtent pas à mettre ce correctif en place, le code automodifiant est alors buggé.

Le décodeur d'instruction dispose aussi d'une micro-opération qui stoppe le préchargement des instructions dans la ''Prefetch input queue''.

: Pour ceux qui ont déjà lu un cours d'architecture des ordinateurs, la relation entre ''prefetch input queue'' et pipeline est quelque peu complexe. En apparence, la ''prefetch input queue'' permet une certaines forme de pipeline, en chargeant une instruction pendant que la précédente s'exécute. Les problématiques liées aux branchements ressemblent beaucoup à celles de la prédiction de branchement. Cependant, il est possible de dire qu'il s'agit plus d'une technique de préchargement que de pipeline. La différence entre les deux est assez subtile et les frontières sont assez floues, mais le fait est que l'instruction en cours d'exécution et le préchargement peuvent tout deux faire des accès mémoire et que l'instruction en cours a la priorité. Un vrai pipeline se débrouillerait avec une architecture Harvard, non avec un bus mémoire unique pour le chargement des instruction et la lecture/écriture des données.

===Le ''Zero-overhead looping''===

Nous avions vu dans le chapitre sur les instructions machines, qu'il existe des instructions qui permettent de grandement faciliter l'implémentation des boucles. Il s'agit de l'instruction REPEAT, utilisée sur certains processeurs de traitement de signal. Elle répète l'instruction suivante, voire une série d'instructions, un certain nombre de fois. Le nombre de répétitions est mémorisé dans un registre décrémenté à chaque itération de la boucle. Elle permet donc d'implémenter une boucle FOR facilement, sans recourir à des branchements ou des conditions.

Une technique en lien avec cette instruction permet de grandement améliorer les performances et la consommation d'énergie. L'idée est de mémoriser la boucle, les instructions à répéter, dans une petite mémoire cache située entre l'unité de chargement et le séquenceur. Le cache en question s'appelle un '''tampon de boucle''', ou encore un ''hardware loop buffer''. Grâce à lui, il n'y a pas besoin de charger les instructions à chaque fois qu'on les exécute, on les charge une bonne fois pour toute : c'est plus rapide. Bien sûr, il ne fonctionne que pour de petites boucles, mais il en est de même avec l'instruction REPEAT.

&lt;noinclude&gt;
{{NavChapitre | book=Fonctionnement d'un ordinateur
           | prev=Le chemin de données
           | prevText=Le chemin de données
           | next=L'unité de contrôle
           | nextText=L'unité de contrôle
}}
&lt;/noinclude&gt;</text>
      <sha1>qa5rniqtk29ctw095nzv0r4bt1szk60</sha1>
    </revision>
    <revision>
      <id>744083</id>
      <parentid>744082</parentid>
      <timestamp>2025-06-03T19:49:46Z</timestamp>
      <contributor>
        <username>Mewtow</username>
        <id>31375</id>
      </contributor>
      <minor />
      <comment>/* La prefetch input queue */</comment>
      <origin>744083</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="45562" sha1="oelta66ka8fz8uixp5g6y5jba1wibom" xml:space="preserve">L'unité de contrôle s'occupe du chargement des instructions et de leur interprétation, leur décodage. Elle contient deux circuits : l''''unité de chargement''' qui charge l'instruction depuis la mémoire, et le '''séquenceur''' qui commande le chemin de données. Les deux circuits sont séparés, mais ils communiquent entre eux, notamment pour gérer les branchements. Dans ce chapitre, nous allons nous intéresser au chargement d'une instruction depuis la RAM/ROM, nous verrons l'étape de décodage de l'instruction au prochain chapitre.

==Le chargement d'une instruction==

[[File:Étape de chargement.png|vignette|upright=1|Étape de chargement.]]

L'étape de chargement (ou ''fetch'') doit faire deux choses : mettre à jour le ''program counter'' et lire l'instruction en mémoire RAM ou en ROM. Les deux étapes peuvent être faites en parallèle, dans des circuits séparés. Pendant que l'instruction est lue depuis la mémoire RAM/ROM, le ''program counter'' est incrémenté et/ou altéré par un branchement.

Pour lire l'instruction, on envoie le ''program counter'' sur le bus d'adresse et on récupère l'instruction sur le bus de données pour l'envoyer sur l'entrée du séquenceur. Et cela demande de connecter le séquenceur au bus mémoire, à travers l'interface mémoire. Et sur ce point, la situation est différente selon que l'on parler d'une architecture Harvard ou Von Neumann.

===Les interconnexions entre séquenceur et bus mémoire===

Sur les architectures Harvard, le séquenceur et le chemin de donnée utilisent des interfaces mémoire séparées. Le séquenceur est directement relié au bus mémoire de la ROM, alors que le chemin de données est connecté à la RAM.

[[File:Microarchitecture de l'interface mémoire d'une architecture Harvard.png|centre|vignette|upright=2|Microarchitecture de l'interface mémoire d'une architecture Harvard]]

Mais sur les architectures Von-Neumann et affiliées, le séquenceur et le chemin de donnée partagent la même interface mémoire. Et cela pose deux problèmes.

Le premier problème est que le bus mémoire doit être libéré une fois l'instruction chargée, pour un éventuel accès mémoire. Mais le séquenceur doit conserver une copie de l'instruction chargée, sans quoi il ne peut pas décoder l'instruction correctement. Par exemple, si l'instruction met plusieurs cycles à s'exécuter, le séquenceur doit conserver une copie de l'instruction durant ces plusieurs cycles. La solution à ce problème est un '''registre d'instruction''' situé juste avant le séquenceur, qui mémorise l'instruction chargée.

[[File:Registre d'instruction.png|centre|vignette|upright=2|Registre d'instruction.]]

Le second problème est de gérer le flot des instructions/données entre le bus mémoire, le chemin de données et le séquenceur. Le processeur doit connecter l'interface mémoire soit au séquenceur, soit au chemin de données et cela complique le réseau d'interconnexion interne au processeur.

Une première solution utilise un bus unique qui relie l'interface mémoire, le séquenceur et le chemin de données. Pour charger une instruction, le séquenceur copie le ''program counter'' sur le bus d'adresse, attend que l'instruction lue soit disponible sur le bus de données, puis la copie dans le registre d'instruction. Le bus mémoire est alors libre et peut être utilisé pour lire ou écrire des données, si le besoin s'en fait sentir.

Il faut noter que l'usage d'un bus unique a un impact sur l'organisation interne du chemin de données. Par exemple, le chapitre précédent nous a montré comment implémenter un chemin de données basique, avec des multiplexeurs et démultiplexeurs. Et bien ces chemins de données ne marchent pas vraiment avec un bus interne unique. Il est possible de les adapter, mais au prix d'une complexité largement supérieure. Un bus interne unique marche mieux quand le banc de registre est mono-port. C'est pourquoi il a été utilisé sur d'anciennes architectures appelées des architectures à accumulateur et à pile, que nous verrons dans quelques chapitres, qui utilisaient un banc de registre mono-port.

[[File:Microarchitecture de l'interface mémoire d'une architecture von neumann.png|centre|vignette|upright=2|Microarchitecture de l'interface mémoire d'une architecture von neumann]]

Une autre solution utilise deux bus interne séparés : un connecté au bus d'adresse, l'autre au bus de données. Le ''program counter'' est alors connecté au bus interne d'adresse, le séquenceur est relié au bus interne de données. Notons que la technique marche bien si le ''program counter'' est dans le banc de registre : les interconnexions utilisées pour gérer l'adressage indirect permettent d'envoyer le ''program counter'' sur le bus d'adresse sans ajout de circuit.

Le tout peut être amélioré en remplaçant les deux bus par des multiplexeurs et démultiplexeurs. Le bus d'adresse est précédé par un multiplexeur, qui permet de faire le choix entre ''Program Counter'', adresse venant du chemin de données, ou adresse provenant du séquenceur (adressage absolu). De même, le bus de données est suivi par un démultiplexeur qui envoie la donnée/instruction lue soit au registre d'instruction, soit au chemin de données. Le tout se marie très bien avec les chemins de donnée vu dans le chapitre précédent. Au passage, il faut noter que cette solution nécessite un banc de registre multi-port.

[[File:Connexion du program counter sur les bus avec PC isolé.png|centre|vignette|upright=2|Connexion du program counter sur les bus avec PC isolé]]

===Le chargement des instructions de longueur variable===

Le chargement des instructions de longueur variable pose de nombreux problèmes. Le premier est que mettre à jour le ''program counter'' demande de connaitre la longueur de l'instruction chargée, pour l'ajouter au ''program counter''. Si la longueur d'une instruction est variable, on doit connaitre cette longueur d'une manière où d'une autre. La solution la plus simple indique la longueur de l'instruction dans une partie de l'opcode ou de la représentation en binaire de l'instruction. Mais les processeurs haute performance de nos PC utilisent d'autres solutions, qui n'encodent pas explicitement la taille de l'instruction.

Les processeurs récents utilisent un registre d'instruction de grande taille, capable de mémoriser l'instruction la plus longue du processeur. Par exemple, si un processeur supporte des instructions allant de 1 à 8 octets, comme les CPU x86, le registre d'instruction fera 8 octets. Le décodeur d'instruction vérifie à chaque cycle le contenu du registre d'instruction. Si une instruction est détectée dedans, son décodage commence, peu importe la taille de l'instruction. Une fois l'instruction exécutée, elle est retirée du registre d'instruction. Reste à alimenter le registre d'instruction, à charger des instructions dedans. Et pour cela deux solutions : soit on charge l'instruction en plusieurs fois, soit d'un seul coup.

La solution la plus simple charge les instructions par mots de 8, 16, 32, 64 bits. Ils sont accumulés dans le registre d'instruction jusqu'à détecter une instruction complète. La technique marche nettement mieux si les instructions sont très longues. Par exemple, les CPU x86 ont des instructions qui vont de 1 à 15 octets, ce qui fait qu'ils utilisent cette technique. Précisément, elle marche si les instructions les plus longues sont plus grandes que le bus mémoire.

Une autre solution charge un bloc de mots mémoire aussi grand que la plus grande instruction. Par exemple, si le processeur gère des instructions allant de 1 à 4 octets, il charge 4 octets d'un seul coup dans le registre d'instruction. Il va de soit que cette solution ne marche que si les instructions du processeur sont assez courtes, au plus aussi courtes que le bus mémoire. Ainsi, on est sûr de charger obligatoirement au moins une instruction complète, et peut-être même plusieurs. Le contenu du registre d'instruction est alors découpé en instructions au fil de l'eau. 

Utiliser un registre d'instruction large pose problème avec des instructions à cheval entre deux blocs. Il se peut qu'on n'ait pas une instruction complète lorsque l'on arrive à la fin du bloc, mais seulement un morceau. Le problème se manifeste peu importe que l'instruction soit chargée d'un seul coup ou bien en plusieurs fois.

[[File:Instructions non alignées.png|centre|vignette|upright=2|Instructions non alignées.]]

Dans ce cas, on doit décaler le morceau de bloc pour le mettre au bon endroit (au début du registre d'instruction), et charger le prochain bloc juste à côté. On a donc besoin d'un circuit qui décale tous les bits du registre d'instruction, couplé à un circuit qui décide où placer dans le registre d'instruction ce qui a été chargé, avec quelques circuits autour pour configurer les deux circuits précédents.

[[File:Décaleur d’instruction.png|centre|vignette|upright=2|Décaleur d’instruction.]]

Une autre solution se passe de registre d'instruction en utilisant à la place l'état interne du séquenceur. Là encore, elle charge l'instruction morceau par morceau, typiquement par blocs de 8, 16 ou 32 bits. Les morceaux ne sont pas accumulés dans le registre d'instruction, la solution utilise à la place l'état interne du séquenceur. Les mots mémoire de l'instruction sont chargés à chaque cycle, faisant passer le séquenceur d'un état interne à un autre à chaque mot mémoire. Tant qu'il n'a pas reçu tous les mots mémoire de l'instruction, chaque mot mémoire non terminal le fera passer d'un état interne à un autre, chaque état interne encodant les mots mémoire chargés auparavant. S'il tombe sur le dernier mot mémoire d'une instruction, il rentre dans un état de décodage.

==L'incrémentation du ''program counter''==

À chaque chargement, le ''program counter'' est mis à jour afin de pointer sur la prochaine instruction à charger. Sur la quasi-totalité des processeurs, les instructions sont placées dans l'ordre d’exécution dans la RAM. En faisant ainsi, on peut mettre à jour le ''program counter'' en lui ajoutant la longueur de l'instruction courante. Déterminer la longueur de l'instruction est simple quand les instructions ont toutes la même taille, mais certains processeurs ont des instructions de taille variable, ce qui complique le calcul. Dans ce qui va suivre, nous allons supposer que les instructions sont de taille fixe, ce qui fait que le ''program counter'' est toujours incrémenté de la même valeur.

Il existe deux méthodes principales pour incrémenter le ''program counter'' : soit le ''program counter'' a son propre additionneur, soit le ''program counter'' est mis à jour par l'ALU. Pour ce qui est de l'organisation des registres, soit le ''program counter'' est un registre séparé des autres, soit il est regroupé avec d'autres registres dans un banc de registre. En tout, cela donne quatre organisations possibles.
* Un ''program counter'' séparé relié à un incrémenteur séparé.
* Un ''program counter'' séparé des autres registres, incrémenté par l'ALU.
* Un ''program counter'' intégré au banc de registre, relié à un incrémenteur séparé.
* Un ''program counter'' intégré au banc de registre, incrémenté par l'ALU.

[[File:Calcul du program counter.png|centre|vignette|upright=2|les différentes méthodes de calcul du program counter.]]

Les processeurs haute performance modernes utilisent tous la première méthode. Les autres méthodes étaient surtout utilisées sur les processeurs 8 ou 16 bits, elles sont encore utilisées sur quelques microcontrôleurs de faible puissance. Nous auront l'occasion de donner des exemples quand nous parlerons des processeurs 8 bits anciens, dans le chapitre sur les architectures à accumulateur et affiliées.

===Le ''program counter'' mis à jour par l'ALU===

Sur certains processeurs, le calcul de l'adresse de la prochaine instruction est effectué par l'ALU. L'avantage de cette méthode est qu'elle économise un incrémenteur dédié au ''program counter''. Ce qui explique que cette méthode était utilisée sur les processeurs assez anciens, à une époque où un additionneur pouvait facilement prendre 10 à 20% des transistors disponibles. Le désavantage principal est une augmentation de la complexité du séquenceur, qui doit gérer la mise à jour du ''program counter''. De plus, la mise à jour du ''program counter'' ne peut pas se faire en même temps qu'une opération arithmétique, ce qui réduit les performances.

Si on incrémente le ''program counter'' avec l'ALU, il est intéressant de le placer dans le banc de registres. Un désavantage est qu'on perd un registre. Par exemple, avec un banc de registre de 16 registres, on ne peut adresser que 15 registres généraux. De plus ce n'est pas l'idéal pour le décodage des instructions et pour le séquenceur. Si le processeur dispose de plusieurs bancs de registres, le ''program counter'' est généralement placé dans le banc de registre dédié aux adresses. Sinon, il est placé avec les nombres entiers/adresses.

D'anciens processeurs incrémentaient le ''program counter'' avec l'ALU, mais utilisaient bien un registre séparé pour le ''program counter''. Cette méthode est relativement simple à implémenter : il suffit de connecter/déconnecter le ''program counter'' du bus interne suivant les besoins. Le ''program counter'' est déconnecté pendant l’exécution d'une instruction, il est connecté au bus interne pour l'incrémenter. C'est le séquenceur qui gère le tout. L'avantage de cette séparation est qu'elle est plus facile à gérer pour le séquenceur. De plus, on gagne un registre général/entier dans le banc de registre.

===Le compteur programme===

Dans la quasi-totalité des processeurs modernes, le ''program counter'' est un vulgaire compteur comme on en a vu dans les chapitres sur les circuits, ce qui fait qu'il passe automatiquement d'une adresse à la suivante. Dans ce qui suit, nous allons appeler ce registre compteur : le '''compteur ordinal'''. L'usage d'un compteur simplifie fortement la conception du séquenceur. Le séquenceur n'a pas à gérer la mise à jour du ''program counter'', sauf en cas de branchements. De plus, il est possible d'incrémenter le ''program counter'' pendant que l'unité de calcul effectue une opération arithmétique, ce qui améliore grandement les performances. Le seul désavantage est qu'elle demande d'ajouter un incrémenteur dédié au ''program counter''.

Sur les processeurs très anciens, les instructions faisaient toutes un seul mot mémoire et le compteur ordinal était un circuit incrémenteur des plus basique. Sur les processeurs modernes, le compteur est incrémenté par pas de 4 si les instructions sont codées sur 4 octets, 8 si les instructions sont codées sur 8 octets, etc. Concrètement, le compteur est un circuit incrémenteur auquel on aurait retiré quelques bits de poids faible. Par exemple, si les instructions sont codées sur 4 octets, on coupe les 2 derniers bits du compteur. Si les instructions sont codées sur 8 octets, on coupe les 3 derniers bits du compteur. Et ainsi de suite.

Il a existé quelques processeurs pour lesquelles le ''program counter'' était non pas un compteur binaire classique, mais un ''linear feedback shift register''. L'avantage est que le circuit d'incrémentation utilisait bien moins de portes logiques, l'économie était substantielle. Mais un défaut est que des instructions consécutives dans le programme n'étaient pas consécutives en mémoire. Il existait cependant une table de correspondance pour dire : la première instruction est à telle adresse, la seconde à telle autre, etc. Un exemple de processeur de ce type est le TMS 1000 de Texas Instrument, un des premiers microcontrôleur 4 bits datant des années 70.

Une amélioration de la solution précédente utilise un circuit incrémenteur partagé entre le ''program counter'' et d'autres registres. L'incrémenteur est utilisé pour incrémenter le ''program counter'', mais aussi pour effectuer d'autres calculs d'adresse. Par exemple, sur les architectures avec une pile d'adresse de retour, il est possible de partager l'incrémenteur/décrémenteur avec le pointeur de pile ( la technique ne marche pas avec une pile d'appel). Un autre exemple est celui des processeurs qui gèrent automatiquement le rafraichissement mémoire, grâce à, un compteur intégré dans le processeur. Il est possible de partager l'incrémenteur du ''program counter'' avec le compteur de rafraichissement mémoire, qui mémorise la prochaine adresse mémoire à rafraichir. Nous avions déjà abordé ce genre de partage dans le chapitre sur le chemin de données, dans l'annexe sur le pointeur de pile, mais nous verrons d'autres exemples dans le chapitre sur les architectures hybride accumulateur-registre 8/16 bits.

===Quand est mis à jour le ''program counter'' ?===

Le ''program counter'' est mis à jour quand il faut charger une nouvelle instruction. Reste qu'il faut savoir quand le mettre à jour. Incrémenter le ''program counter'' à intervalle régulier, par exemple à chaque cycle d’horloge, fonctionne sur les processeurs où toutes les instructions mettent le même temps pour s’exécuter. Mais de tels processeurs sont très rares. Sur la quasi-totalité des processeurs, les instructions ont une durée d’exécution variable, elles ne prennent pas le même nombre de cycle d'horloge pour s’exécuter. Le temps d’exécution d'une instruction varie selon l'instruction, certaines sont plus longues que d'autres. Tout cela amène un problème : comment incrémenter le ''program counter'' avec des instructions avec des temps d’exécution variables ?

La réponse est que la mise à jour du ''program counter'' démarre quand l'instruction précédente a terminée de s’exécuter, plus précisément un cycle avant. C'est un cycle avant pour que l'instruction chargée soit disponible au prochain cycle pour le décodeur. Pour cela, le séquenceur doit déterminer quand l'instruction est terminée et prévenir le ''program counter'' au bon moment. Il faut donc une interaction entre séquenceur et circuit de chargement. Le circuit de chargement contient une entrée Enable, qui autorise la mise à jour du ''program counter''. Le séquenceur met à 1 cette entrée pour prévenir au ''program counter'' qu'il doit être incrémenté au cycle suivant ou lors du cycle courant. Cela permet de gérer simplement le cas des instructions multicycles. 

[[File:Commande de la mise à jour du program counter.png|centre|vignette|upright=2|Commande de la mise à jour du program counter.]]

Toute la difficulté est alors reportée dans le séquenceur, qui doit déterminer la durée d'une instruction. Pour gérer la mise à jour du ''program counter'', le séquenceur doit déterminer la durée d'une instruction. Cela est simple pour les instructions arithmétiques et logiques, qui ont un nombre de cycles fixe, toujours le même. Une fois l'instruction identifiée par le séquenceur, il connait son nombre de cycles et peut programmer un compteur interne au séquenceur, qui compte le nombre de cycles de l'instruction, et fournit le signal Enable au ''program counter''. Mais cette technique ne marche pas vraiment pour les accès mémoire, dont la durée n'est pas connue à l'avance, surtout sur les processeurs avec des mémoires caches. Pour cela, le séquenceur détermine quand l'instruction mémoire est finie et prévient le ''program counter'' quand c'est le cas.

Il existe quelques processeurs pour lesquels le temps de calcul dépend des opérandes de l'instruction. On peut par exemple avoir une division qui prend 10 cycles avec certaines opérandes, mais 40 cycles avec d'autres opérandes. Mais ces processeurs sont rares et cela est surtout valable pour les opérations de multiplication/division, guère plus. Le problème est alors le même qu'avec les accès mémoire et la solution est la même : l'ALU prévient le séquenceur quand le résultat est disponible.

==Les branchements et le ''program counter''==

Un branchement consiste juste à écrire l'adresse de destination dans le ''program counter''. L'implémentation des branchements demande d'extraire l'adresse de destination et d'altérer le ''program counter'' quand un branchement est détecté. Pour cela, le décodeur d'instruction détecte si l'instruction exécutée est un branchement ou non, et il en déduit où trouver l'adresse de destination.

L'adresse de destination se trouve à un endroit qui dépend du mode d'adressage du branchement. Pour rappel, on distingue quatre modes d'adressage pour les branchements : direct, indirect, relatif et implicite. Pour les branchements directs, l'adresse est intégrée dans l'instruction de branchement elle-même et est extraite par le séquenceur. Pour les branchements indirects, l'adresse de destination est dans le banc de registre. Pour les branchements relatifs, il faut ajouter un décalage au ''program counter'', décalage extrait de l'instruction par le séquenceur. Enfin, les instructions de retour de fonction lisent l'adresse de destination depuis la pile. L'implémentation de ces quatre types de branchements est très différente.

L'altération du ''program counter'' dépend de si le ''program counter'' est dans un compteur séparé ou s'il est dans le banc de registre. Nous avons vu plus haut qu'il y a quatre cas différents, mais nous n'allons voir que deux cas : celui où le ''program counter'' est dans le banc de registre et est incrémenté par l'unité de calcul, celui avec un ''program counter'' séparé avec son propre incrémenteur. Les deux autres cas ne sont utilisés que sur des architectures à accumulateur ou à pile spécifiques, que nous n'avons pas encore vu à ce stade du cours et que nous verrons en temps voulu dans le chapitre sur ces architectures.

===L’implémentation des branchements avec un ''program counter'' intégré au banc de registres===

Le cas le plus simple est celui où le ''program counter'' est intégré au banc de registre, avec une incrémentation faite par l'unité de calcul. Charger une instruction revient alors à effectuer une instruction LOAD en adressage indirect, à deux différences près : le registre sélectionné est le ''program counter'', l’instruction est copiée dans le registre d'instruction et non dans le banc de registre. L'incrémentation du ''porgram counter'' est implémenté avec des micro-opérations qui agissent sur le chemin de données, au même titre que les branchements indirects, relatifs et directs.
* Les branchements indirects copient un registre dans le ''program counter'', ce qui revient simplement à faire une opération MOV entre deux registres, dont le ''program counter'' est la destination.
* L'opération inverse d'un branchement indirect, qui copie le ''program counter'' dans un registre général, est utile pour sauvegarder l'adresse de retour d'une fonction.
* Les branchements directs copient une adresse dans le ''program counter'', ce qui les rend équivalents à une opération MOV avec une constante immédiate, dont le ''program counter'' est la destination.
* Les branchements relatifs sont une opération arithmétique entre le ''program counter'' et un opérande en adressage immédiat.

En clair, à partir du moment où le chemin de données supporte les instructions MOV et l'addition, avec les modes d'adressage adéquat, il supporte les branchements. Aucune modification du chemin de données n'est nécessaire, le séquenceur gére le chargement d'une instruction avec les micro-instructions adéquates : une micro-opération ADD pour incrémenter le ''program counter'', une micro-opération LOAD pour le chargement de l'instruction.

Notons que sur certaines architectures, le ''program counter'' est adressable au même titre que les autres registres du banc de registre. Les instructions de branchement sont alors remplacées par des instructions MOV ou des instructions arithmétique équivalentes, comme décrit plus haut.

===L’implémentation des branchements avec un ''program counter'' séparé===

Étudions maintenant le cas où le ''program counter'' est dans un registre/compteur séparé. Rappelons que tout compteur digne de ce nom possède une entrée de réinitialisation, qui remet le compteur à zéro. De plus, on peut préciser à quelle valeur il doit être réinitialisé. Ici, la valeur à laquelle on veut réinitialiser le compteur n'est autre que l'adresse de destination du branchement. Implémenter un branchement est donc simple : l'entrée de réinitialisation est commandée par le circuit de détection des branchements, alors que la valeur de réinitialisation est envoyée sur l'entrée adéquate. En clair, nous partons du principe que le ''program counter'' est implémenté avec ce type de compteur :

[[File:Fonctionnement d'un compteur (décompteur), schématique.jpg|centre|vignette|upright=1.5|Fonctionnement d'un compteur (décompteur), schématique]]

Toute la difficulté est de présenter l'adresse de destination au ''program counter''. Pour les branchements directs, l'adresse de destination est fournie par le séquenceur. L'adresse de destination du branchement sort du séquenceur et est présentée au ''program counter'' sur l'entrée adéquate. Voici donc comment sont implémentés les branchements directs avec un ''program counter'' séparé du banc de registres. Le schéma ci-dessous marche peu importe que le ''program counter'' soit incrémenté par l'ALU ou par un additionneur dédié.

[[File:Unité de détection des branchements dans le décodeur.png|centre|vignette|upright=2|Unité de détection des branchements dans le décodeur]]

Les branchements relatifs sont ceux qui font sauter X instructions plus loin dans le programme. Leur implémentation demande d'ajouter une constante au ''program counter'', la constante étant fournie dans l’instruction. Là encore, deux solutions sont possibles : réutiliser l'ALU pour calculer l'adresse, ou utiliser un additionneur séparé. L'additionneur séparé peut être fusionné avec l'additionneur qui incrémente le ''program counter'' pour passer à l’instruction suivante.

[[File:Unité de chargement qui gère les branchements relatifs.png|centre|vignette|upright=2|Unité de chargement qui gère les branchements relatifs.]]

Pour les branchements indirects, il suffit de lire le registre voulu et d'envoyer le tout sur l'entrée adéquate du ''program counter''. Il faut alors rajouter un multiplexeur pour que l'entrée de réinitialisationr ecoive la bonne adresse de destination.

[[File:Unité de chargement qui gère les branchements directs.png|centre|vignette|upright=2|Unité de chargement qui gère les branchements directs et indirects.]]

Toute la difficulté de l'implémentation des branchements est de configurer les multiplexeurs, ce qui est réalisé par le séquenceur en fonction du mode d'adressage du branchement.

==Les optimisations du chargement des instructions==

Charger une instruction est techniquement une forme d'accès mémoire un peu particulier. En clair, charger une instruction prend au minimum un cycle d'horloge, et cela peut rapidement monter à 3-5 cycles, si ce n'est plus. L'exécution des instructions est alors fortement ralentit par la mémoire. Par exemple, imaginez que la mémoire mette 3 cycles d'horloges pour charger une instruction, alors qu'une instruction s’exécute en 1 cycle (si les opérandes sont dans les registres). La perte de performance liée au chargement des instructions est alors substantielle. Heureusement, il est possible de limiter la casse en utilisant des mémoires caches, ainsi que d'autres optimisations, que nous allons voir dans ce qui suit.

===Le tampon de préchargement===

La technique dite du '''préchargement''' est utilisée dans le cas où la mémoire a un temps d'accès important. Mais si la latence de la RAM est un problème, le débit ne l'est pas. Il est possible d'avoir une RAM lente, mais à fort débit. Par exemple, supposons que la mémoire puisse charger 4 instructions (de taille fixe) en 3 cycles. Le processeur peut alors charger 4 instructions en un seul accès mémoire, et les exécuter l'une après l'autre, une par cycle d'horloge. Les temps d'attente sont éliminés : le processeur peut décoder une nouvelle instruction à chaque cycle. Et quand la dernière instruction préchargée est exécutée, la mémoire est de nouveau libre, ce qui masque la latence des accès mémoire.

[[File:Tampon de préchargement d'instruction.png|vignette|Tampon de préchargement d'instruction]]

La seule contrainte est de mettre les instructions préchargées en attente. La solution pour cela est d'utiliser un registre d'instruction très large, capable de mémoriser plusieurs instructions à la fois. Ce registre est de plus connecté à un multiplexeur qui permet de sélectionner l'instruction adéquate dans ce registre. Ce multiplexeur est commandé par le ''program counter'' et quelques circuits annexes. Ce super-registre d'instruction est appelé un '''tampon de préchargement'''.

La méthode a une implémentation nettement plus simple avec des instructions de taille fixe, alignées en mémoire. La commande du multiplexeur de sélection de l'instruction est alors beaucoup plus simple : il suffit d'utiliser les bits de poids fort du ''program counter''. Par exemple, prenons le cas d'un registre d'instruction de 32 octets pour des instructions de 4 octets, soit 8 instructions. Le choix de l'instruction à sélectionner se fait en utilisant les 3 bits de poids faible du ''program counter''. 

Mais cette méthode ajoute de nouvelles contraintes d'alignement, similaires à celles vues dans le chapitre sur l'alignement et le boutisme, sauf que l'alignement porte ici sur des blocs d'instructions de même taille que le tampon de préchargement. Si on prend l'exemple d'un tampon de préchargement de 128 bits, les instructions devront être alignées par blocs de 128 bits. C'est à dire qu'idéalement, les fonctions et autres blocs de code isolés doivent commencer à des adresses multiples de 128, pour pouvoir charger un bloc d'instruction en une seule fois. Sans cela, les performances seront sous-optimales.

: Il arrive que le tampon de préchargement ait la même taille qu'une ligne de cache.

Lorsque l'on passe d'un bloc d'instruction à un autre, le tampon de préchargement est mis à jour. Par exemple, si on prend un tampon de préchargement de 4 instructions, on doit changer son contenu toutes les 4 instructions. La seule exception est l'exécution d'un branchement. En effet, lors d'un branchement, la destination du branchement n'est pas dans le tampon de préchargement et elle doit être chargée dedans (sauf si le branchement pointe vers une instruction très proche, ce qui est improbable). Pour cela, le tampon de préchargement est mis à jour précocement quand le processeur détecte un branchement.

Le même problème survient avec du code auto-modifiant. Un code auto-modifiant est un programme qui se modifie lui-même, en remplaçant certaines instructions par d'autres, en en retirant, en en ajoutant, lors de sa propre exécution. De tels programmes sont rares, mais la technique était utilisée dans quelques cas au tout début de l'informatique sur des ordinateurs rudimentaires. Ceux-ci avaient des modes d'adressages tellement limités que gérer des tableaux de taille variable demandait d'utiliser du code auto-modifiant pour écrire des boucles. Le problème survient quand des instructions sont modifiées immédiatement après avoir été préchargées. Les instructions dans le tampon de préchargement sont l'ancienne version, alors que la mémoire RAM contient les instructions modifiées. Gérer ce genre de cas demande de vider le tampon de préchargement si le cas arrive, mais ça ne vaut que très rarement le coup, aussi les ingénieurs ne s’embêtent pas à mettre ce correctif en place. Le code automodifiant est alors buggé.

===La ''prefetch input queue''===

La ''prefetch input queue'' est une sorte de cousine du tampon de préchargement, qui a été utilisée sur les processeurs Intel assez ancien. Elle est apparue sur le 8086 et le 8088, des processeurs respectivement 8 et 16 bits. Elle été présente sur le 286 et le 386, mais était un peu améliorée. Elle est apparue sur ces processeurs à une époque où le processeur devenait plus rapide que la mémoire.

L'idée est là encore de précharger des instructions en avance. Sauf que cette fois-ci, on ne charge pas plusieurs instructions à la fois. Au contraire, les instructions sont préchargées séquentiellement, un octet à la fois. En conséquence, le tampon de préchargement est remplacé par une mémoire FIFO appelée la '''''Prefetch Input Queue''''', terme abrévié en PIQ. Les instructions sont accumulées une par une dans la PIQ, elles en sortent une par une au fur et à mesure pour alimenter le décodeur d'instruction.

L'idée est que pendant que le processeur exécute une instruction, on précharge la suivante. Sans ''prefetch input queue'', le processeur chargeait une instruction, la décodait et l'exécutait, puis chargeait la suivante, et ainsi de suite. Avec la ''prefetch input queue'', pendant qu'une instruction est en cours de décodage/exécution, le processeur précharge l'instruction suivante. Si une instruction prend vraiment beaucoup de temps pour s'exécuter, le processeur peut en profiter pour précharger l'instruction encore suivante, et ainsi de suite, jusqu'à une limite de 4/6 instructions (la limite dépend du processeur).

La ''prefetch input queue'' permet de précharger l'instruction suivante à condition qu'aucun autre accès mémoire n'ait lieu. Si l'instruction en cours d'exécution effectue des accès mémoire, ceux-ci sont prioritaires sur tout le reste, le préchargement de l'instruction suivante est alors mis en pause ou inhibé. Par contre, si la mémoire n'est pas utilisée par l'instruction en cours d'exécution, le processeur lit l'instruction suivante en RAM et la copie dans la ''prefetch input queue''. En conséquence, il arrive que la ''prefetch input queue'' n'ait pas préchargé l'instruction suivante, alors que le décodeur d'instruction est prêt pour la décoder. Dans ce cas, le décodeur doit attendre que l'instruction soit chargée.

Les instructions préchargées dans la ''Prefetch input queue'' y attendent que le processeur les lise et les décode. Les instructions préchargées sont conservées dans leur ordre d'arrivée, afin qu'elles soient exécutées dans le bon ordre, ce qui fait que la ''Prefetch input queue'' est une mémoire de type FIFO. L'étape de décodage pioche l'instruction à décoder dans la ''Prefetch input queue'', cette instruction étant par définition la plus ancienne, puis la retire de la file.

Le premier processeur commercial grand public à utiliser une ''prefetch input queue'' était le 8086. Il pouvait précharger à l'avance 6 octets d’instruction. L'Intel 8088 avait lui aussi une ''Prefetch input queue'', mais qui ne permettait que de précharger 4 instructions. La taille idéale de la FIFO dépend de nombreux paramètres. On pourrait croire que plus elle peut contenir d'instructions, mieux c'est, mais ce n'est pas le cas, pour des raisons que nous allons expliquer dans quelques paragraphes.

[[File:80186 arch.png|centre|vignette|700px|upright=2|Architecture du 8086, du 80186 et de ses variantes.]]

Vous remarquerez que j'ai exprimé la capacité de la ''prefetch input queue'' en octets et non en instructions. La raison est que sur les processeurs x86, les instructions sont de taille variable. Les instructions de ces processeurs ont une taille qui varie entre deux octets et 6 octets. La ''prefetch input queue'' était optimisée pour lire des instructions de deux octets, avec quelques mécanismes pour gérer les instructions plus longues. Il faut dire que les instructions les plus courantes faisaient deux octets, respectivement un octet d'opcode et un octet Mod/RM pour préciser le mode d'adressage.

Le bus de données du 8086 faisait 16 bits, ce qui fait qu'il était possible de charger une instruction courte en un cycle. Par contre, sur le 8088, un processeur 8 bits, le bus de donnée ne permettait que de lire un octet à la fois. Dans les deux cas, le décodeur devait attendre que les deux octets d'une instruction soient disponibles dans la ''Prefetch input queue''. Pour cela, un circuit appelé le ''loader'' fournissait deux signaux au décodeur d'instruction : l'un indiquant que le premier octet est déjà chargé, l'autre indiquant que le second octet est disponible.

Le ''loader'' recevait aussi des signaux de la part du décodeur d'instruction, afin de gérer les lectures dans la ''Prefetch input queue''. Le décodeur envoyait le signal ''Run Next Instruction'' pour lire une instruction :  elle était alors dépilée de la ''Prefetch input queue''. Le décodeur d'instruction pouvait aussi envoyer un signal ''Next-to-last (NXT)'' un cycle en avance, un cycle avant que l'instruction en cours ne termine. Le résultat est que le ''loader'' réagissait en préchargeant l'instruction suivante. En clair, ce signal permettait de précharger l'instruction suivante avec un cycle d'avance, si celle-ci n'était pas déjà dans la ''Prefetch input queue''.

Pour gérer les instructions de plus de deux octets, le décodeur pouvait lire une instruction en plusieurs fois dans la ''Prefetch input queue''. Les deux premiers octets sont lus depuis la ''Prefetch input queue'', et sont alors décodés. Le décodeur détermine alors la taille de l'instruction. Si l'instruction fait exactement deux octets, elle est exécutée directement. Sinon, les octets manquants sont lus depuis la ''Prefetch input queue''. Pour cela, le décodeur dispose d'une micro-opération pour lire un octet depuis la ''Prefetch input queue''.

Les branchements posent des problèmes avec la ''Prefetch input queue'' : à cause d'eux, on peut charger à l'avance des instructions qui sont zappées par un branchement et ne sont pas censées être exécutées. Si un branchement est chargé, toutes les instructions préchargées après sont potentiellement invalides. Si le branchement est non-pris, les instructions chargées sont valides, elles sont censées s’exécuter. Mais si le branchement est pris, elles ont été chargées à tort et ne doivent pas s’exécuter. 

Pour éviter cela, la ''Prefetch input queue'' est vidée quand le processeur détecte un branchement. Pour cela, le décodeur d'instruction dispose d'une micro-opération qui vide la ''Prefetch input queue'', elle invalide les instructions préchargées.  Cette détection ne peut se faire qu'une fois le branchement décodé, qu'une fois que l'on sait que l'instruction décodée est un branchement. En clair, le décodeur invalide la ''Prefetch input queue'' quand il détecte un branchement. Les interruptions posent le même genre de problèmes. Il faut impérativement vider la ''Prefetch input queue'' quand une interruption survient, avant de la traiter.

Il faut noter qu'une ''Prefetch input queue'' interagit assez mal avec le ''program counter''. En effet, la ''Prefetch input queue'' précharge les instructions séquentiellement. Pour savoir où elle en est rendue, elle mémorise l'adresse de la prochaine instruction à charger dans un '''registre de préchargement''' dédié. Il serait possible d'utiliser un ''program counter'' en plus du registre de préchargement, mais ce n'est pas la solution qui a été utilisée. Les processeurs Intel anciens ont préféré n'utiliser qu'un seul registre de préchargement en remplacement du ''program counter''. Après tout, le registre de préchargement n'est qu'un ''program counter'' ayant pris une avance de quelques cycles d'horloge, qui a été incrémenté en avance.

Et cela ne pose pas de problèmes, sauf avec certains branchements. Par exemple, certains branchements relatifs demandent de connaitre la véritable valeur du ''program counter'', pas celle calculée en avance. Idem avec les instructions d'appel de fonction, qui demandent de sauvegarder l'adresse de retour exacte, donc le vrai ''program counter''. De telles situations demandent de connaitre la valeur réelle du ''program counter'', celle sans préchargement. Pour cela, le décodeur d'instruction dispose d'une instruction pour reconstituer le ''program counter'', à savoir corriger le ''program coutner'' et éliminer l'effet du préchargement.

La micro-opération de correction se contente de soustraire le nombre d'octets préchargés au registre de préchargement. Le nombre d'octets préchargés est déduit à partir des deux pointeurs intégré à la FIFO, qui indiquent la position du premier et du dernier octet préchargé. Le bit qui indique si la FIFO est vide était aussi utilisé. Les deux pointeurs sont lus depuis la FIFO, et sont envoyés à un circuit qui détermine le nombre d'octets préchargés. Sur le 8086, ce circuit était implémenté non pas par un circuit combinatoire, mais par une mémoire ROM équivalente. La petite taille de la FIFO faisait que les pointeurs étaient très petits et la ROM l'était aussi.

Un autre défaut est que la ''Prefetch input queue'' se marie assez mal avec du code auto-modifiant. Un code auto-modifiant est un programme qui se modifie lui-même, en remplaçant certaines instructions par d'autres, en en retirant, en en ajoutant, lors de sa propre exécution. De tels programmes sont rares, mais la technique était utilisée dans quelques cas au tout début de l'informatique sur des ordinateurs rudimentaires. Ceux-ci avaient des modes d'adressages tellement limités que gérer des tableaux de taille variable demandait d'utiliser du code auto-modifiant pour écrire des boucles.

Le problème avec la ''Prefetch input queue'' survient quand des instructions sont modifiées immédiatement après avoir été préchargées. Les instructions dans la ''Prefetch input queue'' sont l'ancienne version, alors que la mémoire RAM contient les instructions modifiées. Gérer ce genre de cas est quelque peu complexe. Il faut en effet vider la ''Prefetch input queue'' si le cas arrive, ce qui demande d'identifier les écritures qui écrasent des instructions préchargées. C'est parfaitement possible, mais demande de transformer la ''Prefetch input queue'' en une mémoire hybride, à la fois mémoire associative et mémoire FIFO. Cela ne vaut que très rarement le coup, aussi les ingénieurs ne s’embêtent pas à mettre ce correctif en place, le code automodifiant est alors buggé.

Le décodeur d'instruction dispose aussi d'une micro-opération qui stoppe le préchargement des instructions dans la ''Prefetch input queue''.

: Pour ceux qui ont déjà lu un cours d'architecture des ordinateurs, la relation entre ''prefetch input queue'' et pipeline est quelque peu complexe. En apparence, la ''prefetch input queue'' permet une certaines forme de pipeline, en chargeant une instruction pendant que la précédente s'exécute. Les problématiques liées aux branchements ressemblent beaucoup à celles de la prédiction de branchement. Cependant, il est possible de dire qu'il s'agit plus d'une technique de préchargement que de pipeline. La différence entre les deux est assez subtile et les frontières sont assez floues, mais le fait est que l'instruction en cours d'exécution et le préchargement peuvent tout deux faire des accès mémoire et que l'instruction en cours a la priorité. Un vrai pipeline se débrouillerait avec une architecture Harvard, non avec un bus mémoire unique pour le chargement des instruction et la lecture/écriture des données.

===Le ''Zero-overhead looping''===

Nous avions vu dans le chapitre sur les instructions machines, qu'il existe des instructions qui permettent de grandement faciliter l'implémentation des boucles. Il s'agit de l'instruction REPEAT, utilisée sur certains processeurs de traitement de signal. Elle répète l'instruction suivante, voire une série d'instructions, un certain nombre de fois. Le nombre de répétitions est mémorisé dans un registre décrémenté à chaque itération de la boucle. Elle permet donc d'implémenter une boucle FOR facilement, sans recourir à des branchements ou des conditions.

Une technique en lien avec cette instruction permet de grandement améliorer les performances et la consommation d'énergie. L'idée est de mémoriser la boucle, les instructions à répéter, dans une petite mémoire cache située entre l'unité de chargement et le séquenceur. Le cache en question s'appelle un '''tampon de boucle''', ou encore un ''hardware loop buffer''. Grâce à lui, il n'y a pas besoin de charger les instructions à chaque fois qu'on les exécute, on les charge une bonne fois pour toute : c'est plus rapide. Bien sûr, il ne fonctionne que pour de petites boucles, mais il en est de même avec l'instruction REPEAT.

&lt;noinclude&gt;
{{NavChapitre | book=Fonctionnement d'un ordinateur
           | prev=Le chemin de données
           | prevText=Le chemin de données
           | next=L'unité de contrôle
           | nextText=L'unité de contrôle
}}
&lt;/noinclude&gt;</text>
      <sha1>oelta66ka8fz8uixp5g6y5jba1wibom</sha1>
    </revision>
    <revision>
      <id>744084</id>
      <parentid>744083</parentid>
      <timestamp>2025-06-03T20:03:58Z</timestamp>
      <contributor>
        <username>Mewtow</username>
        <id>31375</id>
      </contributor>
      <minor />
      <comment>/* La prefetch input queue */</comment>
      <origin>744084</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="45915" sha1="m6qgnwudqrjf61xcazxq328jlgrwogz" xml:space="preserve">L'unité de contrôle s'occupe du chargement des instructions et de leur interprétation, leur décodage. Elle contient deux circuits : l''''unité de chargement''' qui charge l'instruction depuis la mémoire, et le '''séquenceur''' qui commande le chemin de données. Les deux circuits sont séparés, mais ils communiquent entre eux, notamment pour gérer les branchements. Dans ce chapitre, nous allons nous intéresser au chargement d'une instruction depuis la RAM/ROM, nous verrons l'étape de décodage de l'instruction au prochain chapitre.

==Le chargement d'une instruction==

[[File:Étape de chargement.png|vignette|upright=1|Étape de chargement.]]

L'étape de chargement (ou ''fetch'') doit faire deux choses : mettre à jour le ''program counter'' et lire l'instruction en mémoire RAM ou en ROM. Les deux étapes peuvent être faites en parallèle, dans des circuits séparés. Pendant que l'instruction est lue depuis la mémoire RAM/ROM, le ''program counter'' est incrémenté et/ou altéré par un branchement.

Pour lire l'instruction, on envoie le ''program counter'' sur le bus d'adresse et on récupère l'instruction sur le bus de données pour l'envoyer sur l'entrée du séquenceur. Et cela demande de connecter le séquenceur au bus mémoire, à travers l'interface mémoire. Et sur ce point, la situation est différente selon que l'on parler d'une architecture Harvard ou Von Neumann.

===Les interconnexions entre séquenceur et bus mémoire===

Sur les architectures Harvard, le séquenceur et le chemin de donnée utilisent des interfaces mémoire séparées. Le séquenceur est directement relié au bus mémoire de la ROM, alors que le chemin de données est connecté à la RAM.

[[File:Microarchitecture de l'interface mémoire d'une architecture Harvard.png|centre|vignette|upright=2|Microarchitecture de l'interface mémoire d'une architecture Harvard]]

Mais sur les architectures Von-Neumann et affiliées, le séquenceur et le chemin de donnée partagent la même interface mémoire. Et cela pose deux problèmes.

Le premier problème est que le bus mémoire doit être libéré une fois l'instruction chargée, pour un éventuel accès mémoire. Mais le séquenceur doit conserver une copie de l'instruction chargée, sans quoi il ne peut pas décoder l'instruction correctement. Par exemple, si l'instruction met plusieurs cycles à s'exécuter, le séquenceur doit conserver une copie de l'instruction durant ces plusieurs cycles. La solution à ce problème est un '''registre d'instruction''' situé juste avant le séquenceur, qui mémorise l'instruction chargée.

[[File:Registre d'instruction.png|centre|vignette|upright=2|Registre d'instruction.]]

Le second problème est de gérer le flot des instructions/données entre le bus mémoire, le chemin de données et le séquenceur. Le processeur doit connecter l'interface mémoire soit au séquenceur, soit au chemin de données et cela complique le réseau d'interconnexion interne au processeur.

Une première solution utilise un bus unique qui relie l'interface mémoire, le séquenceur et le chemin de données. Pour charger une instruction, le séquenceur copie le ''program counter'' sur le bus d'adresse, attend que l'instruction lue soit disponible sur le bus de données, puis la copie dans le registre d'instruction. Le bus mémoire est alors libre et peut être utilisé pour lire ou écrire des données, si le besoin s'en fait sentir.

Il faut noter que l'usage d'un bus unique a un impact sur l'organisation interne du chemin de données. Par exemple, le chapitre précédent nous a montré comment implémenter un chemin de données basique, avec des multiplexeurs et démultiplexeurs. Et bien ces chemins de données ne marchent pas vraiment avec un bus interne unique. Il est possible de les adapter, mais au prix d'une complexité largement supérieure. Un bus interne unique marche mieux quand le banc de registre est mono-port. C'est pourquoi il a été utilisé sur d'anciennes architectures appelées des architectures à accumulateur et à pile, que nous verrons dans quelques chapitres, qui utilisaient un banc de registre mono-port.

[[File:Microarchitecture de l'interface mémoire d'une architecture von neumann.png|centre|vignette|upright=2|Microarchitecture de l'interface mémoire d'une architecture von neumann]]

Une autre solution utilise deux bus interne séparés : un connecté au bus d'adresse, l'autre au bus de données. Le ''program counter'' est alors connecté au bus interne d'adresse, le séquenceur est relié au bus interne de données. Notons que la technique marche bien si le ''program counter'' est dans le banc de registre : les interconnexions utilisées pour gérer l'adressage indirect permettent d'envoyer le ''program counter'' sur le bus d'adresse sans ajout de circuit.

Le tout peut être amélioré en remplaçant les deux bus par des multiplexeurs et démultiplexeurs. Le bus d'adresse est précédé par un multiplexeur, qui permet de faire le choix entre ''Program Counter'', adresse venant du chemin de données, ou adresse provenant du séquenceur (adressage absolu). De même, le bus de données est suivi par un démultiplexeur qui envoie la donnée/instruction lue soit au registre d'instruction, soit au chemin de données. Le tout se marie très bien avec les chemins de donnée vu dans le chapitre précédent. Au passage, il faut noter que cette solution nécessite un banc de registre multi-port.

[[File:Connexion du program counter sur les bus avec PC isolé.png|centre|vignette|upright=2|Connexion du program counter sur les bus avec PC isolé]]

===Le chargement des instructions de longueur variable===

Le chargement des instructions de longueur variable pose de nombreux problèmes. Le premier est que mettre à jour le ''program counter'' demande de connaitre la longueur de l'instruction chargée, pour l'ajouter au ''program counter''. Si la longueur d'une instruction est variable, on doit connaitre cette longueur d'une manière où d'une autre. La solution la plus simple indique la longueur de l'instruction dans une partie de l'opcode ou de la représentation en binaire de l'instruction. Mais les processeurs haute performance de nos PC utilisent d'autres solutions, qui n'encodent pas explicitement la taille de l'instruction.

Les processeurs récents utilisent un registre d'instruction de grande taille, capable de mémoriser l'instruction la plus longue du processeur. Par exemple, si un processeur supporte des instructions allant de 1 à 8 octets, comme les CPU x86, le registre d'instruction fera 8 octets. Le décodeur d'instruction vérifie à chaque cycle le contenu du registre d'instruction. Si une instruction est détectée dedans, son décodage commence, peu importe la taille de l'instruction. Une fois l'instruction exécutée, elle est retirée du registre d'instruction. Reste à alimenter le registre d'instruction, à charger des instructions dedans. Et pour cela deux solutions : soit on charge l'instruction en plusieurs fois, soit d'un seul coup.

La solution la plus simple charge les instructions par mots de 8, 16, 32, 64 bits. Ils sont accumulés dans le registre d'instruction jusqu'à détecter une instruction complète. La technique marche nettement mieux si les instructions sont très longues. Par exemple, les CPU x86 ont des instructions qui vont de 1 à 15 octets, ce qui fait qu'ils utilisent cette technique. Précisément, elle marche si les instructions les plus longues sont plus grandes que le bus mémoire.

Une autre solution charge un bloc de mots mémoire aussi grand que la plus grande instruction. Par exemple, si le processeur gère des instructions allant de 1 à 4 octets, il charge 4 octets d'un seul coup dans le registre d'instruction. Il va de soit que cette solution ne marche que si les instructions du processeur sont assez courtes, au plus aussi courtes que le bus mémoire. Ainsi, on est sûr de charger obligatoirement au moins une instruction complète, et peut-être même plusieurs. Le contenu du registre d'instruction est alors découpé en instructions au fil de l'eau. 

Utiliser un registre d'instruction large pose problème avec des instructions à cheval entre deux blocs. Il se peut qu'on n'ait pas une instruction complète lorsque l'on arrive à la fin du bloc, mais seulement un morceau. Le problème se manifeste peu importe que l'instruction soit chargée d'un seul coup ou bien en plusieurs fois.

[[File:Instructions non alignées.png|centre|vignette|upright=2|Instructions non alignées.]]

Dans ce cas, on doit décaler le morceau de bloc pour le mettre au bon endroit (au début du registre d'instruction), et charger le prochain bloc juste à côté. On a donc besoin d'un circuit qui décale tous les bits du registre d'instruction, couplé à un circuit qui décide où placer dans le registre d'instruction ce qui a été chargé, avec quelques circuits autour pour configurer les deux circuits précédents.

[[File:Décaleur d’instruction.png|centre|vignette|upright=2|Décaleur d’instruction.]]

Une autre solution se passe de registre d'instruction en utilisant à la place l'état interne du séquenceur. Là encore, elle charge l'instruction morceau par morceau, typiquement par blocs de 8, 16 ou 32 bits. Les morceaux ne sont pas accumulés dans le registre d'instruction, la solution utilise à la place l'état interne du séquenceur. Les mots mémoire de l'instruction sont chargés à chaque cycle, faisant passer le séquenceur d'un état interne à un autre à chaque mot mémoire. Tant qu'il n'a pas reçu tous les mots mémoire de l'instruction, chaque mot mémoire non terminal le fera passer d'un état interne à un autre, chaque état interne encodant les mots mémoire chargés auparavant. S'il tombe sur le dernier mot mémoire d'une instruction, il rentre dans un état de décodage.

==L'incrémentation du ''program counter''==

À chaque chargement, le ''program counter'' est mis à jour afin de pointer sur la prochaine instruction à charger. Sur la quasi-totalité des processeurs, les instructions sont placées dans l'ordre d’exécution dans la RAM. En faisant ainsi, on peut mettre à jour le ''program counter'' en lui ajoutant la longueur de l'instruction courante. Déterminer la longueur de l'instruction est simple quand les instructions ont toutes la même taille, mais certains processeurs ont des instructions de taille variable, ce qui complique le calcul. Dans ce qui va suivre, nous allons supposer que les instructions sont de taille fixe, ce qui fait que le ''program counter'' est toujours incrémenté de la même valeur.

Il existe deux méthodes principales pour incrémenter le ''program counter'' : soit le ''program counter'' a son propre additionneur, soit le ''program counter'' est mis à jour par l'ALU. Pour ce qui est de l'organisation des registres, soit le ''program counter'' est un registre séparé des autres, soit il est regroupé avec d'autres registres dans un banc de registre. En tout, cela donne quatre organisations possibles.
* Un ''program counter'' séparé relié à un incrémenteur séparé.
* Un ''program counter'' séparé des autres registres, incrémenté par l'ALU.
* Un ''program counter'' intégré au banc de registre, relié à un incrémenteur séparé.
* Un ''program counter'' intégré au banc de registre, incrémenté par l'ALU.

[[File:Calcul du program counter.png|centre|vignette|upright=2|les différentes méthodes de calcul du program counter.]]

Les processeurs haute performance modernes utilisent tous la première méthode. Les autres méthodes étaient surtout utilisées sur les processeurs 8 ou 16 bits, elles sont encore utilisées sur quelques microcontrôleurs de faible puissance. Nous auront l'occasion de donner des exemples quand nous parlerons des processeurs 8 bits anciens, dans le chapitre sur les architectures à accumulateur et affiliées.

===Le ''program counter'' mis à jour par l'ALU===

Sur certains processeurs, le calcul de l'adresse de la prochaine instruction est effectué par l'ALU. L'avantage de cette méthode est qu'elle économise un incrémenteur dédié au ''program counter''. Ce qui explique que cette méthode était utilisée sur les processeurs assez anciens, à une époque où un additionneur pouvait facilement prendre 10 à 20% des transistors disponibles. Le désavantage principal est une augmentation de la complexité du séquenceur, qui doit gérer la mise à jour du ''program counter''. De plus, la mise à jour du ''program counter'' ne peut pas se faire en même temps qu'une opération arithmétique, ce qui réduit les performances.

Si on incrémente le ''program counter'' avec l'ALU, il est intéressant de le placer dans le banc de registres. Un désavantage est qu'on perd un registre. Par exemple, avec un banc de registre de 16 registres, on ne peut adresser que 15 registres généraux. De plus ce n'est pas l'idéal pour le décodage des instructions et pour le séquenceur. Si le processeur dispose de plusieurs bancs de registres, le ''program counter'' est généralement placé dans le banc de registre dédié aux adresses. Sinon, il est placé avec les nombres entiers/adresses.

D'anciens processeurs incrémentaient le ''program counter'' avec l'ALU, mais utilisaient bien un registre séparé pour le ''program counter''. Cette méthode est relativement simple à implémenter : il suffit de connecter/déconnecter le ''program counter'' du bus interne suivant les besoins. Le ''program counter'' est déconnecté pendant l’exécution d'une instruction, il est connecté au bus interne pour l'incrémenter. C'est le séquenceur qui gère le tout. L'avantage de cette séparation est qu'elle est plus facile à gérer pour le séquenceur. De plus, on gagne un registre général/entier dans le banc de registre.

===Le compteur programme===

Dans la quasi-totalité des processeurs modernes, le ''program counter'' est un vulgaire compteur comme on en a vu dans les chapitres sur les circuits, ce qui fait qu'il passe automatiquement d'une adresse à la suivante. Dans ce qui suit, nous allons appeler ce registre compteur : le '''compteur ordinal'''. L'usage d'un compteur simplifie fortement la conception du séquenceur. Le séquenceur n'a pas à gérer la mise à jour du ''program counter'', sauf en cas de branchements. De plus, il est possible d'incrémenter le ''program counter'' pendant que l'unité de calcul effectue une opération arithmétique, ce qui améliore grandement les performances. Le seul désavantage est qu'elle demande d'ajouter un incrémenteur dédié au ''program counter''.

Sur les processeurs très anciens, les instructions faisaient toutes un seul mot mémoire et le compteur ordinal était un circuit incrémenteur des plus basique. Sur les processeurs modernes, le compteur est incrémenté par pas de 4 si les instructions sont codées sur 4 octets, 8 si les instructions sont codées sur 8 octets, etc. Concrètement, le compteur est un circuit incrémenteur auquel on aurait retiré quelques bits de poids faible. Par exemple, si les instructions sont codées sur 4 octets, on coupe les 2 derniers bits du compteur. Si les instructions sont codées sur 8 octets, on coupe les 3 derniers bits du compteur. Et ainsi de suite.

Il a existé quelques processeurs pour lesquelles le ''program counter'' était non pas un compteur binaire classique, mais un ''linear feedback shift register''. L'avantage est que le circuit d'incrémentation utilisait bien moins de portes logiques, l'économie était substantielle. Mais un défaut est que des instructions consécutives dans le programme n'étaient pas consécutives en mémoire. Il existait cependant une table de correspondance pour dire : la première instruction est à telle adresse, la seconde à telle autre, etc. Un exemple de processeur de ce type est le TMS 1000 de Texas Instrument, un des premiers microcontrôleur 4 bits datant des années 70.

Une amélioration de la solution précédente utilise un circuit incrémenteur partagé entre le ''program counter'' et d'autres registres. L'incrémenteur est utilisé pour incrémenter le ''program counter'', mais aussi pour effectuer d'autres calculs d'adresse. Par exemple, sur les architectures avec une pile d'adresse de retour, il est possible de partager l'incrémenteur/décrémenteur avec le pointeur de pile ( la technique ne marche pas avec une pile d'appel). Un autre exemple est celui des processeurs qui gèrent automatiquement le rafraichissement mémoire, grâce à, un compteur intégré dans le processeur. Il est possible de partager l'incrémenteur du ''program counter'' avec le compteur de rafraichissement mémoire, qui mémorise la prochaine adresse mémoire à rafraichir. Nous avions déjà abordé ce genre de partage dans le chapitre sur le chemin de données, dans l'annexe sur le pointeur de pile, mais nous verrons d'autres exemples dans le chapitre sur les architectures hybride accumulateur-registre 8/16 bits.

===Quand est mis à jour le ''program counter'' ?===

Le ''program counter'' est mis à jour quand il faut charger une nouvelle instruction. Reste qu'il faut savoir quand le mettre à jour. Incrémenter le ''program counter'' à intervalle régulier, par exemple à chaque cycle d’horloge, fonctionne sur les processeurs où toutes les instructions mettent le même temps pour s’exécuter. Mais de tels processeurs sont très rares. Sur la quasi-totalité des processeurs, les instructions ont une durée d’exécution variable, elles ne prennent pas le même nombre de cycle d'horloge pour s’exécuter. Le temps d’exécution d'une instruction varie selon l'instruction, certaines sont plus longues que d'autres. Tout cela amène un problème : comment incrémenter le ''program counter'' avec des instructions avec des temps d’exécution variables ?

La réponse est que la mise à jour du ''program counter'' démarre quand l'instruction précédente a terminée de s’exécuter, plus précisément un cycle avant. C'est un cycle avant pour que l'instruction chargée soit disponible au prochain cycle pour le décodeur. Pour cela, le séquenceur doit déterminer quand l'instruction est terminée et prévenir le ''program counter'' au bon moment. Il faut donc une interaction entre séquenceur et circuit de chargement. Le circuit de chargement contient une entrée Enable, qui autorise la mise à jour du ''program counter''. Le séquenceur met à 1 cette entrée pour prévenir au ''program counter'' qu'il doit être incrémenté au cycle suivant ou lors du cycle courant. Cela permet de gérer simplement le cas des instructions multicycles. 

[[File:Commande de la mise à jour du program counter.png|centre|vignette|upright=2|Commande de la mise à jour du program counter.]]

Toute la difficulté est alors reportée dans le séquenceur, qui doit déterminer la durée d'une instruction. Pour gérer la mise à jour du ''program counter'', le séquenceur doit déterminer la durée d'une instruction. Cela est simple pour les instructions arithmétiques et logiques, qui ont un nombre de cycles fixe, toujours le même. Une fois l'instruction identifiée par le séquenceur, il connait son nombre de cycles et peut programmer un compteur interne au séquenceur, qui compte le nombre de cycles de l'instruction, et fournit le signal Enable au ''program counter''. Mais cette technique ne marche pas vraiment pour les accès mémoire, dont la durée n'est pas connue à l'avance, surtout sur les processeurs avec des mémoires caches. Pour cela, le séquenceur détermine quand l'instruction mémoire est finie et prévient le ''program counter'' quand c'est le cas.

Il existe quelques processeurs pour lesquels le temps de calcul dépend des opérandes de l'instruction. On peut par exemple avoir une division qui prend 10 cycles avec certaines opérandes, mais 40 cycles avec d'autres opérandes. Mais ces processeurs sont rares et cela est surtout valable pour les opérations de multiplication/division, guère plus. Le problème est alors le même qu'avec les accès mémoire et la solution est la même : l'ALU prévient le séquenceur quand le résultat est disponible.

==Les branchements et le ''program counter''==

Un branchement consiste juste à écrire l'adresse de destination dans le ''program counter''. L'implémentation des branchements demande d'extraire l'adresse de destination et d'altérer le ''program counter'' quand un branchement est détecté. Pour cela, le décodeur d'instruction détecte si l'instruction exécutée est un branchement ou non, et il en déduit où trouver l'adresse de destination.

L'adresse de destination se trouve à un endroit qui dépend du mode d'adressage du branchement. Pour rappel, on distingue quatre modes d'adressage pour les branchements : direct, indirect, relatif et implicite. Pour les branchements directs, l'adresse est intégrée dans l'instruction de branchement elle-même et est extraite par le séquenceur. Pour les branchements indirects, l'adresse de destination est dans le banc de registre. Pour les branchements relatifs, il faut ajouter un décalage au ''program counter'', décalage extrait de l'instruction par le séquenceur. Enfin, les instructions de retour de fonction lisent l'adresse de destination depuis la pile. L'implémentation de ces quatre types de branchements est très différente.

L'altération du ''program counter'' dépend de si le ''program counter'' est dans un compteur séparé ou s'il est dans le banc de registre. Nous avons vu plus haut qu'il y a quatre cas différents, mais nous n'allons voir que deux cas : celui où le ''program counter'' est dans le banc de registre et est incrémenté par l'unité de calcul, celui avec un ''program counter'' séparé avec son propre incrémenteur. Les deux autres cas ne sont utilisés que sur des architectures à accumulateur ou à pile spécifiques, que nous n'avons pas encore vu à ce stade du cours et que nous verrons en temps voulu dans le chapitre sur ces architectures.

===L’implémentation des branchements avec un ''program counter'' intégré au banc de registres===

Le cas le plus simple est celui où le ''program counter'' est intégré au banc de registre, avec une incrémentation faite par l'unité de calcul. Charger une instruction revient alors à effectuer une instruction LOAD en adressage indirect, à deux différences près : le registre sélectionné est le ''program counter'', l’instruction est copiée dans le registre d'instruction et non dans le banc de registre. L'incrémentation du ''porgram counter'' est implémenté avec des micro-opérations qui agissent sur le chemin de données, au même titre que les branchements indirects, relatifs et directs.
* Les branchements indirects copient un registre dans le ''program counter'', ce qui revient simplement à faire une opération MOV entre deux registres, dont le ''program counter'' est la destination.
* L'opération inverse d'un branchement indirect, qui copie le ''program counter'' dans un registre général, est utile pour sauvegarder l'adresse de retour d'une fonction.
* Les branchements directs copient une adresse dans le ''program counter'', ce qui les rend équivalents à une opération MOV avec une constante immédiate, dont le ''program counter'' est la destination.
* Les branchements relatifs sont une opération arithmétique entre le ''program counter'' et un opérande en adressage immédiat.

En clair, à partir du moment où le chemin de données supporte les instructions MOV et l'addition, avec les modes d'adressage adéquat, il supporte les branchements. Aucune modification du chemin de données n'est nécessaire, le séquenceur gére le chargement d'une instruction avec les micro-instructions adéquates : une micro-opération ADD pour incrémenter le ''program counter'', une micro-opération LOAD pour le chargement de l'instruction.

Notons que sur certaines architectures, le ''program counter'' est adressable au même titre que les autres registres du banc de registre. Les instructions de branchement sont alors remplacées par des instructions MOV ou des instructions arithmétique équivalentes, comme décrit plus haut.

===L’implémentation des branchements avec un ''program counter'' séparé===

Étudions maintenant le cas où le ''program counter'' est dans un registre/compteur séparé. Rappelons que tout compteur digne de ce nom possède une entrée de réinitialisation, qui remet le compteur à zéro. De plus, on peut préciser à quelle valeur il doit être réinitialisé. Ici, la valeur à laquelle on veut réinitialiser le compteur n'est autre que l'adresse de destination du branchement. Implémenter un branchement est donc simple : l'entrée de réinitialisation est commandée par le circuit de détection des branchements, alors que la valeur de réinitialisation est envoyée sur l'entrée adéquate. En clair, nous partons du principe que le ''program counter'' est implémenté avec ce type de compteur :

[[File:Fonctionnement d'un compteur (décompteur), schématique.jpg|centre|vignette|upright=1.5|Fonctionnement d'un compteur (décompteur), schématique]]

Toute la difficulté est de présenter l'adresse de destination au ''program counter''. Pour les branchements directs, l'adresse de destination est fournie par le séquenceur. L'adresse de destination du branchement sort du séquenceur et est présentée au ''program counter'' sur l'entrée adéquate. Voici donc comment sont implémentés les branchements directs avec un ''program counter'' séparé du banc de registres. Le schéma ci-dessous marche peu importe que le ''program counter'' soit incrémenté par l'ALU ou par un additionneur dédié.

[[File:Unité de détection des branchements dans le décodeur.png|centre|vignette|upright=2|Unité de détection des branchements dans le décodeur]]

Les branchements relatifs sont ceux qui font sauter X instructions plus loin dans le programme. Leur implémentation demande d'ajouter une constante au ''program counter'', la constante étant fournie dans l’instruction. Là encore, deux solutions sont possibles : réutiliser l'ALU pour calculer l'adresse, ou utiliser un additionneur séparé. L'additionneur séparé peut être fusionné avec l'additionneur qui incrémente le ''program counter'' pour passer à l’instruction suivante.

[[File:Unité de chargement qui gère les branchements relatifs.png|centre|vignette|upright=2|Unité de chargement qui gère les branchements relatifs.]]

Pour les branchements indirects, il suffit de lire le registre voulu et d'envoyer le tout sur l'entrée adéquate du ''program counter''. Il faut alors rajouter un multiplexeur pour que l'entrée de réinitialisationr ecoive la bonne adresse de destination.

[[File:Unité de chargement qui gère les branchements directs.png|centre|vignette|upright=2|Unité de chargement qui gère les branchements directs et indirects.]]

Toute la difficulté de l'implémentation des branchements est de configurer les multiplexeurs, ce qui est réalisé par le séquenceur en fonction du mode d'adressage du branchement.

==Les optimisations du chargement des instructions==

Charger une instruction est techniquement une forme d'accès mémoire un peu particulier. En clair, charger une instruction prend au minimum un cycle d'horloge, et cela peut rapidement monter à 3-5 cycles, si ce n'est plus. L'exécution des instructions est alors fortement ralentit par la mémoire. Par exemple, imaginez que la mémoire mette 3 cycles d'horloges pour charger une instruction, alors qu'une instruction s’exécute en 1 cycle (si les opérandes sont dans les registres). La perte de performance liée au chargement des instructions est alors substantielle. Heureusement, il est possible de limiter la casse en utilisant des mémoires caches, ainsi que d'autres optimisations, que nous allons voir dans ce qui suit.

===Le tampon de préchargement===

La technique dite du '''préchargement''' est utilisée dans le cas où la mémoire a un temps d'accès important. Mais si la latence de la RAM est un problème, le débit ne l'est pas. Il est possible d'avoir une RAM lente, mais à fort débit. Par exemple, supposons que la mémoire puisse charger 4 instructions (de taille fixe) en 3 cycles. Le processeur peut alors charger 4 instructions en un seul accès mémoire, et les exécuter l'une après l'autre, une par cycle d'horloge. Les temps d'attente sont éliminés : le processeur peut décoder une nouvelle instruction à chaque cycle. Et quand la dernière instruction préchargée est exécutée, la mémoire est de nouveau libre, ce qui masque la latence des accès mémoire.

[[File:Tampon de préchargement d'instruction.png|vignette|Tampon de préchargement d'instruction]]

La seule contrainte est de mettre les instructions préchargées en attente. La solution pour cela est d'utiliser un registre d'instruction très large, capable de mémoriser plusieurs instructions à la fois. Ce registre est de plus connecté à un multiplexeur qui permet de sélectionner l'instruction adéquate dans ce registre. Ce multiplexeur est commandé par le ''program counter'' et quelques circuits annexes. Ce super-registre d'instruction est appelé un '''tampon de préchargement'''.

La méthode a une implémentation nettement plus simple avec des instructions de taille fixe, alignées en mémoire. La commande du multiplexeur de sélection de l'instruction est alors beaucoup plus simple : il suffit d'utiliser les bits de poids fort du ''program counter''. Par exemple, prenons le cas d'un registre d'instruction de 32 octets pour des instructions de 4 octets, soit 8 instructions. Le choix de l'instruction à sélectionner se fait en utilisant les 3 bits de poids faible du ''program counter''. 

Mais cette méthode ajoute de nouvelles contraintes d'alignement, similaires à celles vues dans le chapitre sur l'alignement et le boutisme, sauf que l'alignement porte ici sur des blocs d'instructions de même taille que le tampon de préchargement. Si on prend l'exemple d'un tampon de préchargement de 128 bits, les instructions devront être alignées par blocs de 128 bits. C'est à dire qu'idéalement, les fonctions et autres blocs de code isolés doivent commencer à des adresses multiples de 128, pour pouvoir charger un bloc d'instruction en une seule fois. Sans cela, les performances seront sous-optimales.

: Il arrive que le tampon de préchargement ait la même taille qu'une ligne de cache.

Lorsque l'on passe d'un bloc d'instruction à un autre, le tampon de préchargement est mis à jour. Par exemple, si on prend un tampon de préchargement de 4 instructions, on doit changer son contenu toutes les 4 instructions. La seule exception est l'exécution d'un branchement. En effet, lors d'un branchement, la destination du branchement n'est pas dans le tampon de préchargement et elle doit être chargée dedans (sauf si le branchement pointe vers une instruction très proche, ce qui est improbable). Pour cela, le tampon de préchargement est mis à jour précocement quand le processeur détecte un branchement.

Le même problème survient avec du code auto-modifiant. Un code auto-modifiant est un programme qui se modifie lui-même, en remplaçant certaines instructions par d'autres, en en retirant, en en ajoutant, lors de sa propre exécution. De tels programmes sont rares, mais la technique était utilisée dans quelques cas au tout début de l'informatique sur des ordinateurs rudimentaires. Ceux-ci avaient des modes d'adressages tellement limités que gérer des tableaux de taille variable demandait d'utiliser du code auto-modifiant pour écrire des boucles. Le problème survient quand des instructions sont modifiées immédiatement après avoir été préchargées. Les instructions dans le tampon de préchargement sont l'ancienne version, alors que la mémoire RAM contient les instructions modifiées. Gérer ce genre de cas demande de vider le tampon de préchargement si le cas arrive, mais ça ne vaut que très rarement le coup, aussi les ingénieurs ne s’embêtent pas à mettre ce correctif en place. Le code automodifiant est alors buggé.

===La ''prefetch input queue''===

La ''prefetch input queue'' est une sorte de cousine du tampon de préchargement, qui a été utilisée sur les processeurs Intel assez ancien. Elle est apparue sur le 8086 et le 8088, des processeurs respectivement 8 et 16 bits. Elle été présente sur le 286 et le 386, mais était un peu améliorée. Elle est apparue sur ces processeurs à une époque où le processeur devenait plus rapide que la mémoire.

L'idée est là encore de précharger des instructions en avance. Sauf que cette fois-ci, on ne charge pas plusieurs instructions à la fois. Au contraire, les instructions sont préchargées séquentiellement, un octet à la fois. En conséquence, le tampon de préchargement est remplacé par une mémoire FIFO appelée la '''''Prefetch Input Queue''''', terme abrévié en PIQ. Les instructions sont accumulées une par une dans la PIQ, elles en sortent une par une au fur et à mesure pour alimenter le décodeur d'instruction.

L'idée est que pendant que le processeur exécute une instruction, on précharge la suivante. Sans ''prefetch input queue'', le processeur chargeait une instruction, la décodait et l'exécutait, puis chargeait la suivante, et ainsi de suite. Avec la ''prefetch input queue'', pendant qu'une instruction est en cours de décodage/exécution, le processeur précharge l'instruction suivante. Si une instruction prend vraiment beaucoup de temps pour s'exécuter, le processeur peut en profiter pour précharger l'instruction encore suivante, et ainsi de suite, jusqu'à une limite de 4/6 instructions (la limite dépend du processeur).

La ''prefetch input queue'' permet de précharger l'instruction suivante à condition qu'aucun autre accès mémoire n'ait lieu. Si l'instruction en cours d'exécution effectue des accès mémoire, ceux-ci sont prioritaires sur tout le reste, le préchargement de l'instruction suivante est alors mis en pause ou inhibé. Par contre, si la mémoire n'est pas utilisée par l'instruction en cours d'exécution, le processeur lit l'instruction suivante en RAM et la copie dans la ''prefetch input queue''. En conséquence, il arrive que la ''prefetch input queue'' n'ait pas préchargé l'instruction suivante, alors que le décodeur d'instruction est prêt pour la décoder. Dans ce cas, le décodeur doit attendre que l'instruction soit chargée.

Les instructions préchargées dans la ''Prefetch input queue'' y attendent que le processeur les lise et les décode. Les instructions préchargées sont conservées dans leur ordre d'arrivée, afin qu'elles soient exécutées dans le bon ordre, ce qui fait que la ''Prefetch input queue'' est une mémoire de type FIFO. L'étape de décodage pioche l'instruction à décoder dans la ''Prefetch input queue'', cette instruction étant par définition la plus ancienne, puis la retire de la file.

Le premier processeur commercial grand public à utiliser une ''prefetch input queue'' était le 8086. Il pouvait précharger à l'avance 6 octets d’instruction. L'Intel 8088 avait lui aussi une ''Prefetch input queue'', mais qui ne permettait que de précharger 4 instructions. La taille idéale de la FIFO dépend de nombreux paramètres. On pourrait croire que plus elle peut contenir d'instructions, mieux c'est, mais ce n'est pas le cas, pour des raisons que nous allons expliquer dans quelques paragraphes.

[[File:80186 arch.png|centre|vignette|700px|upright=2|Architecture du 8086, du 80186 et de ses variantes.]]

Vous remarquerez que j'ai exprimé la capacité de la ''prefetch input queue'' en octets et non en instructions. La raison est que sur les processeurs x86, les instructions sont de taille variable. Les instructions de ces processeurs ont une taille qui varie entre un octet et 6 octets. 

Le bus de données du 8086 faisait 16 bits, ce qui fait qu'il était possible de charger une instruction courte en un cycle. Par contre, sur le 8088, un processeur 8 bits, le bus de donnée ne permettait que de lire un octet à la fois.  La ''prefetch input queue'' du 8086 avait un port d'écriture 16 bits relié à la RAM et un port de lecture de 8 bits relié au décodeur. La ''prefetch input queue'' avait des ports de 8 bits uniquement.

Le décodage des instructions se faisait un octet à la fois : le décodeur lisait un octet, puis éventuellement le suivant, et ainsi de suite. Pour gérer les instructions de plus deux octets ou plus, le décodeur pouvait lire une instruction en plusieurs fois dans la ''Prefetch input queue''. Pour cela, le décodeur dispose d'une micro-opération pour lire un octet depuis la ''Prefetch input queue''.

Un circuit appelé le ''loader'' synchronisait le décodeur d'instruction et la ''Prefetch input queue''. Il fournissait un bit qui indiquait si le premier octet d'une instruction était disponible dans la ''Prefetch input queue''. Un second bit indiquait si l'octet suivant était disponible, nous verrons pourquoi dans ce qui suit. Le ''loader'' recevait aussi des signaux de la part du décodeur d'instruction, afin de gérer la micro-opération de lecture dans la ''Prefetch input queue''. Le décodeur envoyait le signal ''Run Next Instruction'' pour lire une instruction, qui était alors dépilée de la ''Prefetch input queue''. Le décodeur d'instruction pouvait aussi envoyer un signal ''Next-to-last (NXT)'', un cycle avant que l'instruction en cours ne termine. Le ''loader'' réagissait en préchargeant l'octet suivant. En clair, ce signal permettait de précharger l'instruction suivante avec un cycle d'avance, si celle-ci n'était pas déjà dans la ''Prefetch input queue''.

Le décodeur devait attendre que qu'un moins un octet soit disponible dans la ''Prefetch input queue'', pour le lire. Il lisait alors cet octet et déterminait s'il contenait une instruction complète ou non. Si c'est une instruction complète, il la décodait et l''exécutait, puis envoyait un signal ''Run Next Instruction'' pour commencer le décodage de l'instruction suivante. Sinon, il lit un second octet depuis la ''Prefetch input queue'', le copie dans le registre d'instruction, et relance le décodage. Là encore, le décodeur vérifie s'il a une instruction complète, et lit un troisième octet si besoin, puis rebelote avec un quatrième octet lu, etc.

Les branchements posent des problèmes avec la ''Prefetch input queue'' : à cause d'eux, on peut charger à l'avance des instructions qui sont zappées par un branchement et ne sont pas censées être exécutées. Si un branchement est chargé, toutes les instructions préchargées après sont potentiellement invalides. Si le branchement est non-pris, les instructions chargées sont valides, elles sont censées s’exécuter. Mais si le branchement est pris, elles ont été chargées à tort et ne doivent pas s’exécuter. 

Pour éviter cela, la ''Prefetch input queue'' est vidée quand le processeur détecte un branchement. Pour cela, le décodeur d'instruction dispose d'une micro-opération qui vide la ''Prefetch input queue'', elle invalide les instructions préchargées.  Cette détection ne peut se faire qu'une fois le branchement décodé, qu'une fois que l'on sait que l'instruction décodée est un branchement. En clair, le décodeur invalide la ''Prefetch input queue'' quand il détecte un branchement. Les interruptions posent le même genre de problèmes. Il faut impérativement vider la ''Prefetch input queue'' quand une interruption survient, avant de la traiter.

Il faut noter qu'une ''Prefetch input queue'' interagit assez mal avec le ''program counter''. En effet, la ''Prefetch input queue'' précharge les instructions séquentiellement. Pour savoir où elle en est rendue, elle mémorise l'adresse de la prochaine instruction à charger dans un '''registre de préchargement''' dédié. Il serait possible d'utiliser un ''program counter'' en plus du registre de préchargement, mais ce n'est pas la solution qui a été utilisée. Les processeurs Intel anciens ont préféré n'utiliser qu'un seul registre de préchargement en remplacement du ''program counter''. Après tout, le registre de préchargement n'est qu'un ''program counter'' ayant pris une avance de quelques cycles d'horloge, qui a été incrémenté en avance.

Et cela ne pose pas de problèmes, sauf avec certains branchements. Par exemple, certains branchements relatifs demandent de connaitre la véritable valeur du ''program counter'', pas celle calculée en avance. Idem avec les instructions d'appel de fonction, qui demandent de sauvegarder l'adresse de retour exacte, donc le vrai ''program counter''. De telles situations demandent de connaitre la valeur réelle du ''program counter'', celle sans préchargement. Pour cela, le décodeur d'instruction dispose d'une instruction pour reconstituer le ''program counter'', à savoir corriger le ''program coutner'' et éliminer l'effet du préchargement.

La micro-opération de correction se contente de soustraire le nombre d'octets préchargés au registre de préchargement. Le nombre d'octets préchargés est déduit à partir des deux pointeurs intégré à la FIFO, qui indiquent la position du premier et du dernier octet préchargé. Le bit qui indique si la FIFO est vide était aussi utilisé. Les deux pointeurs sont lus depuis la FIFO, et sont envoyés à un circuit qui détermine le nombre d'octets préchargés. Sur le 8086, ce circuit était implémenté non pas par un circuit combinatoire, mais par une mémoire ROM équivalente. La petite taille de la FIFO faisait que les pointeurs étaient très petits et la ROM l'était aussi.

Un autre défaut est que la ''Prefetch input queue'' se marie assez mal avec du code auto-modifiant. Un code auto-modifiant est un programme qui se modifie lui-même, en remplaçant certaines instructions par d'autres, en en retirant, en en ajoutant, lors de sa propre exécution. De tels programmes sont rares, mais la technique était utilisée dans quelques cas au tout début de l'informatique sur des ordinateurs rudimentaires. Ceux-ci avaient des modes d'adressages tellement limités que gérer des tableaux de taille variable demandait d'utiliser du code auto-modifiant pour écrire des boucles.

Le problème avec la ''Prefetch input queue'' survient quand des instructions sont modifiées immédiatement après avoir été préchargées. Les instructions dans la ''Prefetch input queue'' sont l'ancienne version, alors que la mémoire RAM contient les instructions modifiées. Gérer ce genre de cas est quelque peu complexe. Il faut en effet vider la ''Prefetch input queue'' si le cas arrive, ce qui demande d'identifier les écritures qui écrasent des instructions préchargées. C'est parfaitement possible, mais demande de transformer la ''Prefetch input queue'' en une mémoire hybride, à la fois mémoire associative et mémoire FIFO. Cela ne vaut que très rarement le coup, aussi les ingénieurs ne s’embêtent pas à mettre ce correctif en place, le code automodifiant est alors buggé.

Le décodeur d'instruction dispose aussi d'une micro-opération qui stoppe le préchargement des instructions dans la ''Prefetch input queue''.

: Pour ceux qui ont déjà lu un cours d'architecture des ordinateurs, la relation entre ''prefetch input queue'' et pipeline est quelque peu complexe. En apparence, la ''prefetch input queue'' permet une certaines forme de pipeline, en chargeant une instruction pendant que la précédente s'exécute. Les problématiques liées aux branchements ressemblent beaucoup à celles de la prédiction de branchement. Cependant, il est possible de dire qu'il s'agit plus d'une technique de préchargement que de pipeline. La différence entre les deux est assez subtile et les frontières sont assez floues, mais le fait est que l'instruction en cours d'exécution et le préchargement peuvent tout deux faire des accès mémoire et que l'instruction en cours a la priorité. Un vrai pipeline se débrouillerait avec une architecture Harvard, non avec un bus mémoire unique pour le chargement des instruction et la lecture/écriture des données.

===Le ''Zero-overhead looping''===

Nous avions vu dans le chapitre sur les instructions machines, qu'il existe des instructions qui permettent de grandement faciliter l'implémentation des boucles. Il s'agit de l'instruction REPEAT, utilisée sur certains processeurs de traitement de signal. Elle répète l'instruction suivante, voire une série d'instructions, un certain nombre de fois. Le nombre de répétitions est mémorisé dans un registre décrémenté à chaque itération de la boucle. Elle permet donc d'implémenter une boucle FOR facilement, sans recourir à des branchements ou des conditions.

Une technique en lien avec cette instruction permet de grandement améliorer les performances et la consommation d'énergie. L'idée est de mémoriser la boucle, les instructions à répéter, dans une petite mémoire cache située entre l'unité de chargement et le séquenceur. Le cache en question s'appelle un '''tampon de boucle''', ou encore un ''hardware loop buffer''. Grâce à lui, il n'y a pas besoin de charger les instructions à chaque fois qu'on les exécute, on les charge une bonne fois pour toute : c'est plus rapide. Bien sûr, il ne fonctionne que pour de petites boucles, mais il en est de même avec l'instruction REPEAT.

&lt;noinclude&gt;
{{NavChapitre | book=Fonctionnement d'un ordinateur
           | prev=Le chemin de données
           | prevText=Le chemin de données
           | next=L'unité de contrôle
           | nextText=L'unité de contrôle
}}
&lt;/noinclude&gt;</text>
      <sha1>m6qgnwudqrjf61xcazxq328jlgrwogz</sha1>
    </revision>
    <revision>
      <id>744085</id>
      <parentid>744084</parentid>
      <timestamp>2025-06-03T20:09:03Z</timestamp>
      <contributor>
        <username>Mewtow</username>
        <id>31375</id>
      </contributor>
      <minor />
      <comment>/* La prefetch input queue */</comment>
      <origin>744085</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="46269" sha1="3n8r252hcdo8mk1fxwskn1wndyvkyr1" xml:space="preserve">L'unité de contrôle s'occupe du chargement des instructions et de leur interprétation, leur décodage. Elle contient deux circuits : l''''unité de chargement''' qui charge l'instruction depuis la mémoire, et le '''séquenceur''' qui commande le chemin de données. Les deux circuits sont séparés, mais ils communiquent entre eux, notamment pour gérer les branchements. Dans ce chapitre, nous allons nous intéresser au chargement d'une instruction depuis la RAM/ROM, nous verrons l'étape de décodage de l'instruction au prochain chapitre.

==Le chargement d'une instruction==

[[File:Étape de chargement.png|vignette|upright=1|Étape de chargement.]]

L'étape de chargement (ou ''fetch'') doit faire deux choses : mettre à jour le ''program counter'' et lire l'instruction en mémoire RAM ou en ROM. Les deux étapes peuvent être faites en parallèle, dans des circuits séparés. Pendant que l'instruction est lue depuis la mémoire RAM/ROM, le ''program counter'' est incrémenté et/ou altéré par un branchement.

Pour lire l'instruction, on envoie le ''program counter'' sur le bus d'adresse et on récupère l'instruction sur le bus de données pour l'envoyer sur l'entrée du séquenceur. Et cela demande de connecter le séquenceur au bus mémoire, à travers l'interface mémoire. Et sur ce point, la situation est différente selon que l'on parler d'une architecture Harvard ou Von Neumann.

===Les interconnexions entre séquenceur et bus mémoire===

Sur les architectures Harvard, le séquenceur et le chemin de donnée utilisent des interfaces mémoire séparées. Le séquenceur est directement relié au bus mémoire de la ROM, alors que le chemin de données est connecté à la RAM.

[[File:Microarchitecture de l'interface mémoire d'une architecture Harvard.png|centre|vignette|upright=2|Microarchitecture de l'interface mémoire d'une architecture Harvard]]

Mais sur les architectures Von-Neumann et affiliées, le séquenceur et le chemin de donnée partagent la même interface mémoire. Et cela pose deux problèmes.

Le premier problème est que le bus mémoire doit être libéré une fois l'instruction chargée, pour un éventuel accès mémoire. Mais le séquenceur doit conserver une copie de l'instruction chargée, sans quoi il ne peut pas décoder l'instruction correctement. Par exemple, si l'instruction met plusieurs cycles à s'exécuter, le séquenceur doit conserver une copie de l'instruction durant ces plusieurs cycles. La solution à ce problème est un '''registre d'instruction''' situé juste avant le séquenceur, qui mémorise l'instruction chargée.

[[File:Registre d'instruction.png|centre|vignette|upright=2|Registre d'instruction.]]

Le second problème est de gérer le flot des instructions/données entre le bus mémoire, le chemin de données et le séquenceur. Le processeur doit connecter l'interface mémoire soit au séquenceur, soit au chemin de données et cela complique le réseau d'interconnexion interne au processeur.

Une première solution utilise un bus unique qui relie l'interface mémoire, le séquenceur et le chemin de données. Pour charger une instruction, le séquenceur copie le ''program counter'' sur le bus d'adresse, attend que l'instruction lue soit disponible sur le bus de données, puis la copie dans le registre d'instruction. Le bus mémoire est alors libre et peut être utilisé pour lire ou écrire des données, si le besoin s'en fait sentir.

Il faut noter que l'usage d'un bus unique a un impact sur l'organisation interne du chemin de données. Par exemple, le chapitre précédent nous a montré comment implémenter un chemin de données basique, avec des multiplexeurs et démultiplexeurs. Et bien ces chemins de données ne marchent pas vraiment avec un bus interne unique. Il est possible de les adapter, mais au prix d'une complexité largement supérieure. Un bus interne unique marche mieux quand le banc de registre est mono-port. C'est pourquoi il a été utilisé sur d'anciennes architectures appelées des architectures à accumulateur et à pile, que nous verrons dans quelques chapitres, qui utilisaient un banc de registre mono-port.

[[File:Microarchitecture de l'interface mémoire d'une architecture von neumann.png|centre|vignette|upright=2|Microarchitecture de l'interface mémoire d'une architecture von neumann]]

Une autre solution utilise deux bus interne séparés : un connecté au bus d'adresse, l'autre au bus de données. Le ''program counter'' est alors connecté au bus interne d'adresse, le séquenceur est relié au bus interne de données. Notons que la technique marche bien si le ''program counter'' est dans le banc de registre : les interconnexions utilisées pour gérer l'adressage indirect permettent d'envoyer le ''program counter'' sur le bus d'adresse sans ajout de circuit.

Le tout peut être amélioré en remplaçant les deux bus par des multiplexeurs et démultiplexeurs. Le bus d'adresse est précédé par un multiplexeur, qui permet de faire le choix entre ''Program Counter'', adresse venant du chemin de données, ou adresse provenant du séquenceur (adressage absolu). De même, le bus de données est suivi par un démultiplexeur qui envoie la donnée/instruction lue soit au registre d'instruction, soit au chemin de données. Le tout se marie très bien avec les chemins de donnée vu dans le chapitre précédent. Au passage, il faut noter que cette solution nécessite un banc de registre multi-port.

[[File:Connexion du program counter sur les bus avec PC isolé.png|centre|vignette|upright=2|Connexion du program counter sur les bus avec PC isolé]]

===Le chargement des instructions de longueur variable===

Le chargement des instructions de longueur variable pose de nombreux problèmes. Le premier est que mettre à jour le ''program counter'' demande de connaitre la longueur de l'instruction chargée, pour l'ajouter au ''program counter''. Si la longueur d'une instruction est variable, on doit connaitre cette longueur d'une manière où d'une autre. La solution la plus simple indique la longueur de l'instruction dans une partie de l'opcode ou de la représentation en binaire de l'instruction. Mais les processeurs haute performance de nos PC utilisent d'autres solutions, qui n'encodent pas explicitement la taille de l'instruction.

Les processeurs récents utilisent un registre d'instruction de grande taille, capable de mémoriser l'instruction la plus longue du processeur. Par exemple, si un processeur supporte des instructions allant de 1 à 8 octets, comme les CPU x86, le registre d'instruction fera 8 octets. Le décodeur d'instruction vérifie à chaque cycle le contenu du registre d'instruction. Si une instruction est détectée dedans, son décodage commence, peu importe la taille de l'instruction. Une fois l'instruction exécutée, elle est retirée du registre d'instruction. Reste à alimenter le registre d'instruction, à charger des instructions dedans. Et pour cela deux solutions : soit on charge l'instruction en plusieurs fois, soit d'un seul coup.

La solution la plus simple charge les instructions par mots de 8, 16, 32, 64 bits. Ils sont accumulés dans le registre d'instruction jusqu'à détecter une instruction complète. La technique marche nettement mieux si les instructions sont très longues. Par exemple, les CPU x86 ont des instructions qui vont de 1 à 15 octets, ce qui fait qu'ils utilisent cette technique. Précisément, elle marche si les instructions les plus longues sont plus grandes que le bus mémoire.

Une autre solution charge un bloc de mots mémoire aussi grand que la plus grande instruction. Par exemple, si le processeur gère des instructions allant de 1 à 4 octets, il charge 4 octets d'un seul coup dans le registre d'instruction. Il va de soit que cette solution ne marche que si les instructions du processeur sont assez courtes, au plus aussi courtes que le bus mémoire. Ainsi, on est sûr de charger obligatoirement au moins une instruction complète, et peut-être même plusieurs. Le contenu du registre d'instruction est alors découpé en instructions au fil de l'eau. 

Utiliser un registre d'instruction large pose problème avec des instructions à cheval entre deux blocs. Il se peut qu'on n'ait pas une instruction complète lorsque l'on arrive à la fin du bloc, mais seulement un morceau. Le problème se manifeste peu importe que l'instruction soit chargée d'un seul coup ou bien en plusieurs fois.

[[File:Instructions non alignées.png|centre|vignette|upright=2|Instructions non alignées.]]

Dans ce cas, on doit décaler le morceau de bloc pour le mettre au bon endroit (au début du registre d'instruction), et charger le prochain bloc juste à côté. On a donc besoin d'un circuit qui décale tous les bits du registre d'instruction, couplé à un circuit qui décide où placer dans le registre d'instruction ce qui a été chargé, avec quelques circuits autour pour configurer les deux circuits précédents.

[[File:Décaleur d’instruction.png|centre|vignette|upright=2|Décaleur d’instruction.]]

Une autre solution se passe de registre d'instruction en utilisant à la place l'état interne du séquenceur. Là encore, elle charge l'instruction morceau par morceau, typiquement par blocs de 8, 16 ou 32 bits. Les morceaux ne sont pas accumulés dans le registre d'instruction, la solution utilise à la place l'état interne du séquenceur. Les mots mémoire de l'instruction sont chargés à chaque cycle, faisant passer le séquenceur d'un état interne à un autre à chaque mot mémoire. Tant qu'il n'a pas reçu tous les mots mémoire de l'instruction, chaque mot mémoire non terminal le fera passer d'un état interne à un autre, chaque état interne encodant les mots mémoire chargés auparavant. S'il tombe sur le dernier mot mémoire d'une instruction, il rentre dans un état de décodage.

==L'incrémentation du ''program counter''==

À chaque chargement, le ''program counter'' est mis à jour afin de pointer sur la prochaine instruction à charger. Sur la quasi-totalité des processeurs, les instructions sont placées dans l'ordre d’exécution dans la RAM. En faisant ainsi, on peut mettre à jour le ''program counter'' en lui ajoutant la longueur de l'instruction courante. Déterminer la longueur de l'instruction est simple quand les instructions ont toutes la même taille, mais certains processeurs ont des instructions de taille variable, ce qui complique le calcul. Dans ce qui va suivre, nous allons supposer que les instructions sont de taille fixe, ce qui fait que le ''program counter'' est toujours incrémenté de la même valeur.

Il existe deux méthodes principales pour incrémenter le ''program counter'' : soit le ''program counter'' a son propre additionneur, soit le ''program counter'' est mis à jour par l'ALU. Pour ce qui est de l'organisation des registres, soit le ''program counter'' est un registre séparé des autres, soit il est regroupé avec d'autres registres dans un banc de registre. En tout, cela donne quatre organisations possibles.
* Un ''program counter'' séparé relié à un incrémenteur séparé.
* Un ''program counter'' séparé des autres registres, incrémenté par l'ALU.
* Un ''program counter'' intégré au banc de registre, relié à un incrémenteur séparé.
* Un ''program counter'' intégré au banc de registre, incrémenté par l'ALU.

[[File:Calcul du program counter.png|centre|vignette|upright=2|les différentes méthodes de calcul du program counter.]]

Les processeurs haute performance modernes utilisent tous la première méthode. Les autres méthodes étaient surtout utilisées sur les processeurs 8 ou 16 bits, elles sont encore utilisées sur quelques microcontrôleurs de faible puissance. Nous auront l'occasion de donner des exemples quand nous parlerons des processeurs 8 bits anciens, dans le chapitre sur les architectures à accumulateur et affiliées.

===Le ''program counter'' mis à jour par l'ALU===

Sur certains processeurs, le calcul de l'adresse de la prochaine instruction est effectué par l'ALU. L'avantage de cette méthode est qu'elle économise un incrémenteur dédié au ''program counter''. Ce qui explique que cette méthode était utilisée sur les processeurs assez anciens, à une époque où un additionneur pouvait facilement prendre 10 à 20% des transistors disponibles. Le désavantage principal est une augmentation de la complexité du séquenceur, qui doit gérer la mise à jour du ''program counter''. De plus, la mise à jour du ''program counter'' ne peut pas se faire en même temps qu'une opération arithmétique, ce qui réduit les performances.

Si on incrémente le ''program counter'' avec l'ALU, il est intéressant de le placer dans le banc de registres. Un désavantage est qu'on perd un registre. Par exemple, avec un banc de registre de 16 registres, on ne peut adresser que 15 registres généraux. De plus ce n'est pas l'idéal pour le décodage des instructions et pour le séquenceur. Si le processeur dispose de plusieurs bancs de registres, le ''program counter'' est généralement placé dans le banc de registre dédié aux adresses. Sinon, il est placé avec les nombres entiers/adresses.

D'anciens processeurs incrémentaient le ''program counter'' avec l'ALU, mais utilisaient bien un registre séparé pour le ''program counter''. Cette méthode est relativement simple à implémenter : il suffit de connecter/déconnecter le ''program counter'' du bus interne suivant les besoins. Le ''program counter'' est déconnecté pendant l’exécution d'une instruction, il est connecté au bus interne pour l'incrémenter. C'est le séquenceur qui gère le tout. L'avantage de cette séparation est qu'elle est plus facile à gérer pour le séquenceur. De plus, on gagne un registre général/entier dans le banc de registre.

===Le compteur programme===

Dans la quasi-totalité des processeurs modernes, le ''program counter'' est un vulgaire compteur comme on en a vu dans les chapitres sur les circuits, ce qui fait qu'il passe automatiquement d'une adresse à la suivante. Dans ce qui suit, nous allons appeler ce registre compteur : le '''compteur ordinal'''. L'usage d'un compteur simplifie fortement la conception du séquenceur. Le séquenceur n'a pas à gérer la mise à jour du ''program counter'', sauf en cas de branchements. De plus, il est possible d'incrémenter le ''program counter'' pendant que l'unité de calcul effectue une opération arithmétique, ce qui améliore grandement les performances. Le seul désavantage est qu'elle demande d'ajouter un incrémenteur dédié au ''program counter''.

Sur les processeurs très anciens, les instructions faisaient toutes un seul mot mémoire et le compteur ordinal était un circuit incrémenteur des plus basique. Sur les processeurs modernes, le compteur est incrémenté par pas de 4 si les instructions sont codées sur 4 octets, 8 si les instructions sont codées sur 8 octets, etc. Concrètement, le compteur est un circuit incrémenteur auquel on aurait retiré quelques bits de poids faible. Par exemple, si les instructions sont codées sur 4 octets, on coupe les 2 derniers bits du compteur. Si les instructions sont codées sur 8 octets, on coupe les 3 derniers bits du compteur. Et ainsi de suite.

Il a existé quelques processeurs pour lesquelles le ''program counter'' était non pas un compteur binaire classique, mais un ''linear feedback shift register''. L'avantage est que le circuit d'incrémentation utilisait bien moins de portes logiques, l'économie était substantielle. Mais un défaut est que des instructions consécutives dans le programme n'étaient pas consécutives en mémoire. Il existait cependant une table de correspondance pour dire : la première instruction est à telle adresse, la seconde à telle autre, etc. Un exemple de processeur de ce type est le TMS 1000 de Texas Instrument, un des premiers microcontrôleur 4 bits datant des années 70.

Une amélioration de la solution précédente utilise un circuit incrémenteur partagé entre le ''program counter'' et d'autres registres. L'incrémenteur est utilisé pour incrémenter le ''program counter'', mais aussi pour effectuer d'autres calculs d'adresse. Par exemple, sur les architectures avec une pile d'adresse de retour, il est possible de partager l'incrémenteur/décrémenteur avec le pointeur de pile ( la technique ne marche pas avec une pile d'appel). Un autre exemple est celui des processeurs qui gèrent automatiquement le rafraichissement mémoire, grâce à, un compteur intégré dans le processeur. Il est possible de partager l'incrémenteur du ''program counter'' avec le compteur de rafraichissement mémoire, qui mémorise la prochaine adresse mémoire à rafraichir. Nous avions déjà abordé ce genre de partage dans le chapitre sur le chemin de données, dans l'annexe sur le pointeur de pile, mais nous verrons d'autres exemples dans le chapitre sur les architectures hybride accumulateur-registre 8/16 bits.

===Quand est mis à jour le ''program counter'' ?===

Le ''program counter'' est mis à jour quand il faut charger une nouvelle instruction. Reste qu'il faut savoir quand le mettre à jour. Incrémenter le ''program counter'' à intervalle régulier, par exemple à chaque cycle d’horloge, fonctionne sur les processeurs où toutes les instructions mettent le même temps pour s’exécuter. Mais de tels processeurs sont très rares. Sur la quasi-totalité des processeurs, les instructions ont une durée d’exécution variable, elles ne prennent pas le même nombre de cycle d'horloge pour s’exécuter. Le temps d’exécution d'une instruction varie selon l'instruction, certaines sont plus longues que d'autres. Tout cela amène un problème : comment incrémenter le ''program counter'' avec des instructions avec des temps d’exécution variables ?

La réponse est que la mise à jour du ''program counter'' démarre quand l'instruction précédente a terminée de s’exécuter, plus précisément un cycle avant. C'est un cycle avant pour que l'instruction chargée soit disponible au prochain cycle pour le décodeur. Pour cela, le séquenceur doit déterminer quand l'instruction est terminée et prévenir le ''program counter'' au bon moment. Il faut donc une interaction entre séquenceur et circuit de chargement. Le circuit de chargement contient une entrée Enable, qui autorise la mise à jour du ''program counter''. Le séquenceur met à 1 cette entrée pour prévenir au ''program counter'' qu'il doit être incrémenté au cycle suivant ou lors du cycle courant. Cela permet de gérer simplement le cas des instructions multicycles. 

[[File:Commande de la mise à jour du program counter.png|centre|vignette|upright=2|Commande de la mise à jour du program counter.]]

Toute la difficulté est alors reportée dans le séquenceur, qui doit déterminer la durée d'une instruction. Pour gérer la mise à jour du ''program counter'', le séquenceur doit déterminer la durée d'une instruction. Cela est simple pour les instructions arithmétiques et logiques, qui ont un nombre de cycles fixe, toujours le même. Une fois l'instruction identifiée par le séquenceur, il connait son nombre de cycles et peut programmer un compteur interne au séquenceur, qui compte le nombre de cycles de l'instruction, et fournit le signal Enable au ''program counter''. Mais cette technique ne marche pas vraiment pour les accès mémoire, dont la durée n'est pas connue à l'avance, surtout sur les processeurs avec des mémoires caches. Pour cela, le séquenceur détermine quand l'instruction mémoire est finie et prévient le ''program counter'' quand c'est le cas.

Il existe quelques processeurs pour lesquels le temps de calcul dépend des opérandes de l'instruction. On peut par exemple avoir une division qui prend 10 cycles avec certaines opérandes, mais 40 cycles avec d'autres opérandes. Mais ces processeurs sont rares et cela est surtout valable pour les opérations de multiplication/division, guère plus. Le problème est alors le même qu'avec les accès mémoire et la solution est la même : l'ALU prévient le séquenceur quand le résultat est disponible.

==Les branchements et le ''program counter''==

Un branchement consiste juste à écrire l'adresse de destination dans le ''program counter''. L'implémentation des branchements demande d'extraire l'adresse de destination et d'altérer le ''program counter'' quand un branchement est détecté. Pour cela, le décodeur d'instruction détecte si l'instruction exécutée est un branchement ou non, et il en déduit où trouver l'adresse de destination.

L'adresse de destination se trouve à un endroit qui dépend du mode d'adressage du branchement. Pour rappel, on distingue quatre modes d'adressage pour les branchements : direct, indirect, relatif et implicite. Pour les branchements directs, l'adresse est intégrée dans l'instruction de branchement elle-même et est extraite par le séquenceur. Pour les branchements indirects, l'adresse de destination est dans le banc de registre. Pour les branchements relatifs, il faut ajouter un décalage au ''program counter'', décalage extrait de l'instruction par le séquenceur. Enfin, les instructions de retour de fonction lisent l'adresse de destination depuis la pile. L'implémentation de ces quatre types de branchements est très différente.

L'altération du ''program counter'' dépend de si le ''program counter'' est dans un compteur séparé ou s'il est dans le banc de registre. Nous avons vu plus haut qu'il y a quatre cas différents, mais nous n'allons voir que deux cas : celui où le ''program counter'' est dans le banc de registre et est incrémenté par l'unité de calcul, celui avec un ''program counter'' séparé avec son propre incrémenteur. Les deux autres cas ne sont utilisés que sur des architectures à accumulateur ou à pile spécifiques, que nous n'avons pas encore vu à ce stade du cours et que nous verrons en temps voulu dans le chapitre sur ces architectures.

===L’implémentation des branchements avec un ''program counter'' intégré au banc de registres===

Le cas le plus simple est celui où le ''program counter'' est intégré au banc de registre, avec une incrémentation faite par l'unité de calcul. Charger une instruction revient alors à effectuer une instruction LOAD en adressage indirect, à deux différences près : le registre sélectionné est le ''program counter'', l’instruction est copiée dans le registre d'instruction et non dans le banc de registre. L'incrémentation du ''porgram counter'' est implémenté avec des micro-opérations qui agissent sur le chemin de données, au même titre que les branchements indirects, relatifs et directs.
* Les branchements indirects copient un registre dans le ''program counter'', ce qui revient simplement à faire une opération MOV entre deux registres, dont le ''program counter'' est la destination.
* L'opération inverse d'un branchement indirect, qui copie le ''program counter'' dans un registre général, est utile pour sauvegarder l'adresse de retour d'une fonction.
* Les branchements directs copient une adresse dans le ''program counter'', ce qui les rend équivalents à une opération MOV avec une constante immédiate, dont le ''program counter'' est la destination.
* Les branchements relatifs sont une opération arithmétique entre le ''program counter'' et un opérande en adressage immédiat.

En clair, à partir du moment où le chemin de données supporte les instructions MOV et l'addition, avec les modes d'adressage adéquat, il supporte les branchements. Aucune modification du chemin de données n'est nécessaire, le séquenceur gére le chargement d'une instruction avec les micro-instructions adéquates : une micro-opération ADD pour incrémenter le ''program counter'', une micro-opération LOAD pour le chargement de l'instruction.

Notons que sur certaines architectures, le ''program counter'' est adressable au même titre que les autres registres du banc de registre. Les instructions de branchement sont alors remplacées par des instructions MOV ou des instructions arithmétique équivalentes, comme décrit plus haut.

===L’implémentation des branchements avec un ''program counter'' séparé===

Étudions maintenant le cas où le ''program counter'' est dans un registre/compteur séparé. Rappelons que tout compteur digne de ce nom possède une entrée de réinitialisation, qui remet le compteur à zéro. De plus, on peut préciser à quelle valeur il doit être réinitialisé. Ici, la valeur à laquelle on veut réinitialiser le compteur n'est autre que l'adresse de destination du branchement. Implémenter un branchement est donc simple : l'entrée de réinitialisation est commandée par le circuit de détection des branchements, alors que la valeur de réinitialisation est envoyée sur l'entrée adéquate. En clair, nous partons du principe que le ''program counter'' est implémenté avec ce type de compteur :

[[File:Fonctionnement d'un compteur (décompteur), schématique.jpg|centre|vignette|upright=1.5|Fonctionnement d'un compteur (décompteur), schématique]]

Toute la difficulté est de présenter l'adresse de destination au ''program counter''. Pour les branchements directs, l'adresse de destination est fournie par le séquenceur. L'adresse de destination du branchement sort du séquenceur et est présentée au ''program counter'' sur l'entrée adéquate. Voici donc comment sont implémentés les branchements directs avec un ''program counter'' séparé du banc de registres. Le schéma ci-dessous marche peu importe que le ''program counter'' soit incrémenté par l'ALU ou par un additionneur dédié.

[[File:Unité de détection des branchements dans le décodeur.png|centre|vignette|upright=2|Unité de détection des branchements dans le décodeur]]

Les branchements relatifs sont ceux qui font sauter X instructions plus loin dans le programme. Leur implémentation demande d'ajouter une constante au ''program counter'', la constante étant fournie dans l’instruction. Là encore, deux solutions sont possibles : réutiliser l'ALU pour calculer l'adresse, ou utiliser un additionneur séparé. L'additionneur séparé peut être fusionné avec l'additionneur qui incrémente le ''program counter'' pour passer à l’instruction suivante.

[[File:Unité de chargement qui gère les branchements relatifs.png|centre|vignette|upright=2|Unité de chargement qui gère les branchements relatifs.]]

Pour les branchements indirects, il suffit de lire le registre voulu et d'envoyer le tout sur l'entrée adéquate du ''program counter''. Il faut alors rajouter un multiplexeur pour que l'entrée de réinitialisationr ecoive la bonne adresse de destination.

[[File:Unité de chargement qui gère les branchements directs.png|centre|vignette|upright=2|Unité de chargement qui gère les branchements directs et indirects.]]

Toute la difficulté de l'implémentation des branchements est de configurer les multiplexeurs, ce qui est réalisé par le séquenceur en fonction du mode d'adressage du branchement.

==Les optimisations du chargement des instructions==

Charger une instruction est techniquement une forme d'accès mémoire un peu particulier. En clair, charger une instruction prend au minimum un cycle d'horloge, et cela peut rapidement monter à 3-5 cycles, si ce n'est plus. L'exécution des instructions est alors fortement ralentit par la mémoire. Par exemple, imaginez que la mémoire mette 3 cycles d'horloges pour charger une instruction, alors qu'une instruction s’exécute en 1 cycle (si les opérandes sont dans les registres). La perte de performance liée au chargement des instructions est alors substantielle. Heureusement, il est possible de limiter la casse en utilisant des mémoires caches, ainsi que d'autres optimisations, que nous allons voir dans ce qui suit.

===Le tampon de préchargement===

La technique dite du '''préchargement''' est utilisée dans le cas où la mémoire a un temps d'accès important. Mais si la latence de la RAM est un problème, le débit ne l'est pas. Il est possible d'avoir une RAM lente, mais à fort débit. Par exemple, supposons que la mémoire puisse charger 4 instructions (de taille fixe) en 3 cycles. Le processeur peut alors charger 4 instructions en un seul accès mémoire, et les exécuter l'une après l'autre, une par cycle d'horloge. Les temps d'attente sont éliminés : le processeur peut décoder une nouvelle instruction à chaque cycle. Et quand la dernière instruction préchargée est exécutée, la mémoire est de nouveau libre, ce qui masque la latence des accès mémoire.

[[File:Tampon de préchargement d'instruction.png|vignette|Tampon de préchargement d'instruction]]

La seule contrainte est de mettre les instructions préchargées en attente. La solution pour cela est d'utiliser un registre d'instruction très large, capable de mémoriser plusieurs instructions à la fois. Ce registre est de plus connecté à un multiplexeur qui permet de sélectionner l'instruction adéquate dans ce registre. Ce multiplexeur est commandé par le ''program counter'' et quelques circuits annexes. Ce super-registre d'instruction est appelé un '''tampon de préchargement'''.

La méthode a une implémentation nettement plus simple avec des instructions de taille fixe, alignées en mémoire. La commande du multiplexeur de sélection de l'instruction est alors beaucoup plus simple : il suffit d'utiliser les bits de poids fort du ''program counter''. Par exemple, prenons le cas d'un registre d'instruction de 32 octets pour des instructions de 4 octets, soit 8 instructions. Le choix de l'instruction à sélectionner se fait en utilisant les 3 bits de poids faible du ''program counter''. 

Mais cette méthode ajoute de nouvelles contraintes d'alignement, similaires à celles vues dans le chapitre sur l'alignement et le boutisme, sauf que l'alignement porte ici sur des blocs d'instructions de même taille que le tampon de préchargement. Si on prend l'exemple d'un tampon de préchargement de 128 bits, les instructions devront être alignées par blocs de 128 bits. C'est à dire qu'idéalement, les fonctions et autres blocs de code isolés doivent commencer à des adresses multiples de 128, pour pouvoir charger un bloc d'instruction en une seule fois. Sans cela, les performances seront sous-optimales.

: Il arrive que le tampon de préchargement ait la même taille qu'une ligne de cache.

Lorsque l'on passe d'un bloc d'instruction à un autre, le tampon de préchargement est mis à jour. Par exemple, si on prend un tampon de préchargement de 4 instructions, on doit changer son contenu toutes les 4 instructions. La seule exception est l'exécution d'un branchement. En effet, lors d'un branchement, la destination du branchement n'est pas dans le tampon de préchargement et elle doit être chargée dedans (sauf si le branchement pointe vers une instruction très proche, ce qui est improbable). Pour cela, le tampon de préchargement est mis à jour précocement quand le processeur détecte un branchement.

Le même problème survient avec du code auto-modifiant. Un code auto-modifiant est un programme qui se modifie lui-même, en remplaçant certaines instructions par d'autres, en en retirant, en en ajoutant, lors de sa propre exécution. De tels programmes sont rares, mais la technique était utilisée dans quelques cas au tout début de l'informatique sur des ordinateurs rudimentaires. Ceux-ci avaient des modes d'adressages tellement limités que gérer des tableaux de taille variable demandait d'utiliser du code auto-modifiant pour écrire des boucles. Le problème survient quand des instructions sont modifiées immédiatement après avoir été préchargées. Les instructions dans le tampon de préchargement sont l'ancienne version, alors que la mémoire RAM contient les instructions modifiées. Gérer ce genre de cas demande de vider le tampon de préchargement si le cas arrive, mais ça ne vaut que très rarement le coup, aussi les ingénieurs ne s’embêtent pas à mettre ce correctif en place. Le code automodifiant est alors buggé.

===La ''prefetch input queue''===

La ''prefetch input queue'' est une sorte de cousine du tampon de préchargement, qui a été utilisée sur les processeurs Intel assez ancien. Elle est apparue sur le 8086 et le 8088, des processeurs respectivement 8 et 16 bits. Elle été présente sur le 286 et le 386, mais était un peu améliorée. Elle est apparue sur ces processeurs à une époque où le processeur devenait plus rapide que la mémoire.

L'idée est là encore de précharger des instructions en avance. Sauf que cette fois-ci, on ne charge pas plusieurs instructions à la fois. Au contraire, les instructions sont préchargées séquentiellement, un octet à la fois. En conséquence, le tampon de préchargement est remplacé par une mémoire FIFO appelée la '''''Prefetch Input Queue''''', terme abrévié en PIQ. Les instructions sont accumulées une par une dans la PIQ, elles en sortent une par une au fur et à mesure pour alimenter le décodeur d'instruction.

L'idée est que pendant que le processeur exécute une instruction, on précharge la suivante. Sans ''prefetch input queue'', le processeur chargeait une instruction, la décodait et l'exécutait, puis chargeait la suivante, et ainsi de suite. Avec la ''prefetch input queue'', pendant qu'une instruction est en cours de décodage/exécution, le processeur précharge l'instruction suivante. Si une instruction prend vraiment beaucoup de temps pour s'exécuter, le processeur peut en profiter pour précharger l'instruction encore suivante, et ainsi de suite, jusqu'à une limite de 4/6 instructions (la limite dépend du processeur).

La ''prefetch input queue'' permet de précharger l'instruction suivante à condition qu'aucun autre accès mémoire n'ait lieu. Si l'instruction en cours d'exécution effectue des accès mémoire, ceux-ci sont prioritaires sur tout le reste, le préchargement de l'instruction suivante est alors mis en pause ou inhibé. Par contre, si la mémoire n'est pas utilisée par l'instruction en cours d'exécution, le processeur lit l'instruction suivante en RAM et la copie dans la ''prefetch input queue''. En conséquence, il arrive que la ''prefetch input queue'' n'ait pas préchargé l'instruction suivante, alors que le décodeur d'instruction est prêt pour la décoder. Dans ce cas, le décodeur doit attendre que l'instruction soit chargée.

Les instructions préchargées dans la ''Prefetch input queue'' y attendent que le processeur les lise et les décode. Les instructions préchargées sont conservées dans leur ordre d'arrivée, afin qu'elles soient exécutées dans le bon ordre, ce qui fait que la ''Prefetch input queue'' est une mémoire de type FIFO. L'étape de décodage pioche l'instruction à décoder dans la ''Prefetch input queue'', cette instruction étant par définition la plus ancienne, puis la retire de la file.

Le premier processeur commercial grand public à utiliser une ''prefetch input queue'' était le 8086. Il pouvait précharger à l'avance 6 octets d’instruction. L'Intel 8088 avait lui aussi une ''Prefetch input queue'', mais qui ne permettait que de précharger 4 instructions. La taille idéale de la FIFO dépend de nombreux paramètres. On pourrait croire que plus elle peut contenir d'instructions, mieux c'est, mais ce n'est pas le cas, pour des raisons que nous allons expliquer dans quelques paragraphes.

[[File:80186 arch.png|centre|vignette|700px|upright=2|Architecture du 8086, du 80186 et de ses variantes.]]

Vous remarquerez que j'ai exprimé la capacité de la ''prefetch input queue'' en octets et non en instructions. La raison est que sur les processeurs x86, les instructions sont de taille variable. Les instructions de ces processeurs ont une taille qui varie entre un octet et 6 octets. 

Le décodage des instructions se faisait un octet à la fois : le décodeur lisait un octet, puis éventuellement le suivant, et ainsi de suite. Pour gérer les instructions de plus deux octets ou plus, le décodeur pouvait lire une instruction en plusieurs fois dans la ''Prefetch input queue''. Pour cela, le décodeur dispose d'une micro-opération pour lire un octet depuis la ''Prefetch input queue''.

Un circuit appelé le ''loader'' synchronisait le décodeur d'instruction et la ''Prefetch input queue''. Il fournissait un bit qui indiquait si le premier octet d'une instruction était disponible dans la ''Prefetch input queue''. Un second bit indiquait si l'octet suivant était disponible, nous verrons pourquoi dans ce qui suit. Le ''loader'' recevait aussi des signaux de la part du décodeur d'instruction, afin de gérer la micro-opération de lecture dans la ''Prefetch input queue''. Le décodeur envoyait le signal ''Run Next Instruction'' pour lire une instruction, qui était alors dépilée de la ''Prefetch input queue''. Le décodeur d'instruction pouvait aussi envoyer un signal ''Next-to-last (NXT)'', un cycle avant que l'instruction en cours ne termine. Le ''loader'' réagissait en préchargeant l'octet suivant. En clair, ce signal permettait de précharger l'instruction suivante avec un cycle d'avance, si celle-ci n'était pas déjà dans la ''Prefetch input queue''.

Le décodeur devait attendre que qu'un moins un octet soit disponible dans la ''Prefetch input queue'', pour le lire. Il lisait alors cet octet et déterminait s'il contenait une instruction complète ou non. Si c'est une instruction complète, il la décodait et l''exécutait, puis envoyait un signal ''Run Next Instruction'' pour commencer le décodage de l'instruction suivante. Sinon, il lit un second octet depuis la ''Prefetch input queue'', le copie dans le registre d'instruction, et relance le décodage. Là encore, le décodeur vérifie s'il a une instruction complète, et lit un troisième octet si besoin, puis rebelote avec un quatrième octet lu, etc.

Le bus de données du 8086 faisait 16 bits, alors que celui du 8088 ne permettait que de lire un octet à la fois. Et cela avait un impact sur la ''prefetch input queue''. La ''prefetch input queue'' était composée de 4 registres de 8 bits, avec un port d'écriture de 8 bits pour précharger les instructions octet par octet, et un port de lecture de 8 bits pour alimenter le décodeur. En clair, tout faisait 8 bits. Le 8086, lui utilisait des registres de 16 bits et un port d'écriture de 16 bits. Sa ''prefetch input queue'' préchargeait les instructions par paquets de 2 octets, non octet par octet, alors que le décodeur consommait les instructions octet par octet. Il s’agissait donc d'une sorte d'intermédiaire entre ''prefetch input queue'' à la 8088 et tampon de préchargement.

Les branchements posent des problèmes avec la ''Prefetch input queue'' : à cause d'eux, on peut charger à l'avance des instructions qui sont zappées par un branchement et ne sont pas censées être exécutées. Si un branchement est chargé, toutes les instructions préchargées après sont potentiellement invalides. Si le branchement est non-pris, les instructions chargées sont valides, elles sont censées s’exécuter. Mais si le branchement est pris, elles ont été chargées à tort et ne doivent pas s’exécuter. 

Pour éviter cela, la ''Prefetch input queue'' est vidée quand le processeur détecte un branchement. Pour cela, le décodeur d'instruction dispose d'une micro-opération qui vide la ''Prefetch input queue'', elle invalide les instructions préchargées.  Cette détection ne peut se faire qu'une fois le branchement décodé, qu'une fois que l'on sait que l'instruction décodée est un branchement. En clair, le décodeur invalide la ''Prefetch input queue'' quand il détecte un branchement. Les interruptions posent le même genre de problèmes. Il faut impérativement vider la ''Prefetch input queue'' quand une interruption survient, avant de la traiter.

Il faut noter qu'une ''Prefetch input queue'' interagit assez mal avec le ''program counter''. En effet, la ''Prefetch input queue'' précharge les instructions séquentiellement. Pour savoir où elle en est rendue, elle mémorise l'adresse de la prochaine instruction à charger dans un '''registre de préchargement''' dédié. Il serait possible d'utiliser un ''program counter'' en plus du registre de préchargement, mais ce n'est pas la solution qui a été utilisée. Les processeurs Intel anciens ont préféré n'utiliser qu'un seul registre de préchargement en remplacement du ''program counter''. Après tout, le registre de préchargement n'est qu'un ''program counter'' ayant pris une avance de quelques cycles d'horloge, qui a été incrémenté en avance.

Et cela ne pose pas de problèmes, sauf avec certains branchements. Par exemple, certains branchements relatifs demandent de connaitre la véritable valeur du ''program counter'', pas celle calculée en avance. Idem avec les instructions d'appel de fonction, qui demandent de sauvegarder l'adresse de retour exacte, donc le vrai ''program counter''. De telles situations demandent de connaitre la valeur réelle du ''program counter'', celle sans préchargement. Pour cela, le décodeur d'instruction dispose d'une instruction pour reconstituer le ''program counter'', à savoir corriger le ''program coutner'' et éliminer l'effet du préchargement.

La micro-opération de correction se contente de soustraire le nombre d'octets préchargés au registre de préchargement. Le nombre d'octets préchargés est déduit à partir des deux pointeurs intégré à la FIFO, qui indiquent la position du premier et du dernier octet préchargé. Le bit qui indique si la FIFO est vide était aussi utilisé. Les deux pointeurs sont lus depuis la FIFO, et sont envoyés à un circuit qui détermine le nombre d'octets préchargés. Sur le 8086, ce circuit était implémenté non pas par un circuit combinatoire, mais par une mémoire ROM équivalente. La petite taille de la FIFO faisait que les pointeurs étaient très petits et la ROM l'était aussi.

Un autre défaut est que la ''Prefetch input queue'' se marie assez mal avec du code auto-modifiant. Un code auto-modifiant est un programme qui se modifie lui-même, en remplaçant certaines instructions par d'autres, en en retirant, en en ajoutant, lors de sa propre exécution. De tels programmes sont rares, mais la technique était utilisée dans quelques cas au tout début de l'informatique sur des ordinateurs rudimentaires. Ceux-ci avaient des modes d'adressages tellement limités que gérer des tableaux de taille variable demandait d'utiliser du code auto-modifiant pour écrire des boucles.

Le problème avec la ''Prefetch input queue'' survient quand des instructions sont modifiées immédiatement après avoir été préchargées. Les instructions dans la ''Prefetch input queue'' sont l'ancienne version, alors que la mémoire RAM contient les instructions modifiées. Gérer ce genre de cas est quelque peu complexe. Il faut en effet vider la ''Prefetch input queue'' si le cas arrive, ce qui demande d'identifier les écritures qui écrasent des instructions préchargées. C'est parfaitement possible, mais demande de transformer la ''Prefetch input queue'' en une mémoire hybride, à la fois mémoire associative et mémoire FIFO. Cela ne vaut que très rarement le coup, aussi les ingénieurs ne s’embêtent pas à mettre ce correctif en place, le code automodifiant est alors buggé.

Le décodeur d'instruction dispose aussi d'une micro-opération qui stoppe le préchargement des instructions dans la ''Prefetch input queue''.

: Pour ceux qui ont déjà lu un cours d'architecture des ordinateurs, la relation entre ''prefetch input queue'' et pipeline est quelque peu complexe. En apparence, la ''prefetch input queue'' permet une certaines forme de pipeline, en chargeant une instruction pendant que la précédente s'exécute. Les problématiques liées aux branchements ressemblent beaucoup à celles de la prédiction de branchement. Cependant, il est possible de dire qu'il s'agit plus d'une technique de préchargement que de pipeline. La différence entre les deux est assez subtile et les frontières sont assez floues, mais le fait est que l'instruction en cours d'exécution et le préchargement peuvent tout deux faire des accès mémoire et que l'instruction en cours a la priorité. Un vrai pipeline se débrouillerait avec une architecture Harvard, non avec un bus mémoire unique pour le chargement des instruction et la lecture/écriture des données.

===Le ''Zero-overhead looping''===

Nous avions vu dans le chapitre sur les instructions machines, qu'il existe des instructions qui permettent de grandement faciliter l'implémentation des boucles. Il s'agit de l'instruction REPEAT, utilisée sur certains processeurs de traitement de signal. Elle répète l'instruction suivante, voire une série d'instructions, un certain nombre de fois. Le nombre de répétitions est mémorisé dans un registre décrémenté à chaque itération de la boucle. Elle permet donc d'implémenter une boucle FOR facilement, sans recourir à des branchements ou des conditions.

Une technique en lien avec cette instruction permet de grandement améliorer les performances et la consommation d'énergie. L'idée est de mémoriser la boucle, les instructions à répéter, dans une petite mémoire cache située entre l'unité de chargement et le séquenceur. Le cache en question s'appelle un '''tampon de boucle''', ou encore un ''hardware loop buffer''. Grâce à lui, il n'y a pas besoin de charger les instructions à chaque fois qu'on les exécute, on les charge une bonne fois pour toute : c'est plus rapide. Bien sûr, il ne fonctionne que pour de petites boucles, mais il en est de même avec l'instruction REPEAT.

&lt;noinclude&gt;
{{NavChapitre | book=Fonctionnement d'un ordinateur
           | prev=Le chemin de données
           | prevText=Le chemin de données
           | next=L'unité de contrôle
           | nextText=L'unité de contrôle
}}
&lt;/noinclude&gt;</text>
      <sha1>3n8r252hcdo8mk1fxwskn1wndyvkyr1</sha1>
    </revision>
    <revision>
      <id>744086</id>
      <parentid>744085</parentid>
      <timestamp>2025-06-03T20:11:35Z</timestamp>
      <contributor>
        <username>Mewtow</username>
        <id>31375</id>
      </contributor>
      <minor />
      <comment>/* La prefetch input queue */</comment>
      <origin>744086</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="46087" sha1="k8w6zf2i1y3g41vvft5knewnvnucdkc" xml:space="preserve">L'unité de contrôle s'occupe du chargement des instructions et de leur interprétation, leur décodage. Elle contient deux circuits : l''''unité de chargement''' qui charge l'instruction depuis la mémoire, et le '''séquenceur''' qui commande le chemin de données. Les deux circuits sont séparés, mais ils communiquent entre eux, notamment pour gérer les branchements. Dans ce chapitre, nous allons nous intéresser au chargement d'une instruction depuis la RAM/ROM, nous verrons l'étape de décodage de l'instruction au prochain chapitre.

==Le chargement d'une instruction==

[[File:Étape de chargement.png|vignette|upright=1|Étape de chargement.]]

L'étape de chargement (ou ''fetch'') doit faire deux choses : mettre à jour le ''program counter'' et lire l'instruction en mémoire RAM ou en ROM. Les deux étapes peuvent être faites en parallèle, dans des circuits séparés. Pendant que l'instruction est lue depuis la mémoire RAM/ROM, le ''program counter'' est incrémenté et/ou altéré par un branchement.

Pour lire l'instruction, on envoie le ''program counter'' sur le bus d'adresse et on récupère l'instruction sur le bus de données pour l'envoyer sur l'entrée du séquenceur. Et cela demande de connecter le séquenceur au bus mémoire, à travers l'interface mémoire. Et sur ce point, la situation est différente selon que l'on parler d'une architecture Harvard ou Von Neumann.

===Les interconnexions entre séquenceur et bus mémoire===

Sur les architectures Harvard, le séquenceur et le chemin de donnée utilisent des interfaces mémoire séparées. Le séquenceur est directement relié au bus mémoire de la ROM, alors que le chemin de données est connecté à la RAM.

[[File:Microarchitecture de l'interface mémoire d'une architecture Harvard.png|centre|vignette|upright=2|Microarchitecture de l'interface mémoire d'une architecture Harvard]]

Mais sur les architectures Von-Neumann et affiliées, le séquenceur et le chemin de donnée partagent la même interface mémoire. Et cela pose deux problèmes.

Le premier problème est que le bus mémoire doit être libéré une fois l'instruction chargée, pour un éventuel accès mémoire. Mais le séquenceur doit conserver une copie de l'instruction chargée, sans quoi il ne peut pas décoder l'instruction correctement. Par exemple, si l'instruction met plusieurs cycles à s'exécuter, le séquenceur doit conserver une copie de l'instruction durant ces plusieurs cycles. La solution à ce problème est un '''registre d'instruction''' situé juste avant le séquenceur, qui mémorise l'instruction chargée.

[[File:Registre d'instruction.png|centre|vignette|upright=2|Registre d'instruction.]]

Le second problème est de gérer le flot des instructions/données entre le bus mémoire, le chemin de données et le séquenceur. Le processeur doit connecter l'interface mémoire soit au séquenceur, soit au chemin de données et cela complique le réseau d'interconnexion interne au processeur.

Une première solution utilise un bus unique qui relie l'interface mémoire, le séquenceur et le chemin de données. Pour charger une instruction, le séquenceur copie le ''program counter'' sur le bus d'adresse, attend que l'instruction lue soit disponible sur le bus de données, puis la copie dans le registre d'instruction. Le bus mémoire est alors libre et peut être utilisé pour lire ou écrire des données, si le besoin s'en fait sentir.

Il faut noter que l'usage d'un bus unique a un impact sur l'organisation interne du chemin de données. Par exemple, le chapitre précédent nous a montré comment implémenter un chemin de données basique, avec des multiplexeurs et démultiplexeurs. Et bien ces chemins de données ne marchent pas vraiment avec un bus interne unique. Il est possible de les adapter, mais au prix d'une complexité largement supérieure. Un bus interne unique marche mieux quand le banc de registre est mono-port. C'est pourquoi il a été utilisé sur d'anciennes architectures appelées des architectures à accumulateur et à pile, que nous verrons dans quelques chapitres, qui utilisaient un banc de registre mono-port.

[[File:Microarchitecture de l'interface mémoire d'une architecture von neumann.png|centre|vignette|upright=2|Microarchitecture de l'interface mémoire d'une architecture von neumann]]

Une autre solution utilise deux bus interne séparés : un connecté au bus d'adresse, l'autre au bus de données. Le ''program counter'' est alors connecté au bus interne d'adresse, le séquenceur est relié au bus interne de données. Notons que la technique marche bien si le ''program counter'' est dans le banc de registre : les interconnexions utilisées pour gérer l'adressage indirect permettent d'envoyer le ''program counter'' sur le bus d'adresse sans ajout de circuit.

Le tout peut être amélioré en remplaçant les deux bus par des multiplexeurs et démultiplexeurs. Le bus d'adresse est précédé par un multiplexeur, qui permet de faire le choix entre ''Program Counter'', adresse venant du chemin de données, ou adresse provenant du séquenceur (adressage absolu). De même, le bus de données est suivi par un démultiplexeur qui envoie la donnée/instruction lue soit au registre d'instruction, soit au chemin de données. Le tout se marie très bien avec les chemins de donnée vu dans le chapitre précédent. Au passage, il faut noter que cette solution nécessite un banc de registre multi-port.

[[File:Connexion du program counter sur les bus avec PC isolé.png|centre|vignette|upright=2|Connexion du program counter sur les bus avec PC isolé]]

===Le chargement des instructions de longueur variable===

Le chargement des instructions de longueur variable pose de nombreux problèmes. Le premier est que mettre à jour le ''program counter'' demande de connaitre la longueur de l'instruction chargée, pour l'ajouter au ''program counter''. Si la longueur d'une instruction est variable, on doit connaitre cette longueur d'une manière où d'une autre. La solution la plus simple indique la longueur de l'instruction dans une partie de l'opcode ou de la représentation en binaire de l'instruction. Mais les processeurs haute performance de nos PC utilisent d'autres solutions, qui n'encodent pas explicitement la taille de l'instruction.

Les processeurs récents utilisent un registre d'instruction de grande taille, capable de mémoriser l'instruction la plus longue du processeur. Par exemple, si un processeur supporte des instructions allant de 1 à 8 octets, comme les CPU x86, le registre d'instruction fera 8 octets. Le décodeur d'instruction vérifie à chaque cycle le contenu du registre d'instruction. Si une instruction est détectée dedans, son décodage commence, peu importe la taille de l'instruction. Une fois l'instruction exécutée, elle est retirée du registre d'instruction. Reste à alimenter le registre d'instruction, à charger des instructions dedans. Et pour cela deux solutions : soit on charge l'instruction en plusieurs fois, soit d'un seul coup.

La solution la plus simple charge les instructions par mots de 8, 16, 32, 64 bits. Ils sont accumulés dans le registre d'instruction jusqu'à détecter une instruction complète. La technique marche nettement mieux si les instructions sont très longues. Par exemple, les CPU x86 ont des instructions qui vont de 1 à 15 octets, ce qui fait qu'ils utilisent cette technique. Précisément, elle marche si les instructions les plus longues sont plus grandes que le bus mémoire.

Une autre solution charge un bloc de mots mémoire aussi grand que la plus grande instruction. Par exemple, si le processeur gère des instructions allant de 1 à 4 octets, il charge 4 octets d'un seul coup dans le registre d'instruction. Il va de soit que cette solution ne marche que si les instructions du processeur sont assez courtes, au plus aussi courtes que le bus mémoire. Ainsi, on est sûr de charger obligatoirement au moins une instruction complète, et peut-être même plusieurs. Le contenu du registre d'instruction est alors découpé en instructions au fil de l'eau. 

Utiliser un registre d'instruction large pose problème avec des instructions à cheval entre deux blocs. Il se peut qu'on n'ait pas une instruction complète lorsque l'on arrive à la fin du bloc, mais seulement un morceau. Le problème se manifeste peu importe que l'instruction soit chargée d'un seul coup ou bien en plusieurs fois.

[[File:Instructions non alignées.png|centre|vignette|upright=2|Instructions non alignées.]]

Dans ce cas, on doit décaler le morceau de bloc pour le mettre au bon endroit (au début du registre d'instruction), et charger le prochain bloc juste à côté. On a donc besoin d'un circuit qui décale tous les bits du registre d'instruction, couplé à un circuit qui décide où placer dans le registre d'instruction ce qui a été chargé, avec quelques circuits autour pour configurer les deux circuits précédents.

[[File:Décaleur d’instruction.png|centre|vignette|upright=2|Décaleur d’instruction.]]

Une autre solution se passe de registre d'instruction en utilisant à la place l'état interne du séquenceur. Là encore, elle charge l'instruction morceau par morceau, typiquement par blocs de 8, 16 ou 32 bits. Les morceaux ne sont pas accumulés dans le registre d'instruction, la solution utilise à la place l'état interne du séquenceur. Les mots mémoire de l'instruction sont chargés à chaque cycle, faisant passer le séquenceur d'un état interne à un autre à chaque mot mémoire. Tant qu'il n'a pas reçu tous les mots mémoire de l'instruction, chaque mot mémoire non terminal le fera passer d'un état interne à un autre, chaque état interne encodant les mots mémoire chargés auparavant. S'il tombe sur le dernier mot mémoire d'une instruction, il rentre dans un état de décodage.

==L'incrémentation du ''program counter''==

À chaque chargement, le ''program counter'' est mis à jour afin de pointer sur la prochaine instruction à charger. Sur la quasi-totalité des processeurs, les instructions sont placées dans l'ordre d’exécution dans la RAM. En faisant ainsi, on peut mettre à jour le ''program counter'' en lui ajoutant la longueur de l'instruction courante. Déterminer la longueur de l'instruction est simple quand les instructions ont toutes la même taille, mais certains processeurs ont des instructions de taille variable, ce qui complique le calcul. Dans ce qui va suivre, nous allons supposer que les instructions sont de taille fixe, ce qui fait que le ''program counter'' est toujours incrémenté de la même valeur.

Il existe deux méthodes principales pour incrémenter le ''program counter'' : soit le ''program counter'' a son propre additionneur, soit le ''program counter'' est mis à jour par l'ALU. Pour ce qui est de l'organisation des registres, soit le ''program counter'' est un registre séparé des autres, soit il est regroupé avec d'autres registres dans un banc de registre. En tout, cela donne quatre organisations possibles.
* Un ''program counter'' séparé relié à un incrémenteur séparé.
* Un ''program counter'' séparé des autres registres, incrémenté par l'ALU.
* Un ''program counter'' intégré au banc de registre, relié à un incrémenteur séparé.
* Un ''program counter'' intégré au banc de registre, incrémenté par l'ALU.

[[File:Calcul du program counter.png|centre|vignette|upright=2|les différentes méthodes de calcul du program counter.]]

Les processeurs haute performance modernes utilisent tous la première méthode. Les autres méthodes étaient surtout utilisées sur les processeurs 8 ou 16 bits, elles sont encore utilisées sur quelques microcontrôleurs de faible puissance. Nous auront l'occasion de donner des exemples quand nous parlerons des processeurs 8 bits anciens, dans le chapitre sur les architectures à accumulateur et affiliées.

===Le ''program counter'' mis à jour par l'ALU===

Sur certains processeurs, le calcul de l'adresse de la prochaine instruction est effectué par l'ALU. L'avantage de cette méthode est qu'elle économise un incrémenteur dédié au ''program counter''. Ce qui explique que cette méthode était utilisée sur les processeurs assez anciens, à une époque où un additionneur pouvait facilement prendre 10 à 20% des transistors disponibles. Le désavantage principal est une augmentation de la complexité du séquenceur, qui doit gérer la mise à jour du ''program counter''. De plus, la mise à jour du ''program counter'' ne peut pas se faire en même temps qu'une opération arithmétique, ce qui réduit les performances.

Si on incrémente le ''program counter'' avec l'ALU, il est intéressant de le placer dans le banc de registres. Un désavantage est qu'on perd un registre. Par exemple, avec un banc de registre de 16 registres, on ne peut adresser que 15 registres généraux. De plus ce n'est pas l'idéal pour le décodage des instructions et pour le séquenceur. Si le processeur dispose de plusieurs bancs de registres, le ''program counter'' est généralement placé dans le banc de registre dédié aux adresses. Sinon, il est placé avec les nombres entiers/adresses.

D'anciens processeurs incrémentaient le ''program counter'' avec l'ALU, mais utilisaient bien un registre séparé pour le ''program counter''. Cette méthode est relativement simple à implémenter : il suffit de connecter/déconnecter le ''program counter'' du bus interne suivant les besoins. Le ''program counter'' est déconnecté pendant l’exécution d'une instruction, il est connecté au bus interne pour l'incrémenter. C'est le séquenceur qui gère le tout. L'avantage de cette séparation est qu'elle est plus facile à gérer pour le séquenceur. De plus, on gagne un registre général/entier dans le banc de registre.

===Le compteur programme===

Dans la quasi-totalité des processeurs modernes, le ''program counter'' est un vulgaire compteur comme on en a vu dans les chapitres sur les circuits, ce qui fait qu'il passe automatiquement d'une adresse à la suivante. Dans ce qui suit, nous allons appeler ce registre compteur : le '''compteur ordinal'''. L'usage d'un compteur simplifie fortement la conception du séquenceur. Le séquenceur n'a pas à gérer la mise à jour du ''program counter'', sauf en cas de branchements. De plus, il est possible d'incrémenter le ''program counter'' pendant que l'unité de calcul effectue une opération arithmétique, ce qui améliore grandement les performances. Le seul désavantage est qu'elle demande d'ajouter un incrémenteur dédié au ''program counter''.

Sur les processeurs très anciens, les instructions faisaient toutes un seul mot mémoire et le compteur ordinal était un circuit incrémenteur des plus basique. Sur les processeurs modernes, le compteur est incrémenté par pas de 4 si les instructions sont codées sur 4 octets, 8 si les instructions sont codées sur 8 octets, etc. Concrètement, le compteur est un circuit incrémenteur auquel on aurait retiré quelques bits de poids faible. Par exemple, si les instructions sont codées sur 4 octets, on coupe les 2 derniers bits du compteur. Si les instructions sont codées sur 8 octets, on coupe les 3 derniers bits du compteur. Et ainsi de suite.

Il a existé quelques processeurs pour lesquelles le ''program counter'' était non pas un compteur binaire classique, mais un ''linear feedback shift register''. L'avantage est que le circuit d'incrémentation utilisait bien moins de portes logiques, l'économie était substantielle. Mais un défaut est que des instructions consécutives dans le programme n'étaient pas consécutives en mémoire. Il existait cependant une table de correspondance pour dire : la première instruction est à telle adresse, la seconde à telle autre, etc. Un exemple de processeur de ce type est le TMS 1000 de Texas Instrument, un des premiers microcontrôleur 4 bits datant des années 70.

Une amélioration de la solution précédente utilise un circuit incrémenteur partagé entre le ''program counter'' et d'autres registres. L'incrémenteur est utilisé pour incrémenter le ''program counter'', mais aussi pour effectuer d'autres calculs d'adresse. Par exemple, sur les architectures avec une pile d'adresse de retour, il est possible de partager l'incrémenteur/décrémenteur avec le pointeur de pile ( la technique ne marche pas avec une pile d'appel). Un autre exemple est celui des processeurs qui gèrent automatiquement le rafraichissement mémoire, grâce à, un compteur intégré dans le processeur. Il est possible de partager l'incrémenteur du ''program counter'' avec le compteur de rafraichissement mémoire, qui mémorise la prochaine adresse mémoire à rafraichir. Nous avions déjà abordé ce genre de partage dans le chapitre sur le chemin de données, dans l'annexe sur le pointeur de pile, mais nous verrons d'autres exemples dans le chapitre sur les architectures hybride accumulateur-registre 8/16 bits.

===Quand est mis à jour le ''program counter'' ?===

Le ''program counter'' est mis à jour quand il faut charger une nouvelle instruction. Reste qu'il faut savoir quand le mettre à jour. Incrémenter le ''program counter'' à intervalle régulier, par exemple à chaque cycle d’horloge, fonctionne sur les processeurs où toutes les instructions mettent le même temps pour s’exécuter. Mais de tels processeurs sont très rares. Sur la quasi-totalité des processeurs, les instructions ont une durée d’exécution variable, elles ne prennent pas le même nombre de cycle d'horloge pour s’exécuter. Le temps d’exécution d'une instruction varie selon l'instruction, certaines sont plus longues que d'autres. Tout cela amène un problème : comment incrémenter le ''program counter'' avec des instructions avec des temps d’exécution variables ?

La réponse est que la mise à jour du ''program counter'' démarre quand l'instruction précédente a terminée de s’exécuter, plus précisément un cycle avant. C'est un cycle avant pour que l'instruction chargée soit disponible au prochain cycle pour le décodeur. Pour cela, le séquenceur doit déterminer quand l'instruction est terminée et prévenir le ''program counter'' au bon moment. Il faut donc une interaction entre séquenceur et circuit de chargement. Le circuit de chargement contient une entrée Enable, qui autorise la mise à jour du ''program counter''. Le séquenceur met à 1 cette entrée pour prévenir au ''program counter'' qu'il doit être incrémenté au cycle suivant ou lors du cycle courant. Cela permet de gérer simplement le cas des instructions multicycles. 

[[File:Commande de la mise à jour du program counter.png|centre|vignette|upright=2|Commande de la mise à jour du program counter.]]

Toute la difficulté est alors reportée dans le séquenceur, qui doit déterminer la durée d'une instruction. Pour gérer la mise à jour du ''program counter'', le séquenceur doit déterminer la durée d'une instruction. Cela est simple pour les instructions arithmétiques et logiques, qui ont un nombre de cycles fixe, toujours le même. Une fois l'instruction identifiée par le séquenceur, il connait son nombre de cycles et peut programmer un compteur interne au séquenceur, qui compte le nombre de cycles de l'instruction, et fournit le signal Enable au ''program counter''. Mais cette technique ne marche pas vraiment pour les accès mémoire, dont la durée n'est pas connue à l'avance, surtout sur les processeurs avec des mémoires caches. Pour cela, le séquenceur détermine quand l'instruction mémoire est finie et prévient le ''program counter'' quand c'est le cas.

Il existe quelques processeurs pour lesquels le temps de calcul dépend des opérandes de l'instruction. On peut par exemple avoir une division qui prend 10 cycles avec certaines opérandes, mais 40 cycles avec d'autres opérandes. Mais ces processeurs sont rares et cela est surtout valable pour les opérations de multiplication/division, guère plus. Le problème est alors le même qu'avec les accès mémoire et la solution est la même : l'ALU prévient le séquenceur quand le résultat est disponible.

==Les branchements et le ''program counter''==

Un branchement consiste juste à écrire l'adresse de destination dans le ''program counter''. L'implémentation des branchements demande d'extraire l'adresse de destination et d'altérer le ''program counter'' quand un branchement est détecté. Pour cela, le décodeur d'instruction détecte si l'instruction exécutée est un branchement ou non, et il en déduit où trouver l'adresse de destination.

L'adresse de destination se trouve à un endroit qui dépend du mode d'adressage du branchement. Pour rappel, on distingue quatre modes d'adressage pour les branchements : direct, indirect, relatif et implicite. Pour les branchements directs, l'adresse est intégrée dans l'instruction de branchement elle-même et est extraite par le séquenceur. Pour les branchements indirects, l'adresse de destination est dans le banc de registre. Pour les branchements relatifs, il faut ajouter un décalage au ''program counter'', décalage extrait de l'instruction par le séquenceur. Enfin, les instructions de retour de fonction lisent l'adresse de destination depuis la pile. L'implémentation de ces quatre types de branchements est très différente.

L'altération du ''program counter'' dépend de si le ''program counter'' est dans un compteur séparé ou s'il est dans le banc de registre. Nous avons vu plus haut qu'il y a quatre cas différents, mais nous n'allons voir que deux cas : celui où le ''program counter'' est dans le banc de registre et est incrémenté par l'unité de calcul, celui avec un ''program counter'' séparé avec son propre incrémenteur. Les deux autres cas ne sont utilisés que sur des architectures à accumulateur ou à pile spécifiques, que nous n'avons pas encore vu à ce stade du cours et que nous verrons en temps voulu dans le chapitre sur ces architectures.

===L’implémentation des branchements avec un ''program counter'' intégré au banc de registres===

Le cas le plus simple est celui où le ''program counter'' est intégré au banc de registre, avec une incrémentation faite par l'unité de calcul. Charger une instruction revient alors à effectuer une instruction LOAD en adressage indirect, à deux différences près : le registre sélectionné est le ''program counter'', l’instruction est copiée dans le registre d'instruction et non dans le banc de registre. L'incrémentation du ''porgram counter'' est implémenté avec des micro-opérations qui agissent sur le chemin de données, au même titre que les branchements indirects, relatifs et directs.
* Les branchements indirects copient un registre dans le ''program counter'', ce qui revient simplement à faire une opération MOV entre deux registres, dont le ''program counter'' est la destination.
* L'opération inverse d'un branchement indirect, qui copie le ''program counter'' dans un registre général, est utile pour sauvegarder l'adresse de retour d'une fonction.
* Les branchements directs copient une adresse dans le ''program counter'', ce qui les rend équivalents à une opération MOV avec une constante immédiate, dont le ''program counter'' est la destination.
* Les branchements relatifs sont une opération arithmétique entre le ''program counter'' et un opérande en adressage immédiat.

En clair, à partir du moment où le chemin de données supporte les instructions MOV et l'addition, avec les modes d'adressage adéquat, il supporte les branchements. Aucune modification du chemin de données n'est nécessaire, le séquenceur gére le chargement d'une instruction avec les micro-instructions adéquates : une micro-opération ADD pour incrémenter le ''program counter'', une micro-opération LOAD pour le chargement de l'instruction.

Notons que sur certaines architectures, le ''program counter'' est adressable au même titre que les autres registres du banc de registre. Les instructions de branchement sont alors remplacées par des instructions MOV ou des instructions arithmétique équivalentes, comme décrit plus haut.

===L’implémentation des branchements avec un ''program counter'' séparé===

Étudions maintenant le cas où le ''program counter'' est dans un registre/compteur séparé. Rappelons que tout compteur digne de ce nom possède une entrée de réinitialisation, qui remet le compteur à zéro. De plus, on peut préciser à quelle valeur il doit être réinitialisé. Ici, la valeur à laquelle on veut réinitialiser le compteur n'est autre que l'adresse de destination du branchement. Implémenter un branchement est donc simple : l'entrée de réinitialisation est commandée par le circuit de détection des branchements, alors que la valeur de réinitialisation est envoyée sur l'entrée adéquate. En clair, nous partons du principe que le ''program counter'' est implémenté avec ce type de compteur :

[[File:Fonctionnement d'un compteur (décompteur), schématique.jpg|centre|vignette|upright=1.5|Fonctionnement d'un compteur (décompteur), schématique]]

Toute la difficulté est de présenter l'adresse de destination au ''program counter''. Pour les branchements directs, l'adresse de destination est fournie par le séquenceur. L'adresse de destination du branchement sort du séquenceur et est présentée au ''program counter'' sur l'entrée adéquate. Voici donc comment sont implémentés les branchements directs avec un ''program counter'' séparé du banc de registres. Le schéma ci-dessous marche peu importe que le ''program counter'' soit incrémenté par l'ALU ou par un additionneur dédié.

[[File:Unité de détection des branchements dans le décodeur.png|centre|vignette|upright=2|Unité de détection des branchements dans le décodeur]]

Les branchements relatifs sont ceux qui font sauter X instructions plus loin dans le programme. Leur implémentation demande d'ajouter une constante au ''program counter'', la constante étant fournie dans l’instruction. Là encore, deux solutions sont possibles : réutiliser l'ALU pour calculer l'adresse, ou utiliser un additionneur séparé. L'additionneur séparé peut être fusionné avec l'additionneur qui incrémente le ''program counter'' pour passer à l’instruction suivante.

[[File:Unité de chargement qui gère les branchements relatifs.png|centre|vignette|upright=2|Unité de chargement qui gère les branchements relatifs.]]

Pour les branchements indirects, il suffit de lire le registre voulu et d'envoyer le tout sur l'entrée adéquate du ''program counter''. Il faut alors rajouter un multiplexeur pour que l'entrée de réinitialisationr ecoive la bonne adresse de destination.

[[File:Unité de chargement qui gère les branchements directs.png|centre|vignette|upright=2|Unité de chargement qui gère les branchements directs et indirects.]]

Toute la difficulté de l'implémentation des branchements est de configurer les multiplexeurs, ce qui est réalisé par le séquenceur en fonction du mode d'adressage du branchement.

==Les optimisations du chargement des instructions==

Charger une instruction est techniquement une forme d'accès mémoire un peu particulier. En clair, charger une instruction prend au minimum un cycle d'horloge, et cela peut rapidement monter à 3-5 cycles, si ce n'est plus. L'exécution des instructions est alors fortement ralentit par la mémoire. Par exemple, imaginez que la mémoire mette 3 cycles d'horloges pour charger une instruction, alors qu'une instruction s’exécute en 1 cycle (si les opérandes sont dans les registres). La perte de performance liée au chargement des instructions est alors substantielle. Heureusement, il est possible de limiter la casse en utilisant des mémoires caches, ainsi que d'autres optimisations, que nous allons voir dans ce qui suit.

===Le tampon de préchargement===

La technique dite du '''préchargement''' est utilisée dans le cas où la mémoire a un temps d'accès important. Mais si la latence de la RAM est un problème, le débit ne l'est pas. Il est possible d'avoir une RAM lente, mais à fort débit. Par exemple, supposons que la mémoire puisse charger 4 instructions (de taille fixe) en 3 cycles. Le processeur peut alors charger 4 instructions en un seul accès mémoire, et les exécuter l'une après l'autre, une par cycle d'horloge. Les temps d'attente sont éliminés : le processeur peut décoder une nouvelle instruction à chaque cycle. Et quand la dernière instruction préchargée est exécutée, la mémoire est de nouveau libre, ce qui masque la latence des accès mémoire.

[[File:Tampon de préchargement d'instruction.png|vignette|Tampon de préchargement d'instruction]]

La seule contrainte est de mettre les instructions préchargées en attente. La solution pour cela est d'utiliser un registre d'instruction très large, capable de mémoriser plusieurs instructions à la fois. Ce registre est de plus connecté à un multiplexeur qui permet de sélectionner l'instruction adéquate dans ce registre. Ce multiplexeur est commandé par le ''program counter'' et quelques circuits annexes. Ce super-registre d'instruction est appelé un '''tampon de préchargement'''.

La méthode a une implémentation nettement plus simple avec des instructions de taille fixe, alignées en mémoire. La commande du multiplexeur de sélection de l'instruction est alors beaucoup plus simple : il suffit d'utiliser les bits de poids fort du ''program counter''. Par exemple, prenons le cas d'un registre d'instruction de 32 octets pour des instructions de 4 octets, soit 8 instructions. Le choix de l'instruction à sélectionner se fait en utilisant les 3 bits de poids faible du ''program counter''. 

Mais cette méthode ajoute de nouvelles contraintes d'alignement, similaires à celles vues dans le chapitre sur l'alignement et le boutisme, sauf que l'alignement porte ici sur des blocs d'instructions de même taille que le tampon de préchargement. Si on prend l'exemple d'un tampon de préchargement de 128 bits, les instructions devront être alignées par blocs de 128 bits. C'est à dire qu'idéalement, les fonctions et autres blocs de code isolés doivent commencer à des adresses multiples de 128, pour pouvoir charger un bloc d'instruction en une seule fois. Sans cela, les performances seront sous-optimales.

: Il arrive que le tampon de préchargement ait la même taille qu'une ligne de cache.

Lorsque l'on passe d'un bloc d'instruction à un autre, le tampon de préchargement est mis à jour. Par exemple, si on prend un tampon de préchargement de 4 instructions, on doit changer son contenu toutes les 4 instructions. La seule exception est l'exécution d'un branchement. En effet, lors d'un branchement, la destination du branchement n'est pas dans le tampon de préchargement et elle doit être chargée dedans (sauf si le branchement pointe vers une instruction très proche, ce qui est improbable). Pour cela, le tampon de préchargement est mis à jour précocement quand le processeur détecte un branchement.

Le même problème survient avec du code auto-modifiant. Un code auto-modifiant est un programme qui se modifie lui-même, en remplaçant certaines instructions par d'autres, en en retirant, en en ajoutant, lors de sa propre exécution. De tels programmes sont rares, mais la technique était utilisée dans quelques cas au tout début de l'informatique sur des ordinateurs rudimentaires. Ceux-ci avaient des modes d'adressages tellement limités que gérer des tableaux de taille variable demandait d'utiliser du code auto-modifiant pour écrire des boucles. Le problème survient quand des instructions sont modifiées immédiatement après avoir été préchargées. Les instructions dans le tampon de préchargement sont l'ancienne version, alors que la mémoire RAM contient les instructions modifiées. Gérer ce genre de cas demande de vider le tampon de préchargement si le cas arrive, mais ça ne vaut que très rarement le coup, aussi les ingénieurs ne s’embêtent pas à mettre ce correctif en place. Le code automodifiant est alors buggé.

===La ''prefetch input queue''===

La ''prefetch input queue'' est une sorte de cousine du tampon de préchargement, qui a été utilisée sur les processeurs Intel assez ancien. Elle est apparue sur le 8086 et le 8088, des processeurs respectivement 8 et 16 bits. Elle été présente sur le 286 et le 386, mais était un peu améliorée. Elle est apparue sur ces processeurs à une époque où le processeur devenait plus rapide que la mémoire.

L'idée est là encore de précharger des instructions en avance. Sauf que cette fois-ci, on ne charge pas plusieurs instructions à la fois. Au contraire, les instructions sont préchargées séquentiellement, un octet à la fois. En conséquence, le tampon de préchargement est remplacé par une mémoire FIFO appelée la '''''Prefetch Input Queue''''', terme abrévié en PIQ. Les instructions sont accumulées une par une dans la PIQ, elles en sortent une par une au fur et à mesure pour alimenter le décodeur d'instruction.

L'idée est que pendant que le processeur exécute une instruction, on précharge la suivante. Sans ''prefetch input queue'', le processeur chargeait une instruction, la décodait et l'exécutait, puis chargeait la suivante, et ainsi de suite. Avec la ''prefetch input queue'', pendant qu'une instruction est en cours de décodage/exécution, le processeur précharge l'instruction suivante. Si une instruction prend vraiment beaucoup de temps pour s'exécuter, le processeur peut en profiter pour précharger l'instruction encore suivante, et ainsi de suite, jusqu'à une limite de 4/6 instructions (la limite dépend du processeur).

La ''prefetch input queue'' permet de précharger l'instruction suivante à condition qu'aucun autre accès mémoire n'ait lieu. Si l'instruction en cours d'exécution effectue des accès mémoire, ceux-ci sont prioritaires sur tout le reste, le préchargement de l'instruction suivante est alors mis en pause ou inhibé. Par contre, si la mémoire n'est pas utilisée par l'instruction en cours d'exécution, le processeur lit l'instruction suivante en RAM et la copie dans la ''prefetch input queue''. En conséquence, il arrive que la ''prefetch input queue'' n'ait pas préchargé l'instruction suivante, alors que le décodeur d'instruction est prêt pour la décoder. Dans ce cas, le décodeur doit attendre que l'instruction soit chargée.

Les instructions préchargées dans la ''Prefetch input queue'' y attendent que le processeur les lise et les décode. Les instructions préchargées sont conservées dans leur ordre d'arrivée, afin qu'elles soient exécutées dans le bon ordre, ce qui fait que la ''Prefetch input queue'' est une mémoire de type FIFO. L'étape de décodage pioche l'instruction à décoder dans la ''Prefetch input queue'', cette instruction étant par définition la plus ancienne, puis la retire de la file.

Le premier processeur commercial grand public à utiliser une ''prefetch input queue'' était le 8086. Il pouvait précharger à l'avance 6 octets d’instruction. L'Intel 8088 avait lui aussi une ''Prefetch input queue'', mais qui ne permettait que de précharger 4 instructions. La taille idéale de la FIFO dépend de nombreux paramètres. On pourrait croire que plus elle peut contenir d'instructions, mieux c'est, mais ce n'est pas le cas, pour des raisons que nous allons expliquer dans quelques paragraphes.

[[File:80186 arch.png|centre|vignette|700px|upright=2|Architecture du 8086, du 80186 et de ses variantes.]]

Vous remarquerez que j'ai exprimé la capacité de la ''prefetch input queue'' en octets et non en instructions. La raison est que sur les processeurs x86, les instructions sont de taille variable, avec une taille qui varie entre un octet et 6 octets. Cependant, le décodage des instructions se fait un octet à la fois : le décodeur lit un octet, puis éventuellement le suivant, et ainsi de suite jusqu'à atteindre la fin de l'instruction. En clair, le décodeur lits les instructions longues octet par octet dans la ''Prefetch input queue''. Pour cela, le décodeur dispose d'une micro-opération pour lire un octet depuis la ''Prefetch input queue''.

Le décodeur devait attendre que qu'un moins un octet soit disponible dans la ''Prefetch input queue'', pour le lire. Il lisait alors cet octet et déterminait s'il contenait une instruction complète ou non. Si c'est une instruction complète, il la décodait et l''exécutait, puis passait à l'instruction suivante. Sinon, il lit un second octet depuis la ''Prefetch input queue'', le copie dans le registre d'instruction, et relance le décodage. Là encore, le décodeur vérifie s'il a une instruction complète, et lit un troisième octet si besoin, puis rebelote avec un quatrième octet lu, etc.

Un circuit appelé le ''loader'' synchronisait le décodeur d'instruction et la ''Prefetch input queue''. Il fournissait un bit qui indiquait si le premier octet d'une instruction était disponible dans la ''Prefetch input queue''. Un second bit indiquait si l'octet suivant était disponible, nous verrons pourquoi dans ce qui suit. Le ''loader'' recevait aussi des signaux de la part du décodeur d'instruction. Le décodeur envoyait le signal ''Run Next Instruction'' pour lire une instruction, qui était alors dépilée de la ''Prefetch input queue''. Le décodeur d'instruction pouvait aussi envoyer un signal ''Next-to-last (NXT)'', un cycle avant que l'instruction en cours ne termine. Le ''loader'' réagissait en préchargeant l'octet suivant. En clair, ce signal permettait de précharger l'instruction suivante avec un cycle d'avance, si celle-ci n'était pas déjà dans la ''Prefetch input queue''.

Le bus de données du 8086 faisait 16 bits, alors que celui du 8088 ne permettait que de lire un octet à la fois. Et cela avait un impact sur la ''prefetch input queue''. La ''prefetch input queue'' était composée de 4 registres de 8 bits, avec un port d'écriture de 8 bits pour précharger les instructions octet par octet, et un port de lecture de 8 bits pour alimenter le décodeur. En clair, tout faisait 8 bits. Le 8086, lui utilisait des registres de 16 bits et un port d'écriture de 16 bits. Sa ''prefetch input queue'' préchargeait les instructions par paquets de 2 octets, non octet par octet, alors que le décodeur consommait les instructions octet par octet. Il s’agissait donc d'une sorte d'intermédiaire entre ''prefetch input queue'' à la 8088 et tampon de préchargement.

Les branchements posent des problèmes avec la ''Prefetch input queue'' : à cause d'eux, on peut charger à l'avance des instructions qui sont zappées par un branchement et ne sont pas censées être exécutées. Si un branchement est chargé, toutes les instructions préchargées après sont potentiellement invalides. Si le branchement est non-pris, les instructions chargées sont valides, elles sont censées s’exécuter. Mais si le branchement est pris, elles ont été chargées à tort et ne doivent pas s’exécuter. 

Pour éviter cela, la ''Prefetch input queue'' est vidée quand le processeur détecte un branchement. Pour cela, le décodeur d'instruction dispose d'une micro-opération qui vide la ''Prefetch input queue'', elle invalide les instructions préchargées.  Cette détection ne peut se faire qu'une fois le branchement décodé, qu'une fois que l'on sait que l'instruction décodée est un branchement. En clair, le décodeur invalide la ''Prefetch input queue'' quand il détecte un branchement. Les interruptions posent le même genre de problèmes. Il faut impérativement vider la ''Prefetch input queue'' quand une interruption survient, avant de la traiter.

Il faut noter qu'une ''Prefetch input queue'' interagit assez mal avec le ''program counter''. En effet, la ''Prefetch input queue'' précharge les instructions séquentiellement. Pour savoir où elle en est rendue, elle mémorise l'adresse de la prochaine instruction à charger dans un '''registre de préchargement''' dédié. Il serait possible d'utiliser un ''program counter'' en plus du registre de préchargement, mais ce n'est pas la solution qui a été utilisée. Les processeurs Intel anciens ont préféré n'utiliser qu'un seul registre de préchargement en remplacement du ''program counter''. Après tout, le registre de préchargement n'est qu'un ''program counter'' ayant pris une avance de quelques cycles d'horloge, qui a été incrémenté en avance.

Et cela ne pose pas de problèmes, sauf avec certains branchements. Par exemple, certains branchements relatifs demandent de connaitre la véritable valeur du ''program counter'', pas celle calculée en avance. Idem avec les instructions d'appel de fonction, qui demandent de sauvegarder l'adresse de retour exacte, donc le vrai ''program counter''. De telles situations demandent de connaitre la valeur réelle du ''program counter'', celle sans préchargement. Pour cela, le décodeur d'instruction dispose d'une instruction pour reconstituer le ''program counter'', à savoir corriger le ''program coutner'' et éliminer l'effet du préchargement.

La micro-opération de correction se contente de soustraire le nombre d'octets préchargés au registre de préchargement. Le nombre d'octets préchargés est déduit à partir des deux pointeurs intégré à la FIFO, qui indiquent la position du premier et du dernier octet préchargé. Le bit qui indique si la FIFO est vide était aussi utilisé. Les deux pointeurs sont lus depuis la FIFO, et sont envoyés à un circuit qui détermine le nombre d'octets préchargés. Sur le 8086, ce circuit était implémenté non pas par un circuit combinatoire, mais par une mémoire ROM équivalente. La petite taille de la FIFO faisait que les pointeurs étaient très petits et la ROM l'était aussi.

Un autre défaut est que la ''Prefetch input queue'' se marie assez mal avec du code auto-modifiant. Un code auto-modifiant est un programme qui se modifie lui-même, en remplaçant certaines instructions par d'autres, en en retirant, en en ajoutant, lors de sa propre exécution. De tels programmes sont rares, mais la technique était utilisée dans quelques cas au tout début de l'informatique sur des ordinateurs rudimentaires. Ceux-ci avaient des modes d'adressages tellement limités que gérer des tableaux de taille variable demandait d'utiliser du code auto-modifiant pour écrire des boucles.

Le problème avec la ''Prefetch input queue'' survient quand des instructions sont modifiées immédiatement après avoir été préchargées. Les instructions dans la ''Prefetch input queue'' sont l'ancienne version, alors que la mémoire RAM contient les instructions modifiées. Gérer ce genre de cas est quelque peu complexe. Il faut en effet vider la ''Prefetch input queue'' si le cas arrive, ce qui demande d'identifier les écritures qui écrasent des instructions préchargées. C'est parfaitement possible, mais demande de transformer la ''Prefetch input queue'' en une mémoire hybride, à la fois mémoire associative et mémoire FIFO. Cela ne vaut que très rarement le coup, aussi les ingénieurs ne s’embêtent pas à mettre ce correctif en place, le code automodifiant est alors buggé.

Le décodeur d'instruction dispose aussi d'une micro-opération qui stoppe le préchargement des instructions dans la ''Prefetch input queue''.

: Pour ceux qui ont déjà lu un cours d'architecture des ordinateurs, la relation entre ''prefetch input queue'' et pipeline est quelque peu complexe. En apparence, la ''prefetch input queue'' permet une certaines forme de pipeline, en chargeant une instruction pendant que la précédente s'exécute. Les problématiques liées aux branchements ressemblent beaucoup à celles de la prédiction de branchement. Cependant, il est possible de dire qu'il s'agit plus d'une technique de préchargement que de pipeline. La différence entre les deux est assez subtile et les frontières sont assez floues, mais le fait est que l'instruction en cours d'exécution et le préchargement peuvent tout deux faire des accès mémoire et que l'instruction en cours a la priorité. Un vrai pipeline se débrouillerait avec une architecture Harvard, non avec un bus mémoire unique pour le chargement des instruction et la lecture/écriture des données.

===Le ''Zero-overhead looping''===

Nous avions vu dans le chapitre sur les instructions machines, qu'il existe des instructions qui permettent de grandement faciliter l'implémentation des boucles. Il s'agit de l'instruction REPEAT, utilisée sur certains processeurs de traitement de signal. Elle répète l'instruction suivante, voire une série d'instructions, un certain nombre de fois. Le nombre de répétitions est mémorisé dans un registre décrémenté à chaque itération de la boucle. Elle permet donc d'implémenter une boucle FOR facilement, sans recourir à des branchements ou des conditions.

Une technique en lien avec cette instruction permet de grandement améliorer les performances et la consommation d'énergie. L'idée est de mémoriser la boucle, les instructions à répéter, dans une petite mémoire cache située entre l'unité de chargement et le séquenceur. Le cache en question s'appelle un '''tampon de boucle''', ou encore un ''hardware loop buffer''. Grâce à lui, il n'y a pas besoin de charger les instructions à chaque fois qu'on les exécute, on les charge une bonne fois pour toute : c'est plus rapide. Bien sûr, il ne fonctionne que pour de petites boucles, mais il en est de même avec l'instruction REPEAT.

&lt;noinclude&gt;
{{NavChapitre | book=Fonctionnement d'un ordinateur
           | prev=Le chemin de données
           | prevText=Le chemin de données
           | next=L'unité de contrôle
           | nextText=L'unité de contrôle
}}
&lt;/noinclude&gt;</text>
      <sha1>k8w6zf2i1y3g41vvft5knewnvnucdkc</sha1>
    </revision>
    <revision>
      <id>744087</id>
      <parentid>744086</parentid>
      <timestamp>2025-06-03T20:12:31Z</timestamp>
      <contributor>
        <username>Mewtow</username>
        <id>31375</id>
      </contributor>
      <minor />
      <comment>/* La prefetch input queue */</comment>
      <origin>744087</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="46220" sha1="btix6ekccls2l2glnwwiv883dacktsf" xml:space="preserve">L'unité de contrôle s'occupe du chargement des instructions et de leur interprétation, leur décodage. Elle contient deux circuits : l''''unité de chargement''' qui charge l'instruction depuis la mémoire, et le '''séquenceur''' qui commande le chemin de données. Les deux circuits sont séparés, mais ils communiquent entre eux, notamment pour gérer les branchements. Dans ce chapitre, nous allons nous intéresser au chargement d'une instruction depuis la RAM/ROM, nous verrons l'étape de décodage de l'instruction au prochain chapitre.

==Le chargement d'une instruction==

[[File:Étape de chargement.png|vignette|upright=1|Étape de chargement.]]

L'étape de chargement (ou ''fetch'') doit faire deux choses : mettre à jour le ''program counter'' et lire l'instruction en mémoire RAM ou en ROM. Les deux étapes peuvent être faites en parallèle, dans des circuits séparés. Pendant que l'instruction est lue depuis la mémoire RAM/ROM, le ''program counter'' est incrémenté et/ou altéré par un branchement.

Pour lire l'instruction, on envoie le ''program counter'' sur le bus d'adresse et on récupère l'instruction sur le bus de données pour l'envoyer sur l'entrée du séquenceur. Et cela demande de connecter le séquenceur au bus mémoire, à travers l'interface mémoire. Et sur ce point, la situation est différente selon que l'on parler d'une architecture Harvard ou Von Neumann.

===Les interconnexions entre séquenceur et bus mémoire===

Sur les architectures Harvard, le séquenceur et le chemin de donnée utilisent des interfaces mémoire séparées. Le séquenceur est directement relié au bus mémoire de la ROM, alors que le chemin de données est connecté à la RAM.

[[File:Microarchitecture de l'interface mémoire d'une architecture Harvard.png|centre|vignette|upright=2|Microarchitecture de l'interface mémoire d'une architecture Harvard]]

Mais sur les architectures Von-Neumann et affiliées, le séquenceur et le chemin de donnée partagent la même interface mémoire. Et cela pose deux problèmes.

Le premier problème est que le bus mémoire doit être libéré une fois l'instruction chargée, pour un éventuel accès mémoire. Mais le séquenceur doit conserver une copie de l'instruction chargée, sans quoi il ne peut pas décoder l'instruction correctement. Par exemple, si l'instruction met plusieurs cycles à s'exécuter, le séquenceur doit conserver une copie de l'instruction durant ces plusieurs cycles. La solution à ce problème est un '''registre d'instruction''' situé juste avant le séquenceur, qui mémorise l'instruction chargée.

[[File:Registre d'instruction.png|centre|vignette|upright=2|Registre d'instruction.]]

Le second problème est de gérer le flot des instructions/données entre le bus mémoire, le chemin de données et le séquenceur. Le processeur doit connecter l'interface mémoire soit au séquenceur, soit au chemin de données et cela complique le réseau d'interconnexion interne au processeur.

Une première solution utilise un bus unique qui relie l'interface mémoire, le séquenceur et le chemin de données. Pour charger une instruction, le séquenceur copie le ''program counter'' sur le bus d'adresse, attend que l'instruction lue soit disponible sur le bus de données, puis la copie dans le registre d'instruction. Le bus mémoire est alors libre et peut être utilisé pour lire ou écrire des données, si le besoin s'en fait sentir.

Il faut noter que l'usage d'un bus unique a un impact sur l'organisation interne du chemin de données. Par exemple, le chapitre précédent nous a montré comment implémenter un chemin de données basique, avec des multiplexeurs et démultiplexeurs. Et bien ces chemins de données ne marchent pas vraiment avec un bus interne unique. Il est possible de les adapter, mais au prix d'une complexité largement supérieure. Un bus interne unique marche mieux quand le banc de registre est mono-port. C'est pourquoi il a été utilisé sur d'anciennes architectures appelées des architectures à accumulateur et à pile, que nous verrons dans quelques chapitres, qui utilisaient un banc de registre mono-port.

[[File:Microarchitecture de l'interface mémoire d'une architecture von neumann.png|centre|vignette|upright=2|Microarchitecture de l'interface mémoire d'une architecture von neumann]]

Une autre solution utilise deux bus interne séparés : un connecté au bus d'adresse, l'autre au bus de données. Le ''program counter'' est alors connecté au bus interne d'adresse, le séquenceur est relié au bus interne de données. Notons que la technique marche bien si le ''program counter'' est dans le banc de registre : les interconnexions utilisées pour gérer l'adressage indirect permettent d'envoyer le ''program counter'' sur le bus d'adresse sans ajout de circuit.

Le tout peut être amélioré en remplaçant les deux bus par des multiplexeurs et démultiplexeurs. Le bus d'adresse est précédé par un multiplexeur, qui permet de faire le choix entre ''Program Counter'', adresse venant du chemin de données, ou adresse provenant du séquenceur (adressage absolu). De même, le bus de données est suivi par un démultiplexeur qui envoie la donnée/instruction lue soit au registre d'instruction, soit au chemin de données. Le tout se marie très bien avec les chemins de donnée vu dans le chapitre précédent. Au passage, il faut noter que cette solution nécessite un banc de registre multi-port.

[[File:Connexion du program counter sur les bus avec PC isolé.png|centre|vignette|upright=2|Connexion du program counter sur les bus avec PC isolé]]

===Le chargement des instructions de longueur variable===

Le chargement des instructions de longueur variable pose de nombreux problèmes. Le premier est que mettre à jour le ''program counter'' demande de connaitre la longueur de l'instruction chargée, pour l'ajouter au ''program counter''. Si la longueur d'une instruction est variable, on doit connaitre cette longueur d'une manière où d'une autre. La solution la plus simple indique la longueur de l'instruction dans une partie de l'opcode ou de la représentation en binaire de l'instruction. Mais les processeurs haute performance de nos PC utilisent d'autres solutions, qui n'encodent pas explicitement la taille de l'instruction.

Les processeurs récents utilisent un registre d'instruction de grande taille, capable de mémoriser l'instruction la plus longue du processeur. Par exemple, si un processeur supporte des instructions allant de 1 à 8 octets, comme les CPU x86, le registre d'instruction fera 8 octets. Le décodeur d'instruction vérifie à chaque cycle le contenu du registre d'instruction. Si une instruction est détectée dedans, son décodage commence, peu importe la taille de l'instruction. Une fois l'instruction exécutée, elle est retirée du registre d'instruction. Reste à alimenter le registre d'instruction, à charger des instructions dedans. Et pour cela deux solutions : soit on charge l'instruction en plusieurs fois, soit d'un seul coup.

La solution la plus simple charge les instructions par mots de 8, 16, 32, 64 bits. Ils sont accumulés dans le registre d'instruction jusqu'à détecter une instruction complète. La technique marche nettement mieux si les instructions sont très longues. Par exemple, les CPU x86 ont des instructions qui vont de 1 à 15 octets, ce qui fait qu'ils utilisent cette technique. Précisément, elle marche si les instructions les plus longues sont plus grandes que le bus mémoire.

Une autre solution charge un bloc de mots mémoire aussi grand que la plus grande instruction. Par exemple, si le processeur gère des instructions allant de 1 à 4 octets, il charge 4 octets d'un seul coup dans le registre d'instruction. Il va de soit que cette solution ne marche que si les instructions du processeur sont assez courtes, au plus aussi courtes que le bus mémoire. Ainsi, on est sûr de charger obligatoirement au moins une instruction complète, et peut-être même plusieurs. Le contenu du registre d'instruction est alors découpé en instructions au fil de l'eau. 

Utiliser un registre d'instruction large pose problème avec des instructions à cheval entre deux blocs. Il se peut qu'on n'ait pas une instruction complète lorsque l'on arrive à la fin du bloc, mais seulement un morceau. Le problème se manifeste peu importe que l'instruction soit chargée d'un seul coup ou bien en plusieurs fois.

[[File:Instructions non alignées.png|centre|vignette|upright=2|Instructions non alignées.]]

Dans ce cas, on doit décaler le morceau de bloc pour le mettre au bon endroit (au début du registre d'instruction), et charger le prochain bloc juste à côté. On a donc besoin d'un circuit qui décale tous les bits du registre d'instruction, couplé à un circuit qui décide où placer dans le registre d'instruction ce qui a été chargé, avec quelques circuits autour pour configurer les deux circuits précédents.

[[File:Décaleur d’instruction.png|centre|vignette|upright=2|Décaleur d’instruction.]]

Une autre solution se passe de registre d'instruction en utilisant à la place l'état interne du séquenceur. Là encore, elle charge l'instruction morceau par morceau, typiquement par blocs de 8, 16 ou 32 bits. Les morceaux ne sont pas accumulés dans le registre d'instruction, la solution utilise à la place l'état interne du séquenceur. Les mots mémoire de l'instruction sont chargés à chaque cycle, faisant passer le séquenceur d'un état interne à un autre à chaque mot mémoire. Tant qu'il n'a pas reçu tous les mots mémoire de l'instruction, chaque mot mémoire non terminal le fera passer d'un état interne à un autre, chaque état interne encodant les mots mémoire chargés auparavant. S'il tombe sur le dernier mot mémoire d'une instruction, il rentre dans un état de décodage.

==L'incrémentation du ''program counter''==

À chaque chargement, le ''program counter'' est mis à jour afin de pointer sur la prochaine instruction à charger. Sur la quasi-totalité des processeurs, les instructions sont placées dans l'ordre d’exécution dans la RAM. En faisant ainsi, on peut mettre à jour le ''program counter'' en lui ajoutant la longueur de l'instruction courante. Déterminer la longueur de l'instruction est simple quand les instructions ont toutes la même taille, mais certains processeurs ont des instructions de taille variable, ce qui complique le calcul. Dans ce qui va suivre, nous allons supposer que les instructions sont de taille fixe, ce qui fait que le ''program counter'' est toujours incrémenté de la même valeur.

Il existe deux méthodes principales pour incrémenter le ''program counter'' : soit le ''program counter'' a son propre additionneur, soit le ''program counter'' est mis à jour par l'ALU. Pour ce qui est de l'organisation des registres, soit le ''program counter'' est un registre séparé des autres, soit il est regroupé avec d'autres registres dans un banc de registre. En tout, cela donne quatre organisations possibles.
* Un ''program counter'' séparé relié à un incrémenteur séparé.
* Un ''program counter'' séparé des autres registres, incrémenté par l'ALU.
* Un ''program counter'' intégré au banc de registre, relié à un incrémenteur séparé.
* Un ''program counter'' intégré au banc de registre, incrémenté par l'ALU.

[[File:Calcul du program counter.png|centre|vignette|upright=2|les différentes méthodes de calcul du program counter.]]

Les processeurs haute performance modernes utilisent tous la première méthode. Les autres méthodes étaient surtout utilisées sur les processeurs 8 ou 16 bits, elles sont encore utilisées sur quelques microcontrôleurs de faible puissance. Nous auront l'occasion de donner des exemples quand nous parlerons des processeurs 8 bits anciens, dans le chapitre sur les architectures à accumulateur et affiliées.

===Le ''program counter'' mis à jour par l'ALU===

Sur certains processeurs, le calcul de l'adresse de la prochaine instruction est effectué par l'ALU. L'avantage de cette méthode est qu'elle économise un incrémenteur dédié au ''program counter''. Ce qui explique que cette méthode était utilisée sur les processeurs assez anciens, à une époque où un additionneur pouvait facilement prendre 10 à 20% des transistors disponibles. Le désavantage principal est une augmentation de la complexité du séquenceur, qui doit gérer la mise à jour du ''program counter''. De plus, la mise à jour du ''program counter'' ne peut pas se faire en même temps qu'une opération arithmétique, ce qui réduit les performances.

Si on incrémente le ''program counter'' avec l'ALU, il est intéressant de le placer dans le banc de registres. Un désavantage est qu'on perd un registre. Par exemple, avec un banc de registre de 16 registres, on ne peut adresser que 15 registres généraux. De plus ce n'est pas l'idéal pour le décodage des instructions et pour le séquenceur. Si le processeur dispose de plusieurs bancs de registres, le ''program counter'' est généralement placé dans le banc de registre dédié aux adresses. Sinon, il est placé avec les nombres entiers/adresses.

D'anciens processeurs incrémentaient le ''program counter'' avec l'ALU, mais utilisaient bien un registre séparé pour le ''program counter''. Cette méthode est relativement simple à implémenter : il suffit de connecter/déconnecter le ''program counter'' du bus interne suivant les besoins. Le ''program counter'' est déconnecté pendant l’exécution d'une instruction, il est connecté au bus interne pour l'incrémenter. C'est le séquenceur qui gère le tout. L'avantage de cette séparation est qu'elle est plus facile à gérer pour le séquenceur. De plus, on gagne un registre général/entier dans le banc de registre.

===Le compteur programme===

Dans la quasi-totalité des processeurs modernes, le ''program counter'' est un vulgaire compteur comme on en a vu dans les chapitres sur les circuits, ce qui fait qu'il passe automatiquement d'une adresse à la suivante. Dans ce qui suit, nous allons appeler ce registre compteur : le '''compteur ordinal'''. L'usage d'un compteur simplifie fortement la conception du séquenceur. Le séquenceur n'a pas à gérer la mise à jour du ''program counter'', sauf en cas de branchements. De plus, il est possible d'incrémenter le ''program counter'' pendant que l'unité de calcul effectue une opération arithmétique, ce qui améliore grandement les performances. Le seul désavantage est qu'elle demande d'ajouter un incrémenteur dédié au ''program counter''.

Sur les processeurs très anciens, les instructions faisaient toutes un seul mot mémoire et le compteur ordinal était un circuit incrémenteur des plus basique. Sur les processeurs modernes, le compteur est incrémenté par pas de 4 si les instructions sont codées sur 4 octets, 8 si les instructions sont codées sur 8 octets, etc. Concrètement, le compteur est un circuit incrémenteur auquel on aurait retiré quelques bits de poids faible. Par exemple, si les instructions sont codées sur 4 octets, on coupe les 2 derniers bits du compteur. Si les instructions sont codées sur 8 octets, on coupe les 3 derniers bits du compteur. Et ainsi de suite.

Il a existé quelques processeurs pour lesquelles le ''program counter'' était non pas un compteur binaire classique, mais un ''linear feedback shift register''. L'avantage est que le circuit d'incrémentation utilisait bien moins de portes logiques, l'économie était substantielle. Mais un défaut est que des instructions consécutives dans le programme n'étaient pas consécutives en mémoire. Il existait cependant une table de correspondance pour dire : la première instruction est à telle adresse, la seconde à telle autre, etc. Un exemple de processeur de ce type est le TMS 1000 de Texas Instrument, un des premiers microcontrôleur 4 bits datant des années 70.

Une amélioration de la solution précédente utilise un circuit incrémenteur partagé entre le ''program counter'' et d'autres registres. L'incrémenteur est utilisé pour incrémenter le ''program counter'', mais aussi pour effectuer d'autres calculs d'adresse. Par exemple, sur les architectures avec une pile d'adresse de retour, il est possible de partager l'incrémenteur/décrémenteur avec le pointeur de pile ( la technique ne marche pas avec une pile d'appel). Un autre exemple est celui des processeurs qui gèrent automatiquement le rafraichissement mémoire, grâce à, un compteur intégré dans le processeur. Il est possible de partager l'incrémenteur du ''program counter'' avec le compteur de rafraichissement mémoire, qui mémorise la prochaine adresse mémoire à rafraichir. Nous avions déjà abordé ce genre de partage dans le chapitre sur le chemin de données, dans l'annexe sur le pointeur de pile, mais nous verrons d'autres exemples dans le chapitre sur les architectures hybride accumulateur-registre 8/16 bits.

===Quand est mis à jour le ''program counter'' ?===

Le ''program counter'' est mis à jour quand il faut charger une nouvelle instruction. Reste qu'il faut savoir quand le mettre à jour. Incrémenter le ''program counter'' à intervalle régulier, par exemple à chaque cycle d’horloge, fonctionne sur les processeurs où toutes les instructions mettent le même temps pour s’exécuter. Mais de tels processeurs sont très rares. Sur la quasi-totalité des processeurs, les instructions ont une durée d’exécution variable, elles ne prennent pas le même nombre de cycle d'horloge pour s’exécuter. Le temps d’exécution d'une instruction varie selon l'instruction, certaines sont plus longues que d'autres. Tout cela amène un problème : comment incrémenter le ''program counter'' avec des instructions avec des temps d’exécution variables ?

La réponse est que la mise à jour du ''program counter'' démarre quand l'instruction précédente a terminée de s’exécuter, plus précisément un cycle avant. C'est un cycle avant pour que l'instruction chargée soit disponible au prochain cycle pour le décodeur. Pour cela, le séquenceur doit déterminer quand l'instruction est terminée et prévenir le ''program counter'' au bon moment. Il faut donc une interaction entre séquenceur et circuit de chargement. Le circuit de chargement contient une entrée Enable, qui autorise la mise à jour du ''program counter''. Le séquenceur met à 1 cette entrée pour prévenir au ''program counter'' qu'il doit être incrémenté au cycle suivant ou lors du cycle courant. Cela permet de gérer simplement le cas des instructions multicycles. 

[[File:Commande de la mise à jour du program counter.png|centre|vignette|upright=2|Commande de la mise à jour du program counter.]]

Toute la difficulté est alors reportée dans le séquenceur, qui doit déterminer la durée d'une instruction. Pour gérer la mise à jour du ''program counter'', le séquenceur doit déterminer la durée d'une instruction. Cela est simple pour les instructions arithmétiques et logiques, qui ont un nombre de cycles fixe, toujours le même. Une fois l'instruction identifiée par le séquenceur, il connait son nombre de cycles et peut programmer un compteur interne au séquenceur, qui compte le nombre de cycles de l'instruction, et fournit le signal Enable au ''program counter''. Mais cette technique ne marche pas vraiment pour les accès mémoire, dont la durée n'est pas connue à l'avance, surtout sur les processeurs avec des mémoires caches. Pour cela, le séquenceur détermine quand l'instruction mémoire est finie et prévient le ''program counter'' quand c'est le cas.

Il existe quelques processeurs pour lesquels le temps de calcul dépend des opérandes de l'instruction. On peut par exemple avoir une division qui prend 10 cycles avec certaines opérandes, mais 40 cycles avec d'autres opérandes. Mais ces processeurs sont rares et cela est surtout valable pour les opérations de multiplication/division, guère plus. Le problème est alors le même qu'avec les accès mémoire et la solution est la même : l'ALU prévient le séquenceur quand le résultat est disponible.

==Les branchements et le ''program counter''==

Un branchement consiste juste à écrire l'adresse de destination dans le ''program counter''. L'implémentation des branchements demande d'extraire l'adresse de destination et d'altérer le ''program counter'' quand un branchement est détecté. Pour cela, le décodeur d'instruction détecte si l'instruction exécutée est un branchement ou non, et il en déduit où trouver l'adresse de destination.

L'adresse de destination se trouve à un endroit qui dépend du mode d'adressage du branchement. Pour rappel, on distingue quatre modes d'adressage pour les branchements : direct, indirect, relatif et implicite. Pour les branchements directs, l'adresse est intégrée dans l'instruction de branchement elle-même et est extraite par le séquenceur. Pour les branchements indirects, l'adresse de destination est dans le banc de registre. Pour les branchements relatifs, il faut ajouter un décalage au ''program counter'', décalage extrait de l'instruction par le séquenceur. Enfin, les instructions de retour de fonction lisent l'adresse de destination depuis la pile. L'implémentation de ces quatre types de branchements est très différente.

L'altération du ''program counter'' dépend de si le ''program counter'' est dans un compteur séparé ou s'il est dans le banc de registre. Nous avons vu plus haut qu'il y a quatre cas différents, mais nous n'allons voir que deux cas : celui où le ''program counter'' est dans le banc de registre et est incrémenté par l'unité de calcul, celui avec un ''program counter'' séparé avec son propre incrémenteur. Les deux autres cas ne sont utilisés que sur des architectures à accumulateur ou à pile spécifiques, que nous n'avons pas encore vu à ce stade du cours et que nous verrons en temps voulu dans le chapitre sur ces architectures.

===L’implémentation des branchements avec un ''program counter'' intégré au banc de registres===

Le cas le plus simple est celui où le ''program counter'' est intégré au banc de registre, avec une incrémentation faite par l'unité de calcul. Charger une instruction revient alors à effectuer une instruction LOAD en adressage indirect, à deux différences près : le registre sélectionné est le ''program counter'', l’instruction est copiée dans le registre d'instruction et non dans le banc de registre. L'incrémentation du ''porgram counter'' est implémenté avec des micro-opérations qui agissent sur le chemin de données, au même titre que les branchements indirects, relatifs et directs.
* Les branchements indirects copient un registre dans le ''program counter'', ce qui revient simplement à faire une opération MOV entre deux registres, dont le ''program counter'' est la destination.
* L'opération inverse d'un branchement indirect, qui copie le ''program counter'' dans un registre général, est utile pour sauvegarder l'adresse de retour d'une fonction.
* Les branchements directs copient une adresse dans le ''program counter'', ce qui les rend équivalents à une opération MOV avec une constante immédiate, dont le ''program counter'' est la destination.
* Les branchements relatifs sont une opération arithmétique entre le ''program counter'' et un opérande en adressage immédiat.

En clair, à partir du moment où le chemin de données supporte les instructions MOV et l'addition, avec les modes d'adressage adéquat, il supporte les branchements. Aucune modification du chemin de données n'est nécessaire, le séquenceur gére le chargement d'une instruction avec les micro-instructions adéquates : une micro-opération ADD pour incrémenter le ''program counter'', une micro-opération LOAD pour le chargement de l'instruction.

Notons que sur certaines architectures, le ''program counter'' est adressable au même titre que les autres registres du banc de registre. Les instructions de branchement sont alors remplacées par des instructions MOV ou des instructions arithmétique équivalentes, comme décrit plus haut.

===L’implémentation des branchements avec un ''program counter'' séparé===

Étudions maintenant le cas où le ''program counter'' est dans un registre/compteur séparé. Rappelons que tout compteur digne de ce nom possède une entrée de réinitialisation, qui remet le compteur à zéro. De plus, on peut préciser à quelle valeur il doit être réinitialisé. Ici, la valeur à laquelle on veut réinitialiser le compteur n'est autre que l'adresse de destination du branchement. Implémenter un branchement est donc simple : l'entrée de réinitialisation est commandée par le circuit de détection des branchements, alors que la valeur de réinitialisation est envoyée sur l'entrée adéquate. En clair, nous partons du principe que le ''program counter'' est implémenté avec ce type de compteur :

[[File:Fonctionnement d'un compteur (décompteur), schématique.jpg|centre|vignette|upright=1.5|Fonctionnement d'un compteur (décompteur), schématique]]

Toute la difficulté est de présenter l'adresse de destination au ''program counter''. Pour les branchements directs, l'adresse de destination est fournie par le séquenceur. L'adresse de destination du branchement sort du séquenceur et est présentée au ''program counter'' sur l'entrée adéquate. Voici donc comment sont implémentés les branchements directs avec un ''program counter'' séparé du banc de registres. Le schéma ci-dessous marche peu importe que le ''program counter'' soit incrémenté par l'ALU ou par un additionneur dédié.

[[File:Unité de détection des branchements dans le décodeur.png|centre|vignette|upright=2|Unité de détection des branchements dans le décodeur]]

Les branchements relatifs sont ceux qui font sauter X instructions plus loin dans le programme. Leur implémentation demande d'ajouter une constante au ''program counter'', la constante étant fournie dans l’instruction. Là encore, deux solutions sont possibles : réutiliser l'ALU pour calculer l'adresse, ou utiliser un additionneur séparé. L'additionneur séparé peut être fusionné avec l'additionneur qui incrémente le ''program counter'' pour passer à l’instruction suivante.

[[File:Unité de chargement qui gère les branchements relatifs.png|centre|vignette|upright=2|Unité de chargement qui gère les branchements relatifs.]]

Pour les branchements indirects, il suffit de lire le registre voulu et d'envoyer le tout sur l'entrée adéquate du ''program counter''. Il faut alors rajouter un multiplexeur pour que l'entrée de réinitialisationr ecoive la bonne adresse de destination.

[[File:Unité de chargement qui gère les branchements directs.png|centre|vignette|upright=2|Unité de chargement qui gère les branchements directs et indirects.]]

Toute la difficulté de l'implémentation des branchements est de configurer les multiplexeurs, ce qui est réalisé par le séquenceur en fonction du mode d'adressage du branchement.

==Les optimisations du chargement des instructions==

Charger une instruction est techniquement une forme d'accès mémoire un peu particulier. En clair, charger une instruction prend au minimum un cycle d'horloge, et cela peut rapidement monter à 3-5 cycles, si ce n'est plus. L'exécution des instructions est alors fortement ralentit par la mémoire. Par exemple, imaginez que la mémoire mette 3 cycles d'horloges pour charger une instruction, alors qu'une instruction s’exécute en 1 cycle (si les opérandes sont dans les registres). La perte de performance liée au chargement des instructions est alors substantielle. Heureusement, il est possible de limiter la casse en utilisant des mémoires caches, ainsi que d'autres optimisations, que nous allons voir dans ce qui suit.

===Le tampon de préchargement===

La technique dite du '''préchargement''' est utilisée dans le cas où la mémoire a un temps d'accès important. Mais si la latence de la RAM est un problème, le débit ne l'est pas. Il est possible d'avoir une RAM lente, mais à fort débit. Par exemple, supposons que la mémoire puisse charger 4 instructions (de taille fixe) en 3 cycles. Le processeur peut alors charger 4 instructions en un seul accès mémoire, et les exécuter l'une après l'autre, une par cycle d'horloge. Les temps d'attente sont éliminés : le processeur peut décoder une nouvelle instruction à chaque cycle. Et quand la dernière instruction préchargée est exécutée, la mémoire est de nouveau libre, ce qui masque la latence des accès mémoire.

[[File:Tampon de préchargement d'instruction.png|vignette|Tampon de préchargement d'instruction]]

La seule contrainte est de mettre les instructions préchargées en attente. La solution pour cela est d'utiliser un registre d'instruction très large, capable de mémoriser plusieurs instructions à la fois. Ce registre est de plus connecté à un multiplexeur qui permet de sélectionner l'instruction adéquate dans ce registre. Ce multiplexeur est commandé par le ''program counter'' et quelques circuits annexes. Ce super-registre d'instruction est appelé un '''tampon de préchargement'''.

La méthode a une implémentation nettement plus simple avec des instructions de taille fixe, alignées en mémoire. La commande du multiplexeur de sélection de l'instruction est alors beaucoup plus simple : il suffit d'utiliser les bits de poids fort du ''program counter''. Par exemple, prenons le cas d'un registre d'instruction de 32 octets pour des instructions de 4 octets, soit 8 instructions. Le choix de l'instruction à sélectionner se fait en utilisant les 3 bits de poids faible du ''program counter''. 

Mais cette méthode ajoute de nouvelles contraintes d'alignement, similaires à celles vues dans le chapitre sur l'alignement et le boutisme, sauf que l'alignement porte ici sur des blocs d'instructions de même taille que le tampon de préchargement. Si on prend l'exemple d'un tampon de préchargement de 128 bits, les instructions devront être alignées par blocs de 128 bits. C'est à dire qu'idéalement, les fonctions et autres blocs de code isolés doivent commencer à des adresses multiples de 128, pour pouvoir charger un bloc d'instruction en une seule fois. Sans cela, les performances seront sous-optimales.

: Il arrive que le tampon de préchargement ait la même taille qu'une ligne de cache.

Lorsque l'on passe d'un bloc d'instruction à un autre, le tampon de préchargement est mis à jour. Par exemple, si on prend un tampon de préchargement de 4 instructions, on doit changer son contenu toutes les 4 instructions. La seule exception est l'exécution d'un branchement. En effet, lors d'un branchement, la destination du branchement n'est pas dans le tampon de préchargement et elle doit être chargée dedans (sauf si le branchement pointe vers une instruction très proche, ce qui est improbable). Pour cela, le tampon de préchargement est mis à jour précocement quand le processeur détecte un branchement.

Le même problème survient avec du code auto-modifiant. Un code auto-modifiant est un programme qui se modifie lui-même, en remplaçant certaines instructions par d'autres, en en retirant, en en ajoutant, lors de sa propre exécution. De tels programmes sont rares, mais la technique était utilisée dans quelques cas au tout début de l'informatique sur des ordinateurs rudimentaires. Ceux-ci avaient des modes d'adressages tellement limités que gérer des tableaux de taille variable demandait d'utiliser du code auto-modifiant pour écrire des boucles. Le problème survient quand des instructions sont modifiées immédiatement après avoir été préchargées. Les instructions dans le tampon de préchargement sont l'ancienne version, alors que la mémoire RAM contient les instructions modifiées. Gérer ce genre de cas demande de vider le tampon de préchargement si le cas arrive, mais ça ne vaut que très rarement le coup, aussi les ingénieurs ne s’embêtent pas à mettre ce correctif en place. Le code automodifiant est alors buggé.

===La ''prefetch input queue''===

La ''prefetch input queue'' est une sorte de cousine du tampon de préchargement, qui a été utilisée sur les processeurs Intel assez ancien. Elle est apparue sur le 8086 et le 8088, des processeurs respectivement 8 et 16 bits. Elle été présente sur le 286 et le 386, mais était un peu améliorée. Elle est apparue sur ces processeurs à une époque où le processeur devenait plus rapide que la mémoire.

L'idée est là encore de précharger des instructions en avance. Sauf que cette fois-ci, on ne charge pas plusieurs instructions à la fois. Au contraire, les instructions sont préchargées séquentiellement, un octet à la fois. En conséquence, le tampon de préchargement est remplacé par une mémoire FIFO appelée la '''''Prefetch Input Queue''''', terme abrévié en PIQ. Les instructions sont accumulées une par une dans la PIQ, elles en sortent une par une au fur et à mesure pour alimenter le décodeur d'instruction.

L'idée est que pendant que le processeur exécute une instruction, on précharge la suivante. Sans ''prefetch input queue'', le processeur chargeait une instruction, la décodait et l'exécutait, puis chargeait la suivante, et ainsi de suite. Avec la ''prefetch input queue'', pendant qu'une instruction est en cours de décodage/exécution, le processeur précharge l'instruction suivante. Si une instruction prend vraiment beaucoup de temps pour s'exécuter, le processeur peut en profiter pour précharger l'instruction encore suivante, et ainsi de suite, jusqu'à une limite de 4/6 instructions (la limite dépend du processeur).

La ''prefetch input queue'' permet de précharger l'instruction suivante à condition qu'aucun autre accès mémoire n'ait lieu. Si l'instruction en cours d'exécution effectue des accès mémoire, ceux-ci sont prioritaires sur tout le reste, le préchargement de l'instruction suivante est alors mis en pause ou inhibé. Par contre, si la mémoire n'est pas utilisée par l'instruction en cours d'exécution, le processeur lit l'instruction suivante en RAM et la copie dans la ''prefetch input queue''. En conséquence, il arrive que la ''prefetch input queue'' n'ait pas préchargé l'instruction suivante, alors que le décodeur d'instruction est prêt pour la décoder. Dans ce cas, le décodeur doit attendre que l'instruction soit chargée.

Les instructions préchargées dans la ''Prefetch input queue'' y attendent que le processeur les lise et les décode. Les instructions préchargées sont conservées dans leur ordre d'arrivée, afin qu'elles soient exécutées dans le bon ordre, ce qui fait que la ''Prefetch input queue'' est une mémoire de type FIFO. L'étape de décodage pioche l'instruction à décoder dans la ''Prefetch input queue'', cette instruction étant par définition la plus ancienne, puis la retire de la file.

Le premier processeur commercial grand public à utiliser une ''prefetch input queue'' était le 8086. Il pouvait précharger à l'avance 6 octets d’instruction. L'Intel 8088 avait lui aussi une ''Prefetch input queue'', mais qui ne permettait que de précharger 4 instructions. La taille idéale de la FIFO dépend de nombreux paramètres. On pourrait croire que plus elle peut contenir d'instructions, mieux c'est, mais ce n'est pas le cas, pour des raisons que nous allons expliquer dans quelques paragraphes.

[[File:80186 arch.png|centre|vignette|700px|upright=2|Architecture du 8086, du 80186 et de ses variantes.]]

Vous remarquerez que j'ai exprimé la capacité de la ''prefetch input queue'' en octets et non en instructions. La raison est que sur les processeurs x86, les instructions sont de taille variable, avec une taille qui varie entre un octet et 6 octets. Cependant, le décodage des instructions se fait un octet à la fois : le décodeur lit un octet, puis éventuellement le suivant, et ainsi de suite jusqu'à atteindre la fin de l'instruction. En clair, le décodeur lits les instructions longues octet par octet dans la ''Prefetch input queue''. Pour cela, le décodeur dispose d'une micro-opération pour lire un octet depuis la ''Prefetch input queue''.

Le décodeur devait attendre que qu'un moins un octet soit disponible dans la ''Prefetch input queue'', pour le lire. Il lisait alors cet octet et déterminait s'il contenait une instruction complète ou non. Si c'est une instruction complète, il la décodait et l''exécutait, puis passait à l'instruction suivante. Sinon, il lit un second octet depuis la ''Prefetch input queue'', le copie dans le registre d'instruction, et relance le décodage. Là encore, le décodeur vérifie s'il a une instruction complète, et lit un troisième octet si besoin, puis rebelote avec un quatrième octet lu, etc.

Un circuit appelé le ''loader'' synchronisait le décodeur d'instruction et la ''Prefetch input queue''. Il fournissait un bit qui indiquait si le premier octet d'une instruction était disponible dans la ''Prefetch input queue''. Un second bit indiquait si l'octet suivant était disponible, nous verrons pourquoi dans ce qui suit. Le ''loader'' recevait aussi des signaux de la part du décodeur d'instruction. Le décodeur envoyait le signal ''Run Next Instruction'' pour lire une instruction, qui était alors dépilée de la ''Prefetch input queue''. Le décodeur d'instruction pouvait aussi envoyer un signal ''Next-to-last (NXT)'', un cycle avant que l'instruction en cours ne termine. Le ''loader'' réagissait en préchargeant l'octet suivant. En clair, ce signal permettait de précharger l'instruction suivante avec un cycle d'avance, si celle-ci n'était pas déjà dans la ''Prefetch input queue''.

Le bus de données du 8086 faisait 16 bits, alors que celui du 8088 ne permettait que de lire un octet à la fois. Et cela avait un impact sur la ''prefetch input queue''. La ''prefetch input queue'' était composée de 4 registres de 8 bits, avec un port d'écriture de 8 bits pour précharger les instructions octet par octet, et un port de lecture de 8 bits pour alimenter le décodeur. En clair, tout faisait 8 bits. Le 8086, lui utilisait des registres de 16 bits et un port d'écriture de 16 bits. le port de lecture restait de 8 bits, et était précédé d'un multiplexeur qui prenait 16 bits et sélectionnait l'octet adéquat. Sa ''prefetch input queue'' préchargeait les instructions par paquets de 2 octets, non octet par octet, alors que le décodeur consommait les instructions octet par octet. Il s’agissait donc d'une sorte d'intermédiaire entre ''prefetch input queue'' à la 8088 et tampon de préchargement.

Les branchements posent des problèmes avec la ''Prefetch input queue'' : à cause d'eux, on peut charger à l'avance des instructions qui sont zappées par un branchement et ne sont pas censées être exécutées. Si un branchement est chargé, toutes les instructions préchargées après sont potentiellement invalides. Si le branchement est non-pris, les instructions chargées sont valides, elles sont censées s’exécuter. Mais si le branchement est pris, elles ont été chargées à tort et ne doivent pas s’exécuter. 

Pour éviter cela, la ''Prefetch input queue'' est vidée quand le processeur détecte un branchement. Pour cela, le décodeur d'instruction dispose d'une micro-opération qui vide la ''Prefetch input queue'', elle invalide les instructions préchargées.  Cette détection ne peut se faire qu'une fois le branchement décodé, qu'une fois que l'on sait que l'instruction décodée est un branchement. En clair, le décodeur invalide la ''Prefetch input queue'' quand il détecte un branchement. Les interruptions posent le même genre de problèmes. Il faut impérativement vider la ''Prefetch input queue'' quand une interruption survient, avant de la traiter.

Il faut noter qu'une ''Prefetch input queue'' interagit assez mal avec le ''program counter''. En effet, la ''Prefetch input queue'' précharge les instructions séquentiellement. Pour savoir où elle en est rendue, elle mémorise l'adresse de la prochaine instruction à charger dans un '''registre de préchargement''' dédié. Il serait possible d'utiliser un ''program counter'' en plus du registre de préchargement, mais ce n'est pas la solution qui a été utilisée. Les processeurs Intel anciens ont préféré n'utiliser qu'un seul registre de préchargement en remplacement du ''program counter''. Après tout, le registre de préchargement n'est qu'un ''program counter'' ayant pris une avance de quelques cycles d'horloge, qui a été incrémenté en avance.

Et cela ne pose pas de problèmes, sauf avec certains branchements. Par exemple, certains branchements relatifs demandent de connaitre la véritable valeur du ''program counter'', pas celle calculée en avance. Idem avec les instructions d'appel de fonction, qui demandent de sauvegarder l'adresse de retour exacte, donc le vrai ''program counter''. De telles situations demandent de connaitre la valeur réelle du ''program counter'', celle sans préchargement. Pour cela, le décodeur d'instruction dispose d'une instruction pour reconstituer le ''program counter'', à savoir corriger le ''program coutner'' et éliminer l'effet du préchargement.

La micro-opération de correction se contente de soustraire le nombre d'octets préchargés au registre de préchargement. Le nombre d'octets préchargés est déduit à partir des deux pointeurs intégré à la FIFO, qui indiquent la position du premier et du dernier octet préchargé. Le bit qui indique si la FIFO est vide était aussi utilisé. Les deux pointeurs sont lus depuis la FIFO, et sont envoyés à un circuit qui détermine le nombre d'octets préchargés. Sur le 8086, ce circuit était implémenté non pas par un circuit combinatoire, mais par une mémoire ROM équivalente. La petite taille de la FIFO faisait que les pointeurs étaient très petits et la ROM l'était aussi.

Un autre défaut est que la ''Prefetch input queue'' se marie assez mal avec du code auto-modifiant. Un code auto-modifiant est un programme qui se modifie lui-même, en remplaçant certaines instructions par d'autres, en en retirant, en en ajoutant, lors de sa propre exécution. De tels programmes sont rares, mais la technique était utilisée dans quelques cas au tout début de l'informatique sur des ordinateurs rudimentaires. Ceux-ci avaient des modes d'adressages tellement limités que gérer des tableaux de taille variable demandait d'utiliser du code auto-modifiant pour écrire des boucles.

Le problème avec la ''Prefetch input queue'' survient quand des instructions sont modifiées immédiatement après avoir été préchargées. Les instructions dans la ''Prefetch input queue'' sont l'ancienne version, alors que la mémoire RAM contient les instructions modifiées. Gérer ce genre de cas est quelque peu complexe. Il faut en effet vider la ''Prefetch input queue'' si le cas arrive, ce qui demande d'identifier les écritures qui écrasent des instructions préchargées. C'est parfaitement possible, mais demande de transformer la ''Prefetch input queue'' en une mémoire hybride, à la fois mémoire associative et mémoire FIFO. Cela ne vaut que très rarement le coup, aussi les ingénieurs ne s’embêtent pas à mettre ce correctif en place, le code automodifiant est alors buggé.

Le décodeur d'instruction dispose aussi d'une micro-opération qui stoppe le préchargement des instructions dans la ''Prefetch input queue''.

: Pour ceux qui ont déjà lu un cours d'architecture des ordinateurs, la relation entre ''prefetch input queue'' et pipeline est quelque peu complexe. En apparence, la ''prefetch input queue'' permet une certaines forme de pipeline, en chargeant une instruction pendant que la précédente s'exécute. Les problématiques liées aux branchements ressemblent beaucoup à celles de la prédiction de branchement. Cependant, il est possible de dire qu'il s'agit plus d'une technique de préchargement que de pipeline. La différence entre les deux est assez subtile et les frontières sont assez floues, mais le fait est que l'instruction en cours d'exécution et le préchargement peuvent tout deux faire des accès mémoire et que l'instruction en cours a la priorité. Un vrai pipeline se débrouillerait avec une architecture Harvard, non avec un bus mémoire unique pour le chargement des instruction et la lecture/écriture des données.

===Le ''Zero-overhead looping''===

Nous avions vu dans le chapitre sur les instructions machines, qu'il existe des instructions qui permettent de grandement faciliter l'implémentation des boucles. Il s'agit de l'instruction REPEAT, utilisée sur certains processeurs de traitement de signal. Elle répète l'instruction suivante, voire une série d'instructions, un certain nombre de fois. Le nombre de répétitions est mémorisé dans un registre décrémenté à chaque itération de la boucle. Elle permet donc d'implémenter une boucle FOR facilement, sans recourir à des branchements ou des conditions.

Une technique en lien avec cette instruction permet de grandement améliorer les performances et la consommation d'énergie. L'idée est de mémoriser la boucle, les instructions à répéter, dans une petite mémoire cache située entre l'unité de chargement et le séquenceur. Le cache en question s'appelle un '''tampon de boucle''', ou encore un ''hardware loop buffer''. Grâce à lui, il n'y a pas besoin de charger les instructions à chaque fois qu'on les exécute, on les charge une bonne fois pour toute : c'est plus rapide. Bien sûr, il ne fonctionne que pour de petites boucles, mais il en est de même avec l'instruction REPEAT.

&lt;noinclude&gt;
{{NavChapitre | book=Fonctionnement d'un ordinateur
           | prev=Le chemin de données
           | prevText=Le chemin de données
           | next=L'unité de contrôle
           | nextText=L'unité de contrôle
}}
&lt;/noinclude&gt;</text>
      <sha1>btix6ekccls2l2glnwwiv883dacktsf</sha1>
    </revision>
    <revision>
      <id>744088</id>
      <parentid>744087</parentid>
      <timestamp>2025-06-03T20:16:04Z</timestamp>
      <contributor>
        <username>Mewtow</username>
        <id>31375</id>
      </contributor>
      <minor />
      <comment>/* La prefetch input queue */</comment>
      <origin>744088</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="46360" sha1="7opblxsu3i2l2l09pdrb037b4uiisvq" xml:space="preserve">L'unité de contrôle s'occupe du chargement des instructions et de leur interprétation, leur décodage. Elle contient deux circuits : l''''unité de chargement''' qui charge l'instruction depuis la mémoire, et le '''séquenceur''' qui commande le chemin de données. Les deux circuits sont séparés, mais ils communiquent entre eux, notamment pour gérer les branchements. Dans ce chapitre, nous allons nous intéresser au chargement d'une instruction depuis la RAM/ROM, nous verrons l'étape de décodage de l'instruction au prochain chapitre.

==Le chargement d'une instruction==

[[File:Étape de chargement.png|vignette|upright=1|Étape de chargement.]]

L'étape de chargement (ou ''fetch'') doit faire deux choses : mettre à jour le ''program counter'' et lire l'instruction en mémoire RAM ou en ROM. Les deux étapes peuvent être faites en parallèle, dans des circuits séparés. Pendant que l'instruction est lue depuis la mémoire RAM/ROM, le ''program counter'' est incrémenté et/ou altéré par un branchement.

Pour lire l'instruction, on envoie le ''program counter'' sur le bus d'adresse et on récupère l'instruction sur le bus de données pour l'envoyer sur l'entrée du séquenceur. Et cela demande de connecter le séquenceur au bus mémoire, à travers l'interface mémoire. Et sur ce point, la situation est différente selon que l'on parler d'une architecture Harvard ou Von Neumann.

===Les interconnexions entre séquenceur et bus mémoire===

Sur les architectures Harvard, le séquenceur et le chemin de donnée utilisent des interfaces mémoire séparées. Le séquenceur est directement relié au bus mémoire de la ROM, alors que le chemin de données est connecté à la RAM.

[[File:Microarchitecture de l'interface mémoire d'une architecture Harvard.png|centre|vignette|upright=2|Microarchitecture de l'interface mémoire d'une architecture Harvard]]

Mais sur les architectures Von-Neumann et affiliées, le séquenceur et le chemin de donnée partagent la même interface mémoire. Et cela pose deux problèmes.

Le premier problème est que le bus mémoire doit être libéré une fois l'instruction chargée, pour un éventuel accès mémoire. Mais le séquenceur doit conserver une copie de l'instruction chargée, sans quoi il ne peut pas décoder l'instruction correctement. Par exemple, si l'instruction met plusieurs cycles à s'exécuter, le séquenceur doit conserver une copie de l'instruction durant ces plusieurs cycles. La solution à ce problème est un '''registre d'instruction''' situé juste avant le séquenceur, qui mémorise l'instruction chargée.

[[File:Registre d'instruction.png|centre|vignette|upright=2|Registre d'instruction.]]

Le second problème est de gérer le flot des instructions/données entre le bus mémoire, le chemin de données et le séquenceur. Le processeur doit connecter l'interface mémoire soit au séquenceur, soit au chemin de données et cela complique le réseau d'interconnexion interne au processeur.

Une première solution utilise un bus unique qui relie l'interface mémoire, le séquenceur et le chemin de données. Pour charger une instruction, le séquenceur copie le ''program counter'' sur le bus d'adresse, attend que l'instruction lue soit disponible sur le bus de données, puis la copie dans le registre d'instruction. Le bus mémoire est alors libre et peut être utilisé pour lire ou écrire des données, si le besoin s'en fait sentir.

Il faut noter que l'usage d'un bus unique a un impact sur l'organisation interne du chemin de données. Par exemple, le chapitre précédent nous a montré comment implémenter un chemin de données basique, avec des multiplexeurs et démultiplexeurs. Et bien ces chemins de données ne marchent pas vraiment avec un bus interne unique. Il est possible de les adapter, mais au prix d'une complexité largement supérieure. Un bus interne unique marche mieux quand le banc de registre est mono-port. C'est pourquoi il a été utilisé sur d'anciennes architectures appelées des architectures à accumulateur et à pile, que nous verrons dans quelques chapitres, qui utilisaient un banc de registre mono-port.

[[File:Microarchitecture de l'interface mémoire d'une architecture von neumann.png|centre|vignette|upright=2|Microarchitecture de l'interface mémoire d'une architecture von neumann]]

Une autre solution utilise deux bus interne séparés : un connecté au bus d'adresse, l'autre au bus de données. Le ''program counter'' est alors connecté au bus interne d'adresse, le séquenceur est relié au bus interne de données. Notons que la technique marche bien si le ''program counter'' est dans le banc de registre : les interconnexions utilisées pour gérer l'adressage indirect permettent d'envoyer le ''program counter'' sur le bus d'adresse sans ajout de circuit.

Le tout peut être amélioré en remplaçant les deux bus par des multiplexeurs et démultiplexeurs. Le bus d'adresse est précédé par un multiplexeur, qui permet de faire le choix entre ''Program Counter'', adresse venant du chemin de données, ou adresse provenant du séquenceur (adressage absolu). De même, le bus de données est suivi par un démultiplexeur qui envoie la donnée/instruction lue soit au registre d'instruction, soit au chemin de données. Le tout se marie très bien avec les chemins de donnée vu dans le chapitre précédent. Au passage, il faut noter que cette solution nécessite un banc de registre multi-port.

[[File:Connexion du program counter sur les bus avec PC isolé.png|centre|vignette|upright=2|Connexion du program counter sur les bus avec PC isolé]]

===Le chargement des instructions de longueur variable===

Le chargement des instructions de longueur variable pose de nombreux problèmes. Le premier est que mettre à jour le ''program counter'' demande de connaitre la longueur de l'instruction chargée, pour l'ajouter au ''program counter''. Si la longueur d'une instruction est variable, on doit connaitre cette longueur d'une manière où d'une autre. La solution la plus simple indique la longueur de l'instruction dans une partie de l'opcode ou de la représentation en binaire de l'instruction. Mais les processeurs haute performance de nos PC utilisent d'autres solutions, qui n'encodent pas explicitement la taille de l'instruction.

Les processeurs récents utilisent un registre d'instruction de grande taille, capable de mémoriser l'instruction la plus longue du processeur. Par exemple, si un processeur supporte des instructions allant de 1 à 8 octets, comme les CPU x86, le registre d'instruction fera 8 octets. Le décodeur d'instruction vérifie à chaque cycle le contenu du registre d'instruction. Si une instruction est détectée dedans, son décodage commence, peu importe la taille de l'instruction. Une fois l'instruction exécutée, elle est retirée du registre d'instruction. Reste à alimenter le registre d'instruction, à charger des instructions dedans. Et pour cela deux solutions : soit on charge l'instruction en plusieurs fois, soit d'un seul coup.

La solution la plus simple charge les instructions par mots de 8, 16, 32, 64 bits. Ils sont accumulés dans le registre d'instruction jusqu'à détecter une instruction complète. La technique marche nettement mieux si les instructions sont très longues. Par exemple, les CPU x86 ont des instructions qui vont de 1 à 15 octets, ce qui fait qu'ils utilisent cette technique. Précisément, elle marche si les instructions les plus longues sont plus grandes que le bus mémoire.

Une autre solution charge un bloc de mots mémoire aussi grand que la plus grande instruction. Par exemple, si le processeur gère des instructions allant de 1 à 4 octets, il charge 4 octets d'un seul coup dans le registre d'instruction. Il va de soit que cette solution ne marche que si les instructions du processeur sont assez courtes, au plus aussi courtes que le bus mémoire. Ainsi, on est sûr de charger obligatoirement au moins une instruction complète, et peut-être même plusieurs. Le contenu du registre d'instruction est alors découpé en instructions au fil de l'eau. 

Utiliser un registre d'instruction large pose problème avec des instructions à cheval entre deux blocs. Il se peut qu'on n'ait pas une instruction complète lorsque l'on arrive à la fin du bloc, mais seulement un morceau. Le problème se manifeste peu importe que l'instruction soit chargée d'un seul coup ou bien en plusieurs fois.

[[File:Instructions non alignées.png|centre|vignette|upright=2|Instructions non alignées.]]

Dans ce cas, on doit décaler le morceau de bloc pour le mettre au bon endroit (au début du registre d'instruction), et charger le prochain bloc juste à côté. On a donc besoin d'un circuit qui décale tous les bits du registre d'instruction, couplé à un circuit qui décide où placer dans le registre d'instruction ce qui a été chargé, avec quelques circuits autour pour configurer les deux circuits précédents.

[[File:Décaleur d’instruction.png|centre|vignette|upright=2|Décaleur d’instruction.]]

Une autre solution se passe de registre d'instruction en utilisant à la place l'état interne du séquenceur. Là encore, elle charge l'instruction morceau par morceau, typiquement par blocs de 8, 16 ou 32 bits. Les morceaux ne sont pas accumulés dans le registre d'instruction, la solution utilise à la place l'état interne du séquenceur. Les mots mémoire de l'instruction sont chargés à chaque cycle, faisant passer le séquenceur d'un état interne à un autre à chaque mot mémoire. Tant qu'il n'a pas reçu tous les mots mémoire de l'instruction, chaque mot mémoire non terminal le fera passer d'un état interne à un autre, chaque état interne encodant les mots mémoire chargés auparavant. S'il tombe sur le dernier mot mémoire d'une instruction, il rentre dans un état de décodage.

==L'incrémentation du ''program counter''==

À chaque chargement, le ''program counter'' est mis à jour afin de pointer sur la prochaine instruction à charger. Sur la quasi-totalité des processeurs, les instructions sont placées dans l'ordre d’exécution dans la RAM. En faisant ainsi, on peut mettre à jour le ''program counter'' en lui ajoutant la longueur de l'instruction courante. Déterminer la longueur de l'instruction est simple quand les instructions ont toutes la même taille, mais certains processeurs ont des instructions de taille variable, ce qui complique le calcul. Dans ce qui va suivre, nous allons supposer que les instructions sont de taille fixe, ce qui fait que le ''program counter'' est toujours incrémenté de la même valeur.

Il existe deux méthodes principales pour incrémenter le ''program counter'' : soit le ''program counter'' a son propre additionneur, soit le ''program counter'' est mis à jour par l'ALU. Pour ce qui est de l'organisation des registres, soit le ''program counter'' est un registre séparé des autres, soit il est regroupé avec d'autres registres dans un banc de registre. En tout, cela donne quatre organisations possibles.
* Un ''program counter'' séparé relié à un incrémenteur séparé.
* Un ''program counter'' séparé des autres registres, incrémenté par l'ALU.
* Un ''program counter'' intégré au banc de registre, relié à un incrémenteur séparé.
* Un ''program counter'' intégré au banc de registre, incrémenté par l'ALU.

[[File:Calcul du program counter.png|centre|vignette|upright=2|les différentes méthodes de calcul du program counter.]]

Les processeurs haute performance modernes utilisent tous la première méthode. Les autres méthodes étaient surtout utilisées sur les processeurs 8 ou 16 bits, elles sont encore utilisées sur quelques microcontrôleurs de faible puissance. Nous auront l'occasion de donner des exemples quand nous parlerons des processeurs 8 bits anciens, dans le chapitre sur les architectures à accumulateur et affiliées.

===Le ''program counter'' mis à jour par l'ALU===

Sur certains processeurs, le calcul de l'adresse de la prochaine instruction est effectué par l'ALU. L'avantage de cette méthode est qu'elle économise un incrémenteur dédié au ''program counter''. Ce qui explique que cette méthode était utilisée sur les processeurs assez anciens, à une époque où un additionneur pouvait facilement prendre 10 à 20% des transistors disponibles. Le désavantage principal est une augmentation de la complexité du séquenceur, qui doit gérer la mise à jour du ''program counter''. De plus, la mise à jour du ''program counter'' ne peut pas se faire en même temps qu'une opération arithmétique, ce qui réduit les performances.

Si on incrémente le ''program counter'' avec l'ALU, il est intéressant de le placer dans le banc de registres. Un désavantage est qu'on perd un registre. Par exemple, avec un banc de registre de 16 registres, on ne peut adresser que 15 registres généraux. De plus ce n'est pas l'idéal pour le décodage des instructions et pour le séquenceur. Si le processeur dispose de plusieurs bancs de registres, le ''program counter'' est généralement placé dans le banc de registre dédié aux adresses. Sinon, il est placé avec les nombres entiers/adresses.

D'anciens processeurs incrémentaient le ''program counter'' avec l'ALU, mais utilisaient bien un registre séparé pour le ''program counter''. Cette méthode est relativement simple à implémenter : il suffit de connecter/déconnecter le ''program counter'' du bus interne suivant les besoins. Le ''program counter'' est déconnecté pendant l’exécution d'une instruction, il est connecté au bus interne pour l'incrémenter. C'est le séquenceur qui gère le tout. L'avantage de cette séparation est qu'elle est plus facile à gérer pour le séquenceur. De plus, on gagne un registre général/entier dans le banc de registre.

===Le compteur programme===

Dans la quasi-totalité des processeurs modernes, le ''program counter'' est un vulgaire compteur comme on en a vu dans les chapitres sur les circuits, ce qui fait qu'il passe automatiquement d'une adresse à la suivante. Dans ce qui suit, nous allons appeler ce registre compteur : le '''compteur ordinal'''. L'usage d'un compteur simplifie fortement la conception du séquenceur. Le séquenceur n'a pas à gérer la mise à jour du ''program counter'', sauf en cas de branchements. De plus, il est possible d'incrémenter le ''program counter'' pendant que l'unité de calcul effectue une opération arithmétique, ce qui améliore grandement les performances. Le seul désavantage est qu'elle demande d'ajouter un incrémenteur dédié au ''program counter''.

Sur les processeurs très anciens, les instructions faisaient toutes un seul mot mémoire et le compteur ordinal était un circuit incrémenteur des plus basique. Sur les processeurs modernes, le compteur est incrémenté par pas de 4 si les instructions sont codées sur 4 octets, 8 si les instructions sont codées sur 8 octets, etc. Concrètement, le compteur est un circuit incrémenteur auquel on aurait retiré quelques bits de poids faible. Par exemple, si les instructions sont codées sur 4 octets, on coupe les 2 derniers bits du compteur. Si les instructions sont codées sur 8 octets, on coupe les 3 derniers bits du compteur. Et ainsi de suite.

Il a existé quelques processeurs pour lesquelles le ''program counter'' était non pas un compteur binaire classique, mais un ''linear feedback shift register''. L'avantage est que le circuit d'incrémentation utilisait bien moins de portes logiques, l'économie était substantielle. Mais un défaut est que des instructions consécutives dans le programme n'étaient pas consécutives en mémoire. Il existait cependant une table de correspondance pour dire : la première instruction est à telle adresse, la seconde à telle autre, etc. Un exemple de processeur de ce type est le TMS 1000 de Texas Instrument, un des premiers microcontrôleur 4 bits datant des années 70.

Une amélioration de la solution précédente utilise un circuit incrémenteur partagé entre le ''program counter'' et d'autres registres. L'incrémenteur est utilisé pour incrémenter le ''program counter'', mais aussi pour effectuer d'autres calculs d'adresse. Par exemple, sur les architectures avec une pile d'adresse de retour, il est possible de partager l'incrémenteur/décrémenteur avec le pointeur de pile ( la technique ne marche pas avec une pile d'appel). Un autre exemple est celui des processeurs qui gèrent automatiquement le rafraichissement mémoire, grâce à, un compteur intégré dans le processeur. Il est possible de partager l'incrémenteur du ''program counter'' avec le compteur de rafraichissement mémoire, qui mémorise la prochaine adresse mémoire à rafraichir. Nous avions déjà abordé ce genre de partage dans le chapitre sur le chemin de données, dans l'annexe sur le pointeur de pile, mais nous verrons d'autres exemples dans le chapitre sur les architectures hybride accumulateur-registre 8/16 bits.

===Quand est mis à jour le ''program counter'' ?===

Le ''program counter'' est mis à jour quand il faut charger une nouvelle instruction. Reste qu'il faut savoir quand le mettre à jour. Incrémenter le ''program counter'' à intervalle régulier, par exemple à chaque cycle d’horloge, fonctionne sur les processeurs où toutes les instructions mettent le même temps pour s’exécuter. Mais de tels processeurs sont très rares. Sur la quasi-totalité des processeurs, les instructions ont une durée d’exécution variable, elles ne prennent pas le même nombre de cycle d'horloge pour s’exécuter. Le temps d’exécution d'une instruction varie selon l'instruction, certaines sont plus longues que d'autres. Tout cela amène un problème : comment incrémenter le ''program counter'' avec des instructions avec des temps d’exécution variables ?

La réponse est que la mise à jour du ''program counter'' démarre quand l'instruction précédente a terminée de s’exécuter, plus précisément un cycle avant. C'est un cycle avant pour que l'instruction chargée soit disponible au prochain cycle pour le décodeur. Pour cela, le séquenceur doit déterminer quand l'instruction est terminée et prévenir le ''program counter'' au bon moment. Il faut donc une interaction entre séquenceur et circuit de chargement. Le circuit de chargement contient une entrée Enable, qui autorise la mise à jour du ''program counter''. Le séquenceur met à 1 cette entrée pour prévenir au ''program counter'' qu'il doit être incrémenté au cycle suivant ou lors du cycle courant. Cela permet de gérer simplement le cas des instructions multicycles. 

[[File:Commande de la mise à jour du program counter.png|centre|vignette|upright=2|Commande de la mise à jour du program counter.]]

Toute la difficulté est alors reportée dans le séquenceur, qui doit déterminer la durée d'une instruction. Pour gérer la mise à jour du ''program counter'', le séquenceur doit déterminer la durée d'une instruction. Cela est simple pour les instructions arithmétiques et logiques, qui ont un nombre de cycles fixe, toujours le même. Une fois l'instruction identifiée par le séquenceur, il connait son nombre de cycles et peut programmer un compteur interne au séquenceur, qui compte le nombre de cycles de l'instruction, et fournit le signal Enable au ''program counter''. Mais cette technique ne marche pas vraiment pour les accès mémoire, dont la durée n'est pas connue à l'avance, surtout sur les processeurs avec des mémoires caches. Pour cela, le séquenceur détermine quand l'instruction mémoire est finie et prévient le ''program counter'' quand c'est le cas.

Il existe quelques processeurs pour lesquels le temps de calcul dépend des opérandes de l'instruction. On peut par exemple avoir une division qui prend 10 cycles avec certaines opérandes, mais 40 cycles avec d'autres opérandes. Mais ces processeurs sont rares et cela est surtout valable pour les opérations de multiplication/division, guère plus. Le problème est alors le même qu'avec les accès mémoire et la solution est la même : l'ALU prévient le séquenceur quand le résultat est disponible.

==Les branchements et le ''program counter''==

Un branchement consiste juste à écrire l'adresse de destination dans le ''program counter''. L'implémentation des branchements demande d'extraire l'adresse de destination et d'altérer le ''program counter'' quand un branchement est détecté. Pour cela, le décodeur d'instruction détecte si l'instruction exécutée est un branchement ou non, et il en déduit où trouver l'adresse de destination.

L'adresse de destination se trouve à un endroit qui dépend du mode d'adressage du branchement. Pour rappel, on distingue quatre modes d'adressage pour les branchements : direct, indirect, relatif et implicite. Pour les branchements directs, l'adresse est intégrée dans l'instruction de branchement elle-même et est extraite par le séquenceur. Pour les branchements indirects, l'adresse de destination est dans le banc de registre. Pour les branchements relatifs, il faut ajouter un décalage au ''program counter'', décalage extrait de l'instruction par le séquenceur. Enfin, les instructions de retour de fonction lisent l'adresse de destination depuis la pile. L'implémentation de ces quatre types de branchements est très différente.

L'altération du ''program counter'' dépend de si le ''program counter'' est dans un compteur séparé ou s'il est dans le banc de registre. Nous avons vu plus haut qu'il y a quatre cas différents, mais nous n'allons voir que deux cas : celui où le ''program counter'' est dans le banc de registre et est incrémenté par l'unité de calcul, celui avec un ''program counter'' séparé avec son propre incrémenteur. Les deux autres cas ne sont utilisés que sur des architectures à accumulateur ou à pile spécifiques, que nous n'avons pas encore vu à ce stade du cours et que nous verrons en temps voulu dans le chapitre sur ces architectures.

===L’implémentation des branchements avec un ''program counter'' intégré au banc de registres===

Le cas le plus simple est celui où le ''program counter'' est intégré au banc de registre, avec une incrémentation faite par l'unité de calcul. Charger une instruction revient alors à effectuer une instruction LOAD en adressage indirect, à deux différences près : le registre sélectionné est le ''program counter'', l’instruction est copiée dans le registre d'instruction et non dans le banc de registre. L'incrémentation du ''porgram counter'' est implémenté avec des micro-opérations qui agissent sur le chemin de données, au même titre que les branchements indirects, relatifs et directs.
* Les branchements indirects copient un registre dans le ''program counter'', ce qui revient simplement à faire une opération MOV entre deux registres, dont le ''program counter'' est la destination.
* L'opération inverse d'un branchement indirect, qui copie le ''program counter'' dans un registre général, est utile pour sauvegarder l'adresse de retour d'une fonction.
* Les branchements directs copient une adresse dans le ''program counter'', ce qui les rend équivalents à une opération MOV avec une constante immédiate, dont le ''program counter'' est la destination.
* Les branchements relatifs sont une opération arithmétique entre le ''program counter'' et un opérande en adressage immédiat.

En clair, à partir du moment où le chemin de données supporte les instructions MOV et l'addition, avec les modes d'adressage adéquat, il supporte les branchements. Aucune modification du chemin de données n'est nécessaire, le séquenceur gére le chargement d'une instruction avec les micro-instructions adéquates : une micro-opération ADD pour incrémenter le ''program counter'', une micro-opération LOAD pour le chargement de l'instruction.

Notons que sur certaines architectures, le ''program counter'' est adressable au même titre que les autres registres du banc de registre. Les instructions de branchement sont alors remplacées par des instructions MOV ou des instructions arithmétique équivalentes, comme décrit plus haut.

===L’implémentation des branchements avec un ''program counter'' séparé===

Étudions maintenant le cas où le ''program counter'' est dans un registre/compteur séparé. Rappelons que tout compteur digne de ce nom possède une entrée de réinitialisation, qui remet le compteur à zéro. De plus, on peut préciser à quelle valeur il doit être réinitialisé. Ici, la valeur à laquelle on veut réinitialiser le compteur n'est autre que l'adresse de destination du branchement. Implémenter un branchement est donc simple : l'entrée de réinitialisation est commandée par le circuit de détection des branchements, alors que la valeur de réinitialisation est envoyée sur l'entrée adéquate. En clair, nous partons du principe que le ''program counter'' est implémenté avec ce type de compteur :

[[File:Fonctionnement d'un compteur (décompteur), schématique.jpg|centre|vignette|upright=1.5|Fonctionnement d'un compteur (décompteur), schématique]]

Toute la difficulté est de présenter l'adresse de destination au ''program counter''. Pour les branchements directs, l'adresse de destination est fournie par le séquenceur. L'adresse de destination du branchement sort du séquenceur et est présentée au ''program counter'' sur l'entrée adéquate. Voici donc comment sont implémentés les branchements directs avec un ''program counter'' séparé du banc de registres. Le schéma ci-dessous marche peu importe que le ''program counter'' soit incrémenté par l'ALU ou par un additionneur dédié.

[[File:Unité de détection des branchements dans le décodeur.png|centre|vignette|upright=2|Unité de détection des branchements dans le décodeur]]

Les branchements relatifs sont ceux qui font sauter X instructions plus loin dans le programme. Leur implémentation demande d'ajouter une constante au ''program counter'', la constante étant fournie dans l’instruction. Là encore, deux solutions sont possibles : réutiliser l'ALU pour calculer l'adresse, ou utiliser un additionneur séparé. L'additionneur séparé peut être fusionné avec l'additionneur qui incrémente le ''program counter'' pour passer à l’instruction suivante.

[[File:Unité de chargement qui gère les branchements relatifs.png|centre|vignette|upright=2|Unité de chargement qui gère les branchements relatifs.]]

Pour les branchements indirects, il suffit de lire le registre voulu et d'envoyer le tout sur l'entrée adéquate du ''program counter''. Il faut alors rajouter un multiplexeur pour que l'entrée de réinitialisationr ecoive la bonne adresse de destination.

[[File:Unité de chargement qui gère les branchements directs.png|centre|vignette|upright=2|Unité de chargement qui gère les branchements directs et indirects.]]

Toute la difficulté de l'implémentation des branchements est de configurer les multiplexeurs, ce qui est réalisé par le séquenceur en fonction du mode d'adressage du branchement.

==Les optimisations du chargement des instructions==

Charger une instruction est techniquement une forme d'accès mémoire un peu particulier. En clair, charger une instruction prend au minimum un cycle d'horloge, et cela peut rapidement monter à 3-5 cycles, si ce n'est plus. L'exécution des instructions est alors fortement ralentit par la mémoire. Par exemple, imaginez que la mémoire mette 3 cycles d'horloges pour charger une instruction, alors qu'une instruction s’exécute en 1 cycle (si les opérandes sont dans les registres). La perte de performance liée au chargement des instructions est alors substantielle. Heureusement, il est possible de limiter la casse en utilisant des mémoires caches, ainsi que d'autres optimisations, que nous allons voir dans ce qui suit.

===Le tampon de préchargement===

La technique dite du '''préchargement''' est utilisée dans le cas où la mémoire a un temps d'accès important. Mais si la latence de la RAM est un problème, le débit ne l'est pas. Il est possible d'avoir une RAM lente, mais à fort débit. Par exemple, supposons que la mémoire puisse charger 4 instructions (de taille fixe) en 3 cycles. Le processeur peut alors charger 4 instructions en un seul accès mémoire, et les exécuter l'une après l'autre, une par cycle d'horloge. Les temps d'attente sont éliminés : le processeur peut décoder une nouvelle instruction à chaque cycle. Et quand la dernière instruction préchargée est exécutée, la mémoire est de nouveau libre, ce qui masque la latence des accès mémoire.

[[File:Tampon de préchargement d'instruction.png|vignette|Tampon de préchargement d'instruction]]

La seule contrainte est de mettre les instructions préchargées en attente. La solution pour cela est d'utiliser un registre d'instruction très large, capable de mémoriser plusieurs instructions à la fois. Ce registre est de plus connecté à un multiplexeur qui permet de sélectionner l'instruction adéquate dans ce registre. Ce multiplexeur est commandé par le ''program counter'' et quelques circuits annexes. Ce super-registre d'instruction est appelé un '''tampon de préchargement'''.

La méthode a une implémentation nettement plus simple avec des instructions de taille fixe, alignées en mémoire. La commande du multiplexeur de sélection de l'instruction est alors beaucoup plus simple : il suffit d'utiliser les bits de poids fort du ''program counter''. Par exemple, prenons le cas d'un registre d'instruction de 32 octets pour des instructions de 4 octets, soit 8 instructions. Le choix de l'instruction à sélectionner se fait en utilisant les 3 bits de poids faible du ''program counter''. 

Mais cette méthode ajoute de nouvelles contraintes d'alignement, similaires à celles vues dans le chapitre sur l'alignement et le boutisme, sauf que l'alignement porte ici sur des blocs d'instructions de même taille que le tampon de préchargement. Si on prend l'exemple d'un tampon de préchargement de 128 bits, les instructions devront être alignées par blocs de 128 bits. C'est à dire qu'idéalement, les fonctions et autres blocs de code isolés doivent commencer à des adresses multiples de 128, pour pouvoir charger un bloc d'instruction en une seule fois. Sans cela, les performances seront sous-optimales.

: Il arrive que le tampon de préchargement ait la même taille qu'une ligne de cache.

Lorsque l'on passe d'un bloc d'instruction à un autre, le tampon de préchargement est mis à jour. Par exemple, si on prend un tampon de préchargement de 4 instructions, on doit changer son contenu toutes les 4 instructions. La seule exception est l'exécution d'un branchement. En effet, lors d'un branchement, la destination du branchement n'est pas dans le tampon de préchargement et elle doit être chargée dedans (sauf si le branchement pointe vers une instruction très proche, ce qui est improbable). Pour cela, le tampon de préchargement est mis à jour précocement quand le processeur détecte un branchement.

Le même problème survient avec du code auto-modifiant. Un code auto-modifiant est un programme qui se modifie lui-même, en remplaçant certaines instructions par d'autres, en en retirant, en en ajoutant, lors de sa propre exécution. De tels programmes sont rares, mais la technique était utilisée dans quelques cas au tout début de l'informatique sur des ordinateurs rudimentaires. Ceux-ci avaient des modes d'adressages tellement limités que gérer des tableaux de taille variable demandait d'utiliser du code auto-modifiant pour écrire des boucles. Le problème survient quand des instructions sont modifiées immédiatement après avoir été préchargées. Les instructions dans le tampon de préchargement sont l'ancienne version, alors que la mémoire RAM contient les instructions modifiées. Gérer ce genre de cas demande de vider le tampon de préchargement si le cas arrive, mais ça ne vaut que très rarement le coup, aussi les ingénieurs ne s’embêtent pas à mettre ce correctif en place. Le code automodifiant est alors buggé.

===La ''prefetch input queue''===

La ''prefetch input queue'' est une sorte de cousine du tampon de préchargement, qui a été utilisée sur les processeurs Intel assez ancien. Elle est apparue sur le 8086 et le 8088, des processeurs respectivement 8 et 16 bits. Elle été présente sur le 286 et le 386, mais était un peu améliorée. Elle est apparue sur ces processeurs à une époque où le processeur devenait plus rapide que la mémoire.

L'idée est là encore de précharger des instructions en avance. Sauf que cette fois-ci, on ne charge pas plusieurs instructions à la fois. Au contraire, les instructions sont préchargées séquentiellement, un ou deux octet à la fois. En conséquence, le tampon de préchargement est remplacé par une mémoire FIFO appelée la '''''Prefetch Input Queue''''', terme abrévié en PIQ. Les instructions sont accumulées une par une dans la PIQ, elles en sortent une par une au fur et à mesure pour alimenter le décodeur d'instruction.

Pendant que le processeur exécute une instruction, on précharge la suivante. Sans ''prefetch input queue'', le processeur chargeait une instruction, la décodait et l'exécutait, puis chargeait la suivante, et ainsi de suite. Avec un tampond e préchargement, le processeur chargeait plusieurs instruction en une seule fois
, puis les exécutait les unes après les autres. Avec la ''prefetch input queue'', pendant qu'une instruction est en cours de décodage/exécution, le processeur précharge l'instruction suivante. Si une instruction prend vraiment beaucoup de temps pour s'exécuter, le processeur peut en profiter pour précharger l'instruction encore suivante, et ainsi de suite, jusqu'à une limite de 4/6 instructions (la limite dépend du processeur).

La ''prefetch input queue'' permet de précharger l'instruction suivante à condition qu'aucun autre accès mémoire n'ait lieu. Si l'instruction en cours d'exécution effectue des accès mémoire, ceux-ci sont prioritaires sur tout le reste, le préchargement de l'instruction suivante est alors mis en pause ou inhibé. Par contre, si la mémoire n'est pas utilisée par l'instruction en cours d'exécution, le processeur lit l'instruction suivante en RAM et la copie dans la ''prefetch input queue''. En conséquence, il arrive que la ''prefetch input queue'' n'ait pas préchargé l'instruction suivante, alors que le décodeur d'instruction est prêt pour la décoder. Dans ce cas, le décodeur doit attendre que l'instruction soit chargée.

Les instructions préchargées dans la ''Prefetch input queue'' y attendent que le processeur les lise et les décode. Les instructions préchargées sont conservées dans leur ordre d'arrivée, afin qu'elles soient exécutées dans le bon ordre, ce qui fait que la ''Prefetch input queue'' est une mémoire de type FIFO. L'étape de décodage pioche l'instruction à décoder dans la ''Prefetch input queue'', cette instruction étant par définition la plus ancienne, puis la retire de la file.

Le premier processeur commercial grand public à utiliser une ''prefetch input queue'' était le 8086. Il pouvait précharger à l'avance 6 octets d’instruction. L'Intel 8088 avait lui aussi une ''Prefetch input queue'', mais qui ne permettait que de précharger 4 instructions. La taille idéale de la FIFO dépend de nombreux paramètres. On pourrait croire que plus elle peut contenir d'instructions, mieux c'est, mais ce n'est pas le cas, pour des raisons que nous allons expliquer dans quelques paragraphes.

[[File:80186 arch.png|centre|vignette|700px|upright=2|Architecture du 8086, du 80186 et de ses variantes.]]

Vous remarquerez que j'ai exprimé la capacité de la ''prefetch input queue'' en octets et non en instructions. La raison est que sur les processeurs x86, les instructions sont de taille variable, avec une taille qui varie entre un octet et 6 octets. Cependant, le décodage des instructions se fait un octet à la fois : le décodeur lit un octet, puis éventuellement le suivant, et ainsi de suite jusqu'à atteindre la fin de l'instruction. En clair, le décodeur lits les instructions longues octet par octet dans la ''Prefetch input queue''. Pour cela, le décodeur dispose d'une micro-opération pour lire un octet depuis la ''Prefetch input queue''.

Le décodeur devait attendre que qu'un moins un octet soit disponible dans la ''Prefetch input queue'', pour le lire. Il lisait alors cet octet et déterminait s'il contenait une instruction complète ou non. Si c'est une instruction complète, il la décodait et l''exécutait, puis passait à l'instruction suivante. Sinon, il lit un second octet depuis la ''Prefetch input queue'', le copie dans le registre d'instruction, et relance le décodage. Là encore, le décodeur vérifie s'il a une instruction complète, et lit un troisième octet si besoin, puis rebelote avec un quatrième octet lu, etc.

Un circuit appelé le ''loader'' synchronisait le décodeur d'instruction et la ''Prefetch input queue''. Il fournissait un bit qui indiquait si le premier octet d'une instruction était disponible dans la ''Prefetch input queue''. Un second bit indiquait si l'octet suivant était disponible, nous verrons pourquoi dans ce qui suit. Le ''loader'' recevait aussi des signaux de la part du décodeur d'instruction. Le décodeur envoyait le signal ''Run Next Instruction'' pour lire une instruction, qui était alors dépilée de la ''Prefetch input queue''. Le décodeur d'instruction pouvait aussi envoyer un signal ''Next-to-last (NXT)'', un cycle avant que l'instruction en cours ne termine. Le ''loader'' réagissait en préchargeant l'octet suivant. En clair, ce signal permettait de précharger l'instruction suivante avec un cycle d'avance, si celle-ci n'était pas déjà dans la ''Prefetch input queue''.

Le bus de données du 8086 faisait 16 bits, alors que celui du 8088 ne permettait que de lire un octet à la fois. Et cela avait un impact sur la ''prefetch input queue''. La ''prefetch input queue'' était composée de 4 registres de 8 bits, avec un port d'écriture de 8 bits pour précharger les instructions octet par octet, et un port de lecture de 8 bits pour alimenter le décodeur. En clair, tout faisait 8 bits. Le 8086, lui utilisait des registres de 16 bits et un port d'écriture de 16 bits. le port de lecture restait de 8 bits, et était précédé d'un multiplexeur qui prenait 16 bits et sélectionnait l'octet adéquat. Sa ''prefetch input queue'' préchargeait les instructions par paquets de 2 octets, non octet par octet, alors que le décodeur consommait les instructions octet par octet. Il s’agissait donc d'une sorte d'intermédiaire entre ''prefetch input queue'' à la 8088 et tampon de préchargement.

Les branchements posent des problèmes avec la ''Prefetch input queue'' : à cause d'eux, on peut charger à l'avance des instructions qui sont zappées par un branchement et ne sont pas censées être exécutées. Si un branchement est chargé, toutes les instructions préchargées après sont potentiellement invalides. Si le branchement est non-pris, les instructions chargées sont valides, elles sont censées s’exécuter. Mais si le branchement est pris, elles ont été chargées à tort et ne doivent pas s’exécuter. 

Pour éviter cela, la ''Prefetch input queue'' est vidée quand le processeur détecte un branchement. Pour cela, le décodeur d'instruction dispose d'une micro-opération qui vide la ''Prefetch input queue'', elle invalide les instructions préchargées.  Cette détection ne peut se faire qu'une fois le branchement décodé, qu'une fois que l'on sait que l'instruction décodée est un branchement. En clair, le décodeur invalide la ''Prefetch input queue'' quand il détecte un branchement. Les interruptions posent le même genre de problèmes. Il faut impérativement vider la ''Prefetch input queue'' quand une interruption survient, avant de la traiter.

Il faut noter qu'une ''Prefetch input queue'' interagit assez mal avec le ''program counter''. En effet, la ''Prefetch input queue'' précharge les instructions séquentiellement. Pour savoir où elle en est rendue, elle mémorise l'adresse de la prochaine instruction à charger dans un '''registre de préchargement''' dédié. Il serait possible d'utiliser un ''program counter'' en plus du registre de préchargement, mais ce n'est pas la solution qui a été utilisée. Les processeurs Intel anciens ont préféré n'utiliser qu'un seul registre de préchargement en remplacement du ''program counter''. Après tout, le registre de préchargement n'est qu'un ''program counter'' ayant pris une avance de quelques cycles d'horloge, qui a été incrémenté en avance.

Et cela ne pose pas de problèmes, sauf avec certains branchements. Par exemple, certains branchements relatifs demandent de connaitre la véritable valeur du ''program counter'', pas celle calculée en avance. Idem avec les instructions d'appel de fonction, qui demandent de sauvegarder l'adresse de retour exacte, donc le vrai ''program counter''. De telles situations demandent de connaitre la valeur réelle du ''program counter'', celle sans préchargement. Pour cela, le décodeur d'instruction dispose d'une instruction pour reconstituer le ''program counter'', à savoir corriger le ''program coutner'' et éliminer l'effet du préchargement.

La micro-opération de correction se contente de soustraire le nombre d'octets préchargés au registre de préchargement. Le nombre d'octets préchargés est déduit à partir des deux pointeurs intégré à la FIFO, qui indiquent la position du premier et du dernier octet préchargé. Le bit qui indique si la FIFO est vide était aussi utilisé. Les deux pointeurs sont lus depuis la FIFO, et sont envoyés à un circuit qui détermine le nombre d'octets préchargés. Sur le 8086, ce circuit était implémenté non pas par un circuit combinatoire, mais par une mémoire ROM équivalente. La petite taille de la FIFO faisait que les pointeurs étaient très petits et la ROM l'était aussi.

Un autre défaut est que la ''Prefetch input queue'' se marie assez mal avec du code auto-modifiant. Un code auto-modifiant est un programme qui se modifie lui-même, en remplaçant certaines instructions par d'autres, en en retirant, en en ajoutant, lors de sa propre exécution. De tels programmes sont rares, mais la technique était utilisée dans quelques cas au tout début de l'informatique sur des ordinateurs rudimentaires. Ceux-ci avaient des modes d'adressages tellement limités que gérer des tableaux de taille variable demandait d'utiliser du code auto-modifiant pour écrire des boucles.

Le problème avec la ''Prefetch input queue'' survient quand des instructions sont modifiées immédiatement après avoir été préchargées. Les instructions dans la ''Prefetch input queue'' sont l'ancienne version, alors que la mémoire RAM contient les instructions modifiées. Gérer ce genre de cas est quelque peu complexe. Il faut en effet vider la ''Prefetch input queue'' si le cas arrive, ce qui demande d'identifier les écritures qui écrasent des instructions préchargées. C'est parfaitement possible, mais demande de transformer la ''Prefetch input queue'' en une mémoire hybride, à la fois mémoire associative et mémoire FIFO. Cela ne vaut que très rarement le coup, aussi les ingénieurs ne s’embêtent pas à mettre ce correctif en place, le code automodifiant est alors buggé.

Le décodeur d'instruction dispose aussi d'une micro-opération qui stoppe le préchargement des instructions dans la ''Prefetch input queue''.

: Pour ceux qui ont déjà lu un cours d'architecture des ordinateurs, la relation entre ''prefetch input queue'' et pipeline est quelque peu complexe. En apparence, la ''prefetch input queue'' permet une certaines forme de pipeline, en chargeant une instruction pendant que la précédente s'exécute. Les problématiques liées aux branchements ressemblent beaucoup à celles de la prédiction de branchement. Cependant, il est possible de dire qu'il s'agit plus d'une technique de préchargement que de pipeline. La différence entre les deux est assez subtile et les frontières sont assez floues, mais le fait est que l'instruction en cours d'exécution et le préchargement peuvent tout deux faire des accès mémoire et que l'instruction en cours a la priorité. Un vrai pipeline se débrouillerait avec une architecture Harvard, non avec un bus mémoire unique pour le chargement des instruction et la lecture/écriture des données.

===Le ''Zero-overhead looping''===

Nous avions vu dans le chapitre sur les instructions machines, qu'il existe des instructions qui permettent de grandement faciliter l'implémentation des boucles. Il s'agit de l'instruction REPEAT, utilisée sur certains processeurs de traitement de signal. Elle répète l'instruction suivante, voire une série d'instructions, un certain nombre de fois. Le nombre de répétitions est mémorisé dans un registre décrémenté à chaque itération de la boucle. Elle permet donc d'implémenter une boucle FOR facilement, sans recourir à des branchements ou des conditions.

Une technique en lien avec cette instruction permet de grandement améliorer les performances et la consommation d'énergie. L'idée est de mémoriser la boucle, les instructions à répéter, dans une petite mémoire cache située entre l'unité de chargement et le séquenceur. Le cache en question s'appelle un '''tampon de boucle''', ou encore un ''hardware loop buffer''. Grâce à lui, il n'y a pas besoin de charger les instructions à chaque fois qu'on les exécute, on les charge une bonne fois pour toute : c'est plus rapide. Bien sûr, il ne fonctionne que pour de petites boucles, mais il en est de même avec l'instruction REPEAT.

&lt;noinclude&gt;
{{NavChapitre | book=Fonctionnement d'un ordinateur
           | prev=Le chemin de données
           | prevText=Le chemin de données
           | next=L'unité de contrôle
           | nextText=L'unité de contrôle
}}
&lt;/noinclude&gt;</text>
      <sha1>7opblxsu3i2l2l09pdrb037b4uiisvq</sha1>
    </revision>
    <revision>
      <id>744089</id>
      <parentid>744088</parentid>
      <timestamp>2025-06-03T20:16:39Z</timestamp>
      <contributor>
        <username>Mewtow</username>
        <id>31375</id>
      </contributor>
      <minor />
      <comment>/* La prefetch input queue */</comment>
      <origin>744089</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="46359" sha1="hj8zq9a97hto7uddt4ao3kyn9of9e6j" xml:space="preserve">L'unité de contrôle s'occupe du chargement des instructions et de leur interprétation, leur décodage. Elle contient deux circuits : l''''unité de chargement''' qui charge l'instruction depuis la mémoire, et le '''séquenceur''' qui commande le chemin de données. Les deux circuits sont séparés, mais ils communiquent entre eux, notamment pour gérer les branchements. Dans ce chapitre, nous allons nous intéresser au chargement d'une instruction depuis la RAM/ROM, nous verrons l'étape de décodage de l'instruction au prochain chapitre.

==Le chargement d'une instruction==

[[File:Étape de chargement.png|vignette|upright=1|Étape de chargement.]]

L'étape de chargement (ou ''fetch'') doit faire deux choses : mettre à jour le ''program counter'' et lire l'instruction en mémoire RAM ou en ROM. Les deux étapes peuvent être faites en parallèle, dans des circuits séparés. Pendant que l'instruction est lue depuis la mémoire RAM/ROM, le ''program counter'' est incrémenté et/ou altéré par un branchement.

Pour lire l'instruction, on envoie le ''program counter'' sur le bus d'adresse et on récupère l'instruction sur le bus de données pour l'envoyer sur l'entrée du séquenceur. Et cela demande de connecter le séquenceur au bus mémoire, à travers l'interface mémoire. Et sur ce point, la situation est différente selon que l'on parler d'une architecture Harvard ou Von Neumann.

===Les interconnexions entre séquenceur et bus mémoire===

Sur les architectures Harvard, le séquenceur et le chemin de donnée utilisent des interfaces mémoire séparées. Le séquenceur est directement relié au bus mémoire de la ROM, alors que le chemin de données est connecté à la RAM.

[[File:Microarchitecture de l'interface mémoire d'une architecture Harvard.png|centre|vignette|upright=2|Microarchitecture de l'interface mémoire d'une architecture Harvard]]

Mais sur les architectures Von-Neumann et affiliées, le séquenceur et le chemin de donnée partagent la même interface mémoire. Et cela pose deux problèmes.

Le premier problème est que le bus mémoire doit être libéré une fois l'instruction chargée, pour un éventuel accès mémoire. Mais le séquenceur doit conserver une copie de l'instruction chargée, sans quoi il ne peut pas décoder l'instruction correctement. Par exemple, si l'instruction met plusieurs cycles à s'exécuter, le séquenceur doit conserver une copie de l'instruction durant ces plusieurs cycles. La solution à ce problème est un '''registre d'instruction''' situé juste avant le séquenceur, qui mémorise l'instruction chargée.

[[File:Registre d'instruction.png|centre|vignette|upright=2|Registre d'instruction.]]

Le second problème est de gérer le flot des instructions/données entre le bus mémoire, le chemin de données et le séquenceur. Le processeur doit connecter l'interface mémoire soit au séquenceur, soit au chemin de données et cela complique le réseau d'interconnexion interne au processeur.

Une première solution utilise un bus unique qui relie l'interface mémoire, le séquenceur et le chemin de données. Pour charger une instruction, le séquenceur copie le ''program counter'' sur le bus d'adresse, attend que l'instruction lue soit disponible sur le bus de données, puis la copie dans le registre d'instruction. Le bus mémoire est alors libre et peut être utilisé pour lire ou écrire des données, si le besoin s'en fait sentir.

Il faut noter que l'usage d'un bus unique a un impact sur l'organisation interne du chemin de données. Par exemple, le chapitre précédent nous a montré comment implémenter un chemin de données basique, avec des multiplexeurs et démultiplexeurs. Et bien ces chemins de données ne marchent pas vraiment avec un bus interne unique. Il est possible de les adapter, mais au prix d'une complexité largement supérieure. Un bus interne unique marche mieux quand le banc de registre est mono-port. C'est pourquoi il a été utilisé sur d'anciennes architectures appelées des architectures à accumulateur et à pile, que nous verrons dans quelques chapitres, qui utilisaient un banc de registre mono-port.

[[File:Microarchitecture de l'interface mémoire d'une architecture von neumann.png|centre|vignette|upright=2|Microarchitecture de l'interface mémoire d'une architecture von neumann]]

Une autre solution utilise deux bus interne séparés : un connecté au bus d'adresse, l'autre au bus de données. Le ''program counter'' est alors connecté au bus interne d'adresse, le séquenceur est relié au bus interne de données. Notons que la technique marche bien si le ''program counter'' est dans le banc de registre : les interconnexions utilisées pour gérer l'adressage indirect permettent d'envoyer le ''program counter'' sur le bus d'adresse sans ajout de circuit.

Le tout peut être amélioré en remplaçant les deux bus par des multiplexeurs et démultiplexeurs. Le bus d'adresse est précédé par un multiplexeur, qui permet de faire le choix entre ''Program Counter'', adresse venant du chemin de données, ou adresse provenant du séquenceur (adressage absolu). De même, le bus de données est suivi par un démultiplexeur qui envoie la donnée/instruction lue soit au registre d'instruction, soit au chemin de données. Le tout se marie très bien avec les chemins de donnée vu dans le chapitre précédent. Au passage, il faut noter que cette solution nécessite un banc de registre multi-port.

[[File:Connexion du program counter sur les bus avec PC isolé.png|centre|vignette|upright=2|Connexion du program counter sur les bus avec PC isolé]]

===Le chargement des instructions de longueur variable===

Le chargement des instructions de longueur variable pose de nombreux problèmes. Le premier est que mettre à jour le ''program counter'' demande de connaitre la longueur de l'instruction chargée, pour l'ajouter au ''program counter''. Si la longueur d'une instruction est variable, on doit connaitre cette longueur d'une manière où d'une autre. La solution la plus simple indique la longueur de l'instruction dans une partie de l'opcode ou de la représentation en binaire de l'instruction. Mais les processeurs haute performance de nos PC utilisent d'autres solutions, qui n'encodent pas explicitement la taille de l'instruction.

Les processeurs récents utilisent un registre d'instruction de grande taille, capable de mémoriser l'instruction la plus longue du processeur. Par exemple, si un processeur supporte des instructions allant de 1 à 8 octets, comme les CPU x86, le registre d'instruction fera 8 octets. Le décodeur d'instruction vérifie à chaque cycle le contenu du registre d'instruction. Si une instruction est détectée dedans, son décodage commence, peu importe la taille de l'instruction. Une fois l'instruction exécutée, elle est retirée du registre d'instruction. Reste à alimenter le registre d'instruction, à charger des instructions dedans. Et pour cela deux solutions : soit on charge l'instruction en plusieurs fois, soit d'un seul coup.

La solution la plus simple charge les instructions par mots de 8, 16, 32, 64 bits. Ils sont accumulés dans le registre d'instruction jusqu'à détecter une instruction complète. La technique marche nettement mieux si les instructions sont très longues. Par exemple, les CPU x86 ont des instructions qui vont de 1 à 15 octets, ce qui fait qu'ils utilisent cette technique. Précisément, elle marche si les instructions les plus longues sont plus grandes que le bus mémoire.

Une autre solution charge un bloc de mots mémoire aussi grand que la plus grande instruction. Par exemple, si le processeur gère des instructions allant de 1 à 4 octets, il charge 4 octets d'un seul coup dans le registre d'instruction. Il va de soit que cette solution ne marche que si les instructions du processeur sont assez courtes, au plus aussi courtes que le bus mémoire. Ainsi, on est sûr de charger obligatoirement au moins une instruction complète, et peut-être même plusieurs. Le contenu du registre d'instruction est alors découpé en instructions au fil de l'eau. 

Utiliser un registre d'instruction large pose problème avec des instructions à cheval entre deux blocs. Il se peut qu'on n'ait pas une instruction complète lorsque l'on arrive à la fin du bloc, mais seulement un morceau. Le problème se manifeste peu importe que l'instruction soit chargée d'un seul coup ou bien en plusieurs fois.

[[File:Instructions non alignées.png|centre|vignette|upright=2|Instructions non alignées.]]

Dans ce cas, on doit décaler le morceau de bloc pour le mettre au bon endroit (au début du registre d'instruction), et charger le prochain bloc juste à côté. On a donc besoin d'un circuit qui décale tous les bits du registre d'instruction, couplé à un circuit qui décide où placer dans le registre d'instruction ce qui a été chargé, avec quelques circuits autour pour configurer les deux circuits précédents.

[[File:Décaleur d’instruction.png|centre|vignette|upright=2|Décaleur d’instruction.]]

Une autre solution se passe de registre d'instruction en utilisant à la place l'état interne du séquenceur. Là encore, elle charge l'instruction morceau par morceau, typiquement par blocs de 8, 16 ou 32 bits. Les morceaux ne sont pas accumulés dans le registre d'instruction, la solution utilise à la place l'état interne du séquenceur. Les mots mémoire de l'instruction sont chargés à chaque cycle, faisant passer le séquenceur d'un état interne à un autre à chaque mot mémoire. Tant qu'il n'a pas reçu tous les mots mémoire de l'instruction, chaque mot mémoire non terminal le fera passer d'un état interne à un autre, chaque état interne encodant les mots mémoire chargés auparavant. S'il tombe sur le dernier mot mémoire d'une instruction, il rentre dans un état de décodage.

==L'incrémentation du ''program counter''==

À chaque chargement, le ''program counter'' est mis à jour afin de pointer sur la prochaine instruction à charger. Sur la quasi-totalité des processeurs, les instructions sont placées dans l'ordre d’exécution dans la RAM. En faisant ainsi, on peut mettre à jour le ''program counter'' en lui ajoutant la longueur de l'instruction courante. Déterminer la longueur de l'instruction est simple quand les instructions ont toutes la même taille, mais certains processeurs ont des instructions de taille variable, ce qui complique le calcul. Dans ce qui va suivre, nous allons supposer que les instructions sont de taille fixe, ce qui fait que le ''program counter'' est toujours incrémenté de la même valeur.

Il existe deux méthodes principales pour incrémenter le ''program counter'' : soit le ''program counter'' a son propre additionneur, soit le ''program counter'' est mis à jour par l'ALU. Pour ce qui est de l'organisation des registres, soit le ''program counter'' est un registre séparé des autres, soit il est regroupé avec d'autres registres dans un banc de registre. En tout, cela donne quatre organisations possibles.
* Un ''program counter'' séparé relié à un incrémenteur séparé.
* Un ''program counter'' séparé des autres registres, incrémenté par l'ALU.
* Un ''program counter'' intégré au banc de registre, relié à un incrémenteur séparé.
* Un ''program counter'' intégré au banc de registre, incrémenté par l'ALU.

[[File:Calcul du program counter.png|centre|vignette|upright=2|les différentes méthodes de calcul du program counter.]]

Les processeurs haute performance modernes utilisent tous la première méthode. Les autres méthodes étaient surtout utilisées sur les processeurs 8 ou 16 bits, elles sont encore utilisées sur quelques microcontrôleurs de faible puissance. Nous auront l'occasion de donner des exemples quand nous parlerons des processeurs 8 bits anciens, dans le chapitre sur les architectures à accumulateur et affiliées.

===Le ''program counter'' mis à jour par l'ALU===

Sur certains processeurs, le calcul de l'adresse de la prochaine instruction est effectué par l'ALU. L'avantage de cette méthode est qu'elle économise un incrémenteur dédié au ''program counter''. Ce qui explique que cette méthode était utilisée sur les processeurs assez anciens, à une époque où un additionneur pouvait facilement prendre 10 à 20% des transistors disponibles. Le désavantage principal est une augmentation de la complexité du séquenceur, qui doit gérer la mise à jour du ''program counter''. De plus, la mise à jour du ''program counter'' ne peut pas se faire en même temps qu'une opération arithmétique, ce qui réduit les performances.

Si on incrémente le ''program counter'' avec l'ALU, il est intéressant de le placer dans le banc de registres. Un désavantage est qu'on perd un registre. Par exemple, avec un banc de registre de 16 registres, on ne peut adresser que 15 registres généraux. De plus ce n'est pas l'idéal pour le décodage des instructions et pour le séquenceur. Si le processeur dispose de plusieurs bancs de registres, le ''program counter'' est généralement placé dans le banc de registre dédié aux adresses. Sinon, il est placé avec les nombres entiers/adresses.

D'anciens processeurs incrémentaient le ''program counter'' avec l'ALU, mais utilisaient bien un registre séparé pour le ''program counter''. Cette méthode est relativement simple à implémenter : il suffit de connecter/déconnecter le ''program counter'' du bus interne suivant les besoins. Le ''program counter'' est déconnecté pendant l’exécution d'une instruction, il est connecté au bus interne pour l'incrémenter. C'est le séquenceur qui gère le tout. L'avantage de cette séparation est qu'elle est plus facile à gérer pour le séquenceur. De plus, on gagne un registre général/entier dans le banc de registre.

===Le compteur programme===

Dans la quasi-totalité des processeurs modernes, le ''program counter'' est un vulgaire compteur comme on en a vu dans les chapitres sur les circuits, ce qui fait qu'il passe automatiquement d'une adresse à la suivante. Dans ce qui suit, nous allons appeler ce registre compteur : le '''compteur ordinal'''. L'usage d'un compteur simplifie fortement la conception du séquenceur. Le séquenceur n'a pas à gérer la mise à jour du ''program counter'', sauf en cas de branchements. De plus, il est possible d'incrémenter le ''program counter'' pendant que l'unité de calcul effectue une opération arithmétique, ce qui améliore grandement les performances. Le seul désavantage est qu'elle demande d'ajouter un incrémenteur dédié au ''program counter''.

Sur les processeurs très anciens, les instructions faisaient toutes un seul mot mémoire et le compteur ordinal était un circuit incrémenteur des plus basique. Sur les processeurs modernes, le compteur est incrémenté par pas de 4 si les instructions sont codées sur 4 octets, 8 si les instructions sont codées sur 8 octets, etc. Concrètement, le compteur est un circuit incrémenteur auquel on aurait retiré quelques bits de poids faible. Par exemple, si les instructions sont codées sur 4 octets, on coupe les 2 derniers bits du compteur. Si les instructions sont codées sur 8 octets, on coupe les 3 derniers bits du compteur. Et ainsi de suite.

Il a existé quelques processeurs pour lesquelles le ''program counter'' était non pas un compteur binaire classique, mais un ''linear feedback shift register''. L'avantage est que le circuit d'incrémentation utilisait bien moins de portes logiques, l'économie était substantielle. Mais un défaut est que des instructions consécutives dans le programme n'étaient pas consécutives en mémoire. Il existait cependant une table de correspondance pour dire : la première instruction est à telle adresse, la seconde à telle autre, etc. Un exemple de processeur de ce type est le TMS 1000 de Texas Instrument, un des premiers microcontrôleur 4 bits datant des années 70.

Une amélioration de la solution précédente utilise un circuit incrémenteur partagé entre le ''program counter'' et d'autres registres. L'incrémenteur est utilisé pour incrémenter le ''program counter'', mais aussi pour effectuer d'autres calculs d'adresse. Par exemple, sur les architectures avec une pile d'adresse de retour, il est possible de partager l'incrémenteur/décrémenteur avec le pointeur de pile ( la technique ne marche pas avec une pile d'appel). Un autre exemple est celui des processeurs qui gèrent automatiquement le rafraichissement mémoire, grâce à, un compteur intégré dans le processeur. Il est possible de partager l'incrémenteur du ''program counter'' avec le compteur de rafraichissement mémoire, qui mémorise la prochaine adresse mémoire à rafraichir. Nous avions déjà abordé ce genre de partage dans le chapitre sur le chemin de données, dans l'annexe sur le pointeur de pile, mais nous verrons d'autres exemples dans le chapitre sur les architectures hybride accumulateur-registre 8/16 bits.

===Quand est mis à jour le ''program counter'' ?===

Le ''program counter'' est mis à jour quand il faut charger une nouvelle instruction. Reste qu'il faut savoir quand le mettre à jour. Incrémenter le ''program counter'' à intervalle régulier, par exemple à chaque cycle d’horloge, fonctionne sur les processeurs où toutes les instructions mettent le même temps pour s’exécuter. Mais de tels processeurs sont très rares. Sur la quasi-totalité des processeurs, les instructions ont une durée d’exécution variable, elles ne prennent pas le même nombre de cycle d'horloge pour s’exécuter. Le temps d’exécution d'une instruction varie selon l'instruction, certaines sont plus longues que d'autres. Tout cela amène un problème : comment incrémenter le ''program counter'' avec des instructions avec des temps d’exécution variables ?

La réponse est que la mise à jour du ''program counter'' démarre quand l'instruction précédente a terminée de s’exécuter, plus précisément un cycle avant. C'est un cycle avant pour que l'instruction chargée soit disponible au prochain cycle pour le décodeur. Pour cela, le séquenceur doit déterminer quand l'instruction est terminée et prévenir le ''program counter'' au bon moment. Il faut donc une interaction entre séquenceur et circuit de chargement. Le circuit de chargement contient une entrée Enable, qui autorise la mise à jour du ''program counter''. Le séquenceur met à 1 cette entrée pour prévenir au ''program counter'' qu'il doit être incrémenté au cycle suivant ou lors du cycle courant. Cela permet de gérer simplement le cas des instructions multicycles. 

[[File:Commande de la mise à jour du program counter.png|centre|vignette|upright=2|Commande de la mise à jour du program counter.]]

Toute la difficulté est alors reportée dans le séquenceur, qui doit déterminer la durée d'une instruction. Pour gérer la mise à jour du ''program counter'', le séquenceur doit déterminer la durée d'une instruction. Cela est simple pour les instructions arithmétiques et logiques, qui ont un nombre de cycles fixe, toujours le même. Une fois l'instruction identifiée par le séquenceur, il connait son nombre de cycles et peut programmer un compteur interne au séquenceur, qui compte le nombre de cycles de l'instruction, et fournit le signal Enable au ''program counter''. Mais cette technique ne marche pas vraiment pour les accès mémoire, dont la durée n'est pas connue à l'avance, surtout sur les processeurs avec des mémoires caches. Pour cela, le séquenceur détermine quand l'instruction mémoire est finie et prévient le ''program counter'' quand c'est le cas.

Il existe quelques processeurs pour lesquels le temps de calcul dépend des opérandes de l'instruction. On peut par exemple avoir une division qui prend 10 cycles avec certaines opérandes, mais 40 cycles avec d'autres opérandes. Mais ces processeurs sont rares et cela est surtout valable pour les opérations de multiplication/division, guère plus. Le problème est alors le même qu'avec les accès mémoire et la solution est la même : l'ALU prévient le séquenceur quand le résultat est disponible.

==Les branchements et le ''program counter''==

Un branchement consiste juste à écrire l'adresse de destination dans le ''program counter''. L'implémentation des branchements demande d'extraire l'adresse de destination et d'altérer le ''program counter'' quand un branchement est détecté. Pour cela, le décodeur d'instruction détecte si l'instruction exécutée est un branchement ou non, et il en déduit où trouver l'adresse de destination.

L'adresse de destination se trouve à un endroit qui dépend du mode d'adressage du branchement. Pour rappel, on distingue quatre modes d'adressage pour les branchements : direct, indirect, relatif et implicite. Pour les branchements directs, l'adresse est intégrée dans l'instruction de branchement elle-même et est extraite par le séquenceur. Pour les branchements indirects, l'adresse de destination est dans le banc de registre. Pour les branchements relatifs, il faut ajouter un décalage au ''program counter'', décalage extrait de l'instruction par le séquenceur. Enfin, les instructions de retour de fonction lisent l'adresse de destination depuis la pile. L'implémentation de ces quatre types de branchements est très différente.

L'altération du ''program counter'' dépend de si le ''program counter'' est dans un compteur séparé ou s'il est dans le banc de registre. Nous avons vu plus haut qu'il y a quatre cas différents, mais nous n'allons voir que deux cas : celui où le ''program counter'' est dans le banc de registre et est incrémenté par l'unité de calcul, celui avec un ''program counter'' séparé avec son propre incrémenteur. Les deux autres cas ne sont utilisés que sur des architectures à accumulateur ou à pile spécifiques, que nous n'avons pas encore vu à ce stade du cours et que nous verrons en temps voulu dans le chapitre sur ces architectures.

===L’implémentation des branchements avec un ''program counter'' intégré au banc de registres===

Le cas le plus simple est celui où le ''program counter'' est intégré au banc de registre, avec une incrémentation faite par l'unité de calcul. Charger une instruction revient alors à effectuer une instruction LOAD en adressage indirect, à deux différences près : le registre sélectionné est le ''program counter'', l’instruction est copiée dans le registre d'instruction et non dans le banc de registre. L'incrémentation du ''porgram counter'' est implémenté avec des micro-opérations qui agissent sur le chemin de données, au même titre que les branchements indirects, relatifs et directs.
* Les branchements indirects copient un registre dans le ''program counter'', ce qui revient simplement à faire une opération MOV entre deux registres, dont le ''program counter'' est la destination.
* L'opération inverse d'un branchement indirect, qui copie le ''program counter'' dans un registre général, est utile pour sauvegarder l'adresse de retour d'une fonction.
* Les branchements directs copient une adresse dans le ''program counter'', ce qui les rend équivalents à une opération MOV avec une constante immédiate, dont le ''program counter'' est la destination.
* Les branchements relatifs sont une opération arithmétique entre le ''program counter'' et un opérande en adressage immédiat.

En clair, à partir du moment où le chemin de données supporte les instructions MOV et l'addition, avec les modes d'adressage adéquat, il supporte les branchements. Aucune modification du chemin de données n'est nécessaire, le séquenceur gére le chargement d'une instruction avec les micro-instructions adéquates : une micro-opération ADD pour incrémenter le ''program counter'', une micro-opération LOAD pour le chargement de l'instruction.

Notons que sur certaines architectures, le ''program counter'' est adressable au même titre que les autres registres du banc de registre. Les instructions de branchement sont alors remplacées par des instructions MOV ou des instructions arithmétique équivalentes, comme décrit plus haut.

===L’implémentation des branchements avec un ''program counter'' séparé===

Étudions maintenant le cas où le ''program counter'' est dans un registre/compteur séparé. Rappelons que tout compteur digne de ce nom possède une entrée de réinitialisation, qui remet le compteur à zéro. De plus, on peut préciser à quelle valeur il doit être réinitialisé. Ici, la valeur à laquelle on veut réinitialiser le compteur n'est autre que l'adresse de destination du branchement. Implémenter un branchement est donc simple : l'entrée de réinitialisation est commandée par le circuit de détection des branchements, alors que la valeur de réinitialisation est envoyée sur l'entrée adéquate. En clair, nous partons du principe que le ''program counter'' est implémenté avec ce type de compteur :

[[File:Fonctionnement d'un compteur (décompteur), schématique.jpg|centre|vignette|upright=1.5|Fonctionnement d'un compteur (décompteur), schématique]]

Toute la difficulté est de présenter l'adresse de destination au ''program counter''. Pour les branchements directs, l'adresse de destination est fournie par le séquenceur. L'adresse de destination du branchement sort du séquenceur et est présentée au ''program counter'' sur l'entrée adéquate. Voici donc comment sont implémentés les branchements directs avec un ''program counter'' séparé du banc de registres. Le schéma ci-dessous marche peu importe que le ''program counter'' soit incrémenté par l'ALU ou par un additionneur dédié.

[[File:Unité de détection des branchements dans le décodeur.png|centre|vignette|upright=2|Unité de détection des branchements dans le décodeur]]

Les branchements relatifs sont ceux qui font sauter X instructions plus loin dans le programme. Leur implémentation demande d'ajouter une constante au ''program counter'', la constante étant fournie dans l’instruction. Là encore, deux solutions sont possibles : réutiliser l'ALU pour calculer l'adresse, ou utiliser un additionneur séparé. L'additionneur séparé peut être fusionné avec l'additionneur qui incrémente le ''program counter'' pour passer à l’instruction suivante.

[[File:Unité de chargement qui gère les branchements relatifs.png|centre|vignette|upright=2|Unité de chargement qui gère les branchements relatifs.]]

Pour les branchements indirects, il suffit de lire le registre voulu et d'envoyer le tout sur l'entrée adéquate du ''program counter''. Il faut alors rajouter un multiplexeur pour que l'entrée de réinitialisationr ecoive la bonne adresse de destination.

[[File:Unité de chargement qui gère les branchements directs.png|centre|vignette|upright=2|Unité de chargement qui gère les branchements directs et indirects.]]

Toute la difficulté de l'implémentation des branchements est de configurer les multiplexeurs, ce qui est réalisé par le séquenceur en fonction du mode d'adressage du branchement.

==Les optimisations du chargement des instructions==

Charger une instruction est techniquement une forme d'accès mémoire un peu particulier. En clair, charger une instruction prend au minimum un cycle d'horloge, et cela peut rapidement monter à 3-5 cycles, si ce n'est plus. L'exécution des instructions est alors fortement ralentit par la mémoire. Par exemple, imaginez que la mémoire mette 3 cycles d'horloges pour charger une instruction, alors qu'une instruction s’exécute en 1 cycle (si les opérandes sont dans les registres). La perte de performance liée au chargement des instructions est alors substantielle. Heureusement, il est possible de limiter la casse en utilisant des mémoires caches, ainsi que d'autres optimisations, que nous allons voir dans ce qui suit.

===Le tampon de préchargement===

La technique dite du '''préchargement''' est utilisée dans le cas où la mémoire a un temps d'accès important. Mais si la latence de la RAM est un problème, le débit ne l'est pas. Il est possible d'avoir une RAM lente, mais à fort débit. Par exemple, supposons que la mémoire puisse charger 4 instructions (de taille fixe) en 3 cycles. Le processeur peut alors charger 4 instructions en un seul accès mémoire, et les exécuter l'une après l'autre, une par cycle d'horloge. Les temps d'attente sont éliminés : le processeur peut décoder une nouvelle instruction à chaque cycle. Et quand la dernière instruction préchargée est exécutée, la mémoire est de nouveau libre, ce qui masque la latence des accès mémoire.

[[File:Tampon de préchargement d'instruction.png|vignette|Tampon de préchargement d'instruction]]

La seule contrainte est de mettre les instructions préchargées en attente. La solution pour cela est d'utiliser un registre d'instruction très large, capable de mémoriser plusieurs instructions à la fois. Ce registre est de plus connecté à un multiplexeur qui permet de sélectionner l'instruction adéquate dans ce registre. Ce multiplexeur est commandé par le ''program counter'' et quelques circuits annexes. Ce super-registre d'instruction est appelé un '''tampon de préchargement'''.

La méthode a une implémentation nettement plus simple avec des instructions de taille fixe, alignées en mémoire. La commande du multiplexeur de sélection de l'instruction est alors beaucoup plus simple : il suffit d'utiliser les bits de poids fort du ''program counter''. Par exemple, prenons le cas d'un registre d'instruction de 32 octets pour des instructions de 4 octets, soit 8 instructions. Le choix de l'instruction à sélectionner se fait en utilisant les 3 bits de poids faible du ''program counter''. 

Mais cette méthode ajoute de nouvelles contraintes d'alignement, similaires à celles vues dans le chapitre sur l'alignement et le boutisme, sauf que l'alignement porte ici sur des blocs d'instructions de même taille que le tampon de préchargement. Si on prend l'exemple d'un tampon de préchargement de 128 bits, les instructions devront être alignées par blocs de 128 bits. C'est à dire qu'idéalement, les fonctions et autres blocs de code isolés doivent commencer à des adresses multiples de 128, pour pouvoir charger un bloc d'instruction en une seule fois. Sans cela, les performances seront sous-optimales.

: Il arrive que le tampon de préchargement ait la même taille qu'une ligne de cache.

Lorsque l'on passe d'un bloc d'instruction à un autre, le tampon de préchargement est mis à jour. Par exemple, si on prend un tampon de préchargement de 4 instructions, on doit changer son contenu toutes les 4 instructions. La seule exception est l'exécution d'un branchement. En effet, lors d'un branchement, la destination du branchement n'est pas dans le tampon de préchargement et elle doit être chargée dedans (sauf si le branchement pointe vers une instruction très proche, ce qui est improbable). Pour cela, le tampon de préchargement est mis à jour précocement quand le processeur détecte un branchement.

Le même problème survient avec du code auto-modifiant. Un code auto-modifiant est un programme qui se modifie lui-même, en remplaçant certaines instructions par d'autres, en en retirant, en en ajoutant, lors de sa propre exécution. De tels programmes sont rares, mais la technique était utilisée dans quelques cas au tout début de l'informatique sur des ordinateurs rudimentaires. Ceux-ci avaient des modes d'adressages tellement limités que gérer des tableaux de taille variable demandait d'utiliser du code auto-modifiant pour écrire des boucles. Le problème survient quand des instructions sont modifiées immédiatement après avoir été préchargées. Les instructions dans le tampon de préchargement sont l'ancienne version, alors que la mémoire RAM contient les instructions modifiées. Gérer ce genre de cas demande de vider le tampon de préchargement si le cas arrive, mais ça ne vaut que très rarement le coup, aussi les ingénieurs ne s’embêtent pas à mettre ce correctif en place. Le code automodifiant est alors buggé.

===La ''prefetch input queue''===

La ''prefetch input queue'' est une sorte de cousine du tampon de préchargement, qui a été utilisée sur les processeurs Intel assez ancien. Elle est apparue sur le 8086 et le 8088, des processeurs respectivement 8 et 16 bits. Elle été présente sur le 286 et le 386, mais était un peu améliorée. Elle est apparue sur ces processeurs à une époque où le processeur devenait plus rapide que la mémoire.

L'idée est là encore de précharger des instructions en avance. Sauf que cette fois-ci, on ne charge pas plusieurs instructions à la fois. Au contraire, les instructions sont préchargées séquentiellement, un ou deux octet à la fois. En conséquence, le tampon de préchargement est remplacé par une mémoire FIFO appelée la '''''Prefetch Input Queue''''', terme abrévié en PIQ. Les instructions sont accumulées une par une dans la PIQ, elles en sortent une par une au fur et à mesure pour alimenter le décodeur d'instruction.

Pendant que le processeur exécute une instruction, on précharge la suivante. Sans ''prefetch input queue'', le processeur chargeait une instruction, la décodait et l'exécutait, puis chargeait la suivante, et ainsi de suite. Avec un tampon de préchargement, le processeur chargeait plusieurs instruction en une seule fois, puis les exécutait les unes après les autres. Avec la ''prefetch input queue'', pendant qu'une instruction est en cours de décodage/exécution, le processeur précharge l'instruction suivante. Si une instruction prend vraiment beaucoup de temps pour s'exécuter, le processeur peut en profiter pour précharger l'instruction encore suivante, et ainsi de suite, jusqu'à une limite de 4/6 instructions (la limite dépend du processeur).

La ''prefetch input queue'' permet de précharger l'instruction suivante à condition qu'aucun autre accès mémoire n'ait lieu. Si l'instruction en cours d'exécution effectue des accès mémoire, ceux-ci sont prioritaires sur tout le reste, le préchargement de l'instruction suivante est alors mis en pause ou inhibé. Par contre, si la mémoire n'est pas utilisée par l'instruction en cours d'exécution, le processeur lit l'instruction suivante en RAM et la copie dans la ''prefetch input queue''. En conséquence, il arrive que la ''prefetch input queue'' n'ait pas préchargé l'instruction suivante, alors que le décodeur d'instruction est prêt pour la décoder. Dans ce cas, le décodeur doit attendre que l'instruction soit chargée.

Les instructions préchargées dans la ''Prefetch input queue'' y attendent que le processeur les lise et les décode. Les instructions préchargées sont conservées dans leur ordre d'arrivée, afin qu'elles soient exécutées dans le bon ordre, ce qui fait que la ''Prefetch input queue'' est une mémoire de type FIFO. L'étape de décodage pioche l'instruction à décoder dans la ''Prefetch input queue'', cette instruction étant par définition la plus ancienne, puis la retire de la file.

Le premier processeur commercial grand public à utiliser une ''prefetch input queue'' était le 8086. Il pouvait précharger à l'avance 6 octets d’instruction. L'Intel 8088 avait lui aussi une ''Prefetch input queue'', mais qui ne permettait que de précharger 4 instructions. La taille idéale de la FIFO dépend de nombreux paramètres. On pourrait croire que plus elle peut contenir d'instructions, mieux c'est, mais ce n'est pas le cas, pour des raisons que nous allons expliquer dans quelques paragraphes.

[[File:80186 arch.png|centre|vignette|700px|upright=2|Architecture du 8086, du 80186 et de ses variantes.]]

Vous remarquerez que j'ai exprimé la capacité de la ''prefetch input queue'' en octets et non en instructions. La raison est que sur les processeurs x86, les instructions sont de taille variable, avec une taille qui varie entre un octet et 6 octets. Cependant, le décodage des instructions se fait un octet à la fois : le décodeur lit un octet, puis éventuellement le suivant, et ainsi de suite jusqu'à atteindre la fin de l'instruction. En clair, le décodeur lits les instructions longues octet par octet dans la ''Prefetch input queue''. Pour cela, le décodeur dispose d'une micro-opération pour lire un octet depuis la ''Prefetch input queue''.

Le décodeur devait attendre que qu'un moins un octet soit disponible dans la ''Prefetch input queue'', pour le lire. Il lisait alors cet octet et déterminait s'il contenait une instruction complète ou non. Si c'est une instruction complète, il la décodait et l''exécutait, puis passait à l'instruction suivante. Sinon, il lit un second octet depuis la ''Prefetch input queue'', le copie dans le registre d'instruction, et relance le décodage. Là encore, le décodeur vérifie s'il a une instruction complète, et lit un troisième octet si besoin, puis rebelote avec un quatrième octet lu, etc.

Un circuit appelé le ''loader'' synchronisait le décodeur d'instruction et la ''Prefetch input queue''. Il fournissait un bit qui indiquait si le premier octet d'une instruction était disponible dans la ''Prefetch input queue''. Un second bit indiquait si l'octet suivant était disponible, nous verrons pourquoi dans ce qui suit. Le ''loader'' recevait aussi des signaux de la part du décodeur d'instruction. Le décodeur envoyait le signal ''Run Next Instruction'' pour lire une instruction, qui était alors dépilée de la ''Prefetch input queue''. Le décodeur d'instruction pouvait aussi envoyer un signal ''Next-to-last (NXT)'', un cycle avant que l'instruction en cours ne termine. Le ''loader'' réagissait en préchargeant l'octet suivant. En clair, ce signal permettait de précharger l'instruction suivante avec un cycle d'avance, si celle-ci n'était pas déjà dans la ''Prefetch input queue''.

Le bus de données du 8086 faisait 16 bits, alors que celui du 8088 ne permettait que de lire un octet à la fois. Et cela avait un impact sur la ''prefetch input queue''. La ''prefetch input queue'' était composée de 4 registres de 8 bits, avec un port d'écriture de 8 bits pour précharger les instructions octet par octet, et un port de lecture de 8 bits pour alimenter le décodeur. En clair, tout faisait 8 bits. Le 8086, lui utilisait des registres de 16 bits et un port d'écriture de 16 bits. le port de lecture restait de 8 bits, et était précédé d'un multiplexeur qui prenait 16 bits et sélectionnait l'octet adéquat. Sa ''prefetch input queue'' préchargeait les instructions par paquets de 2 octets, non octet par octet, alors que le décodeur consommait les instructions octet par octet. Il s’agissait donc d'une sorte d'intermédiaire entre ''prefetch input queue'' à la 8088 et tampon de préchargement.

Les branchements posent des problèmes avec la ''Prefetch input queue'' : à cause d'eux, on peut charger à l'avance des instructions qui sont zappées par un branchement et ne sont pas censées être exécutées. Si un branchement est chargé, toutes les instructions préchargées après sont potentiellement invalides. Si le branchement est non-pris, les instructions chargées sont valides, elles sont censées s’exécuter. Mais si le branchement est pris, elles ont été chargées à tort et ne doivent pas s’exécuter. 

Pour éviter cela, la ''Prefetch input queue'' est vidée quand le processeur détecte un branchement. Pour cela, le décodeur d'instruction dispose d'une micro-opération qui vide la ''Prefetch input queue'', elle invalide les instructions préchargées.  Cette détection ne peut se faire qu'une fois le branchement décodé, qu'une fois que l'on sait que l'instruction décodée est un branchement. En clair, le décodeur invalide la ''Prefetch input queue'' quand il détecte un branchement. Les interruptions posent le même genre de problèmes. Il faut impérativement vider la ''Prefetch input queue'' quand une interruption survient, avant de la traiter.

Il faut noter qu'une ''Prefetch input queue'' interagit assez mal avec le ''program counter''. En effet, la ''Prefetch input queue'' précharge les instructions séquentiellement. Pour savoir où elle en est rendue, elle mémorise l'adresse de la prochaine instruction à charger dans un '''registre de préchargement''' dédié. Il serait possible d'utiliser un ''program counter'' en plus du registre de préchargement, mais ce n'est pas la solution qui a été utilisée. Les processeurs Intel anciens ont préféré n'utiliser qu'un seul registre de préchargement en remplacement du ''program counter''. Après tout, le registre de préchargement n'est qu'un ''program counter'' ayant pris une avance de quelques cycles d'horloge, qui a été incrémenté en avance.

Et cela ne pose pas de problèmes, sauf avec certains branchements. Par exemple, certains branchements relatifs demandent de connaitre la véritable valeur du ''program counter'', pas celle calculée en avance. Idem avec les instructions d'appel de fonction, qui demandent de sauvegarder l'adresse de retour exacte, donc le vrai ''program counter''. De telles situations demandent de connaitre la valeur réelle du ''program counter'', celle sans préchargement. Pour cela, le décodeur d'instruction dispose d'une instruction pour reconstituer le ''program counter'', à savoir corriger le ''program coutner'' et éliminer l'effet du préchargement.

La micro-opération de correction se contente de soustraire le nombre d'octets préchargés au registre de préchargement. Le nombre d'octets préchargés est déduit à partir des deux pointeurs intégré à la FIFO, qui indiquent la position du premier et du dernier octet préchargé. Le bit qui indique si la FIFO est vide était aussi utilisé. Les deux pointeurs sont lus depuis la FIFO, et sont envoyés à un circuit qui détermine le nombre d'octets préchargés. Sur le 8086, ce circuit était implémenté non pas par un circuit combinatoire, mais par une mémoire ROM équivalente. La petite taille de la FIFO faisait que les pointeurs étaient très petits et la ROM l'était aussi.

Un autre défaut est que la ''Prefetch input queue'' se marie assez mal avec du code auto-modifiant. Un code auto-modifiant est un programme qui se modifie lui-même, en remplaçant certaines instructions par d'autres, en en retirant, en en ajoutant, lors de sa propre exécution. De tels programmes sont rares, mais la technique était utilisée dans quelques cas au tout début de l'informatique sur des ordinateurs rudimentaires. Ceux-ci avaient des modes d'adressages tellement limités que gérer des tableaux de taille variable demandait d'utiliser du code auto-modifiant pour écrire des boucles.

Le problème avec la ''Prefetch input queue'' survient quand des instructions sont modifiées immédiatement après avoir été préchargées. Les instructions dans la ''Prefetch input queue'' sont l'ancienne version, alors que la mémoire RAM contient les instructions modifiées. Gérer ce genre de cas est quelque peu complexe. Il faut en effet vider la ''Prefetch input queue'' si le cas arrive, ce qui demande d'identifier les écritures qui écrasent des instructions préchargées. C'est parfaitement possible, mais demande de transformer la ''Prefetch input queue'' en une mémoire hybride, à la fois mémoire associative et mémoire FIFO. Cela ne vaut que très rarement le coup, aussi les ingénieurs ne s’embêtent pas à mettre ce correctif en place, le code automodifiant est alors buggé.

Le décodeur d'instruction dispose aussi d'une micro-opération qui stoppe le préchargement des instructions dans la ''Prefetch input queue''.

: Pour ceux qui ont déjà lu un cours d'architecture des ordinateurs, la relation entre ''prefetch input queue'' et pipeline est quelque peu complexe. En apparence, la ''prefetch input queue'' permet une certaines forme de pipeline, en chargeant une instruction pendant que la précédente s'exécute. Les problématiques liées aux branchements ressemblent beaucoup à celles de la prédiction de branchement. Cependant, il est possible de dire qu'il s'agit plus d'une technique de préchargement que de pipeline. La différence entre les deux est assez subtile et les frontières sont assez floues, mais le fait est que l'instruction en cours d'exécution et le préchargement peuvent tout deux faire des accès mémoire et que l'instruction en cours a la priorité. Un vrai pipeline se débrouillerait avec une architecture Harvard, non avec un bus mémoire unique pour le chargement des instruction et la lecture/écriture des données.

===Le ''Zero-overhead looping''===

Nous avions vu dans le chapitre sur les instructions machines, qu'il existe des instructions qui permettent de grandement faciliter l'implémentation des boucles. Il s'agit de l'instruction REPEAT, utilisée sur certains processeurs de traitement de signal. Elle répète l'instruction suivante, voire une série d'instructions, un certain nombre de fois. Le nombre de répétitions est mémorisé dans un registre décrémenté à chaque itération de la boucle. Elle permet donc d'implémenter une boucle FOR facilement, sans recourir à des branchements ou des conditions.

Une technique en lien avec cette instruction permet de grandement améliorer les performances et la consommation d'énergie. L'idée est de mémoriser la boucle, les instructions à répéter, dans une petite mémoire cache située entre l'unité de chargement et le séquenceur. Le cache en question s'appelle un '''tampon de boucle''', ou encore un ''hardware loop buffer''. Grâce à lui, il n'y a pas besoin de charger les instructions à chaque fois qu'on les exécute, on les charge une bonne fois pour toute : c'est plus rapide. Bien sûr, il ne fonctionne que pour de petites boucles, mais il en est de même avec l'instruction REPEAT.

&lt;noinclude&gt;
{{NavChapitre | book=Fonctionnement d'un ordinateur
           | prev=Le chemin de données
           | prevText=Le chemin de données
           | next=L'unité de contrôle
           | nextText=L'unité de contrôle
}}
&lt;/noinclude&gt;</text>
      <sha1>hj8zq9a97hto7uddt4ao3kyn9of9e6j</sha1>
    </revision>
    <revision>
      <id>744090</id>
      <parentid>744089</parentid>
      <timestamp>2025-06-03T20:21:32Z</timestamp>
      <contributor>
        <username>Mewtow</username>
        <id>31375</id>
      </contributor>
      <minor />
      <comment>/* La prefetch input queue */</comment>
      <origin>744090</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="47077" sha1="7d9gi09tk0ue7jiwylj88abuw16ke5k" xml:space="preserve">L'unité de contrôle s'occupe du chargement des instructions et de leur interprétation, leur décodage. Elle contient deux circuits : l''''unité de chargement''' qui charge l'instruction depuis la mémoire, et le '''séquenceur''' qui commande le chemin de données. Les deux circuits sont séparés, mais ils communiquent entre eux, notamment pour gérer les branchements. Dans ce chapitre, nous allons nous intéresser au chargement d'une instruction depuis la RAM/ROM, nous verrons l'étape de décodage de l'instruction au prochain chapitre.

==Le chargement d'une instruction==

[[File:Étape de chargement.png|vignette|upright=1|Étape de chargement.]]

L'étape de chargement (ou ''fetch'') doit faire deux choses : mettre à jour le ''program counter'' et lire l'instruction en mémoire RAM ou en ROM. Les deux étapes peuvent être faites en parallèle, dans des circuits séparés. Pendant que l'instruction est lue depuis la mémoire RAM/ROM, le ''program counter'' est incrémenté et/ou altéré par un branchement.

Pour lire l'instruction, on envoie le ''program counter'' sur le bus d'adresse et on récupère l'instruction sur le bus de données pour l'envoyer sur l'entrée du séquenceur. Et cela demande de connecter le séquenceur au bus mémoire, à travers l'interface mémoire. Et sur ce point, la situation est différente selon que l'on parler d'une architecture Harvard ou Von Neumann.

===Les interconnexions entre séquenceur et bus mémoire===

Sur les architectures Harvard, le séquenceur et le chemin de donnée utilisent des interfaces mémoire séparées. Le séquenceur est directement relié au bus mémoire de la ROM, alors que le chemin de données est connecté à la RAM.

[[File:Microarchitecture de l'interface mémoire d'une architecture Harvard.png|centre|vignette|upright=2|Microarchitecture de l'interface mémoire d'une architecture Harvard]]

Mais sur les architectures Von-Neumann et affiliées, le séquenceur et le chemin de donnée partagent la même interface mémoire. Et cela pose deux problèmes.

Le premier problème est que le bus mémoire doit être libéré une fois l'instruction chargée, pour un éventuel accès mémoire. Mais le séquenceur doit conserver une copie de l'instruction chargée, sans quoi il ne peut pas décoder l'instruction correctement. Par exemple, si l'instruction met plusieurs cycles à s'exécuter, le séquenceur doit conserver une copie de l'instruction durant ces plusieurs cycles. La solution à ce problème est un '''registre d'instruction''' situé juste avant le séquenceur, qui mémorise l'instruction chargée.

[[File:Registre d'instruction.png|centre|vignette|upright=2|Registre d'instruction.]]

Le second problème est de gérer le flot des instructions/données entre le bus mémoire, le chemin de données et le séquenceur. Le processeur doit connecter l'interface mémoire soit au séquenceur, soit au chemin de données et cela complique le réseau d'interconnexion interne au processeur.

Une première solution utilise un bus unique qui relie l'interface mémoire, le séquenceur et le chemin de données. Pour charger une instruction, le séquenceur copie le ''program counter'' sur le bus d'adresse, attend que l'instruction lue soit disponible sur le bus de données, puis la copie dans le registre d'instruction. Le bus mémoire est alors libre et peut être utilisé pour lire ou écrire des données, si le besoin s'en fait sentir.

Il faut noter que l'usage d'un bus unique a un impact sur l'organisation interne du chemin de données. Par exemple, le chapitre précédent nous a montré comment implémenter un chemin de données basique, avec des multiplexeurs et démultiplexeurs. Et bien ces chemins de données ne marchent pas vraiment avec un bus interne unique. Il est possible de les adapter, mais au prix d'une complexité largement supérieure. Un bus interne unique marche mieux quand le banc de registre est mono-port. C'est pourquoi il a été utilisé sur d'anciennes architectures appelées des architectures à accumulateur et à pile, que nous verrons dans quelques chapitres, qui utilisaient un banc de registre mono-port.

[[File:Microarchitecture de l'interface mémoire d'une architecture von neumann.png|centre|vignette|upright=2|Microarchitecture de l'interface mémoire d'une architecture von neumann]]

Une autre solution utilise deux bus interne séparés : un connecté au bus d'adresse, l'autre au bus de données. Le ''program counter'' est alors connecté au bus interne d'adresse, le séquenceur est relié au bus interne de données. Notons que la technique marche bien si le ''program counter'' est dans le banc de registre : les interconnexions utilisées pour gérer l'adressage indirect permettent d'envoyer le ''program counter'' sur le bus d'adresse sans ajout de circuit.

Le tout peut être amélioré en remplaçant les deux bus par des multiplexeurs et démultiplexeurs. Le bus d'adresse est précédé par un multiplexeur, qui permet de faire le choix entre ''Program Counter'', adresse venant du chemin de données, ou adresse provenant du séquenceur (adressage absolu). De même, le bus de données est suivi par un démultiplexeur qui envoie la donnée/instruction lue soit au registre d'instruction, soit au chemin de données. Le tout se marie très bien avec les chemins de donnée vu dans le chapitre précédent. Au passage, il faut noter que cette solution nécessite un banc de registre multi-port.

[[File:Connexion du program counter sur les bus avec PC isolé.png|centre|vignette|upright=2|Connexion du program counter sur les bus avec PC isolé]]

===Le chargement des instructions de longueur variable===

Le chargement des instructions de longueur variable pose de nombreux problèmes. Le premier est que mettre à jour le ''program counter'' demande de connaitre la longueur de l'instruction chargée, pour l'ajouter au ''program counter''. Si la longueur d'une instruction est variable, on doit connaitre cette longueur d'une manière où d'une autre. La solution la plus simple indique la longueur de l'instruction dans une partie de l'opcode ou de la représentation en binaire de l'instruction. Mais les processeurs haute performance de nos PC utilisent d'autres solutions, qui n'encodent pas explicitement la taille de l'instruction.

Les processeurs récents utilisent un registre d'instruction de grande taille, capable de mémoriser l'instruction la plus longue du processeur. Par exemple, si un processeur supporte des instructions allant de 1 à 8 octets, comme les CPU x86, le registre d'instruction fera 8 octets. Le décodeur d'instruction vérifie à chaque cycle le contenu du registre d'instruction. Si une instruction est détectée dedans, son décodage commence, peu importe la taille de l'instruction. Une fois l'instruction exécutée, elle est retirée du registre d'instruction. Reste à alimenter le registre d'instruction, à charger des instructions dedans. Et pour cela deux solutions : soit on charge l'instruction en plusieurs fois, soit d'un seul coup.

La solution la plus simple charge les instructions par mots de 8, 16, 32, 64 bits. Ils sont accumulés dans le registre d'instruction jusqu'à détecter une instruction complète. La technique marche nettement mieux si les instructions sont très longues. Par exemple, les CPU x86 ont des instructions qui vont de 1 à 15 octets, ce qui fait qu'ils utilisent cette technique. Précisément, elle marche si les instructions les plus longues sont plus grandes que le bus mémoire.

Une autre solution charge un bloc de mots mémoire aussi grand que la plus grande instruction. Par exemple, si le processeur gère des instructions allant de 1 à 4 octets, il charge 4 octets d'un seul coup dans le registre d'instruction. Il va de soit que cette solution ne marche que si les instructions du processeur sont assez courtes, au plus aussi courtes que le bus mémoire. Ainsi, on est sûr de charger obligatoirement au moins une instruction complète, et peut-être même plusieurs. Le contenu du registre d'instruction est alors découpé en instructions au fil de l'eau. 

Utiliser un registre d'instruction large pose problème avec des instructions à cheval entre deux blocs. Il se peut qu'on n'ait pas une instruction complète lorsque l'on arrive à la fin du bloc, mais seulement un morceau. Le problème se manifeste peu importe que l'instruction soit chargée d'un seul coup ou bien en plusieurs fois.

[[File:Instructions non alignées.png|centre|vignette|upright=2|Instructions non alignées.]]

Dans ce cas, on doit décaler le morceau de bloc pour le mettre au bon endroit (au début du registre d'instruction), et charger le prochain bloc juste à côté. On a donc besoin d'un circuit qui décale tous les bits du registre d'instruction, couplé à un circuit qui décide où placer dans le registre d'instruction ce qui a été chargé, avec quelques circuits autour pour configurer les deux circuits précédents.

[[File:Décaleur d’instruction.png|centre|vignette|upright=2|Décaleur d’instruction.]]

Une autre solution se passe de registre d'instruction en utilisant à la place l'état interne du séquenceur. Là encore, elle charge l'instruction morceau par morceau, typiquement par blocs de 8, 16 ou 32 bits. Les morceaux ne sont pas accumulés dans le registre d'instruction, la solution utilise à la place l'état interne du séquenceur. Les mots mémoire de l'instruction sont chargés à chaque cycle, faisant passer le séquenceur d'un état interne à un autre à chaque mot mémoire. Tant qu'il n'a pas reçu tous les mots mémoire de l'instruction, chaque mot mémoire non terminal le fera passer d'un état interne à un autre, chaque état interne encodant les mots mémoire chargés auparavant. S'il tombe sur le dernier mot mémoire d'une instruction, il rentre dans un état de décodage.

==L'incrémentation du ''program counter''==

À chaque chargement, le ''program counter'' est mis à jour afin de pointer sur la prochaine instruction à charger. Sur la quasi-totalité des processeurs, les instructions sont placées dans l'ordre d’exécution dans la RAM. En faisant ainsi, on peut mettre à jour le ''program counter'' en lui ajoutant la longueur de l'instruction courante. Déterminer la longueur de l'instruction est simple quand les instructions ont toutes la même taille, mais certains processeurs ont des instructions de taille variable, ce qui complique le calcul. Dans ce qui va suivre, nous allons supposer que les instructions sont de taille fixe, ce qui fait que le ''program counter'' est toujours incrémenté de la même valeur.

Il existe deux méthodes principales pour incrémenter le ''program counter'' : soit le ''program counter'' a son propre additionneur, soit le ''program counter'' est mis à jour par l'ALU. Pour ce qui est de l'organisation des registres, soit le ''program counter'' est un registre séparé des autres, soit il est regroupé avec d'autres registres dans un banc de registre. En tout, cela donne quatre organisations possibles.
* Un ''program counter'' séparé relié à un incrémenteur séparé.
* Un ''program counter'' séparé des autres registres, incrémenté par l'ALU.
* Un ''program counter'' intégré au banc de registre, relié à un incrémenteur séparé.
* Un ''program counter'' intégré au banc de registre, incrémenté par l'ALU.

[[File:Calcul du program counter.png|centre|vignette|upright=2|les différentes méthodes de calcul du program counter.]]

Les processeurs haute performance modernes utilisent tous la première méthode. Les autres méthodes étaient surtout utilisées sur les processeurs 8 ou 16 bits, elles sont encore utilisées sur quelques microcontrôleurs de faible puissance. Nous auront l'occasion de donner des exemples quand nous parlerons des processeurs 8 bits anciens, dans le chapitre sur les architectures à accumulateur et affiliées.

===Le ''program counter'' mis à jour par l'ALU===

Sur certains processeurs, le calcul de l'adresse de la prochaine instruction est effectué par l'ALU. L'avantage de cette méthode est qu'elle économise un incrémenteur dédié au ''program counter''. Ce qui explique que cette méthode était utilisée sur les processeurs assez anciens, à une époque où un additionneur pouvait facilement prendre 10 à 20% des transistors disponibles. Le désavantage principal est une augmentation de la complexité du séquenceur, qui doit gérer la mise à jour du ''program counter''. De plus, la mise à jour du ''program counter'' ne peut pas se faire en même temps qu'une opération arithmétique, ce qui réduit les performances.

Si on incrémente le ''program counter'' avec l'ALU, il est intéressant de le placer dans le banc de registres. Un désavantage est qu'on perd un registre. Par exemple, avec un banc de registre de 16 registres, on ne peut adresser que 15 registres généraux. De plus ce n'est pas l'idéal pour le décodage des instructions et pour le séquenceur. Si le processeur dispose de plusieurs bancs de registres, le ''program counter'' est généralement placé dans le banc de registre dédié aux adresses. Sinon, il est placé avec les nombres entiers/adresses.

D'anciens processeurs incrémentaient le ''program counter'' avec l'ALU, mais utilisaient bien un registre séparé pour le ''program counter''. Cette méthode est relativement simple à implémenter : il suffit de connecter/déconnecter le ''program counter'' du bus interne suivant les besoins. Le ''program counter'' est déconnecté pendant l’exécution d'une instruction, il est connecté au bus interne pour l'incrémenter. C'est le séquenceur qui gère le tout. L'avantage de cette séparation est qu'elle est plus facile à gérer pour le séquenceur. De plus, on gagne un registre général/entier dans le banc de registre.

===Le compteur programme===

Dans la quasi-totalité des processeurs modernes, le ''program counter'' est un vulgaire compteur comme on en a vu dans les chapitres sur les circuits, ce qui fait qu'il passe automatiquement d'une adresse à la suivante. Dans ce qui suit, nous allons appeler ce registre compteur : le '''compteur ordinal'''. L'usage d'un compteur simplifie fortement la conception du séquenceur. Le séquenceur n'a pas à gérer la mise à jour du ''program counter'', sauf en cas de branchements. De plus, il est possible d'incrémenter le ''program counter'' pendant que l'unité de calcul effectue une opération arithmétique, ce qui améliore grandement les performances. Le seul désavantage est qu'elle demande d'ajouter un incrémenteur dédié au ''program counter''.

Sur les processeurs très anciens, les instructions faisaient toutes un seul mot mémoire et le compteur ordinal était un circuit incrémenteur des plus basique. Sur les processeurs modernes, le compteur est incrémenté par pas de 4 si les instructions sont codées sur 4 octets, 8 si les instructions sont codées sur 8 octets, etc. Concrètement, le compteur est un circuit incrémenteur auquel on aurait retiré quelques bits de poids faible. Par exemple, si les instructions sont codées sur 4 octets, on coupe les 2 derniers bits du compteur. Si les instructions sont codées sur 8 octets, on coupe les 3 derniers bits du compteur. Et ainsi de suite.

Il a existé quelques processeurs pour lesquelles le ''program counter'' était non pas un compteur binaire classique, mais un ''linear feedback shift register''. L'avantage est que le circuit d'incrémentation utilisait bien moins de portes logiques, l'économie était substantielle. Mais un défaut est que des instructions consécutives dans le programme n'étaient pas consécutives en mémoire. Il existait cependant une table de correspondance pour dire : la première instruction est à telle adresse, la seconde à telle autre, etc. Un exemple de processeur de ce type est le TMS 1000 de Texas Instrument, un des premiers microcontrôleur 4 bits datant des années 70.

Une amélioration de la solution précédente utilise un circuit incrémenteur partagé entre le ''program counter'' et d'autres registres. L'incrémenteur est utilisé pour incrémenter le ''program counter'', mais aussi pour effectuer d'autres calculs d'adresse. Par exemple, sur les architectures avec une pile d'adresse de retour, il est possible de partager l'incrémenteur/décrémenteur avec le pointeur de pile ( la technique ne marche pas avec une pile d'appel). Un autre exemple est celui des processeurs qui gèrent automatiquement le rafraichissement mémoire, grâce à, un compteur intégré dans le processeur. Il est possible de partager l'incrémenteur du ''program counter'' avec le compteur de rafraichissement mémoire, qui mémorise la prochaine adresse mémoire à rafraichir. Nous avions déjà abordé ce genre de partage dans le chapitre sur le chemin de données, dans l'annexe sur le pointeur de pile, mais nous verrons d'autres exemples dans le chapitre sur les architectures hybride accumulateur-registre 8/16 bits.

===Quand est mis à jour le ''program counter'' ?===

Le ''program counter'' est mis à jour quand il faut charger une nouvelle instruction. Reste qu'il faut savoir quand le mettre à jour. Incrémenter le ''program counter'' à intervalle régulier, par exemple à chaque cycle d’horloge, fonctionne sur les processeurs où toutes les instructions mettent le même temps pour s’exécuter. Mais de tels processeurs sont très rares. Sur la quasi-totalité des processeurs, les instructions ont une durée d’exécution variable, elles ne prennent pas le même nombre de cycle d'horloge pour s’exécuter. Le temps d’exécution d'une instruction varie selon l'instruction, certaines sont plus longues que d'autres. Tout cela amène un problème : comment incrémenter le ''program counter'' avec des instructions avec des temps d’exécution variables ?

La réponse est que la mise à jour du ''program counter'' démarre quand l'instruction précédente a terminée de s’exécuter, plus précisément un cycle avant. C'est un cycle avant pour que l'instruction chargée soit disponible au prochain cycle pour le décodeur. Pour cela, le séquenceur doit déterminer quand l'instruction est terminée et prévenir le ''program counter'' au bon moment. Il faut donc une interaction entre séquenceur et circuit de chargement. Le circuit de chargement contient une entrée Enable, qui autorise la mise à jour du ''program counter''. Le séquenceur met à 1 cette entrée pour prévenir au ''program counter'' qu'il doit être incrémenté au cycle suivant ou lors du cycle courant. Cela permet de gérer simplement le cas des instructions multicycles. 

[[File:Commande de la mise à jour du program counter.png|centre|vignette|upright=2|Commande de la mise à jour du program counter.]]

Toute la difficulté est alors reportée dans le séquenceur, qui doit déterminer la durée d'une instruction. Pour gérer la mise à jour du ''program counter'', le séquenceur doit déterminer la durée d'une instruction. Cela est simple pour les instructions arithmétiques et logiques, qui ont un nombre de cycles fixe, toujours le même. Une fois l'instruction identifiée par le séquenceur, il connait son nombre de cycles et peut programmer un compteur interne au séquenceur, qui compte le nombre de cycles de l'instruction, et fournit le signal Enable au ''program counter''. Mais cette technique ne marche pas vraiment pour les accès mémoire, dont la durée n'est pas connue à l'avance, surtout sur les processeurs avec des mémoires caches. Pour cela, le séquenceur détermine quand l'instruction mémoire est finie et prévient le ''program counter'' quand c'est le cas.

Il existe quelques processeurs pour lesquels le temps de calcul dépend des opérandes de l'instruction. On peut par exemple avoir une division qui prend 10 cycles avec certaines opérandes, mais 40 cycles avec d'autres opérandes. Mais ces processeurs sont rares et cela est surtout valable pour les opérations de multiplication/division, guère plus. Le problème est alors le même qu'avec les accès mémoire et la solution est la même : l'ALU prévient le séquenceur quand le résultat est disponible.

==Les branchements et le ''program counter''==

Un branchement consiste juste à écrire l'adresse de destination dans le ''program counter''. L'implémentation des branchements demande d'extraire l'adresse de destination et d'altérer le ''program counter'' quand un branchement est détecté. Pour cela, le décodeur d'instruction détecte si l'instruction exécutée est un branchement ou non, et il en déduit où trouver l'adresse de destination.

L'adresse de destination se trouve à un endroit qui dépend du mode d'adressage du branchement. Pour rappel, on distingue quatre modes d'adressage pour les branchements : direct, indirect, relatif et implicite. Pour les branchements directs, l'adresse est intégrée dans l'instruction de branchement elle-même et est extraite par le séquenceur. Pour les branchements indirects, l'adresse de destination est dans le banc de registre. Pour les branchements relatifs, il faut ajouter un décalage au ''program counter'', décalage extrait de l'instruction par le séquenceur. Enfin, les instructions de retour de fonction lisent l'adresse de destination depuis la pile. L'implémentation de ces quatre types de branchements est très différente.

L'altération du ''program counter'' dépend de si le ''program counter'' est dans un compteur séparé ou s'il est dans le banc de registre. Nous avons vu plus haut qu'il y a quatre cas différents, mais nous n'allons voir que deux cas : celui où le ''program counter'' est dans le banc de registre et est incrémenté par l'unité de calcul, celui avec un ''program counter'' séparé avec son propre incrémenteur. Les deux autres cas ne sont utilisés que sur des architectures à accumulateur ou à pile spécifiques, que nous n'avons pas encore vu à ce stade du cours et que nous verrons en temps voulu dans le chapitre sur ces architectures.

===L’implémentation des branchements avec un ''program counter'' intégré au banc de registres===

Le cas le plus simple est celui où le ''program counter'' est intégré au banc de registre, avec une incrémentation faite par l'unité de calcul. Charger une instruction revient alors à effectuer une instruction LOAD en adressage indirect, à deux différences près : le registre sélectionné est le ''program counter'', l’instruction est copiée dans le registre d'instruction et non dans le banc de registre. L'incrémentation du ''porgram counter'' est implémenté avec des micro-opérations qui agissent sur le chemin de données, au même titre que les branchements indirects, relatifs et directs.
* Les branchements indirects copient un registre dans le ''program counter'', ce qui revient simplement à faire une opération MOV entre deux registres, dont le ''program counter'' est la destination.
* L'opération inverse d'un branchement indirect, qui copie le ''program counter'' dans un registre général, est utile pour sauvegarder l'adresse de retour d'une fonction.
* Les branchements directs copient une adresse dans le ''program counter'', ce qui les rend équivalents à une opération MOV avec une constante immédiate, dont le ''program counter'' est la destination.
* Les branchements relatifs sont une opération arithmétique entre le ''program counter'' et un opérande en adressage immédiat.

En clair, à partir du moment où le chemin de données supporte les instructions MOV et l'addition, avec les modes d'adressage adéquat, il supporte les branchements. Aucune modification du chemin de données n'est nécessaire, le séquenceur gére le chargement d'une instruction avec les micro-instructions adéquates : une micro-opération ADD pour incrémenter le ''program counter'', une micro-opération LOAD pour le chargement de l'instruction.

Notons que sur certaines architectures, le ''program counter'' est adressable au même titre que les autres registres du banc de registre. Les instructions de branchement sont alors remplacées par des instructions MOV ou des instructions arithmétique équivalentes, comme décrit plus haut.

===L’implémentation des branchements avec un ''program counter'' séparé===

Étudions maintenant le cas où le ''program counter'' est dans un registre/compteur séparé. Rappelons que tout compteur digne de ce nom possède une entrée de réinitialisation, qui remet le compteur à zéro. De plus, on peut préciser à quelle valeur il doit être réinitialisé. Ici, la valeur à laquelle on veut réinitialiser le compteur n'est autre que l'adresse de destination du branchement. Implémenter un branchement est donc simple : l'entrée de réinitialisation est commandée par le circuit de détection des branchements, alors que la valeur de réinitialisation est envoyée sur l'entrée adéquate. En clair, nous partons du principe que le ''program counter'' est implémenté avec ce type de compteur :

[[File:Fonctionnement d'un compteur (décompteur), schématique.jpg|centre|vignette|upright=1.5|Fonctionnement d'un compteur (décompteur), schématique]]

Toute la difficulté est de présenter l'adresse de destination au ''program counter''. Pour les branchements directs, l'adresse de destination est fournie par le séquenceur. L'adresse de destination du branchement sort du séquenceur et est présentée au ''program counter'' sur l'entrée adéquate. Voici donc comment sont implémentés les branchements directs avec un ''program counter'' séparé du banc de registres. Le schéma ci-dessous marche peu importe que le ''program counter'' soit incrémenté par l'ALU ou par un additionneur dédié.

[[File:Unité de détection des branchements dans le décodeur.png|centre|vignette|upright=2|Unité de détection des branchements dans le décodeur]]

Les branchements relatifs sont ceux qui font sauter X instructions plus loin dans le programme. Leur implémentation demande d'ajouter une constante au ''program counter'', la constante étant fournie dans l’instruction. Là encore, deux solutions sont possibles : réutiliser l'ALU pour calculer l'adresse, ou utiliser un additionneur séparé. L'additionneur séparé peut être fusionné avec l'additionneur qui incrémente le ''program counter'' pour passer à l’instruction suivante.

[[File:Unité de chargement qui gère les branchements relatifs.png|centre|vignette|upright=2|Unité de chargement qui gère les branchements relatifs.]]

Pour les branchements indirects, il suffit de lire le registre voulu et d'envoyer le tout sur l'entrée adéquate du ''program counter''. Il faut alors rajouter un multiplexeur pour que l'entrée de réinitialisationr ecoive la bonne adresse de destination.

[[File:Unité de chargement qui gère les branchements directs.png|centre|vignette|upright=2|Unité de chargement qui gère les branchements directs et indirects.]]

Toute la difficulté de l'implémentation des branchements est de configurer les multiplexeurs, ce qui est réalisé par le séquenceur en fonction du mode d'adressage du branchement.

==Les optimisations du chargement des instructions==

Charger une instruction est techniquement une forme d'accès mémoire un peu particulier. En clair, charger une instruction prend au minimum un cycle d'horloge, et cela peut rapidement monter à 3-5 cycles, si ce n'est plus. L'exécution des instructions est alors fortement ralentit par la mémoire. Par exemple, imaginez que la mémoire mette 3 cycles d'horloges pour charger une instruction, alors qu'une instruction s’exécute en 1 cycle (si les opérandes sont dans les registres). La perte de performance liée au chargement des instructions est alors substantielle. Heureusement, il est possible de limiter la casse en utilisant des mémoires caches, ainsi que d'autres optimisations, que nous allons voir dans ce qui suit.

===Le tampon de préchargement===

La technique dite du '''préchargement''' est utilisée dans le cas où la mémoire a un temps d'accès important. Mais si la latence de la RAM est un problème, le débit ne l'est pas. Il est possible d'avoir une RAM lente, mais à fort débit. Par exemple, supposons que la mémoire puisse charger 4 instructions (de taille fixe) en 3 cycles. Le processeur peut alors charger 4 instructions en un seul accès mémoire, et les exécuter l'une après l'autre, une par cycle d'horloge. Les temps d'attente sont éliminés : le processeur peut décoder une nouvelle instruction à chaque cycle. Et quand la dernière instruction préchargée est exécutée, la mémoire est de nouveau libre, ce qui masque la latence des accès mémoire.

[[File:Tampon de préchargement d'instruction.png|vignette|Tampon de préchargement d'instruction]]

La seule contrainte est de mettre les instructions préchargées en attente. La solution pour cela est d'utiliser un registre d'instruction très large, capable de mémoriser plusieurs instructions à la fois. Ce registre est de plus connecté à un multiplexeur qui permet de sélectionner l'instruction adéquate dans ce registre. Ce multiplexeur est commandé par le ''program counter'' et quelques circuits annexes. Ce super-registre d'instruction est appelé un '''tampon de préchargement'''.

La méthode a une implémentation nettement plus simple avec des instructions de taille fixe, alignées en mémoire. La commande du multiplexeur de sélection de l'instruction est alors beaucoup plus simple : il suffit d'utiliser les bits de poids fort du ''program counter''. Par exemple, prenons le cas d'un registre d'instruction de 32 octets pour des instructions de 4 octets, soit 8 instructions. Le choix de l'instruction à sélectionner se fait en utilisant les 3 bits de poids faible du ''program counter''. 

Mais cette méthode ajoute de nouvelles contraintes d'alignement, similaires à celles vues dans le chapitre sur l'alignement et le boutisme, sauf que l'alignement porte ici sur des blocs d'instructions de même taille que le tampon de préchargement. Si on prend l'exemple d'un tampon de préchargement de 128 bits, les instructions devront être alignées par blocs de 128 bits. C'est à dire qu'idéalement, les fonctions et autres blocs de code isolés doivent commencer à des adresses multiples de 128, pour pouvoir charger un bloc d'instruction en une seule fois. Sans cela, les performances seront sous-optimales.

: Il arrive que le tampon de préchargement ait la même taille qu'une ligne de cache.

Lorsque l'on passe d'un bloc d'instruction à un autre, le tampon de préchargement est mis à jour. Par exemple, si on prend un tampon de préchargement de 4 instructions, on doit changer son contenu toutes les 4 instructions. La seule exception est l'exécution d'un branchement. En effet, lors d'un branchement, la destination du branchement n'est pas dans le tampon de préchargement et elle doit être chargée dedans (sauf si le branchement pointe vers une instruction très proche, ce qui est improbable). Pour cela, le tampon de préchargement est mis à jour précocement quand le processeur détecte un branchement.

Le même problème survient avec du code auto-modifiant. Un code auto-modifiant est un programme qui se modifie lui-même, en remplaçant certaines instructions par d'autres, en en retirant, en en ajoutant, lors de sa propre exécution. De tels programmes sont rares, mais la technique était utilisée dans quelques cas au tout début de l'informatique sur des ordinateurs rudimentaires. Ceux-ci avaient des modes d'adressages tellement limités que gérer des tableaux de taille variable demandait d'utiliser du code auto-modifiant pour écrire des boucles. Le problème survient quand des instructions sont modifiées immédiatement après avoir été préchargées. Les instructions dans le tampon de préchargement sont l'ancienne version, alors que la mémoire RAM contient les instructions modifiées. Gérer ce genre de cas demande de vider le tampon de préchargement si le cas arrive, mais ça ne vaut que très rarement le coup, aussi les ingénieurs ne s’embêtent pas à mettre ce correctif en place. Le code automodifiant est alors buggé.

===La ''prefetch input queue''===

La ''prefetch input queue'' est une sorte de cousine du tampon de préchargement, qui a été utilisée sur les processeurs Intel assez ancien. Elle est apparue sur le 8086 et le 8088, des processeurs respectivement 8 et 16 bits. Elle été présente sur le 286 et le 386, mais était un peu améliorée. Elle est apparue sur ces processeurs à une époque où le processeur devenait plus rapide que la mémoire.

L'idée est là encore de précharger des instructions en avance. Sauf que cette fois-ci, on ne charge pas plusieurs instructions à la fois. Au contraire, les instructions sont préchargées séquentiellement, un ou deux octet à la fois. En conséquence, le tampon de préchargement est remplacé par une mémoire FIFO appelée la '''''Prefetch Input Queue''''', terme abrévié en PIQ. Les instructions sont accumulées une par une dans la PIQ, elles en sortent une par une au fur et à mesure pour alimenter le décodeur d'instruction.

Pendant que le processeur exécute une instruction, on précharge la suivante. Sans ''prefetch input queue'', le processeur chargeait une instruction, la décodait et l'exécutait, puis chargeait la suivante, et ainsi de suite. Avec un tampon de préchargement, le processeur chargeait plusieurs instruction en une seule fois, puis les exécutait les unes après les autres. Avec la ''prefetch input queue'', pendant qu'une instruction est en cours de décodage/exécution, le processeur précharge l'instruction suivante. Si une instruction prend vraiment beaucoup de temps pour s'exécuter, le processeur peut en profiter pour précharger l'instruction encore suivante, et ainsi de suite, jusqu'à une limite de 4/6 instructions (la limite dépend du processeur).

La ''prefetch input queue'' permet de précharger l'instruction suivante à condition qu'aucun autre accès mémoire n'ait lieu. Si l'instruction en cours d'exécution effectue des accès mémoire, ceux-ci sont prioritaires sur tout le reste, le préchargement de l'instruction suivante est alors mis en pause ou inhibé. Par contre, si la mémoire n'est pas utilisée par l'instruction en cours d'exécution, le processeur lit l'instruction suivante en RAM et la copie dans la ''prefetch input queue''. En conséquence, il arrive que la ''prefetch input queue'' n'ait pas préchargé l'instruction suivante, alors que le décodeur d'instruction est prêt pour la décoder. Dans ce cas, le décodeur doit attendre que l'instruction soit chargée.

Les instructions préchargées dans la ''Prefetch input queue'' y attendent que le processeur les lise et les décode. Les instructions préchargées sont conservées dans leur ordre d'arrivée, afin qu'elles soient exécutées dans le bon ordre, ce qui fait que la ''Prefetch input queue'' est une mémoire de type FIFO. L'étape de décodage pioche l'instruction à décoder dans la ''Prefetch input queue'', cette instruction étant par définition la plus ancienne, puis la retire de la file.

Le premier processeur commercial grand public à utiliser une ''prefetch input queue'' était le 8086. Il pouvait précharger à l'avance 6 octets d’instruction. L'Intel 8088 avait lui aussi une ''Prefetch input queue'', mais qui ne permettait que de précharger 4 instructions. La taille idéale de la FIFO dépend de nombreux paramètres. On pourrait croire que plus elle peut contenir d'instructions, mieux c'est, mais ce n'est pas le cas, pour des raisons que nous allons expliquer dans quelques paragraphes.

[[File:80186 arch.png|centre|vignette|700px|upright=2|Architecture du 8086, du 80186 et de ses variantes.]]

Vous remarquerez que j'ai exprimé la capacité de la ''prefetch input queue'' en octets et non en instructions. La raison est que sur les processeurs x86, les instructions sont de taille variable, avec une taille qui varie entre un octet et 6 octets. Cependant, le décodage des instructions se fait un octet à la fois : le décodeur lit un octet, puis éventuellement le suivant, et ainsi de suite jusqu'à atteindre la fin de l'instruction. En clair, le décodeur lits les instructions longues octet par octet dans la ''Prefetch input queue''. Pour cela, le décodeur dispose d'une micro-opération pour lire un octet depuis la ''Prefetch input queue''.

Le décodeur devait attendre que qu'un moins un octet soit disponible dans la ''Prefetch input queue'', pour le lire. Il lisait alors cet octet et déterminait s'il contenait une instruction complète ou non. Si c'est une instruction complète, il la décodait et l''exécutait, puis passait à l'instruction suivante. Sinon, il lit un second octet depuis la ''Prefetch input queue'', le copie dans le registre d'instruction, et relance le décodage. Là encore, le décodeur vérifie s'il a une instruction complète, et lit un troisième octet si besoin, puis rebelote avec un quatrième octet lu, etc.

Les octets lus pouvaient être accumulés dans le registre d'instruction, mais aussi ailleurs. Par exemple, prenons le cas d'une addition entre le registre AX et une constante immédiate. L'instruction fait trois octets : un opcode suivie par une constante immédiate codée sur deux octets. L'opcode était envoyé au décodeur, mais pas la constante immédiate. Elle était lue octet par octet et mémorisée dans un registre temporaire placé en entrée de l'ALU. Tout se passait du décodage : l'instruction était composée de quatre micro-opérations : une qui lisait le premier octet de la constante immédiate, une seconde pour le second, une troisième micro-opération qui commande l'ALU et fait le calcul.

Un circuit appelé le ''loader'' synchronisait le décodeur d'instruction et la ''Prefetch input queue''. Il fournissait un bit qui indiquait si le premier octet d'une instruction était disponible dans la ''Prefetch input queue''. Un second bit indiquait si l'octet suivant était disponible, nous verrons pourquoi dans ce qui suit. Le ''loader'' recevait aussi des signaux de la part du décodeur d'instruction. Le décodeur envoyait le signal ''Run Next Instruction'' pour lire une instruction, qui était alors dépilée de la ''Prefetch input queue''. Le décodeur d'instruction pouvait aussi envoyer un signal ''Next-to-last (NXT)'', un cycle avant que l'instruction en cours ne termine. Le ''loader'' réagissait en préchargeant l'octet suivant. En clair, ce signal permettait de précharger l'instruction suivante avec un cycle d'avance, si celle-ci n'était pas déjà dans la ''Prefetch input queue''.

Le bus de données du 8086 faisait 16 bits, alors que celui du 8088 ne permettait que de lire un octet à la fois. Et cela avait un impact sur la ''prefetch input queue''. La ''prefetch input queue'' était composée de 4 registres de 8 bits, avec un port d'écriture de 8 bits pour précharger les instructions octet par octet, et un port de lecture de 8 bits pour alimenter le décodeur. En clair, tout faisait 8 bits. Le 8086, lui utilisait des registres de 16 bits et un port d'écriture de 16 bits. le port de lecture restait de 8 bits, et était précédé d'un multiplexeur qui prenait 16 bits et sélectionnait l'octet adéquat. Sa ''prefetch input queue'' préchargeait les instructions par paquets de 2 octets, non octet par octet, alors que le décodeur consommait les instructions octet par octet. Il s’agissait donc d'une sorte d'intermédiaire entre ''prefetch input queue'' à la 8088 et tampon de préchargement.

Les branchements posent des problèmes avec la ''Prefetch input queue'' : à cause d'eux, on peut charger à l'avance des instructions qui sont zappées par un branchement et ne sont pas censées être exécutées. Si un branchement est chargé, toutes les instructions préchargées après sont potentiellement invalides. Si le branchement est non-pris, les instructions chargées sont valides, elles sont censées s’exécuter. Mais si le branchement est pris, elles ont été chargées à tort et ne doivent pas s’exécuter. 

Pour éviter cela, la ''Prefetch input queue'' est vidée quand le processeur détecte un branchement. Pour cela, le décodeur d'instruction dispose d'une micro-opération qui vide la ''Prefetch input queue'', elle invalide les instructions préchargées.  Cette détection ne peut se faire qu'une fois le branchement décodé, qu'une fois que l'on sait que l'instruction décodée est un branchement. En clair, le décodeur invalide la ''Prefetch input queue'' quand il détecte un branchement. Les interruptions posent le même genre de problèmes. Il faut impérativement vider la ''Prefetch input queue'' quand une interruption survient, avant de la traiter.

Il faut noter qu'une ''Prefetch input queue'' interagit assez mal avec le ''program counter''. En effet, la ''Prefetch input queue'' précharge les instructions séquentiellement. Pour savoir où elle en est rendue, elle mémorise l'adresse de la prochaine instruction à charger dans un '''registre de préchargement''' dédié. Il serait possible d'utiliser un ''program counter'' en plus du registre de préchargement, mais ce n'est pas la solution qui a été utilisée. Les processeurs Intel anciens ont préféré n'utiliser qu'un seul registre de préchargement en remplacement du ''program counter''. Après tout, le registre de préchargement n'est qu'un ''program counter'' ayant pris une avance de quelques cycles d'horloge, qui a été incrémenté en avance.

Et cela ne pose pas de problèmes, sauf avec certains branchements. Par exemple, certains branchements relatifs demandent de connaitre la véritable valeur du ''program counter'', pas celle calculée en avance. Idem avec les instructions d'appel de fonction, qui demandent de sauvegarder l'adresse de retour exacte, donc le vrai ''program counter''. De telles situations demandent de connaitre la valeur réelle du ''program counter'', celle sans préchargement. Pour cela, le décodeur d'instruction dispose d'une instruction pour reconstituer le ''program counter'', à savoir corriger le ''program coutner'' et éliminer l'effet du préchargement.

La micro-opération de correction se contente de soustraire le nombre d'octets préchargés au registre de préchargement. Le nombre d'octets préchargés est déduit à partir des deux pointeurs intégré à la FIFO, qui indiquent la position du premier et du dernier octet préchargé. Le bit qui indique si la FIFO est vide était aussi utilisé. Les deux pointeurs sont lus depuis la FIFO, et sont envoyés à un circuit qui détermine le nombre d'octets préchargés. Sur le 8086, ce circuit était implémenté non pas par un circuit combinatoire, mais par une mémoire ROM équivalente. La petite taille de la FIFO faisait que les pointeurs étaient très petits et la ROM l'était aussi.

Un autre défaut est que la ''Prefetch input queue'' se marie assez mal avec du code auto-modifiant. Un code auto-modifiant est un programme qui se modifie lui-même, en remplaçant certaines instructions par d'autres, en en retirant, en en ajoutant, lors de sa propre exécution. De tels programmes sont rares, mais la technique était utilisée dans quelques cas au tout début de l'informatique sur des ordinateurs rudimentaires. Ceux-ci avaient des modes d'adressages tellement limités que gérer des tableaux de taille variable demandait d'utiliser du code auto-modifiant pour écrire des boucles.

Le problème avec la ''Prefetch input queue'' survient quand des instructions sont modifiées immédiatement après avoir été préchargées. Les instructions dans la ''Prefetch input queue'' sont l'ancienne version, alors que la mémoire RAM contient les instructions modifiées. Gérer ce genre de cas est quelque peu complexe. Il faut en effet vider la ''Prefetch input queue'' si le cas arrive, ce qui demande d'identifier les écritures qui écrasent des instructions préchargées. C'est parfaitement possible, mais demande de transformer la ''Prefetch input queue'' en une mémoire hybride, à la fois mémoire associative et mémoire FIFO. Cela ne vaut que très rarement le coup, aussi les ingénieurs ne s’embêtent pas à mettre ce correctif en place, le code automodifiant est alors buggé.

Le décodeur d'instruction dispose aussi d'une micro-opération qui stoppe le préchargement des instructions dans la ''Prefetch input queue''.

: Pour ceux qui ont déjà lu un cours d'architecture des ordinateurs, la relation entre ''prefetch input queue'' et pipeline est quelque peu complexe. En apparence, la ''prefetch input queue'' permet une certaines forme de pipeline, en chargeant une instruction pendant que la précédente s'exécute. Les problématiques liées aux branchements ressemblent beaucoup à celles de la prédiction de branchement. Cependant, il est possible de dire qu'il s'agit plus d'une technique de préchargement que de pipeline. La différence entre les deux est assez subtile et les frontières sont assez floues, mais le fait est que l'instruction en cours d'exécution et le préchargement peuvent tout deux faire des accès mémoire et que l'instruction en cours a la priorité. Un vrai pipeline se débrouillerait avec une architecture Harvard, non avec un bus mémoire unique pour le chargement des instruction et la lecture/écriture des données.

===Le ''Zero-overhead looping''===

Nous avions vu dans le chapitre sur les instructions machines, qu'il existe des instructions qui permettent de grandement faciliter l'implémentation des boucles. Il s'agit de l'instruction REPEAT, utilisée sur certains processeurs de traitement de signal. Elle répète l'instruction suivante, voire une série d'instructions, un certain nombre de fois. Le nombre de répétitions est mémorisé dans un registre décrémenté à chaque itération de la boucle. Elle permet donc d'implémenter une boucle FOR facilement, sans recourir à des branchements ou des conditions.

Une technique en lien avec cette instruction permet de grandement améliorer les performances et la consommation d'énergie. L'idée est de mémoriser la boucle, les instructions à répéter, dans une petite mémoire cache située entre l'unité de chargement et le séquenceur. Le cache en question s'appelle un '''tampon de boucle''', ou encore un ''hardware loop buffer''. Grâce à lui, il n'y a pas besoin de charger les instructions à chaque fois qu'on les exécute, on les charge une bonne fois pour toute : c'est plus rapide. Bien sûr, il ne fonctionne que pour de petites boucles, mais il en est de même avec l'instruction REPEAT.

&lt;noinclude&gt;
{{NavChapitre | book=Fonctionnement d'un ordinateur
           | prev=Le chemin de données
           | prevText=Le chemin de données
           | next=L'unité de contrôle
           | nextText=L'unité de contrôle
}}
&lt;/noinclude&gt;</text>
      <sha1>7d9gi09tk0ue7jiwylj88abuw16ke5k</sha1>
    </revision>
    <revision>
      <id>744091</id>
      <parentid>744090</parentid>
      <timestamp>2025-06-03T20:27:49Z</timestamp>
      <contributor>
        <username>Mewtow</username>
        <id>31375</id>
      </contributor>
      <minor />
      <comment>/* La prefetch input queue */</comment>
      <origin>744091</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="47786" sha1="5vet1d38ownpjhyh29uqsl5k4ilsu2x" xml:space="preserve">L'unité de contrôle s'occupe du chargement des instructions et de leur interprétation, leur décodage. Elle contient deux circuits : l''''unité de chargement''' qui charge l'instruction depuis la mémoire, et le '''séquenceur''' qui commande le chemin de données. Les deux circuits sont séparés, mais ils communiquent entre eux, notamment pour gérer les branchements. Dans ce chapitre, nous allons nous intéresser au chargement d'une instruction depuis la RAM/ROM, nous verrons l'étape de décodage de l'instruction au prochain chapitre.

==Le chargement d'une instruction==

[[File:Étape de chargement.png|vignette|upright=1|Étape de chargement.]]

L'étape de chargement (ou ''fetch'') doit faire deux choses : mettre à jour le ''program counter'' et lire l'instruction en mémoire RAM ou en ROM. Les deux étapes peuvent être faites en parallèle, dans des circuits séparés. Pendant que l'instruction est lue depuis la mémoire RAM/ROM, le ''program counter'' est incrémenté et/ou altéré par un branchement.

Pour lire l'instruction, on envoie le ''program counter'' sur le bus d'adresse et on récupère l'instruction sur le bus de données pour l'envoyer sur l'entrée du séquenceur. Et cela demande de connecter le séquenceur au bus mémoire, à travers l'interface mémoire. Et sur ce point, la situation est différente selon que l'on parler d'une architecture Harvard ou Von Neumann.

===Les interconnexions entre séquenceur et bus mémoire===

Sur les architectures Harvard, le séquenceur et le chemin de donnée utilisent des interfaces mémoire séparées. Le séquenceur est directement relié au bus mémoire de la ROM, alors que le chemin de données est connecté à la RAM.

[[File:Microarchitecture de l'interface mémoire d'une architecture Harvard.png|centre|vignette|upright=2|Microarchitecture de l'interface mémoire d'une architecture Harvard]]

Mais sur les architectures Von-Neumann et affiliées, le séquenceur et le chemin de donnée partagent la même interface mémoire. Et cela pose deux problèmes.

Le premier problème est que le bus mémoire doit être libéré une fois l'instruction chargée, pour un éventuel accès mémoire. Mais le séquenceur doit conserver une copie de l'instruction chargée, sans quoi il ne peut pas décoder l'instruction correctement. Par exemple, si l'instruction met plusieurs cycles à s'exécuter, le séquenceur doit conserver une copie de l'instruction durant ces plusieurs cycles. La solution à ce problème est un '''registre d'instruction''' situé juste avant le séquenceur, qui mémorise l'instruction chargée.

[[File:Registre d'instruction.png|centre|vignette|upright=2|Registre d'instruction.]]

Le second problème est de gérer le flot des instructions/données entre le bus mémoire, le chemin de données et le séquenceur. Le processeur doit connecter l'interface mémoire soit au séquenceur, soit au chemin de données et cela complique le réseau d'interconnexion interne au processeur.

Une première solution utilise un bus unique qui relie l'interface mémoire, le séquenceur et le chemin de données. Pour charger une instruction, le séquenceur copie le ''program counter'' sur le bus d'adresse, attend que l'instruction lue soit disponible sur le bus de données, puis la copie dans le registre d'instruction. Le bus mémoire est alors libre et peut être utilisé pour lire ou écrire des données, si le besoin s'en fait sentir.

Il faut noter que l'usage d'un bus unique a un impact sur l'organisation interne du chemin de données. Par exemple, le chapitre précédent nous a montré comment implémenter un chemin de données basique, avec des multiplexeurs et démultiplexeurs. Et bien ces chemins de données ne marchent pas vraiment avec un bus interne unique. Il est possible de les adapter, mais au prix d'une complexité largement supérieure. Un bus interne unique marche mieux quand le banc de registre est mono-port. C'est pourquoi il a été utilisé sur d'anciennes architectures appelées des architectures à accumulateur et à pile, que nous verrons dans quelques chapitres, qui utilisaient un banc de registre mono-port.

[[File:Microarchitecture de l'interface mémoire d'une architecture von neumann.png|centre|vignette|upright=2|Microarchitecture de l'interface mémoire d'une architecture von neumann]]

Une autre solution utilise deux bus interne séparés : un connecté au bus d'adresse, l'autre au bus de données. Le ''program counter'' est alors connecté au bus interne d'adresse, le séquenceur est relié au bus interne de données. Notons que la technique marche bien si le ''program counter'' est dans le banc de registre : les interconnexions utilisées pour gérer l'adressage indirect permettent d'envoyer le ''program counter'' sur le bus d'adresse sans ajout de circuit.

Le tout peut être amélioré en remplaçant les deux bus par des multiplexeurs et démultiplexeurs. Le bus d'adresse est précédé par un multiplexeur, qui permet de faire le choix entre ''Program Counter'', adresse venant du chemin de données, ou adresse provenant du séquenceur (adressage absolu). De même, le bus de données est suivi par un démultiplexeur qui envoie la donnée/instruction lue soit au registre d'instruction, soit au chemin de données. Le tout se marie très bien avec les chemins de donnée vu dans le chapitre précédent. Au passage, il faut noter que cette solution nécessite un banc de registre multi-port.

[[File:Connexion du program counter sur les bus avec PC isolé.png|centre|vignette|upright=2|Connexion du program counter sur les bus avec PC isolé]]

===Le chargement des instructions de longueur variable===

Le chargement des instructions de longueur variable pose de nombreux problèmes. Le premier est que mettre à jour le ''program counter'' demande de connaitre la longueur de l'instruction chargée, pour l'ajouter au ''program counter''. Si la longueur d'une instruction est variable, on doit connaitre cette longueur d'une manière où d'une autre. La solution la plus simple indique la longueur de l'instruction dans une partie de l'opcode ou de la représentation en binaire de l'instruction. Mais les processeurs haute performance de nos PC utilisent d'autres solutions, qui n'encodent pas explicitement la taille de l'instruction.

Les processeurs récents utilisent un registre d'instruction de grande taille, capable de mémoriser l'instruction la plus longue du processeur. Par exemple, si un processeur supporte des instructions allant de 1 à 8 octets, comme les CPU x86, le registre d'instruction fera 8 octets. Le décodeur d'instruction vérifie à chaque cycle le contenu du registre d'instruction. Si une instruction est détectée dedans, son décodage commence, peu importe la taille de l'instruction. Une fois l'instruction exécutée, elle est retirée du registre d'instruction. Reste à alimenter le registre d'instruction, à charger des instructions dedans. Et pour cela deux solutions : soit on charge l'instruction en plusieurs fois, soit d'un seul coup.

La solution la plus simple charge les instructions par mots de 8, 16, 32, 64 bits. Ils sont accumulés dans le registre d'instruction jusqu'à détecter une instruction complète. La technique marche nettement mieux si les instructions sont très longues. Par exemple, les CPU x86 ont des instructions qui vont de 1 à 15 octets, ce qui fait qu'ils utilisent cette technique. Précisément, elle marche si les instructions les plus longues sont plus grandes que le bus mémoire.

Une autre solution charge un bloc de mots mémoire aussi grand que la plus grande instruction. Par exemple, si le processeur gère des instructions allant de 1 à 4 octets, il charge 4 octets d'un seul coup dans le registre d'instruction. Il va de soit que cette solution ne marche que si les instructions du processeur sont assez courtes, au plus aussi courtes que le bus mémoire. Ainsi, on est sûr de charger obligatoirement au moins une instruction complète, et peut-être même plusieurs. Le contenu du registre d'instruction est alors découpé en instructions au fil de l'eau. 

Utiliser un registre d'instruction large pose problème avec des instructions à cheval entre deux blocs. Il se peut qu'on n'ait pas une instruction complète lorsque l'on arrive à la fin du bloc, mais seulement un morceau. Le problème se manifeste peu importe que l'instruction soit chargée d'un seul coup ou bien en plusieurs fois.

[[File:Instructions non alignées.png|centre|vignette|upright=2|Instructions non alignées.]]

Dans ce cas, on doit décaler le morceau de bloc pour le mettre au bon endroit (au début du registre d'instruction), et charger le prochain bloc juste à côté. On a donc besoin d'un circuit qui décale tous les bits du registre d'instruction, couplé à un circuit qui décide où placer dans le registre d'instruction ce qui a été chargé, avec quelques circuits autour pour configurer les deux circuits précédents.

[[File:Décaleur d’instruction.png|centre|vignette|upright=2|Décaleur d’instruction.]]

Une autre solution se passe de registre d'instruction en utilisant à la place l'état interne du séquenceur. Là encore, elle charge l'instruction morceau par morceau, typiquement par blocs de 8, 16 ou 32 bits. Les morceaux ne sont pas accumulés dans le registre d'instruction, la solution utilise à la place l'état interne du séquenceur. Les mots mémoire de l'instruction sont chargés à chaque cycle, faisant passer le séquenceur d'un état interne à un autre à chaque mot mémoire. Tant qu'il n'a pas reçu tous les mots mémoire de l'instruction, chaque mot mémoire non terminal le fera passer d'un état interne à un autre, chaque état interne encodant les mots mémoire chargés auparavant. S'il tombe sur le dernier mot mémoire d'une instruction, il rentre dans un état de décodage.

==L'incrémentation du ''program counter''==

À chaque chargement, le ''program counter'' est mis à jour afin de pointer sur la prochaine instruction à charger. Sur la quasi-totalité des processeurs, les instructions sont placées dans l'ordre d’exécution dans la RAM. En faisant ainsi, on peut mettre à jour le ''program counter'' en lui ajoutant la longueur de l'instruction courante. Déterminer la longueur de l'instruction est simple quand les instructions ont toutes la même taille, mais certains processeurs ont des instructions de taille variable, ce qui complique le calcul. Dans ce qui va suivre, nous allons supposer que les instructions sont de taille fixe, ce qui fait que le ''program counter'' est toujours incrémenté de la même valeur.

Il existe deux méthodes principales pour incrémenter le ''program counter'' : soit le ''program counter'' a son propre additionneur, soit le ''program counter'' est mis à jour par l'ALU. Pour ce qui est de l'organisation des registres, soit le ''program counter'' est un registre séparé des autres, soit il est regroupé avec d'autres registres dans un banc de registre. En tout, cela donne quatre organisations possibles.
* Un ''program counter'' séparé relié à un incrémenteur séparé.
* Un ''program counter'' séparé des autres registres, incrémenté par l'ALU.
* Un ''program counter'' intégré au banc de registre, relié à un incrémenteur séparé.
* Un ''program counter'' intégré au banc de registre, incrémenté par l'ALU.

[[File:Calcul du program counter.png|centre|vignette|upright=2|les différentes méthodes de calcul du program counter.]]

Les processeurs haute performance modernes utilisent tous la première méthode. Les autres méthodes étaient surtout utilisées sur les processeurs 8 ou 16 bits, elles sont encore utilisées sur quelques microcontrôleurs de faible puissance. Nous auront l'occasion de donner des exemples quand nous parlerons des processeurs 8 bits anciens, dans le chapitre sur les architectures à accumulateur et affiliées.

===Le ''program counter'' mis à jour par l'ALU===

Sur certains processeurs, le calcul de l'adresse de la prochaine instruction est effectué par l'ALU. L'avantage de cette méthode est qu'elle économise un incrémenteur dédié au ''program counter''. Ce qui explique que cette méthode était utilisée sur les processeurs assez anciens, à une époque où un additionneur pouvait facilement prendre 10 à 20% des transistors disponibles. Le désavantage principal est une augmentation de la complexité du séquenceur, qui doit gérer la mise à jour du ''program counter''. De plus, la mise à jour du ''program counter'' ne peut pas se faire en même temps qu'une opération arithmétique, ce qui réduit les performances.

Si on incrémente le ''program counter'' avec l'ALU, il est intéressant de le placer dans le banc de registres. Un désavantage est qu'on perd un registre. Par exemple, avec un banc de registre de 16 registres, on ne peut adresser que 15 registres généraux. De plus ce n'est pas l'idéal pour le décodage des instructions et pour le séquenceur. Si le processeur dispose de plusieurs bancs de registres, le ''program counter'' est généralement placé dans le banc de registre dédié aux adresses. Sinon, il est placé avec les nombres entiers/adresses.

D'anciens processeurs incrémentaient le ''program counter'' avec l'ALU, mais utilisaient bien un registre séparé pour le ''program counter''. Cette méthode est relativement simple à implémenter : il suffit de connecter/déconnecter le ''program counter'' du bus interne suivant les besoins. Le ''program counter'' est déconnecté pendant l’exécution d'une instruction, il est connecté au bus interne pour l'incrémenter. C'est le séquenceur qui gère le tout. L'avantage de cette séparation est qu'elle est plus facile à gérer pour le séquenceur. De plus, on gagne un registre général/entier dans le banc de registre.

===Le compteur programme===

Dans la quasi-totalité des processeurs modernes, le ''program counter'' est un vulgaire compteur comme on en a vu dans les chapitres sur les circuits, ce qui fait qu'il passe automatiquement d'une adresse à la suivante. Dans ce qui suit, nous allons appeler ce registre compteur : le '''compteur ordinal'''. L'usage d'un compteur simplifie fortement la conception du séquenceur. Le séquenceur n'a pas à gérer la mise à jour du ''program counter'', sauf en cas de branchements. De plus, il est possible d'incrémenter le ''program counter'' pendant que l'unité de calcul effectue une opération arithmétique, ce qui améliore grandement les performances. Le seul désavantage est qu'elle demande d'ajouter un incrémenteur dédié au ''program counter''.

Sur les processeurs très anciens, les instructions faisaient toutes un seul mot mémoire et le compteur ordinal était un circuit incrémenteur des plus basique. Sur les processeurs modernes, le compteur est incrémenté par pas de 4 si les instructions sont codées sur 4 octets, 8 si les instructions sont codées sur 8 octets, etc. Concrètement, le compteur est un circuit incrémenteur auquel on aurait retiré quelques bits de poids faible. Par exemple, si les instructions sont codées sur 4 octets, on coupe les 2 derniers bits du compteur. Si les instructions sont codées sur 8 octets, on coupe les 3 derniers bits du compteur. Et ainsi de suite.

Il a existé quelques processeurs pour lesquelles le ''program counter'' était non pas un compteur binaire classique, mais un ''linear feedback shift register''. L'avantage est que le circuit d'incrémentation utilisait bien moins de portes logiques, l'économie était substantielle. Mais un défaut est que des instructions consécutives dans le programme n'étaient pas consécutives en mémoire. Il existait cependant une table de correspondance pour dire : la première instruction est à telle adresse, la seconde à telle autre, etc. Un exemple de processeur de ce type est le TMS 1000 de Texas Instrument, un des premiers microcontrôleur 4 bits datant des années 70.

Une amélioration de la solution précédente utilise un circuit incrémenteur partagé entre le ''program counter'' et d'autres registres. L'incrémenteur est utilisé pour incrémenter le ''program counter'', mais aussi pour effectuer d'autres calculs d'adresse. Par exemple, sur les architectures avec une pile d'adresse de retour, il est possible de partager l'incrémenteur/décrémenteur avec le pointeur de pile ( la technique ne marche pas avec une pile d'appel). Un autre exemple est celui des processeurs qui gèrent automatiquement le rafraichissement mémoire, grâce à, un compteur intégré dans le processeur. Il est possible de partager l'incrémenteur du ''program counter'' avec le compteur de rafraichissement mémoire, qui mémorise la prochaine adresse mémoire à rafraichir. Nous avions déjà abordé ce genre de partage dans le chapitre sur le chemin de données, dans l'annexe sur le pointeur de pile, mais nous verrons d'autres exemples dans le chapitre sur les architectures hybride accumulateur-registre 8/16 bits.

===Quand est mis à jour le ''program counter'' ?===

Le ''program counter'' est mis à jour quand il faut charger une nouvelle instruction. Reste qu'il faut savoir quand le mettre à jour. Incrémenter le ''program counter'' à intervalle régulier, par exemple à chaque cycle d’horloge, fonctionne sur les processeurs où toutes les instructions mettent le même temps pour s’exécuter. Mais de tels processeurs sont très rares. Sur la quasi-totalité des processeurs, les instructions ont une durée d’exécution variable, elles ne prennent pas le même nombre de cycle d'horloge pour s’exécuter. Le temps d’exécution d'une instruction varie selon l'instruction, certaines sont plus longues que d'autres. Tout cela amène un problème : comment incrémenter le ''program counter'' avec des instructions avec des temps d’exécution variables ?

La réponse est que la mise à jour du ''program counter'' démarre quand l'instruction précédente a terminée de s’exécuter, plus précisément un cycle avant. C'est un cycle avant pour que l'instruction chargée soit disponible au prochain cycle pour le décodeur. Pour cela, le séquenceur doit déterminer quand l'instruction est terminée et prévenir le ''program counter'' au bon moment. Il faut donc une interaction entre séquenceur et circuit de chargement. Le circuit de chargement contient une entrée Enable, qui autorise la mise à jour du ''program counter''. Le séquenceur met à 1 cette entrée pour prévenir au ''program counter'' qu'il doit être incrémenté au cycle suivant ou lors du cycle courant. Cela permet de gérer simplement le cas des instructions multicycles. 

[[File:Commande de la mise à jour du program counter.png|centre|vignette|upright=2|Commande de la mise à jour du program counter.]]

Toute la difficulté est alors reportée dans le séquenceur, qui doit déterminer la durée d'une instruction. Pour gérer la mise à jour du ''program counter'', le séquenceur doit déterminer la durée d'une instruction. Cela est simple pour les instructions arithmétiques et logiques, qui ont un nombre de cycles fixe, toujours le même. Une fois l'instruction identifiée par le séquenceur, il connait son nombre de cycles et peut programmer un compteur interne au séquenceur, qui compte le nombre de cycles de l'instruction, et fournit le signal Enable au ''program counter''. Mais cette technique ne marche pas vraiment pour les accès mémoire, dont la durée n'est pas connue à l'avance, surtout sur les processeurs avec des mémoires caches. Pour cela, le séquenceur détermine quand l'instruction mémoire est finie et prévient le ''program counter'' quand c'est le cas.

Il existe quelques processeurs pour lesquels le temps de calcul dépend des opérandes de l'instruction. On peut par exemple avoir une division qui prend 10 cycles avec certaines opérandes, mais 40 cycles avec d'autres opérandes. Mais ces processeurs sont rares et cela est surtout valable pour les opérations de multiplication/division, guère plus. Le problème est alors le même qu'avec les accès mémoire et la solution est la même : l'ALU prévient le séquenceur quand le résultat est disponible.

==Les branchements et le ''program counter''==

Un branchement consiste juste à écrire l'adresse de destination dans le ''program counter''. L'implémentation des branchements demande d'extraire l'adresse de destination et d'altérer le ''program counter'' quand un branchement est détecté. Pour cela, le décodeur d'instruction détecte si l'instruction exécutée est un branchement ou non, et il en déduit où trouver l'adresse de destination.

L'adresse de destination se trouve à un endroit qui dépend du mode d'adressage du branchement. Pour rappel, on distingue quatre modes d'adressage pour les branchements : direct, indirect, relatif et implicite. Pour les branchements directs, l'adresse est intégrée dans l'instruction de branchement elle-même et est extraite par le séquenceur. Pour les branchements indirects, l'adresse de destination est dans le banc de registre. Pour les branchements relatifs, il faut ajouter un décalage au ''program counter'', décalage extrait de l'instruction par le séquenceur. Enfin, les instructions de retour de fonction lisent l'adresse de destination depuis la pile. L'implémentation de ces quatre types de branchements est très différente.

L'altération du ''program counter'' dépend de si le ''program counter'' est dans un compteur séparé ou s'il est dans le banc de registre. Nous avons vu plus haut qu'il y a quatre cas différents, mais nous n'allons voir que deux cas : celui où le ''program counter'' est dans le banc de registre et est incrémenté par l'unité de calcul, celui avec un ''program counter'' séparé avec son propre incrémenteur. Les deux autres cas ne sont utilisés que sur des architectures à accumulateur ou à pile spécifiques, que nous n'avons pas encore vu à ce stade du cours et que nous verrons en temps voulu dans le chapitre sur ces architectures.

===L’implémentation des branchements avec un ''program counter'' intégré au banc de registres===

Le cas le plus simple est celui où le ''program counter'' est intégré au banc de registre, avec une incrémentation faite par l'unité de calcul. Charger une instruction revient alors à effectuer une instruction LOAD en adressage indirect, à deux différences près : le registre sélectionné est le ''program counter'', l’instruction est copiée dans le registre d'instruction et non dans le banc de registre. L'incrémentation du ''porgram counter'' est implémenté avec des micro-opérations qui agissent sur le chemin de données, au même titre que les branchements indirects, relatifs et directs.
* Les branchements indirects copient un registre dans le ''program counter'', ce qui revient simplement à faire une opération MOV entre deux registres, dont le ''program counter'' est la destination.
* L'opération inverse d'un branchement indirect, qui copie le ''program counter'' dans un registre général, est utile pour sauvegarder l'adresse de retour d'une fonction.
* Les branchements directs copient une adresse dans le ''program counter'', ce qui les rend équivalents à une opération MOV avec une constante immédiate, dont le ''program counter'' est la destination.
* Les branchements relatifs sont une opération arithmétique entre le ''program counter'' et un opérande en adressage immédiat.

En clair, à partir du moment où le chemin de données supporte les instructions MOV et l'addition, avec les modes d'adressage adéquat, il supporte les branchements. Aucune modification du chemin de données n'est nécessaire, le séquenceur gére le chargement d'une instruction avec les micro-instructions adéquates : une micro-opération ADD pour incrémenter le ''program counter'', une micro-opération LOAD pour le chargement de l'instruction.

Notons que sur certaines architectures, le ''program counter'' est adressable au même titre que les autres registres du banc de registre. Les instructions de branchement sont alors remplacées par des instructions MOV ou des instructions arithmétique équivalentes, comme décrit plus haut.

===L’implémentation des branchements avec un ''program counter'' séparé===

Étudions maintenant le cas où le ''program counter'' est dans un registre/compteur séparé. Rappelons que tout compteur digne de ce nom possède une entrée de réinitialisation, qui remet le compteur à zéro. De plus, on peut préciser à quelle valeur il doit être réinitialisé. Ici, la valeur à laquelle on veut réinitialiser le compteur n'est autre que l'adresse de destination du branchement. Implémenter un branchement est donc simple : l'entrée de réinitialisation est commandée par le circuit de détection des branchements, alors que la valeur de réinitialisation est envoyée sur l'entrée adéquate. En clair, nous partons du principe que le ''program counter'' est implémenté avec ce type de compteur :

[[File:Fonctionnement d'un compteur (décompteur), schématique.jpg|centre|vignette|upright=1.5|Fonctionnement d'un compteur (décompteur), schématique]]

Toute la difficulté est de présenter l'adresse de destination au ''program counter''. Pour les branchements directs, l'adresse de destination est fournie par le séquenceur. L'adresse de destination du branchement sort du séquenceur et est présentée au ''program counter'' sur l'entrée adéquate. Voici donc comment sont implémentés les branchements directs avec un ''program counter'' séparé du banc de registres. Le schéma ci-dessous marche peu importe que le ''program counter'' soit incrémenté par l'ALU ou par un additionneur dédié.

[[File:Unité de détection des branchements dans le décodeur.png|centre|vignette|upright=2|Unité de détection des branchements dans le décodeur]]

Les branchements relatifs sont ceux qui font sauter X instructions plus loin dans le programme. Leur implémentation demande d'ajouter une constante au ''program counter'', la constante étant fournie dans l’instruction. Là encore, deux solutions sont possibles : réutiliser l'ALU pour calculer l'adresse, ou utiliser un additionneur séparé. L'additionneur séparé peut être fusionné avec l'additionneur qui incrémente le ''program counter'' pour passer à l’instruction suivante.

[[File:Unité de chargement qui gère les branchements relatifs.png|centre|vignette|upright=2|Unité de chargement qui gère les branchements relatifs.]]

Pour les branchements indirects, il suffit de lire le registre voulu et d'envoyer le tout sur l'entrée adéquate du ''program counter''. Il faut alors rajouter un multiplexeur pour que l'entrée de réinitialisationr ecoive la bonne adresse de destination.

[[File:Unité de chargement qui gère les branchements directs.png|centre|vignette|upright=2|Unité de chargement qui gère les branchements directs et indirects.]]

Toute la difficulté de l'implémentation des branchements est de configurer les multiplexeurs, ce qui est réalisé par le séquenceur en fonction du mode d'adressage du branchement.

==Les optimisations du chargement des instructions==

Charger une instruction est techniquement une forme d'accès mémoire un peu particulier. En clair, charger une instruction prend au minimum un cycle d'horloge, et cela peut rapidement monter à 3-5 cycles, si ce n'est plus. L'exécution des instructions est alors fortement ralentit par la mémoire. Par exemple, imaginez que la mémoire mette 3 cycles d'horloges pour charger une instruction, alors qu'une instruction s’exécute en 1 cycle (si les opérandes sont dans les registres). La perte de performance liée au chargement des instructions est alors substantielle. Heureusement, il est possible de limiter la casse en utilisant des mémoires caches, ainsi que d'autres optimisations, que nous allons voir dans ce qui suit.

===Le tampon de préchargement===

La technique dite du '''préchargement''' est utilisée dans le cas où la mémoire a un temps d'accès important. Mais si la latence de la RAM est un problème, le débit ne l'est pas. Il est possible d'avoir une RAM lente, mais à fort débit. Par exemple, supposons que la mémoire puisse charger 4 instructions (de taille fixe) en 3 cycles. Le processeur peut alors charger 4 instructions en un seul accès mémoire, et les exécuter l'une après l'autre, une par cycle d'horloge. Les temps d'attente sont éliminés : le processeur peut décoder une nouvelle instruction à chaque cycle. Et quand la dernière instruction préchargée est exécutée, la mémoire est de nouveau libre, ce qui masque la latence des accès mémoire.

[[File:Tampon de préchargement d'instruction.png|vignette|Tampon de préchargement d'instruction]]

La seule contrainte est de mettre les instructions préchargées en attente. La solution pour cela est d'utiliser un registre d'instruction très large, capable de mémoriser plusieurs instructions à la fois. Ce registre est de plus connecté à un multiplexeur qui permet de sélectionner l'instruction adéquate dans ce registre. Ce multiplexeur est commandé par le ''program counter'' et quelques circuits annexes. Ce super-registre d'instruction est appelé un '''tampon de préchargement'''.

La méthode a une implémentation nettement plus simple avec des instructions de taille fixe, alignées en mémoire. La commande du multiplexeur de sélection de l'instruction est alors beaucoup plus simple : il suffit d'utiliser les bits de poids fort du ''program counter''. Par exemple, prenons le cas d'un registre d'instruction de 32 octets pour des instructions de 4 octets, soit 8 instructions. Le choix de l'instruction à sélectionner se fait en utilisant les 3 bits de poids faible du ''program counter''. 

Mais cette méthode ajoute de nouvelles contraintes d'alignement, similaires à celles vues dans le chapitre sur l'alignement et le boutisme, sauf que l'alignement porte ici sur des blocs d'instructions de même taille que le tampon de préchargement. Si on prend l'exemple d'un tampon de préchargement de 128 bits, les instructions devront être alignées par blocs de 128 bits. C'est à dire qu'idéalement, les fonctions et autres blocs de code isolés doivent commencer à des adresses multiples de 128, pour pouvoir charger un bloc d'instruction en une seule fois. Sans cela, les performances seront sous-optimales.

: Il arrive que le tampon de préchargement ait la même taille qu'une ligne de cache.

Lorsque l'on passe d'un bloc d'instruction à un autre, le tampon de préchargement est mis à jour. Par exemple, si on prend un tampon de préchargement de 4 instructions, on doit changer son contenu toutes les 4 instructions. La seule exception est l'exécution d'un branchement. En effet, lors d'un branchement, la destination du branchement n'est pas dans le tampon de préchargement et elle doit être chargée dedans (sauf si le branchement pointe vers une instruction très proche, ce qui est improbable). Pour cela, le tampon de préchargement est mis à jour précocement quand le processeur détecte un branchement.

Le même problème survient avec du code auto-modifiant. Un code auto-modifiant est un programme qui se modifie lui-même, en remplaçant certaines instructions par d'autres, en en retirant, en en ajoutant, lors de sa propre exécution. De tels programmes sont rares, mais la technique était utilisée dans quelques cas au tout début de l'informatique sur des ordinateurs rudimentaires. Ceux-ci avaient des modes d'adressages tellement limités que gérer des tableaux de taille variable demandait d'utiliser du code auto-modifiant pour écrire des boucles. Le problème survient quand des instructions sont modifiées immédiatement après avoir été préchargées. Les instructions dans le tampon de préchargement sont l'ancienne version, alors que la mémoire RAM contient les instructions modifiées. Gérer ce genre de cas demande de vider le tampon de préchargement si le cas arrive, mais ça ne vaut que très rarement le coup, aussi les ingénieurs ne s’embêtent pas à mettre ce correctif en place. Le code automodifiant est alors buggé.

===La ''prefetch input queue''===

La ''prefetch input queue'' est une sorte de cousine du tampon de préchargement, qui a été utilisée sur les processeurs Intel assez ancien. Elle est apparue sur le 8086 et le 8088, des processeurs respectivement 8 et 16 bits. Elle été présente sur le 286 et le 386, mais était un peu améliorée. Elle est apparue sur ces processeurs à une époque où le processeur devenait plus rapide que la mémoire.

L'idée est là encore de précharger des instructions en avance. Sauf que cette fois-ci, on ne charge pas plusieurs instructions à la fois. Au contraire, les instructions sont préchargées séquentiellement, un ou deux octet à la fois. En conséquence, le tampon de préchargement est remplacé par une mémoire FIFO appelée la '''''Prefetch Input Queue''''', terme abrévié en PIQ. Les instructions sont accumulées une par une dans la PIQ, elles en sortent une par une au fur et à mesure pour alimenter le décodeur d'instruction.

Pendant que le processeur exécute une instruction, on précharge la suivante. Sans ''prefetch input queue'', le processeur chargeait une instruction, la décodait et l'exécutait, puis chargeait la suivante, et ainsi de suite. Avec un tampon de préchargement, le processeur chargeait plusieurs instruction en une seule fois, puis les exécutait les unes après les autres. Avec la ''prefetch input queue'', pendant qu'une instruction est en cours de décodage/exécution, le processeur précharge l'instruction suivante. Si une instruction prend vraiment beaucoup de temps pour s'exécuter, le processeur peut en profiter pour précharger l'instruction encore suivante, et ainsi de suite, jusqu'à une limite de 4/6 instructions (la limite dépend du processeur).

La ''prefetch input queue'' permet de précharger l'instruction suivante à condition qu'aucun autre accès mémoire n'ait lieu. Si l'instruction en cours d'exécution effectue des accès mémoire, ceux-ci sont prioritaires sur tout le reste, le préchargement de l'instruction suivante est alors mis en pause ou inhibé. Par contre, si la mémoire n'est pas utilisée par l'instruction en cours d'exécution, le processeur lit l'instruction suivante en RAM et la copie dans la ''prefetch input queue''. En conséquence, il arrive que la ''prefetch input queue'' n'ait pas préchargé l'instruction suivante, alors que le décodeur d'instruction est prêt pour la décoder. Dans ce cas, le décodeur doit attendre que l'instruction soit chargée.

Les instructions préchargées dans la ''Prefetch input queue'' y attendent que le processeur les lise et les décode. Les instructions préchargées sont conservées dans leur ordre d'arrivée, afin qu'elles soient exécutées dans le bon ordre, ce qui fait que la ''Prefetch input queue'' est une mémoire de type FIFO. L'étape de décodage pioche l'instruction à décoder dans la ''Prefetch input queue'', cette instruction étant par définition la plus ancienne, puis la retire de la file.

Le premier processeur commercial grand public à utiliser une ''prefetch input queue'' était le 8086. Il pouvait précharger à l'avance 6 octets d’instruction. L'Intel 8088 avait lui aussi une ''Prefetch input queue'', mais qui ne permettait que de précharger 4 instructions. La taille idéale de la FIFO dépend de nombreux paramètres. On pourrait croire que plus elle peut contenir d'instructions, mieux c'est, mais ce n'est pas le cas, pour des raisons que nous allons expliquer dans quelques paragraphes.

[[File:80186 arch.png|centre|vignette|700px|upright=2|Architecture du 8086, du 80186 et de ses variantes.]]

Vous remarquerez que j'ai exprimé la capacité de la ''prefetch input queue'' en octets et non en instructions. La raison est que sur les processeurs x86, les instructions sont de taille variable, avec une taille qui varie entre un octet et 6 octets. Cependant, le décodage des instructions se fait un octet à la fois : le décodeur lit un octet, puis éventuellement le suivant, et ainsi de suite jusqu'à atteindre la fin de l'instruction. En clair, le décodeur lit les instructions longues octet par octet dans la ''Prefetch input queue''. Pour cela, le décodeur dispose d'une micro-opération pour lire un octet depuis la ''prefetch input queue''.

Les instructions varient entre 1 et 6 octets, mais tous ne sont pas utile au décodeur d'instruction. Par exemple, le décodeur d'instruction n'a pas besoin d'analyser les constantes immédiates intégrées dans une instruction, ni les adresses mémoires en adressage absolu. Il a besoin de deux octets : l'opcode, et l'octet Mod/RM qui précise le mode d'adressage. Le second est facultatif. En clair, le décodeur a besoin de lire deux octets maximum depuis la ''prefetch input queue'', avant de passer à l’instruction suivante.

Les octets n'étant ni un opcode ni l'octet Mod/RN étaient envoyés ailleurs. Par exemple, prenons le cas d'une addition entre le registre AX et une constante immédiate. L'instruction fait trois octets : un opcode suivie par une constante immédiate codée sur deux octets. L'opcode était envoyé au décodeur, mais pas la constante immédiate. Elle était lue octet par octet et mémorisée dans un registre temporaire placé en entrée de l'ALU. Tout se passait du décodage : l'instruction était composée de quatre micro-opérations : une qui lisait le premier octet de la constante immédiate, une seconde pour le second, une troisième micro-opération qui commande l'ALU et fait le calcul. Idem avec les adresses immédiates, qui étaient envoyées dans un registre d’interfaçage mémoire sans passer par le décodeur d'instruction. En clair, la ''prefetch input queue'' était connectée au bus interne du processeur !

Le décodeur devait attendre que qu'un moins un octet soit disponible dans la ''Prefetch input queue'', pour le lire. Il lisait alors cet octet et déterminait s'il contenait une instruction complète ou non. Si c'est une instruction complète, il la décodait et l''exécutait, puis passait à l'instruction suivante. Sinon, il lit un second octet depuis la ''Prefetch input queue'' et relance le décodage. Là encore, le décodeur vérifie s'il a une instruction complète, et lit un troisième octet si besoin, puis rebelote avec un quatrième octet lu, etc.

Un circuit appelé le ''loader'' synchronisait le décodeur d'instruction et la ''Prefetch input queue''. Il fournissait un bit qui indiquait si le premier octet d'une instruction était disponible dans la ''Prefetch input queue''. Un second bit indiquait si l'octet suivant était disponible, nous verrons pourquoi dans ce qui suit. Le ''loader'' recevait aussi des signaux de la part du décodeur d'instruction. Le décodeur envoyait le signal ''Run Next Instruction'' pour lire une instruction, qui était alors dépilée de la ''Prefetch input queue''. Le décodeur d'instruction pouvait aussi envoyer un signal ''Next-to-last (NXT)'', un cycle avant que l'instruction en cours ne termine. Le ''loader'' réagissait en préchargeant l'octet suivant. En clair, ce signal permettait de précharger l'instruction suivante avec un cycle d'avance, si celle-ci n'était pas déjà dans la ''Prefetch input queue''.

Le bus de données du 8086 faisait 16 bits, alors que celui du 8088 ne permettait que de lire un octet à la fois. Et cela avait un impact sur la ''prefetch input queue''. La ''prefetch input queue'' était composée de 4 registres de 8 bits, avec un port d'écriture de 8 bits pour précharger les instructions octet par octet, et un port de lecture de 8 bits pour alimenter le décodeur. En clair, tout faisait 8 bits. Le 8086, lui utilisait des registres de 16 bits et un port d'écriture de 16 bits. le port de lecture restait de 8 bits, et était précédé d'un multiplexeur qui prenait 16 bits et sélectionnait l'octet adéquat. Sa ''prefetch input queue'' préchargeait les instructions par paquets de 2 octets, non octet par octet, alors que le décodeur consommait les instructions octet par octet. Il s’agissait donc d'une sorte d'intermédiaire entre ''prefetch input queue'' à la 8088 et tampon de préchargement.

Les branchements posent des problèmes avec la ''Prefetch input queue'' : à cause d'eux, on peut charger à l'avance des instructions qui sont zappées par un branchement et ne sont pas censées être exécutées. Si un branchement est chargé, toutes les instructions préchargées après sont potentiellement invalides. Si le branchement est non-pris, les instructions chargées sont valides, elles sont censées s’exécuter. Mais si le branchement est pris, elles ont été chargées à tort et ne doivent pas s’exécuter. 

Pour éviter cela, la ''Prefetch input queue'' est vidée quand le processeur détecte un branchement. Pour cela, le décodeur d'instruction dispose d'une micro-opération qui vide la ''Prefetch input queue'', elle invalide les instructions préchargées.  Cette détection ne peut se faire qu'une fois le branchement décodé, qu'une fois que l'on sait que l'instruction décodée est un branchement. En clair, le décodeur invalide la ''Prefetch input queue'' quand il détecte un branchement. Les interruptions posent le même genre de problèmes. Il faut impérativement vider la ''Prefetch input queue'' quand une interruption survient, avant de la traiter.

Il faut noter qu'une ''Prefetch input queue'' interagit assez mal avec le ''program counter''. En effet, la ''Prefetch input queue'' précharge les instructions séquentiellement. Pour savoir où elle en est rendue, elle mémorise l'adresse de la prochaine instruction à charger dans un '''registre de préchargement''' dédié. Il serait possible d'utiliser un ''program counter'' en plus du registre de préchargement, mais ce n'est pas la solution qui a été utilisée. Les processeurs Intel anciens ont préféré n'utiliser qu'un seul registre de préchargement en remplacement du ''program counter''. Après tout, le registre de préchargement n'est qu'un ''program counter'' ayant pris une avance de quelques cycles d'horloge, qui a été incrémenté en avance.

Et cela ne pose pas de problèmes, sauf avec certains branchements. Par exemple, certains branchements relatifs demandent de connaitre la véritable valeur du ''program counter'', pas celle calculée en avance. Idem avec les instructions d'appel de fonction, qui demandent de sauvegarder l'adresse de retour exacte, donc le vrai ''program counter''. De telles situations demandent de connaitre la valeur réelle du ''program counter'', celle sans préchargement. Pour cela, le décodeur d'instruction dispose d'une instruction pour reconstituer le ''program counter'', à savoir corriger le ''program coutner'' et éliminer l'effet du préchargement.

La micro-opération de correction se contente de soustraire le nombre d'octets préchargés au registre de préchargement. Le nombre d'octets préchargés est déduit à partir des deux pointeurs intégré à la FIFO, qui indiquent la position du premier et du dernier octet préchargé. Le bit qui indique si la FIFO est vide était aussi utilisé. Les deux pointeurs sont lus depuis la FIFO, et sont envoyés à un circuit qui détermine le nombre d'octets préchargés. Sur le 8086, ce circuit était implémenté non pas par un circuit combinatoire, mais par une mémoire ROM équivalente. La petite taille de la FIFO faisait que les pointeurs étaient très petits et la ROM l'était aussi.

Un autre défaut est que la ''Prefetch input queue'' se marie assez mal avec du code auto-modifiant. Un code auto-modifiant est un programme qui se modifie lui-même, en remplaçant certaines instructions par d'autres, en en retirant, en en ajoutant, lors de sa propre exécution. De tels programmes sont rares, mais la technique était utilisée dans quelques cas au tout début de l'informatique sur des ordinateurs rudimentaires. Ceux-ci avaient des modes d'adressages tellement limités que gérer des tableaux de taille variable demandait d'utiliser du code auto-modifiant pour écrire des boucles.

Le problème avec la ''Prefetch input queue'' survient quand des instructions sont modifiées immédiatement après avoir été préchargées. Les instructions dans la ''Prefetch input queue'' sont l'ancienne version, alors que la mémoire RAM contient les instructions modifiées. Gérer ce genre de cas est quelque peu complexe. Il faut en effet vider la ''Prefetch input queue'' si le cas arrive, ce qui demande d'identifier les écritures qui écrasent des instructions préchargées. C'est parfaitement possible, mais demande de transformer la ''Prefetch input queue'' en une mémoire hybride, à la fois mémoire associative et mémoire FIFO. Cela ne vaut que très rarement le coup, aussi les ingénieurs ne s’embêtent pas à mettre ce correctif en place, le code automodifiant est alors buggé.

Le décodeur d'instruction dispose aussi d'une micro-opération qui stoppe le préchargement des instructions dans la ''Prefetch input queue''.

: Pour ceux qui ont déjà lu un cours d'architecture des ordinateurs, la relation entre ''prefetch input queue'' et pipeline est quelque peu complexe. En apparence, la ''prefetch input queue'' permet une certaines forme de pipeline, en chargeant une instruction pendant que la précédente s'exécute. Les problématiques liées aux branchements ressemblent beaucoup à celles de la prédiction de branchement. Cependant, il est possible de dire qu'il s'agit plus d'une technique de préchargement que de pipeline. La différence entre les deux est assez subtile et les frontières sont assez floues, mais le fait est que l'instruction en cours d'exécution et le préchargement peuvent tout deux faire des accès mémoire et que l'instruction en cours a la priorité. Un vrai pipeline se débrouillerait avec une architecture Harvard, non avec un bus mémoire unique pour le chargement des instruction et la lecture/écriture des données.

===Le ''Zero-overhead looping''===

Nous avions vu dans le chapitre sur les instructions machines, qu'il existe des instructions qui permettent de grandement faciliter l'implémentation des boucles. Il s'agit de l'instruction REPEAT, utilisée sur certains processeurs de traitement de signal. Elle répète l'instruction suivante, voire une série d'instructions, un certain nombre de fois. Le nombre de répétitions est mémorisé dans un registre décrémenté à chaque itération de la boucle. Elle permet donc d'implémenter une boucle FOR facilement, sans recourir à des branchements ou des conditions.

Une technique en lien avec cette instruction permet de grandement améliorer les performances et la consommation d'énergie. L'idée est de mémoriser la boucle, les instructions à répéter, dans une petite mémoire cache située entre l'unité de chargement et le séquenceur. Le cache en question s'appelle un '''tampon de boucle''', ou encore un ''hardware loop buffer''. Grâce à lui, il n'y a pas besoin de charger les instructions à chaque fois qu'on les exécute, on les charge une bonne fois pour toute : c'est plus rapide. Bien sûr, il ne fonctionne que pour de petites boucles, mais il en est de même avec l'instruction REPEAT.

&lt;noinclude&gt;
{{NavChapitre | book=Fonctionnement d'un ordinateur
           | prev=Le chemin de données
           | prevText=Le chemin de données
           | next=L'unité de contrôle
           | nextText=L'unité de contrôle
}}
&lt;/noinclude&gt;</text>
      <sha1>5vet1d38ownpjhyh29uqsl5k4ilsu2x</sha1>
    </revision>
    <revision>
      <id>744092</id>
      <parentid>744091</parentid>
      <timestamp>2025-06-03T20:30:05Z</timestamp>
      <contributor>
        <username>Mewtow</username>
        <id>31375</id>
      </contributor>
      <minor />
      <comment>/* La prefetch input queue */</comment>
      <origin>744092</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="47880" sha1="b5ghgr3billegb8wdkidggqcf2lheib" xml:space="preserve">L'unité de contrôle s'occupe du chargement des instructions et de leur interprétation, leur décodage. Elle contient deux circuits : l''''unité de chargement''' qui charge l'instruction depuis la mémoire, et le '''séquenceur''' qui commande le chemin de données. Les deux circuits sont séparés, mais ils communiquent entre eux, notamment pour gérer les branchements. Dans ce chapitre, nous allons nous intéresser au chargement d'une instruction depuis la RAM/ROM, nous verrons l'étape de décodage de l'instruction au prochain chapitre.

==Le chargement d'une instruction==

[[File:Étape de chargement.png|vignette|upright=1|Étape de chargement.]]

L'étape de chargement (ou ''fetch'') doit faire deux choses : mettre à jour le ''program counter'' et lire l'instruction en mémoire RAM ou en ROM. Les deux étapes peuvent être faites en parallèle, dans des circuits séparés. Pendant que l'instruction est lue depuis la mémoire RAM/ROM, le ''program counter'' est incrémenté et/ou altéré par un branchement.

Pour lire l'instruction, on envoie le ''program counter'' sur le bus d'adresse et on récupère l'instruction sur le bus de données pour l'envoyer sur l'entrée du séquenceur. Et cela demande de connecter le séquenceur au bus mémoire, à travers l'interface mémoire. Et sur ce point, la situation est différente selon que l'on parler d'une architecture Harvard ou Von Neumann.

===Les interconnexions entre séquenceur et bus mémoire===

Sur les architectures Harvard, le séquenceur et le chemin de donnée utilisent des interfaces mémoire séparées. Le séquenceur est directement relié au bus mémoire de la ROM, alors que le chemin de données est connecté à la RAM.

[[File:Microarchitecture de l'interface mémoire d'une architecture Harvard.png|centre|vignette|upright=2|Microarchitecture de l'interface mémoire d'une architecture Harvard]]

Mais sur les architectures Von-Neumann et affiliées, le séquenceur et le chemin de donnée partagent la même interface mémoire. Et cela pose deux problèmes.

Le premier problème est que le bus mémoire doit être libéré une fois l'instruction chargée, pour un éventuel accès mémoire. Mais le séquenceur doit conserver une copie de l'instruction chargée, sans quoi il ne peut pas décoder l'instruction correctement. Par exemple, si l'instruction met plusieurs cycles à s'exécuter, le séquenceur doit conserver une copie de l'instruction durant ces plusieurs cycles. La solution à ce problème est un '''registre d'instruction''' situé juste avant le séquenceur, qui mémorise l'instruction chargée.

[[File:Registre d'instruction.png|centre|vignette|upright=2|Registre d'instruction.]]

Le second problème est de gérer le flot des instructions/données entre le bus mémoire, le chemin de données et le séquenceur. Le processeur doit connecter l'interface mémoire soit au séquenceur, soit au chemin de données et cela complique le réseau d'interconnexion interne au processeur.

Une première solution utilise un bus unique qui relie l'interface mémoire, le séquenceur et le chemin de données. Pour charger une instruction, le séquenceur copie le ''program counter'' sur le bus d'adresse, attend que l'instruction lue soit disponible sur le bus de données, puis la copie dans le registre d'instruction. Le bus mémoire est alors libre et peut être utilisé pour lire ou écrire des données, si le besoin s'en fait sentir.

Il faut noter que l'usage d'un bus unique a un impact sur l'organisation interne du chemin de données. Par exemple, le chapitre précédent nous a montré comment implémenter un chemin de données basique, avec des multiplexeurs et démultiplexeurs. Et bien ces chemins de données ne marchent pas vraiment avec un bus interne unique. Il est possible de les adapter, mais au prix d'une complexité largement supérieure. Un bus interne unique marche mieux quand le banc de registre est mono-port. C'est pourquoi il a été utilisé sur d'anciennes architectures appelées des architectures à accumulateur et à pile, que nous verrons dans quelques chapitres, qui utilisaient un banc de registre mono-port.

[[File:Microarchitecture de l'interface mémoire d'une architecture von neumann.png|centre|vignette|upright=2|Microarchitecture de l'interface mémoire d'une architecture von neumann]]

Une autre solution utilise deux bus interne séparés : un connecté au bus d'adresse, l'autre au bus de données. Le ''program counter'' est alors connecté au bus interne d'adresse, le séquenceur est relié au bus interne de données. Notons que la technique marche bien si le ''program counter'' est dans le banc de registre : les interconnexions utilisées pour gérer l'adressage indirect permettent d'envoyer le ''program counter'' sur le bus d'adresse sans ajout de circuit.

Le tout peut être amélioré en remplaçant les deux bus par des multiplexeurs et démultiplexeurs. Le bus d'adresse est précédé par un multiplexeur, qui permet de faire le choix entre ''Program Counter'', adresse venant du chemin de données, ou adresse provenant du séquenceur (adressage absolu). De même, le bus de données est suivi par un démultiplexeur qui envoie la donnée/instruction lue soit au registre d'instruction, soit au chemin de données. Le tout se marie très bien avec les chemins de donnée vu dans le chapitre précédent. Au passage, il faut noter que cette solution nécessite un banc de registre multi-port.

[[File:Connexion du program counter sur les bus avec PC isolé.png|centre|vignette|upright=2|Connexion du program counter sur les bus avec PC isolé]]

===Le chargement des instructions de longueur variable===

Le chargement des instructions de longueur variable pose de nombreux problèmes. Le premier est que mettre à jour le ''program counter'' demande de connaitre la longueur de l'instruction chargée, pour l'ajouter au ''program counter''. Si la longueur d'une instruction est variable, on doit connaitre cette longueur d'une manière où d'une autre. La solution la plus simple indique la longueur de l'instruction dans une partie de l'opcode ou de la représentation en binaire de l'instruction. Mais les processeurs haute performance de nos PC utilisent d'autres solutions, qui n'encodent pas explicitement la taille de l'instruction.

Les processeurs récents utilisent un registre d'instruction de grande taille, capable de mémoriser l'instruction la plus longue du processeur. Par exemple, si un processeur supporte des instructions allant de 1 à 8 octets, comme les CPU x86, le registre d'instruction fera 8 octets. Le décodeur d'instruction vérifie à chaque cycle le contenu du registre d'instruction. Si une instruction est détectée dedans, son décodage commence, peu importe la taille de l'instruction. Une fois l'instruction exécutée, elle est retirée du registre d'instruction. Reste à alimenter le registre d'instruction, à charger des instructions dedans. Et pour cela deux solutions : soit on charge l'instruction en plusieurs fois, soit d'un seul coup.

La solution la plus simple charge les instructions par mots de 8, 16, 32, 64 bits. Ils sont accumulés dans le registre d'instruction jusqu'à détecter une instruction complète. La technique marche nettement mieux si les instructions sont très longues. Par exemple, les CPU x86 ont des instructions qui vont de 1 à 15 octets, ce qui fait qu'ils utilisent cette technique. Précisément, elle marche si les instructions les plus longues sont plus grandes que le bus mémoire.

Une autre solution charge un bloc de mots mémoire aussi grand que la plus grande instruction. Par exemple, si le processeur gère des instructions allant de 1 à 4 octets, il charge 4 octets d'un seul coup dans le registre d'instruction. Il va de soit que cette solution ne marche que si les instructions du processeur sont assez courtes, au plus aussi courtes que le bus mémoire. Ainsi, on est sûr de charger obligatoirement au moins une instruction complète, et peut-être même plusieurs. Le contenu du registre d'instruction est alors découpé en instructions au fil de l'eau. 

Utiliser un registre d'instruction large pose problème avec des instructions à cheval entre deux blocs. Il se peut qu'on n'ait pas une instruction complète lorsque l'on arrive à la fin du bloc, mais seulement un morceau. Le problème se manifeste peu importe que l'instruction soit chargée d'un seul coup ou bien en plusieurs fois.

[[File:Instructions non alignées.png|centre|vignette|upright=2|Instructions non alignées.]]

Dans ce cas, on doit décaler le morceau de bloc pour le mettre au bon endroit (au début du registre d'instruction), et charger le prochain bloc juste à côté. On a donc besoin d'un circuit qui décale tous les bits du registre d'instruction, couplé à un circuit qui décide où placer dans le registre d'instruction ce qui a été chargé, avec quelques circuits autour pour configurer les deux circuits précédents.

[[File:Décaleur d’instruction.png|centre|vignette|upright=2|Décaleur d’instruction.]]

Une autre solution se passe de registre d'instruction en utilisant à la place l'état interne du séquenceur. Là encore, elle charge l'instruction morceau par morceau, typiquement par blocs de 8, 16 ou 32 bits. Les morceaux ne sont pas accumulés dans le registre d'instruction, la solution utilise à la place l'état interne du séquenceur. Les mots mémoire de l'instruction sont chargés à chaque cycle, faisant passer le séquenceur d'un état interne à un autre à chaque mot mémoire. Tant qu'il n'a pas reçu tous les mots mémoire de l'instruction, chaque mot mémoire non terminal le fera passer d'un état interne à un autre, chaque état interne encodant les mots mémoire chargés auparavant. S'il tombe sur le dernier mot mémoire d'une instruction, il rentre dans un état de décodage.

==L'incrémentation du ''program counter''==

À chaque chargement, le ''program counter'' est mis à jour afin de pointer sur la prochaine instruction à charger. Sur la quasi-totalité des processeurs, les instructions sont placées dans l'ordre d’exécution dans la RAM. En faisant ainsi, on peut mettre à jour le ''program counter'' en lui ajoutant la longueur de l'instruction courante. Déterminer la longueur de l'instruction est simple quand les instructions ont toutes la même taille, mais certains processeurs ont des instructions de taille variable, ce qui complique le calcul. Dans ce qui va suivre, nous allons supposer que les instructions sont de taille fixe, ce qui fait que le ''program counter'' est toujours incrémenté de la même valeur.

Il existe deux méthodes principales pour incrémenter le ''program counter'' : soit le ''program counter'' a son propre additionneur, soit le ''program counter'' est mis à jour par l'ALU. Pour ce qui est de l'organisation des registres, soit le ''program counter'' est un registre séparé des autres, soit il est regroupé avec d'autres registres dans un banc de registre. En tout, cela donne quatre organisations possibles.
* Un ''program counter'' séparé relié à un incrémenteur séparé.
* Un ''program counter'' séparé des autres registres, incrémenté par l'ALU.
* Un ''program counter'' intégré au banc de registre, relié à un incrémenteur séparé.
* Un ''program counter'' intégré au banc de registre, incrémenté par l'ALU.

[[File:Calcul du program counter.png|centre|vignette|upright=2|les différentes méthodes de calcul du program counter.]]

Les processeurs haute performance modernes utilisent tous la première méthode. Les autres méthodes étaient surtout utilisées sur les processeurs 8 ou 16 bits, elles sont encore utilisées sur quelques microcontrôleurs de faible puissance. Nous auront l'occasion de donner des exemples quand nous parlerons des processeurs 8 bits anciens, dans le chapitre sur les architectures à accumulateur et affiliées.

===Le ''program counter'' mis à jour par l'ALU===

Sur certains processeurs, le calcul de l'adresse de la prochaine instruction est effectué par l'ALU. L'avantage de cette méthode est qu'elle économise un incrémenteur dédié au ''program counter''. Ce qui explique que cette méthode était utilisée sur les processeurs assez anciens, à une époque où un additionneur pouvait facilement prendre 10 à 20% des transistors disponibles. Le désavantage principal est une augmentation de la complexité du séquenceur, qui doit gérer la mise à jour du ''program counter''. De plus, la mise à jour du ''program counter'' ne peut pas se faire en même temps qu'une opération arithmétique, ce qui réduit les performances.

Si on incrémente le ''program counter'' avec l'ALU, il est intéressant de le placer dans le banc de registres. Un désavantage est qu'on perd un registre. Par exemple, avec un banc de registre de 16 registres, on ne peut adresser que 15 registres généraux. De plus ce n'est pas l'idéal pour le décodage des instructions et pour le séquenceur. Si le processeur dispose de plusieurs bancs de registres, le ''program counter'' est généralement placé dans le banc de registre dédié aux adresses. Sinon, il est placé avec les nombres entiers/adresses.

D'anciens processeurs incrémentaient le ''program counter'' avec l'ALU, mais utilisaient bien un registre séparé pour le ''program counter''. Cette méthode est relativement simple à implémenter : il suffit de connecter/déconnecter le ''program counter'' du bus interne suivant les besoins. Le ''program counter'' est déconnecté pendant l’exécution d'une instruction, il est connecté au bus interne pour l'incrémenter. C'est le séquenceur qui gère le tout. L'avantage de cette séparation est qu'elle est plus facile à gérer pour le séquenceur. De plus, on gagne un registre général/entier dans le banc de registre.

===Le compteur programme===

Dans la quasi-totalité des processeurs modernes, le ''program counter'' est un vulgaire compteur comme on en a vu dans les chapitres sur les circuits, ce qui fait qu'il passe automatiquement d'une adresse à la suivante. Dans ce qui suit, nous allons appeler ce registre compteur : le '''compteur ordinal'''. L'usage d'un compteur simplifie fortement la conception du séquenceur. Le séquenceur n'a pas à gérer la mise à jour du ''program counter'', sauf en cas de branchements. De plus, il est possible d'incrémenter le ''program counter'' pendant que l'unité de calcul effectue une opération arithmétique, ce qui améliore grandement les performances. Le seul désavantage est qu'elle demande d'ajouter un incrémenteur dédié au ''program counter''.

Sur les processeurs très anciens, les instructions faisaient toutes un seul mot mémoire et le compteur ordinal était un circuit incrémenteur des plus basique. Sur les processeurs modernes, le compteur est incrémenté par pas de 4 si les instructions sont codées sur 4 octets, 8 si les instructions sont codées sur 8 octets, etc. Concrètement, le compteur est un circuit incrémenteur auquel on aurait retiré quelques bits de poids faible. Par exemple, si les instructions sont codées sur 4 octets, on coupe les 2 derniers bits du compteur. Si les instructions sont codées sur 8 octets, on coupe les 3 derniers bits du compteur. Et ainsi de suite.

Il a existé quelques processeurs pour lesquelles le ''program counter'' était non pas un compteur binaire classique, mais un ''linear feedback shift register''. L'avantage est que le circuit d'incrémentation utilisait bien moins de portes logiques, l'économie était substantielle. Mais un défaut est que des instructions consécutives dans le programme n'étaient pas consécutives en mémoire. Il existait cependant une table de correspondance pour dire : la première instruction est à telle adresse, la seconde à telle autre, etc. Un exemple de processeur de ce type est le TMS 1000 de Texas Instrument, un des premiers microcontrôleur 4 bits datant des années 70.

Une amélioration de la solution précédente utilise un circuit incrémenteur partagé entre le ''program counter'' et d'autres registres. L'incrémenteur est utilisé pour incrémenter le ''program counter'', mais aussi pour effectuer d'autres calculs d'adresse. Par exemple, sur les architectures avec une pile d'adresse de retour, il est possible de partager l'incrémenteur/décrémenteur avec le pointeur de pile ( la technique ne marche pas avec une pile d'appel). Un autre exemple est celui des processeurs qui gèrent automatiquement le rafraichissement mémoire, grâce à, un compteur intégré dans le processeur. Il est possible de partager l'incrémenteur du ''program counter'' avec le compteur de rafraichissement mémoire, qui mémorise la prochaine adresse mémoire à rafraichir. Nous avions déjà abordé ce genre de partage dans le chapitre sur le chemin de données, dans l'annexe sur le pointeur de pile, mais nous verrons d'autres exemples dans le chapitre sur les architectures hybride accumulateur-registre 8/16 bits.

===Quand est mis à jour le ''program counter'' ?===

Le ''program counter'' est mis à jour quand il faut charger une nouvelle instruction. Reste qu'il faut savoir quand le mettre à jour. Incrémenter le ''program counter'' à intervalle régulier, par exemple à chaque cycle d’horloge, fonctionne sur les processeurs où toutes les instructions mettent le même temps pour s’exécuter. Mais de tels processeurs sont très rares. Sur la quasi-totalité des processeurs, les instructions ont une durée d’exécution variable, elles ne prennent pas le même nombre de cycle d'horloge pour s’exécuter. Le temps d’exécution d'une instruction varie selon l'instruction, certaines sont plus longues que d'autres. Tout cela amène un problème : comment incrémenter le ''program counter'' avec des instructions avec des temps d’exécution variables ?

La réponse est que la mise à jour du ''program counter'' démarre quand l'instruction précédente a terminée de s’exécuter, plus précisément un cycle avant. C'est un cycle avant pour que l'instruction chargée soit disponible au prochain cycle pour le décodeur. Pour cela, le séquenceur doit déterminer quand l'instruction est terminée et prévenir le ''program counter'' au bon moment. Il faut donc une interaction entre séquenceur et circuit de chargement. Le circuit de chargement contient une entrée Enable, qui autorise la mise à jour du ''program counter''. Le séquenceur met à 1 cette entrée pour prévenir au ''program counter'' qu'il doit être incrémenté au cycle suivant ou lors du cycle courant. Cela permet de gérer simplement le cas des instructions multicycles. 

[[File:Commande de la mise à jour du program counter.png|centre|vignette|upright=2|Commande de la mise à jour du program counter.]]

Toute la difficulté est alors reportée dans le séquenceur, qui doit déterminer la durée d'une instruction. Pour gérer la mise à jour du ''program counter'', le séquenceur doit déterminer la durée d'une instruction. Cela est simple pour les instructions arithmétiques et logiques, qui ont un nombre de cycles fixe, toujours le même. Une fois l'instruction identifiée par le séquenceur, il connait son nombre de cycles et peut programmer un compteur interne au séquenceur, qui compte le nombre de cycles de l'instruction, et fournit le signal Enable au ''program counter''. Mais cette technique ne marche pas vraiment pour les accès mémoire, dont la durée n'est pas connue à l'avance, surtout sur les processeurs avec des mémoires caches. Pour cela, le séquenceur détermine quand l'instruction mémoire est finie et prévient le ''program counter'' quand c'est le cas.

Il existe quelques processeurs pour lesquels le temps de calcul dépend des opérandes de l'instruction. On peut par exemple avoir une division qui prend 10 cycles avec certaines opérandes, mais 40 cycles avec d'autres opérandes. Mais ces processeurs sont rares et cela est surtout valable pour les opérations de multiplication/division, guère plus. Le problème est alors le même qu'avec les accès mémoire et la solution est la même : l'ALU prévient le séquenceur quand le résultat est disponible.

==Les branchements et le ''program counter''==

Un branchement consiste juste à écrire l'adresse de destination dans le ''program counter''. L'implémentation des branchements demande d'extraire l'adresse de destination et d'altérer le ''program counter'' quand un branchement est détecté. Pour cela, le décodeur d'instruction détecte si l'instruction exécutée est un branchement ou non, et il en déduit où trouver l'adresse de destination.

L'adresse de destination se trouve à un endroit qui dépend du mode d'adressage du branchement. Pour rappel, on distingue quatre modes d'adressage pour les branchements : direct, indirect, relatif et implicite. Pour les branchements directs, l'adresse est intégrée dans l'instruction de branchement elle-même et est extraite par le séquenceur. Pour les branchements indirects, l'adresse de destination est dans le banc de registre. Pour les branchements relatifs, il faut ajouter un décalage au ''program counter'', décalage extrait de l'instruction par le séquenceur. Enfin, les instructions de retour de fonction lisent l'adresse de destination depuis la pile. L'implémentation de ces quatre types de branchements est très différente.

L'altération du ''program counter'' dépend de si le ''program counter'' est dans un compteur séparé ou s'il est dans le banc de registre. Nous avons vu plus haut qu'il y a quatre cas différents, mais nous n'allons voir que deux cas : celui où le ''program counter'' est dans le banc de registre et est incrémenté par l'unité de calcul, celui avec un ''program counter'' séparé avec son propre incrémenteur. Les deux autres cas ne sont utilisés que sur des architectures à accumulateur ou à pile spécifiques, que nous n'avons pas encore vu à ce stade du cours et que nous verrons en temps voulu dans le chapitre sur ces architectures.

===L’implémentation des branchements avec un ''program counter'' intégré au banc de registres===

Le cas le plus simple est celui où le ''program counter'' est intégré au banc de registre, avec une incrémentation faite par l'unité de calcul. Charger une instruction revient alors à effectuer une instruction LOAD en adressage indirect, à deux différences près : le registre sélectionné est le ''program counter'', l’instruction est copiée dans le registre d'instruction et non dans le banc de registre. L'incrémentation du ''porgram counter'' est implémenté avec des micro-opérations qui agissent sur le chemin de données, au même titre que les branchements indirects, relatifs et directs.
* Les branchements indirects copient un registre dans le ''program counter'', ce qui revient simplement à faire une opération MOV entre deux registres, dont le ''program counter'' est la destination.
* L'opération inverse d'un branchement indirect, qui copie le ''program counter'' dans un registre général, est utile pour sauvegarder l'adresse de retour d'une fonction.
* Les branchements directs copient une adresse dans le ''program counter'', ce qui les rend équivalents à une opération MOV avec une constante immédiate, dont le ''program counter'' est la destination.
* Les branchements relatifs sont une opération arithmétique entre le ''program counter'' et un opérande en adressage immédiat.

En clair, à partir du moment où le chemin de données supporte les instructions MOV et l'addition, avec les modes d'adressage adéquat, il supporte les branchements. Aucune modification du chemin de données n'est nécessaire, le séquenceur gére le chargement d'une instruction avec les micro-instructions adéquates : une micro-opération ADD pour incrémenter le ''program counter'', une micro-opération LOAD pour le chargement de l'instruction.

Notons que sur certaines architectures, le ''program counter'' est adressable au même titre que les autres registres du banc de registre. Les instructions de branchement sont alors remplacées par des instructions MOV ou des instructions arithmétique équivalentes, comme décrit plus haut.

===L’implémentation des branchements avec un ''program counter'' séparé===

Étudions maintenant le cas où le ''program counter'' est dans un registre/compteur séparé. Rappelons que tout compteur digne de ce nom possède une entrée de réinitialisation, qui remet le compteur à zéro. De plus, on peut préciser à quelle valeur il doit être réinitialisé. Ici, la valeur à laquelle on veut réinitialiser le compteur n'est autre que l'adresse de destination du branchement. Implémenter un branchement est donc simple : l'entrée de réinitialisation est commandée par le circuit de détection des branchements, alors que la valeur de réinitialisation est envoyée sur l'entrée adéquate. En clair, nous partons du principe que le ''program counter'' est implémenté avec ce type de compteur :

[[File:Fonctionnement d'un compteur (décompteur), schématique.jpg|centre|vignette|upright=1.5|Fonctionnement d'un compteur (décompteur), schématique]]

Toute la difficulté est de présenter l'adresse de destination au ''program counter''. Pour les branchements directs, l'adresse de destination est fournie par le séquenceur. L'adresse de destination du branchement sort du séquenceur et est présentée au ''program counter'' sur l'entrée adéquate. Voici donc comment sont implémentés les branchements directs avec un ''program counter'' séparé du banc de registres. Le schéma ci-dessous marche peu importe que le ''program counter'' soit incrémenté par l'ALU ou par un additionneur dédié.

[[File:Unité de détection des branchements dans le décodeur.png|centre|vignette|upright=2|Unité de détection des branchements dans le décodeur]]

Les branchements relatifs sont ceux qui font sauter X instructions plus loin dans le programme. Leur implémentation demande d'ajouter une constante au ''program counter'', la constante étant fournie dans l’instruction. Là encore, deux solutions sont possibles : réutiliser l'ALU pour calculer l'adresse, ou utiliser un additionneur séparé. L'additionneur séparé peut être fusionné avec l'additionneur qui incrémente le ''program counter'' pour passer à l’instruction suivante.

[[File:Unité de chargement qui gère les branchements relatifs.png|centre|vignette|upright=2|Unité de chargement qui gère les branchements relatifs.]]

Pour les branchements indirects, il suffit de lire le registre voulu et d'envoyer le tout sur l'entrée adéquate du ''program counter''. Il faut alors rajouter un multiplexeur pour que l'entrée de réinitialisationr ecoive la bonne adresse de destination.

[[File:Unité de chargement qui gère les branchements directs.png|centre|vignette|upright=2|Unité de chargement qui gère les branchements directs et indirects.]]

Toute la difficulté de l'implémentation des branchements est de configurer les multiplexeurs, ce qui est réalisé par le séquenceur en fonction du mode d'adressage du branchement.

==Les optimisations du chargement des instructions==

Charger une instruction est techniquement une forme d'accès mémoire un peu particulier. En clair, charger une instruction prend au minimum un cycle d'horloge, et cela peut rapidement monter à 3-5 cycles, si ce n'est plus. L'exécution des instructions est alors fortement ralentit par la mémoire. Par exemple, imaginez que la mémoire mette 3 cycles d'horloges pour charger une instruction, alors qu'une instruction s’exécute en 1 cycle (si les opérandes sont dans les registres). La perte de performance liée au chargement des instructions est alors substantielle. Heureusement, il est possible de limiter la casse en utilisant des mémoires caches, ainsi que d'autres optimisations, que nous allons voir dans ce qui suit.

===Le tampon de préchargement===

La technique dite du '''préchargement''' est utilisée dans le cas où la mémoire a un temps d'accès important. Mais si la latence de la RAM est un problème, le débit ne l'est pas. Il est possible d'avoir une RAM lente, mais à fort débit. Par exemple, supposons que la mémoire puisse charger 4 instructions (de taille fixe) en 3 cycles. Le processeur peut alors charger 4 instructions en un seul accès mémoire, et les exécuter l'une après l'autre, une par cycle d'horloge. Les temps d'attente sont éliminés : le processeur peut décoder une nouvelle instruction à chaque cycle. Et quand la dernière instruction préchargée est exécutée, la mémoire est de nouveau libre, ce qui masque la latence des accès mémoire.

[[File:Tampon de préchargement d'instruction.png|vignette|Tampon de préchargement d'instruction]]

La seule contrainte est de mettre les instructions préchargées en attente. La solution pour cela est d'utiliser un registre d'instruction très large, capable de mémoriser plusieurs instructions à la fois. Ce registre est de plus connecté à un multiplexeur qui permet de sélectionner l'instruction adéquate dans ce registre. Ce multiplexeur est commandé par le ''program counter'' et quelques circuits annexes. Ce super-registre d'instruction est appelé un '''tampon de préchargement'''.

La méthode a une implémentation nettement plus simple avec des instructions de taille fixe, alignées en mémoire. La commande du multiplexeur de sélection de l'instruction est alors beaucoup plus simple : il suffit d'utiliser les bits de poids fort du ''program counter''. Par exemple, prenons le cas d'un registre d'instruction de 32 octets pour des instructions de 4 octets, soit 8 instructions. Le choix de l'instruction à sélectionner se fait en utilisant les 3 bits de poids faible du ''program counter''. 

Mais cette méthode ajoute de nouvelles contraintes d'alignement, similaires à celles vues dans le chapitre sur l'alignement et le boutisme, sauf que l'alignement porte ici sur des blocs d'instructions de même taille que le tampon de préchargement. Si on prend l'exemple d'un tampon de préchargement de 128 bits, les instructions devront être alignées par blocs de 128 bits. C'est à dire qu'idéalement, les fonctions et autres blocs de code isolés doivent commencer à des adresses multiples de 128, pour pouvoir charger un bloc d'instruction en une seule fois. Sans cela, les performances seront sous-optimales.

: Il arrive que le tampon de préchargement ait la même taille qu'une ligne de cache.

Lorsque l'on passe d'un bloc d'instruction à un autre, le tampon de préchargement est mis à jour. Par exemple, si on prend un tampon de préchargement de 4 instructions, on doit changer son contenu toutes les 4 instructions. La seule exception est l'exécution d'un branchement. En effet, lors d'un branchement, la destination du branchement n'est pas dans le tampon de préchargement et elle doit être chargée dedans (sauf si le branchement pointe vers une instruction très proche, ce qui est improbable). Pour cela, le tampon de préchargement est mis à jour précocement quand le processeur détecte un branchement.

Le même problème survient avec du code auto-modifiant. Un code auto-modifiant est un programme qui se modifie lui-même, en remplaçant certaines instructions par d'autres, en en retirant, en en ajoutant, lors de sa propre exécution. De tels programmes sont rares, mais la technique était utilisée dans quelques cas au tout début de l'informatique sur des ordinateurs rudimentaires. Ceux-ci avaient des modes d'adressages tellement limités que gérer des tableaux de taille variable demandait d'utiliser du code auto-modifiant pour écrire des boucles. Le problème survient quand des instructions sont modifiées immédiatement après avoir été préchargées. Les instructions dans le tampon de préchargement sont l'ancienne version, alors que la mémoire RAM contient les instructions modifiées. Gérer ce genre de cas demande de vider le tampon de préchargement si le cas arrive, mais ça ne vaut que très rarement le coup, aussi les ingénieurs ne s’embêtent pas à mettre ce correctif en place. Le code automodifiant est alors buggé.

===La ''prefetch input queue''===

La ''prefetch input queue'' est une sorte de cousine du tampon de préchargement, qui a été utilisée sur les processeurs Intel assez ancien. Elle est apparue sur le 8086 et le 8088, des processeurs respectivement 8 et 16 bits. Elle été présente sur le 286 et le 386, mais était un peu améliorée. Elle est apparue sur ces processeurs à une époque où le processeur devenait plus rapide que la mémoire.

L'idée est là encore de précharger des instructions en avance. Sauf que cette fois-ci, on ne charge pas plusieurs instructions à la fois. Au contraire, les instructions sont préchargées séquentiellement, un ou deux octet à la fois. En conséquence, le tampon de préchargement est remplacé par une mémoire FIFO appelée la '''''Prefetch Input Queue''''', terme abrévié en PIQ. Les instructions sont accumulées une par une dans la PIQ, elles en sortent une par une au fur et à mesure pour alimenter le décodeur d'instruction.

Pendant que le processeur exécute une instruction, on précharge la suivante. Sans ''prefetch input queue'', le processeur chargeait une instruction, la décodait et l'exécutait, puis chargeait la suivante, et ainsi de suite. Avec un tampon de préchargement, le processeur chargeait plusieurs instruction en une seule fois, puis les exécutait les unes après les autres. Avec la ''prefetch input queue'', pendant qu'une instruction est en cours de décodage/exécution, le processeur précharge l'instruction suivante. Si une instruction prend vraiment beaucoup de temps pour s'exécuter, le processeur peut en profiter pour précharger l'instruction encore suivante, et ainsi de suite, jusqu'à une limite de 4/6 instructions (la limite dépend du processeur).

La ''prefetch input queue'' permet de précharger l'instruction suivante à condition qu'aucun autre accès mémoire n'ait lieu. Si l'instruction en cours d'exécution effectue des accès mémoire, ceux-ci sont prioritaires sur tout le reste, le préchargement de l'instruction suivante est alors mis en pause ou inhibé. Par contre, si la mémoire n'est pas utilisée par l'instruction en cours d'exécution, le processeur lit l'instruction suivante en RAM et la copie dans la ''prefetch input queue''. En conséquence, il arrive que la ''prefetch input queue'' n'ait pas préchargé l'instruction suivante, alors que le décodeur d'instruction est prêt pour la décoder. Dans ce cas, le décodeur doit attendre que l'instruction soit chargée.

Les instructions préchargées dans la ''Prefetch input queue'' y attendent que le processeur les lise et les décode. Les instructions préchargées sont conservées dans leur ordre d'arrivée, afin qu'elles soient exécutées dans le bon ordre, ce qui fait que la ''Prefetch input queue'' est une mémoire de type FIFO. L'étape de décodage pioche l'instruction à décoder dans la ''Prefetch input queue'', cette instruction étant par définition la plus ancienne, puis la retire de la file.

Le premier processeur commercial grand public à utiliser une ''prefetch input queue'' était le 8086. Il pouvait précharger à l'avance 6 octets d’instruction. L'Intel 8088 avait lui aussi une ''Prefetch input queue'', mais qui ne permettait que de précharger 4 instructions. La taille idéale de la FIFO dépend de nombreux paramètres. On pourrait croire que plus elle peut contenir d'instructions, mieux c'est, mais ce n'est pas le cas, pour des raisons que nous allons expliquer dans quelques paragraphes.

[[File:80186 arch.png|centre|vignette|700px|upright=2|Architecture du 8086, du 80186 et de ses variantes.]]

Vous remarquerez que j'ai exprimé la capacité de la ''prefetch input queue'' en octets et non en instructions. La raison est que sur les processeurs x86, les instructions sont de taille variable, avec une taille qui varie entre un octet et 6 octets. Cependant, le décodage des instructions se fait un octet à la fois : le décodeur lit un octet, puis éventuellement le suivant, et ainsi de suite jusqu'à atteindre la fin de l'instruction. En clair, le décodeur lit les instructions longues octet par octet dans la ''Prefetch input queue''.

Les instructions varient entre 1 et 6 octets, mais tous ne sont pas utile au décodeur d'instruction. Par exemple, le décodeur d'instruction n'a pas besoin d'analyser les constantes immédiates intégrées dans une instruction, ni les adresses mémoires en adressage absolu. Il n'a besoin que de deux octets : l'opcode et l'octet Mod/RM qui précise le mode d'adressage. Le second est facultatif. En clair, le décodeur a besoin de lire deux octets maximum depuis la ''prefetch input queue'', avant de passer à l’instruction suivante. Les autres octets étaient envoyés ailleurs, typiquement dans le chemin de données.

Par exemple, prenons le cas d'une addition entre le registre AX et une constante immédiate. L'instruction fait trois octets : un opcode suivie par une constante immédiate codée sur deux octets. L'opcode était envoyé au décodeur, mais pas la constante immédiate. Elle était lue octet par octet et mémorisée dans un registre temporaire placé en entrée de l'ALU. Idem avec les adresses immédiates, qui étaient envoyées dans un registre d’interfaçage mémoire sans passer par le décodeur d'instruction. Pour cela, la ''prefetch input queue'' était connectée au bus interne du processeur ! Le décodeur dispose d'une micro-opération pour lire un octet depuis la ''prefetch input queue'' et le copier ailleurs dans le chemin de données. Par exemple, l'instruction d'addition entre le registre AX et une constante immédiate était composée de quatre micro-opérations : une qui lisait le premier octet de la constante immédiate, une seconde pour le second, une troisième micro-opération qui commande l'ALU et fait le calcul. 

Le décodeur devait attendre que qu'un moins un octet soit disponible dans la ''Prefetch input queue'', pour le lire. Il lisait alors cet octet et déterminait s'il contenait une instruction complète ou non. Si c'est une instruction complète, il la décodait et l''exécutait, puis passait à l'instruction suivante. Sinon, il lit un second octet depuis la ''Prefetch input queue'' et relance le décodage. Là encore, le décodeur vérifie s'il a une instruction complète, et lit un troisième octet si besoin, puis rebelote avec un quatrième octet lu, etc.

Un circuit appelé le ''loader'' synchronisait le décodeur d'instruction et la ''Prefetch input queue''. Il fournissait un bit qui indiquait si le premier octet d'une instruction était disponible dans la ''Prefetch input queue''. Un second bit indiquait si l'octet suivant était disponible, nous verrons pourquoi dans ce qui suit. Le ''loader'' recevait aussi des signaux de la part du décodeur d'instruction. Le décodeur envoyait le signal ''Run Next Instruction'' pour lire une instruction, qui était alors dépilée de la ''Prefetch input queue''. Le décodeur d'instruction pouvait aussi envoyer un signal ''Next-to-last (NXT)'', un cycle avant que l'instruction en cours ne termine. Le ''loader'' réagissait en préchargeant l'octet suivant. En clair, ce signal permettait de précharger l'instruction suivante avec un cycle d'avance, si celle-ci n'était pas déjà dans la ''Prefetch input queue''.

Le bus de données du 8086 faisait 16 bits, alors que celui du 8088 ne permettait que de lire un octet à la fois. Et cela avait un impact sur la ''prefetch input queue''. La ''prefetch input queue'' était composée de 4 registres de 8 bits, avec un port d'écriture de 8 bits pour précharger les instructions octet par octet, et un port de lecture de 8 bits pour alimenter le décodeur. En clair, tout faisait 8 bits. Le 8086, lui utilisait des registres de 16 bits et un port d'écriture de 16 bits. le port de lecture restait de 8 bits, et était précédé d'un multiplexeur qui prenait 16 bits et sélectionnait l'octet adéquat. Sa ''prefetch input queue'' préchargeait les instructions par paquets de 2 octets, non octet par octet, alors que le décodeur consommait les instructions octet par octet. Il s’agissait donc d'une sorte d'intermédiaire entre ''prefetch input queue'' à la 8088 et tampon de préchargement.

Les branchements posent des problèmes avec la ''Prefetch input queue'' : à cause d'eux, on peut charger à l'avance des instructions qui sont zappées par un branchement et ne sont pas censées être exécutées. Si un branchement est chargé, toutes les instructions préchargées après sont potentiellement invalides. Si le branchement est non-pris, les instructions chargées sont valides, elles sont censées s’exécuter. Mais si le branchement est pris, elles ont été chargées à tort et ne doivent pas s’exécuter. 

Pour éviter cela, la ''Prefetch input queue'' est vidée quand le processeur détecte un branchement. Pour cela, le décodeur d'instruction dispose d'une micro-opération qui vide la ''Prefetch input queue'', elle invalide les instructions préchargées.  Cette détection ne peut se faire qu'une fois le branchement décodé, qu'une fois que l'on sait que l'instruction décodée est un branchement. En clair, le décodeur invalide la ''Prefetch input queue'' quand il détecte un branchement. Les interruptions posent le même genre de problèmes. Il faut impérativement vider la ''Prefetch input queue'' quand une interruption survient, avant de la traiter.

Il faut noter qu'une ''Prefetch input queue'' interagit assez mal avec le ''program counter''. En effet, la ''Prefetch input queue'' précharge les instructions séquentiellement. Pour savoir où elle en est rendue, elle mémorise l'adresse de la prochaine instruction à charger dans un '''registre de préchargement''' dédié. Il serait possible d'utiliser un ''program counter'' en plus du registre de préchargement, mais ce n'est pas la solution qui a été utilisée. Les processeurs Intel anciens ont préféré n'utiliser qu'un seul registre de préchargement en remplacement du ''program counter''. Après tout, le registre de préchargement n'est qu'un ''program counter'' ayant pris une avance de quelques cycles d'horloge, qui a été incrémenté en avance.

Et cela ne pose pas de problèmes, sauf avec certains branchements. Par exemple, certains branchements relatifs demandent de connaitre la véritable valeur du ''program counter'', pas celle calculée en avance. Idem avec les instructions d'appel de fonction, qui demandent de sauvegarder l'adresse de retour exacte, donc le vrai ''program counter''. De telles situations demandent de connaitre la valeur réelle du ''program counter'', celle sans préchargement. Pour cela, le décodeur d'instruction dispose d'une instruction pour reconstituer le ''program counter'', à savoir corriger le ''program coutner'' et éliminer l'effet du préchargement.

La micro-opération de correction se contente de soustraire le nombre d'octets préchargés au registre de préchargement. Le nombre d'octets préchargés est déduit à partir des deux pointeurs intégré à la FIFO, qui indiquent la position du premier et du dernier octet préchargé. Le bit qui indique si la FIFO est vide était aussi utilisé. Les deux pointeurs sont lus depuis la FIFO, et sont envoyés à un circuit qui détermine le nombre d'octets préchargés. Sur le 8086, ce circuit était implémenté non pas par un circuit combinatoire, mais par une mémoire ROM équivalente. La petite taille de la FIFO faisait que les pointeurs étaient très petits et la ROM l'était aussi.

Un autre défaut est que la ''Prefetch input queue'' se marie assez mal avec du code auto-modifiant. Un code auto-modifiant est un programme qui se modifie lui-même, en remplaçant certaines instructions par d'autres, en en retirant, en en ajoutant, lors de sa propre exécution. De tels programmes sont rares, mais la technique était utilisée dans quelques cas au tout début de l'informatique sur des ordinateurs rudimentaires. Ceux-ci avaient des modes d'adressages tellement limités que gérer des tableaux de taille variable demandait d'utiliser du code auto-modifiant pour écrire des boucles.

Le problème avec la ''Prefetch input queue'' survient quand des instructions sont modifiées immédiatement après avoir été préchargées. Les instructions dans la ''Prefetch input queue'' sont l'ancienne version, alors que la mémoire RAM contient les instructions modifiées. Gérer ce genre de cas est quelque peu complexe. Il faut en effet vider la ''Prefetch input queue'' si le cas arrive, ce qui demande d'identifier les écritures qui écrasent des instructions préchargées. C'est parfaitement possible, mais demande de transformer la ''Prefetch input queue'' en une mémoire hybride, à la fois mémoire associative et mémoire FIFO. Cela ne vaut que très rarement le coup, aussi les ingénieurs ne s’embêtent pas à mettre ce correctif en place, le code automodifiant est alors buggé.

Le décodeur d'instruction dispose aussi d'une micro-opération qui stoppe le préchargement des instructions dans la ''Prefetch input queue''.

: Pour ceux qui ont déjà lu un cours d'architecture des ordinateurs, la relation entre ''prefetch input queue'' et pipeline est quelque peu complexe. En apparence, la ''prefetch input queue'' permet une certaines forme de pipeline, en chargeant une instruction pendant que la précédente s'exécute. Les problématiques liées aux branchements ressemblent beaucoup à celles de la prédiction de branchement. Cependant, il est possible de dire qu'il s'agit plus d'une technique de préchargement que de pipeline. La différence entre les deux est assez subtile et les frontières sont assez floues, mais le fait est que l'instruction en cours d'exécution et le préchargement peuvent tout deux faire des accès mémoire et que l'instruction en cours a la priorité. Un vrai pipeline se débrouillerait avec une architecture Harvard, non avec un bus mémoire unique pour le chargement des instruction et la lecture/écriture des données.

===Le ''Zero-overhead looping''===

Nous avions vu dans le chapitre sur les instructions machines, qu'il existe des instructions qui permettent de grandement faciliter l'implémentation des boucles. Il s'agit de l'instruction REPEAT, utilisée sur certains processeurs de traitement de signal. Elle répète l'instruction suivante, voire une série d'instructions, un certain nombre de fois. Le nombre de répétitions est mémorisé dans un registre décrémenté à chaque itération de la boucle. Elle permet donc d'implémenter une boucle FOR facilement, sans recourir à des branchements ou des conditions.

Une technique en lien avec cette instruction permet de grandement améliorer les performances et la consommation d'énergie. L'idée est de mémoriser la boucle, les instructions à répéter, dans une petite mémoire cache située entre l'unité de chargement et le séquenceur. Le cache en question s'appelle un '''tampon de boucle''', ou encore un ''hardware loop buffer''. Grâce à lui, il n'y a pas besoin de charger les instructions à chaque fois qu'on les exécute, on les charge une bonne fois pour toute : c'est plus rapide. Bien sûr, il ne fonctionne que pour de petites boucles, mais il en est de même avec l'instruction REPEAT.

&lt;noinclude&gt;
{{NavChapitre | book=Fonctionnement d'un ordinateur
           | prev=Le chemin de données
           | prevText=Le chemin de données
           | next=L'unité de contrôle
           | nextText=L'unité de contrôle
}}
&lt;/noinclude&gt;</text>
      <sha1>b5ghgr3billegb8wdkidggqcf2lheib</sha1>
    </revision>
    <revision>
      <id>744093</id>
      <parentid>744092</parentid>
      <timestamp>2025-06-03T20:32:21Z</timestamp>
      <contributor>
        <username>Mewtow</username>
        <id>31375</id>
      </contributor>
      <minor />
      <comment>/* La prefetch input queue */</comment>
      <origin>744093</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="47855" sha1="a5hpzf9x4qobw5p2fgzc8b4xnysp3s6" xml:space="preserve">L'unité de contrôle s'occupe du chargement des instructions et de leur interprétation, leur décodage. Elle contient deux circuits : l''''unité de chargement''' qui charge l'instruction depuis la mémoire, et le '''séquenceur''' qui commande le chemin de données. Les deux circuits sont séparés, mais ils communiquent entre eux, notamment pour gérer les branchements. Dans ce chapitre, nous allons nous intéresser au chargement d'une instruction depuis la RAM/ROM, nous verrons l'étape de décodage de l'instruction au prochain chapitre.

==Le chargement d'une instruction==

[[File:Étape de chargement.png|vignette|upright=1|Étape de chargement.]]

L'étape de chargement (ou ''fetch'') doit faire deux choses : mettre à jour le ''program counter'' et lire l'instruction en mémoire RAM ou en ROM. Les deux étapes peuvent être faites en parallèle, dans des circuits séparés. Pendant que l'instruction est lue depuis la mémoire RAM/ROM, le ''program counter'' est incrémenté et/ou altéré par un branchement.

Pour lire l'instruction, on envoie le ''program counter'' sur le bus d'adresse et on récupère l'instruction sur le bus de données pour l'envoyer sur l'entrée du séquenceur. Et cela demande de connecter le séquenceur au bus mémoire, à travers l'interface mémoire. Et sur ce point, la situation est différente selon que l'on parler d'une architecture Harvard ou Von Neumann.

===Les interconnexions entre séquenceur et bus mémoire===

Sur les architectures Harvard, le séquenceur et le chemin de donnée utilisent des interfaces mémoire séparées. Le séquenceur est directement relié au bus mémoire de la ROM, alors que le chemin de données est connecté à la RAM.

[[File:Microarchitecture de l'interface mémoire d'une architecture Harvard.png|centre|vignette|upright=2|Microarchitecture de l'interface mémoire d'une architecture Harvard]]

Mais sur les architectures Von-Neumann et affiliées, le séquenceur et le chemin de donnée partagent la même interface mémoire. Et cela pose deux problèmes.

Le premier problème est que le bus mémoire doit être libéré une fois l'instruction chargée, pour un éventuel accès mémoire. Mais le séquenceur doit conserver une copie de l'instruction chargée, sans quoi il ne peut pas décoder l'instruction correctement. Par exemple, si l'instruction met plusieurs cycles à s'exécuter, le séquenceur doit conserver une copie de l'instruction durant ces plusieurs cycles. La solution à ce problème est un '''registre d'instruction''' situé juste avant le séquenceur, qui mémorise l'instruction chargée.

[[File:Registre d'instruction.png|centre|vignette|upright=2|Registre d'instruction.]]

Le second problème est de gérer le flot des instructions/données entre le bus mémoire, le chemin de données et le séquenceur. Le processeur doit connecter l'interface mémoire soit au séquenceur, soit au chemin de données et cela complique le réseau d'interconnexion interne au processeur.

Une première solution utilise un bus unique qui relie l'interface mémoire, le séquenceur et le chemin de données. Pour charger une instruction, le séquenceur copie le ''program counter'' sur le bus d'adresse, attend que l'instruction lue soit disponible sur le bus de données, puis la copie dans le registre d'instruction. Le bus mémoire est alors libre et peut être utilisé pour lire ou écrire des données, si le besoin s'en fait sentir.

Il faut noter que l'usage d'un bus unique a un impact sur l'organisation interne du chemin de données. Par exemple, le chapitre précédent nous a montré comment implémenter un chemin de données basique, avec des multiplexeurs et démultiplexeurs. Et bien ces chemins de données ne marchent pas vraiment avec un bus interne unique. Il est possible de les adapter, mais au prix d'une complexité largement supérieure. Un bus interne unique marche mieux quand le banc de registre est mono-port. C'est pourquoi il a été utilisé sur d'anciennes architectures appelées des architectures à accumulateur et à pile, que nous verrons dans quelques chapitres, qui utilisaient un banc de registre mono-port.

[[File:Microarchitecture de l'interface mémoire d'une architecture von neumann.png|centre|vignette|upright=2|Microarchitecture de l'interface mémoire d'une architecture von neumann]]

Une autre solution utilise deux bus interne séparés : un connecté au bus d'adresse, l'autre au bus de données. Le ''program counter'' est alors connecté au bus interne d'adresse, le séquenceur est relié au bus interne de données. Notons que la technique marche bien si le ''program counter'' est dans le banc de registre : les interconnexions utilisées pour gérer l'adressage indirect permettent d'envoyer le ''program counter'' sur le bus d'adresse sans ajout de circuit.

Le tout peut être amélioré en remplaçant les deux bus par des multiplexeurs et démultiplexeurs. Le bus d'adresse est précédé par un multiplexeur, qui permet de faire le choix entre ''Program Counter'', adresse venant du chemin de données, ou adresse provenant du séquenceur (adressage absolu). De même, le bus de données est suivi par un démultiplexeur qui envoie la donnée/instruction lue soit au registre d'instruction, soit au chemin de données. Le tout se marie très bien avec les chemins de donnée vu dans le chapitre précédent. Au passage, il faut noter que cette solution nécessite un banc de registre multi-port.

[[File:Connexion du program counter sur les bus avec PC isolé.png|centre|vignette|upright=2|Connexion du program counter sur les bus avec PC isolé]]

===Le chargement des instructions de longueur variable===

Le chargement des instructions de longueur variable pose de nombreux problèmes. Le premier est que mettre à jour le ''program counter'' demande de connaitre la longueur de l'instruction chargée, pour l'ajouter au ''program counter''. Si la longueur d'une instruction est variable, on doit connaitre cette longueur d'une manière où d'une autre. La solution la plus simple indique la longueur de l'instruction dans une partie de l'opcode ou de la représentation en binaire de l'instruction. Mais les processeurs haute performance de nos PC utilisent d'autres solutions, qui n'encodent pas explicitement la taille de l'instruction.

Les processeurs récents utilisent un registre d'instruction de grande taille, capable de mémoriser l'instruction la plus longue du processeur. Par exemple, si un processeur supporte des instructions allant de 1 à 8 octets, comme les CPU x86, le registre d'instruction fera 8 octets. Le décodeur d'instruction vérifie à chaque cycle le contenu du registre d'instruction. Si une instruction est détectée dedans, son décodage commence, peu importe la taille de l'instruction. Une fois l'instruction exécutée, elle est retirée du registre d'instruction. Reste à alimenter le registre d'instruction, à charger des instructions dedans. Et pour cela deux solutions : soit on charge l'instruction en plusieurs fois, soit d'un seul coup.

La solution la plus simple charge les instructions par mots de 8, 16, 32, 64 bits. Ils sont accumulés dans le registre d'instruction jusqu'à détecter une instruction complète. La technique marche nettement mieux si les instructions sont très longues. Par exemple, les CPU x86 ont des instructions qui vont de 1 à 15 octets, ce qui fait qu'ils utilisent cette technique. Précisément, elle marche si les instructions les plus longues sont plus grandes que le bus mémoire.

Une autre solution charge un bloc de mots mémoire aussi grand que la plus grande instruction. Par exemple, si le processeur gère des instructions allant de 1 à 4 octets, il charge 4 octets d'un seul coup dans le registre d'instruction. Il va de soit que cette solution ne marche que si les instructions du processeur sont assez courtes, au plus aussi courtes que le bus mémoire. Ainsi, on est sûr de charger obligatoirement au moins une instruction complète, et peut-être même plusieurs. Le contenu du registre d'instruction est alors découpé en instructions au fil de l'eau. 

Utiliser un registre d'instruction large pose problème avec des instructions à cheval entre deux blocs. Il se peut qu'on n'ait pas une instruction complète lorsque l'on arrive à la fin du bloc, mais seulement un morceau. Le problème se manifeste peu importe que l'instruction soit chargée d'un seul coup ou bien en plusieurs fois.

[[File:Instructions non alignées.png|centre|vignette|upright=2|Instructions non alignées.]]

Dans ce cas, on doit décaler le morceau de bloc pour le mettre au bon endroit (au début du registre d'instruction), et charger le prochain bloc juste à côté. On a donc besoin d'un circuit qui décale tous les bits du registre d'instruction, couplé à un circuit qui décide où placer dans le registre d'instruction ce qui a été chargé, avec quelques circuits autour pour configurer les deux circuits précédents.

[[File:Décaleur d’instruction.png|centre|vignette|upright=2|Décaleur d’instruction.]]

Une autre solution se passe de registre d'instruction en utilisant à la place l'état interne du séquenceur. Là encore, elle charge l'instruction morceau par morceau, typiquement par blocs de 8, 16 ou 32 bits. Les morceaux ne sont pas accumulés dans le registre d'instruction, la solution utilise à la place l'état interne du séquenceur. Les mots mémoire de l'instruction sont chargés à chaque cycle, faisant passer le séquenceur d'un état interne à un autre à chaque mot mémoire. Tant qu'il n'a pas reçu tous les mots mémoire de l'instruction, chaque mot mémoire non terminal le fera passer d'un état interne à un autre, chaque état interne encodant les mots mémoire chargés auparavant. S'il tombe sur le dernier mot mémoire d'une instruction, il rentre dans un état de décodage.

==L'incrémentation du ''program counter''==

À chaque chargement, le ''program counter'' est mis à jour afin de pointer sur la prochaine instruction à charger. Sur la quasi-totalité des processeurs, les instructions sont placées dans l'ordre d’exécution dans la RAM. En faisant ainsi, on peut mettre à jour le ''program counter'' en lui ajoutant la longueur de l'instruction courante. Déterminer la longueur de l'instruction est simple quand les instructions ont toutes la même taille, mais certains processeurs ont des instructions de taille variable, ce qui complique le calcul. Dans ce qui va suivre, nous allons supposer que les instructions sont de taille fixe, ce qui fait que le ''program counter'' est toujours incrémenté de la même valeur.

Il existe deux méthodes principales pour incrémenter le ''program counter'' : soit le ''program counter'' a son propre additionneur, soit le ''program counter'' est mis à jour par l'ALU. Pour ce qui est de l'organisation des registres, soit le ''program counter'' est un registre séparé des autres, soit il est regroupé avec d'autres registres dans un banc de registre. En tout, cela donne quatre organisations possibles.
* Un ''program counter'' séparé relié à un incrémenteur séparé.
* Un ''program counter'' séparé des autres registres, incrémenté par l'ALU.
* Un ''program counter'' intégré au banc de registre, relié à un incrémenteur séparé.
* Un ''program counter'' intégré au banc de registre, incrémenté par l'ALU.

[[File:Calcul du program counter.png|centre|vignette|upright=2|les différentes méthodes de calcul du program counter.]]

Les processeurs haute performance modernes utilisent tous la première méthode. Les autres méthodes étaient surtout utilisées sur les processeurs 8 ou 16 bits, elles sont encore utilisées sur quelques microcontrôleurs de faible puissance. Nous auront l'occasion de donner des exemples quand nous parlerons des processeurs 8 bits anciens, dans le chapitre sur les architectures à accumulateur et affiliées.

===Le ''program counter'' mis à jour par l'ALU===

Sur certains processeurs, le calcul de l'adresse de la prochaine instruction est effectué par l'ALU. L'avantage de cette méthode est qu'elle économise un incrémenteur dédié au ''program counter''. Ce qui explique que cette méthode était utilisée sur les processeurs assez anciens, à une époque où un additionneur pouvait facilement prendre 10 à 20% des transistors disponibles. Le désavantage principal est une augmentation de la complexité du séquenceur, qui doit gérer la mise à jour du ''program counter''. De plus, la mise à jour du ''program counter'' ne peut pas se faire en même temps qu'une opération arithmétique, ce qui réduit les performances.

Si on incrémente le ''program counter'' avec l'ALU, il est intéressant de le placer dans le banc de registres. Un désavantage est qu'on perd un registre. Par exemple, avec un banc de registre de 16 registres, on ne peut adresser que 15 registres généraux. De plus ce n'est pas l'idéal pour le décodage des instructions et pour le séquenceur. Si le processeur dispose de plusieurs bancs de registres, le ''program counter'' est généralement placé dans le banc de registre dédié aux adresses. Sinon, il est placé avec les nombres entiers/adresses.

D'anciens processeurs incrémentaient le ''program counter'' avec l'ALU, mais utilisaient bien un registre séparé pour le ''program counter''. Cette méthode est relativement simple à implémenter : il suffit de connecter/déconnecter le ''program counter'' du bus interne suivant les besoins. Le ''program counter'' est déconnecté pendant l’exécution d'une instruction, il est connecté au bus interne pour l'incrémenter. C'est le séquenceur qui gère le tout. L'avantage de cette séparation est qu'elle est plus facile à gérer pour le séquenceur. De plus, on gagne un registre général/entier dans le banc de registre.

===Le compteur programme===

Dans la quasi-totalité des processeurs modernes, le ''program counter'' est un vulgaire compteur comme on en a vu dans les chapitres sur les circuits, ce qui fait qu'il passe automatiquement d'une adresse à la suivante. Dans ce qui suit, nous allons appeler ce registre compteur : le '''compteur ordinal'''. L'usage d'un compteur simplifie fortement la conception du séquenceur. Le séquenceur n'a pas à gérer la mise à jour du ''program counter'', sauf en cas de branchements. De plus, il est possible d'incrémenter le ''program counter'' pendant que l'unité de calcul effectue une opération arithmétique, ce qui améliore grandement les performances. Le seul désavantage est qu'elle demande d'ajouter un incrémenteur dédié au ''program counter''.

Sur les processeurs très anciens, les instructions faisaient toutes un seul mot mémoire et le compteur ordinal était un circuit incrémenteur des plus basique. Sur les processeurs modernes, le compteur est incrémenté par pas de 4 si les instructions sont codées sur 4 octets, 8 si les instructions sont codées sur 8 octets, etc. Concrètement, le compteur est un circuit incrémenteur auquel on aurait retiré quelques bits de poids faible. Par exemple, si les instructions sont codées sur 4 octets, on coupe les 2 derniers bits du compteur. Si les instructions sont codées sur 8 octets, on coupe les 3 derniers bits du compteur. Et ainsi de suite.

Il a existé quelques processeurs pour lesquelles le ''program counter'' était non pas un compteur binaire classique, mais un ''linear feedback shift register''. L'avantage est que le circuit d'incrémentation utilisait bien moins de portes logiques, l'économie était substantielle. Mais un défaut est que des instructions consécutives dans le programme n'étaient pas consécutives en mémoire. Il existait cependant une table de correspondance pour dire : la première instruction est à telle adresse, la seconde à telle autre, etc. Un exemple de processeur de ce type est le TMS 1000 de Texas Instrument, un des premiers microcontrôleur 4 bits datant des années 70.

Une amélioration de la solution précédente utilise un circuit incrémenteur partagé entre le ''program counter'' et d'autres registres. L'incrémenteur est utilisé pour incrémenter le ''program counter'', mais aussi pour effectuer d'autres calculs d'adresse. Par exemple, sur les architectures avec une pile d'adresse de retour, il est possible de partager l'incrémenteur/décrémenteur avec le pointeur de pile ( la technique ne marche pas avec une pile d'appel). Un autre exemple est celui des processeurs qui gèrent automatiquement le rafraichissement mémoire, grâce à, un compteur intégré dans le processeur. Il est possible de partager l'incrémenteur du ''program counter'' avec le compteur de rafraichissement mémoire, qui mémorise la prochaine adresse mémoire à rafraichir. Nous avions déjà abordé ce genre de partage dans le chapitre sur le chemin de données, dans l'annexe sur le pointeur de pile, mais nous verrons d'autres exemples dans le chapitre sur les architectures hybride accumulateur-registre 8/16 bits.

===Quand est mis à jour le ''program counter'' ?===

Le ''program counter'' est mis à jour quand il faut charger une nouvelle instruction. Reste qu'il faut savoir quand le mettre à jour. Incrémenter le ''program counter'' à intervalle régulier, par exemple à chaque cycle d’horloge, fonctionne sur les processeurs où toutes les instructions mettent le même temps pour s’exécuter. Mais de tels processeurs sont très rares. Sur la quasi-totalité des processeurs, les instructions ont une durée d’exécution variable, elles ne prennent pas le même nombre de cycle d'horloge pour s’exécuter. Le temps d’exécution d'une instruction varie selon l'instruction, certaines sont plus longues que d'autres. Tout cela amène un problème : comment incrémenter le ''program counter'' avec des instructions avec des temps d’exécution variables ?

La réponse est que la mise à jour du ''program counter'' démarre quand l'instruction précédente a terminée de s’exécuter, plus précisément un cycle avant. C'est un cycle avant pour que l'instruction chargée soit disponible au prochain cycle pour le décodeur. Pour cela, le séquenceur doit déterminer quand l'instruction est terminée et prévenir le ''program counter'' au bon moment. Il faut donc une interaction entre séquenceur et circuit de chargement. Le circuit de chargement contient une entrée Enable, qui autorise la mise à jour du ''program counter''. Le séquenceur met à 1 cette entrée pour prévenir au ''program counter'' qu'il doit être incrémenté au cycle suivant ou lors du cycle courant. Cela permet de gérer simplement le cas des instructions multicycles. 

[[File:Commande de la mise à jour du program counter.png|centre|vignette|upright=2|Commande de la mise à jour du program counter.]]

Toute la difficulté est alors reportée dans le séquenceur, qui doit déterminer la durée d'une instruction. Pour gérer la mise à jour du ''program counter'', le séquenceur doit déterminer la durée d'une instruction. Cela est simple pour les instructions arithmétiques et logiques, qui ont un nombre de cycles fixe, toujours le même. Une fois l'instruction identifiée par le séquenceur, il connait son nombre de cycles et peut programmer un compteur interne au séquenceur, qui compte le nombre de cycles de l'instruction, et fournit le signal Enable au ''program counter''. Mais cette technique ne marche pas vraiment pour les accès mémoire, dont la durée n'est pas connue à l'avance, surtout sur les processeurs avec des mémoires caches. Pour cela, le séquenceur détermine quand l'instruction mémoire est finie et prévient le ''program counter'' quand c'est le cas.

Il existe quelques processeurs pour lesquels le temps de calcul dépend des opérandes de l'instruction. On peut par exemple avoir une division qui prend 10 cycles avec certaines opérandes, mais 40 cycles avec d'autres opérandes. Mais ces processeurs sont rares et cela est surtout valable pour les opérations de multiplication/division, guère plus. Le problème est alors le même qu'avec les accès mémoire et la solution est la même : l'ALU prévient le séquenceur quand le résultat est disponible.

==Les branchements et le ''program counter''==

Un branchement consiste juste à écrire l'adresse de destination dans le ''program counter''. L'implémentation des branchements demande d'extraire l'adresse de destination et d'altérer le ''program counter'' quand un branchement est détecté. Pour cela, le décodeur d'instruction détecte si l'instruction exécutée est un branchement ou non, et il en déduit où trouver l'adresse de destination.

L'adresse de destination se trouve à un endroit qui dépend du mode d'adressage du branchement. Pour rappel, on distingue quatre modes d'adressage pour les branchements : direct, indirect, relatif et implicite. Pour les branchements directs, l'adresse est intégrée dans l'instruction de branchement elle-même et est extraite par le séquenceur. Pour les branchements indirects, l'adresse de destination est dans le banc de registre. Pour les branchements relatifs, il faut ajouter un décalage au ''program counter'', décalage extrait de l'instruction par le séquenceur. Enfin, les instructions de retour de fonction lisent l'adresse de destination depuis la pile. L'implémentation de ces quatre types de branchements est très différente.

L'altération du ''program counter'' dépend de si le ''program counter'' est dans un compteur séparé ou s'il est dans le banc de registre. Nous avons vu plus haut qu'il y a quatre cas différents, mais nous n'allons voir que deux cas : celui où le ''program counter'' est dans le banc de registre et est incrémenté par l'unité de calcul, celui avec un ''program counter'' séparé avec son propre incrémenteur. Les deux autres cas ne sont utilisés que sur des architectures à accumulateur ou à pile spécifiques, que nous n'avons pas encore vu à ce stade du cours et que nous verrons en temps voulu dans le chapitre sur ces architectures.

===L’implémentation des branchements avec un ''program counter'' intégré au banc de registres===

Le cas le plus simple est celui où le ''program counter'' est intégré au banc de registre, avec une incrémentation faite par l'unité de calcul. Charger une instruction revient alors à effectuer une instruction LOAD en adressage indirect, à deux différences près : le registre sélectionné est le ''program counter'', l’instruction est copiée dans le registre d'instruction et non dans le banc de registre. L'incrémentation du ''porgram counter'' est implémenté avec des micro-opérations qui agissent sur le chemin de données, au même titre que les branchements indirects, relatifs et directs.
* Les branchements indirects copient un registre dans le ''program counter'', ce qui revient simplement à faire une opération MOV entre deux registres, dont le ''program counter'' est la destination.
* L'opération inverse d'un branchement indirect, qui copie le ''program counter'' dans un registre général, est utile pour sauvegarder l'adresse de retour d'une fonction.
* Les branchements directs copient une adresse dans le ''program counter'', ce qui les rend équivalents à une opération MOV avec une constante immédiate, dont le ''program counter'' est la destination.
* Les branchements relatifs sont une opération arithmétique entre le ''program counter'' et un opérande en adressage immédiat.

En clair, à partir du moment où le chemin de données supporte les instructions MOV et l'addition, avec les modes d'adressage adéquat, il supporte les branchements. Aucune modification du chemin de données n'est nécessaire, le séquenceur gére le chargement d'une instruction avec les micro-instructions adéquates : une micro-opération ADD pour incrémenter le ''program counter'', une micro-opération LOAD pour le chargement de l'instruction.

Notons que sur certaines architectures, le ''program counter'' est adressable au même titre que les autres registres du banc de registre. Les instructions de branchement sont alors remplacées par des instructions MOV ou des instructions arithmétique équivalentes, comme décrit plus haut.

===L’implémentation des branchements avec un ''program counter'' séparé===

Étudions maintenant le cas où le ''program counter'' est dans un registre/compteur séparé. Rappelons que tout compteur digne de ce nom possède une entrée de réinitialisation, qui remet le compteur à zéro. De plus, on peut préciser à quelle valeur il doit être réinitialisé. Ici, la valeur à laquelle on veut réinitialiser le compteur n'est autre que l'adresse de destination du branchement. Implémenter un branchement est donc simple : l'entrée de réinitialisation est commandée par le circuit de détection des branchements, alors que la valeur de réinitialisation est envoyée sur l'entrée adéquate. En clair, nous partons du principe que le ''program counter'' est implémenté avec ce type de compteur :

[[File:Fonctionnement d'un compteur (décompteur), schématique.jpg|centre|vignette|upright=1.5|Fonctionnement d'un compteur (décompteur), schématique]]

Toute la difficulté est de présenter l'adresse de destination au ''program counter''. Pour les branchements directs, l'adresse de destination est fournie par le séquenceur. L'adresse de destination du branchement sort du séquenceur et est présentée au ''program counter'' sur l'entrée adéquate. Voici donc comment sont implémentés les branchements directs avec un ''program counter'' séparé du banc de registres. Le schéma ci-dessous marche peu importe que le ''program counter'' soit incrémenté par l'ALU ou par un additionneur dédié.

[[File:Unité de détection des branchements dans le décodeur.png|centre|vignette|upright=2|Unité de détection des branchements dans le décodeur]]

Les branchements relatifs sont ceux qui font sauter X instructions plus loin dans le programme. Leur implémentation demande d'ajouter une constante au ''program counter'', la constante étant fournie dans l’instruction. Là encore, deux solutions sont possibles : réutiliser l'ALU pour calculer l'adresse, ou utiliser un additionneur séparé. L'additionneur séparé peut être fusionné avec l'additionneur qui incrémente le ''program counter'' pour passer à l’instruction suivante.

[[File:Unité de chargement qui gère les branchements relatifs.png|centre|vignette|upright=2|Unité de chargement qui gère les branchements relatifs.]]

Pour les branchements indirects, il suffit de lire le registre voulu et d'envoyer le tout sur l'entrée adéquate du ''program counter''. Il faut alors rajouter un multiplexeur pour que l'entrée de réinitialisationr ecoive la bonne adresse de destination.

[[File:Unité de chargement qui gère les branchements directs.png|centre|vignette|upright=2|Unité de chargement qui gère les branchements directs et indirects.]]

Toute la difficulté de l'implémentation des branchements est de configurer les multiplexeurs, ce qui est réalisé par le séquenceur en fonction du mode d'adressage du branchement.

==Les optimisations du chargement des instructions==

Charger une instruction est techniquement une forme d'accès mémoire un peu particulier. En clair, charger une instruction prend au minimum un cycle d'horloge, et cela peut rapidement monter à 3-5 cycles, si ce n'est plus. L'exécution des instructions est alors fortement ralentit par la mémoire. Par exemple, imaginez que la mémoire mette 3 cycles d'horloges pour charger une instruction, alors qu'une instruction s’exécute en 1 cycle (si les opérandes sont dans les registres). La perte de performance liée au chargement des instructions est alors substantielle. Heureusement, il est possible de limiter la casse en utilisant des mémoires caches, ainsi que d'autres optimisations, que nous allons voir dans ce qui suit.

===Le tampon de préchargement===

La technique dite du '''préchargement''' est utilisée dans le cas où la mémoire a un temps d'accès important. Mais si la latence de la RAM est un problème, le débit ne l'est pas. Il est possible d'avoir une RAM lente, mais à fort débit. Par exemple, supposons que la mémoire puisse charger 4 instructions (de taille fixe) en 3 cycles. Le processeur peut alors charger 4 instructions en un seul accès mémoire, et les exécuter l'une après l'autre, une par cycle d'horloge. Les temps d'attente sont éliminés : le processeur peut décoder une nouvelle instruction à chaque cycle. Et quand la dernière instruction préchargée est exécutée, la mémoire est de nouveau libre, ce qui masque la latence des accès mémoire.

[[File:Tampon de préchargement d'instruction.png|vignette|Tampon de préchargement d'instruction]]

La seule contrainte est de mettre les instructions préchargées en attente. La solution pour cela est d'utiliser un registre d'instruction très large, capable de mémoriser plusieurs instructions à la fois. Ce registre est de plus connecté à un multiplexeur qui permet de sélectionner l'instruction adéquate dans ce registre. Ce multiplexeur est commandé par le ''program counter'' et quelques circuits annexes. Ce super-registre d'instruction est appelé un '''tampon de préchargement'''.

La méthode a une implémentation nettement plus simple avec des instructions de taille fixe, alignées en mémoire. La commande du multiplexeur de sélection de l'instruction est alors beaucoup plus simple : il suffit d'utiliser les bits de poids fort du ''program counter''. Par exemple, prenons le cas d'un registre d'instruction de 32 octets pour des instructions de 4 octets, soit 8 instructions. Le choix de l'instruction à sélectionner se fait en utilisant les 3 bits de poids faible du ''program counter''. 

Mais cette méthode ajoute de nouvelles contraintes d'alignement, similaires à celles vues dans le chapitre sur l'alignement et le boutisme, sauf que l'alignement porte ici sur des blocs d'instructions de même taille que le tampon de préchargement. Si on prend l'exemple d'un tampon de préchargement de 128 bits, les instructions devront être alignées par blocs de 128 bits. C'est à dire qu'idéalement, les fonctions et autres blocs de code isolés doivent commencer à des adresses multiples de 128, pour pouvoir charger un bloc d'instruction en une seule fois. Sans cela, les performances seront sous-optimales.

: Il arrive que le tampon de préchargement ait la même taille qu'une ligne de cache.

Lorsque l'on passe d'un bloc d'instruction à un autre, le tampon de préchargement est mis à jour. Par exemple, si on prend un tampon de préchargement de 4 instructions, on doit changer son contenu toutes les 4 instructions. La seule exception est l'exécution d'un branchement. En effet, lors d'un branchement, la destination du branchement n'est pas dans le tampon de préchargement et elle doit être chargée dedans (sauf si le branchement pointe vers une instruction très proche, ce qui est improbable). Pour cela, le tampon de préchargement est mis à jour précocement quand le processeur détecte un branchement.

Le même problème survient avec du code auto-modifiant. Un code auto-modifiant est un programme qui se modifie lui-même, en remplaçant certaines instructions par d'autres, en en retirant, en en ajoutant, lors de sa propre exécution. De tels programmes sont rares, mais la technique était utilisée dans quelques cas au tout début de l'informatique sur des ordinateurs rudimentaires. Ceux-ci avaient des modes d'adressages tellement limités que gérer des tableaux de taille variable demandait d'utiliser du code auto-modifiant pour écrire des boucles. Le problème survient quand des instructions sont modifiées immédiatement après avoir été préchargées. Les instructions dans le tampon de préchargement sont l'ancienne version, alors que la mémoire RAM contient les instructions modifiées. Gérer ce genre de cas demande de vider le tampon de préchargement si le cas arrive, mais ça ne vaut que très rarement le coup, aussi les ingénieurs ne s’embêtent pas à mettre ce correctif en place. Le code automodifiant est alors buggé.

===La ''prefetch input queue''===

La ''prefetch input queue'' est une sorte de cousine du tampon de préchargement, qui a été utilisée sur les processeurs Intel assez ancien. Elle est apparue sur le 8086 et le 8088, des processeurs respectivement 8 et 16 bits. Elle été présente sur le 286 et le 386, mais était un peu améliorée. Elle est apparue sur ces processeurs à une époque où le processeur devenait plus rapide que la mémoire.

L'idée est là encore de précharger des instructions en avance. Sauf que cette fois-ci, on ne charge pas plusieurs instructions à la fois. Au contraire, les instructions sont préchargées séquentiellement, un ou deux octet à la fois. En conséquence, le tampon de préchargement est remplacé par une mémoire FIFO appelée la '''''Prefetch Input Queue''''', terme abrévié en PIQ. Les instructions sont accumulées une par une dans la PIQ, elles en sortent une par une au fur et à mesure pour alimenter le décodeur d'instruction.

Pendant que le processeur exécute une instruction, on précharge la suivante. Sans ''prefetch input queue'', le processeur chargeait une instruction, la décodait et l'exécutait, puis chargeait la suivante, et ainsi de suite. Avec un tampon de préchargement, le processeur chargeait plusieurs instruction en une seule fois, puis les exécutait les unes après les autres. Avec la ''prefetch input queue'', pendant qu'une instruction est en cours de décodage/exécution, le processeur précharge l'instruction suivante. Si une instruction prend vraiment beaucoup de temps pour s'exécuter, le processeur peut en profiter pour précharger l'instruction encore suivante, et ainsi de suite, jusqu'à une limite de 4/6 instructions (la limite dépend du processeur).

La ''prefetch input queue'' permet de précharger l'instruction suivante à condition qu'aucun autre accès mémoire n'ait lieu. Si l'instruction en cours d'exécution effectue des accès mémoire, ceux-ci sont prioritaires sur tout le reste, le préchargement de l'instruction suivante est alors mis en pause ou inhibé. Par contre, si la mémoire n'est pas utilisée par l'instruction en cours d'exécution, le processeur lit l'instruction suivante en RAM et la copie dans la ''prefetch input queue''. En conséquence, il arrive que la ''prefetch input queue'' n'ait pas préchargé l'instruction suivante, alors que le décodeur d'instruction est prêt pour la décoder. Dans ce cas, le décodeur doit attendre que l'instruction soit chargée.

Les instructions préchargées dans la ''Prefetch input queue'' y attendent que le processeur les lise et les décode. Les instructions préchargées sont conservées dans leur ordre d'arrivée, afin qu'elles soient exécutées dans le bon ordre, ce qui fait que la ''Prefetch input queue'' est une mémoire de type FIFO. L'étape de décodage pioche l'instruction à décoder dans la ''Prefetch input queue'', cette instruction étant par définition la plus ancienne, puis la retire de la file.

Le premier processeur commercial grand public à utiliser une ''prefetch input queue'' était le 8086. Il pouvait précharger à l'avance 6 octets d’instruction. L'Intel 8088 avait lui aussi une ''Prefetch input queue'', mais qui ne permettait que de précharger 4 instructions. La taille idéale de la FIFO dépend de nombreux paramètres. On pourrait croire que plus elle peut contenir d'instructions, mieux c'est, mais ce n'est pas le cas, pour des raisons que nous allons expliquer dans quelques paragraphes.

[[File:80186 arch.png|centre|vignette|700px|upright=2|Architecture du 8086, du 80186 et de ses variantes.]]

Vous remarquerez que j'ai exprimé la capacité de la ''prefetch input queue'' en octets et non en instructions. La raison est que sur les processeurs x86, les instructions sont de taille variable, avec une taille qui varie entre un octet et 6 octets. Cependant, le décodage des instructions se fait un octet à la fois : le décodeur lit un octet, puis éventuellement le suivant, et ainsi de suite jusqu'à atteindre la fin de l'instruction. En clair, le décodeur lit les instructions longues octet par octet dans la ''Prefetch input queue''.

Les instructions varient entre 1 et 6 octets, mais tous ne sont pas utile au décodeur d'instruction. Par exemple, le décodeur d'instruction n'a pas besoin d'analyser les constantes immédiates intégrées dans une instruction, ni les adresses mémoires en adressage absolu. Il n'a besoin que de deux octets : l'opcode et l'octet Mod/RM qui précise le mode d'adressage. Le second est facultatif. En clair, le décodeur a besoin de lire deux octets maximum depuis la ''prefetch input queue'', avant de passer à l’instruction suivante. Les autres octets étaient envoyés ailleurs, typiquement dans le chemin de données.

Par exemple, prenons le cas d'une addition entre le registre AX et une constante immédiate. L'instruction fait trois octets : un opcode suivie par une constante immédiate codée sur deux octets. L'opcode était envoyé au décodeur, mais pas la constante immédiate. Elle était lue octet par octet et mémorisée dans un registre temporaire placé en entrée de l'ALU. Idem avec les adresses immédiates, qui étaient envoyées dans un registre d’interfaçage mémoire sans passer par le décodeur d'instruction. Pour cela, la ''prefetch input queue'' était connectée au bus interne du processeur ! Le décodeur dispose d'une micro-opération pour lire un octet depuis la ''prefetch input queue'' et le copier ailleurs dans le chemin de données. Par exemple, l'instruction d'addition entre le registre AX et une constante immédiate était composée de quatre micro-opérations : une qui lisait le premier octet de la constante immédiate, une seconde pour le second, une troisième micro-opération qui commande l'ALU et fait le calcul. 

Le décodeur devait attendre que qu'un moins un octet soit disponible dans la ''Prefetch input queue'', pour le lire. Il lisait alors cet octet et déterminait s'il contenait une instruction complète ou non. Si c'est une instruction complète, il la décodait et l''exécutait, puis passait à l'instruction suivante. Sinon, il lit un second octet depuis la ''Prefetch input queue'' et relance le décodage. Là encore, le décodeur vérifie s'il a une instruction complète, et lit un troisième octet si besoin, puis rebelote avec un quatrième octet lu, etc.

Un circuit appelé le ''loader'' synchronisait le décodeur d'instruction et la ''Prefetch input queue''. Il fournissait deux bits : un premier bit pour indiquer que le premier octet d'une instruction était disponible dans la ''Prefetch input queue'', un second bit pour le second octet. Le ''loader'' recevait aussi des signaux de la part du décodeur d'instruction. Le signal ''Run Next Instruction'' entrainait la lecture d'une nouvelle instruction, d'un premier octet, qui était alors dépilé de la ''Prefetch input queue''. Le décodeur d'instruction pouvait aussi envoyer un signal ''Next-to-last (NXT)'', un cycle avant que l'instruction en cours ne termine. Le ''loader'' réagissait en préchargeant l'octet suivant. En clair, ce signal permettait de précharger l'instruction suivante avec un cycle d'avance, si celle-ci n'était pas déjà dans la ''Prefetch input queue''.

Le bus de données du 8086 faisait 16 bits, alors que celui du 8088 ne permettait que de lire un octet à la fois. Et cela avait un impact sur la ''prefetch input queue''. La ''prefetch input queue'' était composée de 4 registres de 8 bits, avec un port d'écriture de 8 bits pour précharger les instructions octet par octet, et un port de lecture de 8 bits pour alimenter le décodeur. En clair, tout faisait 8 bits. Le 8086, lui utilisait des registres de 16 bits et un port d'écriture de 16 bits. le port de lecture restait de 8 bits, et était précédé d'un multiplexeur qui prenait 16 bits et sélectionnait l'octet adéquat. Sa ''prefetch input queue'' préchargeait les instructions par paquets de 2 octets, non octet par octet, alors que le décodeur consommait les instructions octet par octet. Il s’agissait donc d'une sorte d'intermédiaire entre ''prefetch input queue'' à la 8088 et tampon de préchargement.

Les branchements posent des problèmes avec la ''Prefetch input queue'' : à cause d'eux, on peut charger à l'avance des instructions qui sont zappées par un branchement et ne sont pas censées être exécutées. Si un branchement est chargé, toutes les instructions préchargées après sont potentiellement invalides. Si le branchement est non-pris, les instructions chargées sont valides, elles sont censées s’exécuter. Mais si le branchement est pris, elles ont été chargées à tort et ne doivent pas s’exécuter. 

Pour éviter cela, la ''Prefetch input queue'' est vidée quand le processeur détecte un branchement. Pour cela, le décodeur d'instruction dispose d'une micro-opération qui vide la ''Prefetch input queue'', elle invalide les instructions préchargées.  Cette détection ne peut se faire qu'une fois le branchement décodé, qu'une fois que l'on sait que l'instruction décodée est un branchement. En clair, le décodeur invalide la ''Prefetch input queue'' quand il détecte un branchement. Les interruptions posent le même genre de problèmes. Il faut impérativement vider la ''Prefetch input queue'' quand une interruption survient, avant de la traiter.

Il faut noter qu'une ''Prefetch input queue'' interagit assez mal avec le ''program counter''. En effet, la ''Prefetch input queue'' précharge les instructions séquentiellement. Pour savoir où elle en est rendue, elle mémorise l'adresse de la prochaine instruction à charger dans un '''registre de préchargement''' dédié. Il serait possible d'utiliser un ''program counter'' en plus du registre de préchargement, mais ce n'est pas la solution qui a été utilisée. Les processeurs Intel anciens ont préféré n'utiliser qu'un seul registre de préchargement en remplacement du ''program counter''. Après tout, le registre de préchargement n'est qu'un ''program counter'' ayant pris une avance de quelques cycles d'horloge, qui a été incrémenté en avance.

Et cela ne pose pas de problèmes, sauf avec certains branchements. Par exemple, certains branchements relatifs demandent de connaitre la véritable valeur du ''program counter'', pas celle calculée en avance. Idem avec les instructions d'appel de fonction, qui demandent de sauvegarder l'adresse de retour exacte, donc le vrai ''program counter''. De telles situations demandent de connaitre la valeur réelle du ''program counter'', celle sans préchargement. Pour cela, le décodeur d'instruction dispose d'une instruction pour reconstituer le ''program counter'', à savoir corriger le ''program coutner'' et éliminer l'effet du préchargement.

La micro-opération de correction se contente de soustraire le nombre d'octets préchargés au registre de préchargement. Le nombre d'octets préchargés est déduit à partir des deux pointeurs intégré à la FIFO, qui indiquent la position du premier et du dernier octet préchargé. Le bit qui indique si la FIFO est vide était aussi utilisé. Les deux pointeurs sont lus depuis la FIFO, et sont envoyés à un circuit qui détermine le nombre d'octets préchargés. Sur le 8086, ce circuit était implémenté non pas par un circuit combinatoire, mais par une mémoire ROM équivalente. La petite taille de la FIFO faisait que les pointeurs étaient très petits et la ROM l'était aussi.

Un autre défaut est que la ''Prefetch input queue'' se marie assez mal avec du code auto-modifiant. Un code auto-modifiant est un programme qui se modifie lui-même, en remplaçant certaines instructions par d'autres, en en retirant, en en ajoutant, lors de sa propre exécution. De tels programmes sont rares, mais la technique était utilisée dans quelques cas au tout début de l'informatique sur des ordinateurs rudimentaires. Ceux-ci avaient des modes d'adressages tellement limités que gérer des tableaux de taille variable demandait d'utiliser du code auto-modifiant pour écrire des boucles.

Le problème avec la ''Prefetch input queue'' survient quand des instructions sont modifiées immédiatement après avoir été préchargées. Les instructions dans la ''Prefetch input queue'' sont l'ancienne version, alors que la mémoire RAM contient les instructions modifiées. Gérer ce genre de cas est quelque peu complexe. Il faut en effet vider la ''Prefetch input queue'' si le cas arrive, ce qui demande d'identifier les écritures qui écrasent des instructions préchargées. C'est parfaitement possible, mais demande de transformer la ''Prefetch input queue'' en une mémoire hybride, à la fois mémoire associative et mémoire FIFO. Cela ne vaut que très rarement le coup, aussi les ingénieurs ne s’embêtent pas à mettre ce correctif en place, le code automodifiant est alors buggé.

Le décodeur d'instruction dispose aussi d'une micro-opération qui stoppe le préchargement des instructions dans la ''Prefetch input queue''.

: Pour ceux qui ont déjà lu un cours d'architecture des ordinateurs, la relation entre ''prefetch input queue'' et pipeline est quelque peu complexe. En apparence, la ''prefetch input queue'' permet une certaines forme de pipeline, en chargeant une instruction pendant que la précédente s'exécute. Les problématiques liées aux branchements ressemblent beaucoup à celles de la prédiction de branchement. Cependant, il est possible de dire qu'il s'agit plus d'une technique de préchargement que de pipeline. La différence entre les deux est assez subtile et les frontières sont assez floues, mais le fait est que l'instruction en cours d'exécution et le préchargement peuvent tout deux faire des accès mémoire et que l'instruction en cours a la priorité. Un vrai pipeline se débrouillerait avec une architecture Harvard, non avec un bus mémoire unique pour le chargement des instruction et la lecture/écriture des données.

===Le ''Zero-overhead looping''===

Nous avions vu dans le chapitre sur les instructions machines, qu'il existe des instructions qui permettent de grandement faciliter l'implémentation des boucles. Il s'agit de l'instruction REPEAT, utilisée sur certains processeurs de traitement de signal. Elle répète l'instruction suivante, voire une série d'instructions, un certain nombre de fois. Le nombre de répétitions est mémorisé dans un registre décrémenté à chaque itération de la boucle. Elle permet donc d'implémenter une boucle FOR facilement, sans recourir à des branchements ou des conditions.

Une technique en lien avec cette instruction permet de grandement améliorer les performances et la consommation d'énergie. L'idée est de mémoriser la boucle, les instructions à répéter, dans une petite mémoire cache située entre l'unité de chargement et le séquenceur. Le cache en question s'appelle un '''tampon de boucle''', ou encore un ''hardware loop buffer''. Grâce à lui, il n'y a pas besoin de charger les instructions à chaque fois qu'on les exécute, on les charge une bonne fois pour toute : c'est plus rapide. Bien sûr, il ne fonctionne que pour de petites boucles, mais il en est de même avec l'instruction REPEAT.

&lt;noinclude&gt;
{{NavChapitre | book=Fonctionnement d'un ordinateur
           | prev=Le chemin de données
           | prevText=Le chemin de données
           | next=L'unité de contrôle
           | nextText=L'unité de contrôle
}}
&lt;/noinclude&gt;</text>
      <sha1>a5hpzf9x4qobw5p2fgzc8b4xnysp3s6</sha1>
    </revision>
    <revision>
      <id>744094</id>
      <parentid>744093</parentid>
      <timestamp>2025-06-03T20:40:41Z</timestamp>
      <contributor>
        <username>Mewtow</username>
        <id>31375</id>
      </contributor>
      <minor />
      <comment>/* La prefetch input queue */</comment>
      <origin>744094</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="48679" sha1="lu50g3obx7oh5kyy3scsfhc3vbbasyv" xml:space="preserve">L'unité de contrôle s'occupe du chargement des instructions et de leur interprétation, leur décodage. Elle contient deux circuits : l''''unité de chargement''' qui charge l'instruction depuis la mémoire, et le '''séquenceur''' qui commande le chemin de données. Les deux circuits sont séparés, mais ils communiquent entre eux, notamment pour gérer les branchements. Dans ce chapitre, nous allons nous intéresser au chargement d'une instruction depuis la RAM/ROM, nous verrons l'étape de décodage de l'instruction au prochain chapitre.

==Le chargement d'une instruction==

[[File:Étape de chargement.png|vignette|upright=1|Étape de chargement.]]

L'étape de chargement (ou ''fetch'') doit faire deux choses : mettre à jour le ''program counter'' et lire l'instruction en mémoire RAM ou en ROM. Les deux étapes peuvent être faites en parallèle, dans des circuits séparés. Pendant que l'instruction est lue depuis la mémoire RAM/ROM, le ''program counter'' est incrémenté et/ou altéré par un branchement.

Pour lire l'instruction, on envoie le ''program counter'' sur le bus d'adresse et on récupère l'instruction sur le bus de données pour l'envoyer sur l'entrée du séquenceur. Et cela demande de connecter le séquenceur au bus mémoire, à travers l'interface mémoire. Et sur ce point, la situation est différente selon que l'on parler d'une architecture Harvard ou Von Neumann.

===Les interconnexions entre séquenceur et bus mémoire===

Sur les architectures Harvard, le séquenceur et le chemin de donnée utilisent des interfaces mémoire séparées. Le séquenceur est directement relié au bus mémoire de la ROM, alors que le chemin de données est connecté à la RAM.

[[File:Microarchitecture de l'interface mémoire d'une architecture Harvard.png|centre|vignette|upright=2|Microarchitecture de l'interface mémoire d'une architecture Harvard]]

Mais sur les architectures Von-Neumann et affiliées, le séquenceur et le chemin de donnée partagent la même interface mémoire. Et cela pose deux problèmes.

Le premier problème est que le bus mémoire doit être libéré une fois l'instruction chargée, pour un éventuel accès mémoire. Mais le séquenceur doit conserver une copie de l'instruction chargée, sans quoi il ne peut pas décoder l'instruction correctement. Par exemple, si l'instruction met plusieurs cycles à s'exécuter, le séquenceur doit conserver une copie de l'instruction durant ces plusieurs cycles. La solution à ce problème est un '''registre d'instruction''' situé juste avant le séquenceur, qui mémorise l'instruction chargée.

[[File:Registre d'instruction.png|centre|vignette|upright=2|Registre d'instruction.]]

Le second problème est de gérer le flot des instructions/données entre le bus mémoire, le chemin de données et le séquenceur. Le processeur doit connecter l'interface mémoire soit au séquenceur, soit au chemin de données et cela complique le réseau d'interconnexion interne au processeur.

Une première solution utilise un bus unique qui relie l'interface mémoire, le séquenceur et le chemin de données. Pour charger une instruction, le séquenceur copie le ''program counter'' sur le bus d'adresse, attend que l'instruction lue soit disponible sur le bus de données, puis la copie dans le registre d'instruction. Le bus mémoire est alors libre et peut être utilisé pour lire ou écrire des données, si le besoin s'en fait sentir.

Il faut noter que l'usage d'un bus unique a un impact sur l'organisation interne du chemin de données. Par exemple, le chapitre précédent nous a montré comment implémenter un chemin de données basique, avec des multiplexeurs et démultiplexeurs. Et bien ces chemins de données ne marchent pas vraiment avec un bus interne unique. Il est possible de les adapter, mais au prix d'une complexité largement supérieure. Un bus interne unique marche mieux quand le banc de registre est mono-port. C'est pourquoi il a été utilisé sur d'anciennes architectures appelées des architectures à accumulateur et à pile, que nous verrons dans quelques chapitres, qui utilisaient un banc de registre mono-port.

[[File:Microarchitecture de l'interface mémoire d'une architecture von neumann.png|centre|vignette|upright=2|Microarchitecture de l'interface mémoire d'une architecture von neumann]]

Une autre solution utilise deux bus interne séparés : un connecté au bus d'adresse, l'autre au bus de données. Le ''program counter'' est alors connecté au bus interne d'adresse, le séquenceur est relié au bus interne de données. Notons que la technique marche bien si le ''program counter'' est dans le banc de registre : les interconnexions utilisées pour gérer l'adressage indirect permettent d'envoyer le ''program counter'' sur le bus d'adresse sans ajout de circuit.

Le tout peut être amélioré en remplaçant les deux bus par des multiplexeurs et démultiplexeurs. Le bus d'adresse est précédé par un multiplexeur, qui permet de faire le choix entre ''Program Counter'', adresse venant du chemin de données, ou adresse provenant du séquenceur (adressage absolu). De même, le bus de données est suivi par un démultiplexeur qui envoie la donnée/instruction lue soit au registre d'instruction, soit au chemin de données. Le tout se marie très bien avec les chemins de donnée vu dans le chapitre précédent. Au passage, il faut noter que cette solution nécessite un banc de registre multi-port.

[[File:Connexion du program counter sur les bus avec PC isolé.png|centre|vignette|upright=2|Connexion du program counter sur les bus avec PC isolé]]

===Le chargement des instructions de longueur variable===

Le chargement des instructions de longueur variable pose de nombreux problèmes. Le premier est que mettre à jour le ''program counter'' demande de connaitre la longueur de l'instruction chargée, pour l'ajouter au ''program counter''. Si la longueur d'une instruction est variable, on doit connaitre cette longueur d'une manière où d'une autre. La solution la plus simple indique la longueur de l'instruction dans une partie de l'opcode ou de la représentation en binaire de l'instruction. Mais les processeurs haute performance de nos PC utilisent d'autres solutions, qui n'encodent pas explicitement la taille de l'instruction.

Les processeurs récents utilisent un registre d'instruction de grande taille, capable de mémoriser l'instruction la plus longue du processeur. Par exemple, si un processeur supporte des instructions allant de 1 à 8 octets, comme les CPU x86, le registre d'instruction fera 8 octets. Le décodeur d'instruction vérifie à chaque cycle le contenu du registre d'instruction. Si une instruction est détectée dedans, son décodage commence, peu importe la taille de l'instruction. Une fois l'instruction exécutée, elle est retirée du registre d'instruction. Reste à alimenter le registre d'instruction, à charger des instructions dedans. Et pour cela deux solutions : soit on charge l'instruction en plusieurs fois, soit d'un seul coup.

La solution la plus simple charge les instructions par mots de 8, 16, 32, 64 bits. Ils sont accumulés dans le registre d'instruction jusqu'à détecter une instruction complète. La technique marche nettement mieux si les instructions sont très longues. Par exemple, les CPU x86 ont des instructions qui vont de 1 à 15 octets, ce qui fait qu'ils utilisent cette technique. Précisément, elle marche si les instructions les plus longues sont plus grandes que le bus mémoire.

Une autre solution charge un bloc de mots mémoire aussi grand que la plus grande instruction. Par exemple, si le processeur gère des instructions allant de 1 à 4 octets, il charge 4 octets d'un seul coup dans le registre d'instruction. Il va de soit que cette solution ne marche que si les instructions du processeur sont assez courtes, au plus aussi courtes que le bus mémoire. Ainsi, on est sûr de charger obligatoirement au moins une instruction complète, et peut-être même plusieurs. Le contenu du registre d'instruction est alors découpé en instructions au fil de l'eau. 

Utiliser un registre d'instruction large pose problème avec des instructions à cheval entre deux blocs. Il se peut qu'on n'ait pas une instruction complète lorsque l'on arrive à la fin du bloc, mais seulement un morceau. Le problème se manifeste peu importe que l'instruction soit chargée d'un seul coup ou bien en plusieurs fois.

[[File:Instructions non alignées.png|centre|vignette|upright=2|Instructions non alignées.]]

Dans ce cas, on doit décaler le morceau de bloc pour le mettre au bon endroit (au début du registre d'instruction), et charger le prochain bloc juste à côté. On a donc besoin d'un circuit qui décale tous les bits du registre d'instruction, couplé à un circuit qui décide où placer dans le registre d'instruction ce qui a été chargé, avec quelques circuits autour pour configurer les deux circuits précédents.

[[File:Décaleur d’instruction.png|centre|vignette|upright=2|Décaleur d’instruction.]]

Une autre solution se passe de registre d'instruction en utilisant à la place l'état interne du séquenceur. Là encore, elle charge l'instruction morceau par morceau, typiquement par blocs de 8, 16 ou 32 bits. Les morceaux ne sont pas accumulés dans le registre d'instruction, la solution utilise à la place l'état interne du séquenceur. Les mots mémoire de l'instruction sont chargés à chaque cycle, faisant passer le séquenceur d'un état interne à un autre à chaque mot mémoire. Tant qu'il n'a pas reçu tous les mots mémoire de l'instruction, chaque mot mémoire non terminal le fera passer d'un état interne à un autre, chaque état interne encodant les mots mémoire chargés auparavant. S'il tombe sur le dernier mot mémoire d'une instruction, il rentre dans un état de décodage.

==L'incrémentation du ''program counter''==

À chaque chargement, le ''program counter'' est mis à jour afin de pointer sur la prochaine instruction à charger. Sur la quasi-totalité des processeurs, les instructions sont placées dans l'ordre d’exécution dans la RAM. En faisant ainsi, on peut mettre à jour le ''program counter'' en lui ajoutant la longueur de l'instruction courante. Déterminer la longueur de l'instruction est simple quand les instructions ont toutes la même taille, mais certains processeurs ont des instructions de taille variable, ce qui complique le calcul. Dans ce qui va suivre, nous allons supposer que les instructions sont de taille fixe, ce qui fait que le ''program counter'' est toujours incrémenté de la même valeur.

Il existe deux méthodes principales pour incrémenter le ''program counter'' : soit le ''program counter'' a son propre additionneur, soit le ''program counter'' est mis à jour par l'ALU. Pour ce qui est de l'organisation des registres, soit le ''program counter'' est un registre séparé des autres, soit il est regroupé avec d'autres registres dans un banc de registre. En tout, cela donne quatre organisations possibles.
* Un ''program counter'' séparé relié à un incrémenteur séparé.
* Un ''program counter'' séparé des autres registres, incrémenté par l'ALU.
* Un ''program counter'' intégré au banc de registre, relié à un incrémenteur séparé.
* Un ''program counter'' intégré au banc de registre, incrémenté par l'ALU.

[[File:Calcul du program counter.png|centre|vignette|upright=2|les différentes méthodes de calcul du program counter.]]

Les processeurs haute performance modernes utilisent tous la première méthode. Les autres méthodes étaient surtout utilisées sur les processeurs 8 ou 16 bits, elles sont encore utilisées sur quelques microcontrôleurs de faible puissance. Nous auront l'occasion de donner des exemples quand nous parlerons des processeurs 8 bits anciens, dans le chapitre sur les architectures à accumulateur et affiliées.

===Le ''program counter'' mis à jour par l'ALU===

Sur certains processeurs, le calcul de l'adresse de la prochaine instruction est effectué par l'ALU. L'avantage de cette méthode est qu'elle économise un incrémenteur dédié au ''program counter''. Ce qui explique que cette méthode était utilisée sur les processeurs assez anciens, à une époque où un additionneur pouvait facilement prendre 10 à 20% des transistors disponibles. Le désavantage principal est une augmentation de la complexité du séquenceur, qui doit gérer la mise à jour du ''program counter''. De plus, la mise à jour du ''program counter'' ne peut pas se faire en même temps qu'une opération arithmétique, ce qui réduit les performances.

Si on incrémente le ''program counter'' avec l'ALU, il est intéressant de le placer dans le banc de registres. Un désavantage est qu'on perd un registre. Par exemple, avec un banc de registre de 16 registres, on ne peut adresser que 15 registres généraux. De plus ce n'est pas l'idéal pour le décodage des instructions et pour le séquenceur. Si le processeur dispose de plusieurs bancs de registres, le ''program counter'' est généralement placé dans le banc de registre dédié aux adresses. Sinon, il est placé avec les nombres entiers/adresses.

D'anciens processeurs incrémentaient le ''program counter'' avec l'ALU, mais utilisaient bien un registre séparé pour le ''program counter''. Cette méthode est relativement simple à implémenter : il suffit de connecter/déconnecter le ''program counter'' du bus interne suivant les besoins. Le ''program counter'' est déconnecté pendant l’exécution d'une instruction, il est connecté au bus interne pour l'incrémenter. C'est le séquenceur qui gère le tout. L'avantage de cette séparation est qu'elle est plus facile à gérer pour le séquenceur. De plus, on gagne un registre général/entier dans le banc de registre.

===Le compteur programme===

Dans la quasi-totalité des processeurs modernes, le ''program counter'' est un vulgaire compteur comme on en a vu dans les chapitres sur les circuits, ce qui fait qu'il passe automatiquement d'une adresse à la suivante. Dans ce qui suit, nous allons appeler ce registre compteur : le '''compteur ordinal'''. L'usage d'un compteur simplifie fortement la conception du séquenceur. Le séquenceur n'a pas à gérer la mise à jour du ''program counter'', sauf en cas de branchements. De plus, il est possible d'incrémenter le ''program counter'' pendant que l'unité de calcul effectue une opération arithmétique, ce qui améliore grandement les performances. Le seul désavantage est qu'elle demande d'ajouter un incrémenteur dédié au ''program counter''.

Sur les processeurs très anciens, les instructions faisaient toutes un seul mot mémoire et le compteur ordinal était un circuit incrémenteur des plus basique. Sur les processeurs modernes, le compteur est incrémenté par pas de 4 si les instructions sont codées sur 4 octets, 8 si les instructions sont codées sur 8 octets, etc. Concrètement, le compteur est un circuit incrémenteur auquel on aurait retiré quelques bits de poids faible. Par exemple, si les instructions sont codées sur 4 octets, on coupe les 2 derniers bits du compteur. Si les instructions sont codées sur 8 octets, on coupe les 3 derniers bits du compteur. Et ainsi de suite.

Il a existé quelques processeurs pour lesquelles le ''program counter'' était non pas un compteur binaire classique, mais un ''linear feedback shift register''. L'avantage est que le circuit d'incrémentation utilisait bien moins de portes logiques, l'économie était substantielle. Mais un défaut est que des instructions consécutives dans le programme n'étaient pas consécutives en mémoire. Il existait cependant une table de correspondance pour dire : la première instruction est à telle adresse, la seconde à telle autre, etc. Un exemple de processeur de ce type est le TMS 1000 de Texas Instrument, un des premiers microcontrôleur 4 bits datant des années 70.

Une amélioration de la solution précédente utilise un circuit incrémenteur partagé entre le ''program counter'' et d'autres registres. L'incrémenteur est utilisé pour incrémenter le ''program counter'', mais aussi pour effectuer d'autres calculs d'adresse. Par exemple, sur les architectures avec une pile d'adresse de retour, il est possible de partager l'incrémenteur/décrémenteur avec le pointeur de pile ( la technique ne marche pas avec une pile d'appel). Un autre exemple est celui des processeurs qui gèrent automatiquement le rafraichissement mémoire, grâce à, un compteur intégré dans le processeur. Il est possible de partager l'incrémenteur du ''program counter'' avec le compteur de rafraichissement mémoire, qui mémorise la prochaine adresse mémoire à rafraichir. Nous avions déjà abordé ce genre de partage dans le chapitre sur le chemin de données, dans l'annexe sur le pointeur de pile, mais nous verrons d'autres exemples dans le chapitre sur les architectures hybride accumulateur-registre 8/16 bits.

===Quand est mis à jour le ''program counter'' ?===

Le ''program counter'' est mis à jour quand il faut charger une nouvelle instruction. Reste qu'il faut savoir quand le mettre à jour. Incrémenter le ''program counter'' à intervalle régulier, par exemple à chaque cycle d’horloge, fonctionne sur les processeurs où toutes les instructions mettent le même temps pour s’exécuter. Mais de tels processeurs sont très rares. Sur la quasi-totalité des processeurs, les instructions ont une durée d’exécution variable, elles ne prennent pas le même nombre de cycle d'horloge pour s’exécuter. Le temps d’exécution d'une instruction varie selon l'instruction, certaines sont plus longues que d'autres. Tout cela amène un problème : comment incrémenter le ''program counter'' avec des instructions avec des temps d’exécution variables ?

La réponse est que la mise à jour du ''program counter'' démarre quand l'instruction précédente a terminée de s’exécuter, plus précisément un cycle avant. C'est un cycle avant pour que l'instruction chargée soit disponible au prochain cycle pour le décodeur. Pour cela, le séquenceur doit déterminer quand l'instruction est terminée et prévenir le ''program counter'' au bon moment. Il faut donc une interaction entre séquenceur et circuit de chargement. Le circuit de chargement contient une entrée Enable, qui autorise la mise à jour du ''program counter''. Le séquenceur met à 1 cette entrée pour prévenir au ''program counter'' qu'il doit être incrémenté au cycle suivant ou lors du cycle courant. Cela permet de gérer simplement le cas des instructions multicycles. 

[[File:Commande de la mise à jour du program counter.png|centre|vignette|upright=2|Commande de la mise à jour du program counter.]]

Toute la difficulté est alors reportée dans le séquenceur, qui doit déterminer la durée d'une instruction. Pour gérer la mise à jour du ''program counter'', le séquenceur doit déterminer la durée d'une instruction. Cela est simple pour les instructions arithmétiques et logiques, qui ont un nombre de cycles fixe, toujours le même. Une fois l'instruction identifiée par le séquenceur, il connait son nombre de cycles et peut programmer un compteur interne au séquenceur, qui compte le nombre de cycles de l'instruction, et fournit le signal Enable au ''program counter''. Mais cette technique ne marche pas vraiment pour les accès mémoire, dont la durée n'est pas connue à l'avance, surtout sur les processeurs avec des mémoires caches. Pour cela, le séquenceur détermine quand l'instruction mémoire est finie et prévient le ''program counter'' quand c'est le cas.

Il existe quelques processeurs pour lesquels le temps de calcul dépend des opérandes de l'instruction. On peut par exemple avoir une division qui prend 10 cycles avec certaines opérandes, mais 40 cycles avec d'autres opérandes. Mais ces processeurs sont rares et cela est surtout valable pour les opérations de multiplication/division, guère plus. Le problème est alors le même qu'avec les accès mémoire et la solution est la même : l'ALU prévient le séquenceur quand le résultat est disponible.

==Les branchements et le ''program counter''==

Un branchement consiste juste à écrire l'adresse de destination dans le ''program counter''. L'implémentation des branchements demande d'extraire l'adresse de destination et d'altérer le ''program counter'' quand un branchement est détecté. Pour cela, le décodeur d'instruction détecte si l'instruction exécutée est un branchement ou non, et il en déduit où trouver l'adresse de destination.

L'adresse de destination se trouve à un endroit qui dépend du mode d'adressage du branchement. Pour rappel, on distingue quatre modes d'adressage pour les branchements : direct, indirect, relatif et implicite. Pour les branchements directs, l'adresse est intégrée dans l'instruction de branchement elle-même et est extraite par le séquenceur. Pour les branchements indirects, l'adresse de destination est dans le banc de registre. Pour les branchements relatifs, il faut ajouter un décalage au ''program counter'', décalage extrait de l'instruction par le séquenceur. Enfin, les instructions de retour de fonction lisent l'adresse de destination depuis la pile. L'implémentation de ces quatre types de branchements est très différente.

L'altération du ''program counter'' dépend de si le ''program counter'' est dans un compteur séparé ou s'il est dans le banc de registre. Nous avons vu plus haut qu'il y a quatre cas différents, mais nous n'allons voir que deux cas : celui où le ''program counter'' est dans le banc de registre et est incrémenté par l'unité de calcul, celui avec un ''program counter'' séparé avec son propre incrémenteur. Les deux autres cas ne sont utilisés que sur des architectures à accumulateur ou à pile spécifiques, que nous n'avons pas encore vu à ce stade du cours et que nous verrons en temps voulu dans le chapitre sur ces architectures.

===L’implémentation des branchements avec un ''program counter'' intégré au banc de registres===

Le cas le plus simple est celui où le ''program counter'' est intégré au banc de registre, avec une incrémentation faite par l'unité de calcul. Charger une instruction revient alors à effectuer une instruction LOAD en adressage indirect, à deux différences près : le registre sélectionné est le ''program counter'', l’instruction est copiée dans le registre d'instruction et non dans le banc de registre. L'incrémentation du ''porgram counter'' est implémenté avec des micro-opérations qui agissent sur le chemin de données, au même titre que les branchements indirects, relatifs et directs.
* Les branchements indirects copient un registre dans le ''program counter'', ce qui revient simplement à faire une opération MOV entre deux registres, dont le ''program counter'' est la destination.
* L'opération inverse d'un branchement indirect, qui copie le ''program counter'' dans un registre général, est utile pour sauvegarder l'adresse de retour d'une fonction.
* Les branchements directs copient une adresse dans le ''program counter'', ce qui les rend équivalents à une opération MOV avec une constante immédiate, dont le ''program counter'' est la destination.
* Les branchements relatifs sont une opération arithmétique entre le ''program counter'' et un opérande en adressage immédiat.

En clair, à partir du moment où le chemin de données supporte les instructions MOV et l'addition, avec les modes d'adressage adéquat, il supporte les branchements. Aucune modification du chemin de données n'est nécessaire, le séquenceur gére le chargement d'une instruction avec les micro-instructions adéquates : une micro-opération ADD pour incrémenter le ''program counter'', une micro-opération LOAD pour le chargement de l'instruction.

Notons que sur certaines architectures, le ''program counter'' est adressable au même titre que les autres registres du banc de registre. Les instructions de branchement sont alors remplacées par des instructions MOV ou des instructions arithmétique équivalentes, comme décrit plus haut.

===L’implémentation des branchements avec un ''program counter'' séparé===

Étudions maintenant le cas où le ''program counter'' est dans un registre/compteur séparé. Rappelons que tout compteur digne de ce nom possède une entrée de réinitialisation, qui remet le compteur à zéro. De plus, on peut préciser à quelle valeur il doit être réinitialisé. Ici, la valeur à laquelle on veut réinitialiser le compteur n'est autre que l'adresse de destination du branchement. Implémenter un branchement est donc simple : l'entrée de réinitialisation est commandée par le circuit de détection des branchements, alors que la valeur de réinitialisation est envoyée sur l'entrée adéquate. En clair, nous partons du principe que le ''program counter'' est implémenté avec ce type de compteur :

[[File:Fonctionnement d'un compteur (décompteur), schématique.jpg|centre|vignette|upright=1.5|Fonctionnement d'un compteur (décompteur), schématique]]

Toute la difficulté est de présenter l'adresse de destination au ''program counter''. Pour les branchements directs, l'adresse de destination est fournie par le séquenceur. L'adresse de destination du branchement sort du séquenceur et est présentée au ''program counter'' sur l'entrée adéquate. Voici donc comment sont implémentés les branchements directs avec un ''program counter'' séparé du banc de registres. Le schéma ci-dessous marche peu importe que le ''program counter'' soit incrémenté par l'ALU ou par un additionneur dédié.

[[File:Unité de détection des branchements dans le décodeur.png|centre|vignette|upright=2|Unité de détection des branchements dans le décodeur]]

Les branchements relatifs sont ceux qui font sauter X instructions plus loin dans le programme. Leur implémentation demande d'ajouter une constante au ''program counter'', la constante étant fournie dans l’instruction. Là encore, deux solutions sont possibles : réutiliser l'ALU pour calculer l'adresse, ou utiliser un additionneur séparé. L'additionneur séparé peut être fusionné avec l'additionneur qui incrémente le ''program counter'' pour passer à l’instruction suivante.

[[File:Unité de chargement qui gère les branchements relatifs.png|centre|vignette|upright=2|Unité de chargement qui gère les branchements relatifs.]]

Pour les branchements indirects, il suffit de lire le registre voulu et d'envoyer le tout sur l'entrée adéquate du ''program counter''. Il faut alors rajouter un multiplexeur pour que l'entrée de réinitialisationr ecoive la bonne adresse de destination.

[[File:Unité de chargement qui gère les branchements directs.png|centre|vignette|upright=2|Unité de chargement qui gère les branchements directs et indirects.]]

Toute la difficulté de l'implémentation des branchements est de configurer les multiplexeurs, ce qui est réalisé par le séquenceur en fonction du mode d'adressage du branchement.

==Les optimisations du chargement des instructions==

Charger une instruction est techniquement une forme d'accès mémoire un peu particulier. En clair, charger une instruction prend au minimum un cycle d'horloge, et cela peut rapidement monter à 3-5 cycles, si ce n'est plus. L'exécution des instructions est alors fortement ralentit par la mémoire. Par exemple, imaginez que la mémoire mette 3 cycles d'horloges pour charger une instruction, alors qu'une instruction s’exécute en 1 cycle (si les opérandes sont dans les registres). La perte de performance liée au chargement des instructions est alors substantielle. Heureusement, il est possible de limiter la casse en utilisant des mémoires caches, ainsi que d'autres optimisations, que nous allons voir dans ce qui suit.

===Le tampon de préchargement===

La technique dite du '''préchargement''' est utilisée dans le cas où la mémoire a un temps d'accès important. Mais si la latence de la RAM est un problème, le débit ne l'est pas. Il est possible d'avoir une RAM lente, mais à fort débit. Par exemple, supposons que la mémoire puisse charger 4 instructions (de taille fixe) en 3 cycles. Le processeur peut alors charger 4 instructions en un seul accès mémoire, et les exécuter l'une après l'autre, une par cycle d'horloge. Les temps d'attente sont éliminés : le processeur peut décoder une nouvelle instruction à chaque cycle. Et quand la dernière instruction préchargée est exécutée, la mémoire est de nouveau libre, ce qui masque la latence des accès mémoire.

[[File:Tampon de préchargement d'instruction.png|vignette|Tampon de préchargement d'instruction]]

La seule contrainte est de mettre les instructions préchargées en attente. La solution pour cela est d'utiliser un registre d'instruction très large, capable de mémoriser plusieurs instructions à la fois. Ce registre est de plus connecté à un multiplexeur qui permet de sélectionner l'instruction adéquate dans ce registre. Ce multiplexeur est commandé par le ''program counter'' et quelques circuits annexes. Ce super-registre d'instruction est appelé un '''tampon de préchargement'''.

La méthode a une implémentation nettement plus simple avec des instructions de taille fixe, alignées en mémoire. La commande du multiplexeur de sélection de l'instruction est alors beaucoup plus simple : il suffit d'utiliser les bits de poids fort du ''program counter''. Par exemple, prenons le cas d'un registre d'instruction de 32 octets pour des instructions de 4 octets, soit 8 instructions. Le choix de l'instruction à sélectionner se fait en utilisant les 3 bits de poids faible du ''program counter''. 

Mais cette méthode ajoute de nouvelles contraintes d'alignement, similaires à celles vues dans le chapitre sur l'alignement et le boutisme, sauf que l'alignement porte ici sur des blocs d'instructions de même taille que le tampon de préchargement. Si on prend l'exemple d'un tampon de préchargement de 128 bits, les instructions devront être alignées par blocs de 128 bits. C'est à dire qu'idéalement, les fonctions et autres blocs de code isolés doivent commencer à des adresses multiples de 128, pour pouvoir charger un bloc d'instruction en une seule fois. Sans cela, les performances seront sous-optimales.

: Il arrive que le tampon de préchargement ait la même taille qu'une ligne de cache.

Lorsque l'on passe d'un bloc d'instruction à un autre, le tampon de préchargement est mis à jour. Par exemple, si on prend un tampon de préchargement de 4 instructions, on doit changer son contenu toutes les 4 instructions. La seule exception est l'exécution d'un branchement. En effet, lors d'un branchement, la destination du branchement n'est pas dans le tampon de préchargement et elle doit être chargée dedans (sauf si le branchement pointe vers une instruction très proche, ce qui est improbable). Pour cela, le tampon de préchargement est mis à jour précocement quand le processeur détecte un branchement.

Le même problème survient avec du code auto-modifiant. Un code auto-modifiant est un programme qui se modifie lui-même, en remplaçant certaines instructions par d'autres, en en retirant, en en ajoutant, lors de sa propre exécution. De tels programmes sont rares, mais la technique était utilisée dans quelques cas au tout début de l'informatique sur des ordinateurs rudimentaires. Ceux-ci avaient des modes d'adressages tellement limités que gérer des tableaux de taille variable demandait d'utiliser du code auto-modifiant pour écrire des boucles. Le problème survient quand des instructions sont modifiées immédiatement après avoir été préchargées. Les instructions dans le tampon de préchargement sont l'ancienne version, alors que la mémoire RAM contient les instructions modifiées. Gérer ce genre de cas demande de vider le tampon de préchargement si le cas arrive, mais ça ne vaut que très rarement le coup, aussi les ingénieurs ne s’embêtent pas à mettre ce correctif en place. Le code automodifiant est alors buggé.

===La ''prefetch input queue''===

La ''prefetch input queue'' est une sorte de cousine du tampon de préchargement, qui a été utilisée sur les processeurs Intel assez ancien. Elle est apparue sur le 8086 et le 8088, des processeurs respectivement 8 et 16 bits. Elle été présente sur le 286 et le 386, mais était un peu améliorée. Elle est apparue sur ces processeurs à une époque où le processeur devenait plus rapide que la mémoire.

L'idée est là encore de précharger des instructions en avance. Sauf que cette fois-ci, on ne charge pas plusieurs instructions à la fois. Au contraire, les instructions sont préchargées séquentiellement, un ou deux octet à la fois. En conséquence, le tampon de préchargement est remplacé par une mémoire FIFO appelée la '''''Prefetch Input Queue''''', terme abrévié en PIQ. Les instructions sont accumulées une par une dans la PIQ, elles en sortent une par une au fur et à mesure pour alimenter le décodeur d'instruction.

Pendant que le processeur exécute une instruction, on précharge la suivante. Sans ''prefetch input queue'', le processeur chargeait une instruction, la décodait et l'exécutait, puis chargeait la suivante, et ainsi de suite. Avec un tampon de préchargement, le processeur chargeait plusieurs instruction en une seule fois, puis les exécutait les unes après les autres. Avec la ''prefetch input queue'', pendant qu'une instruction est en cours de décodage/exécution, le processeur précharge l'instruction suivante. Si une instruction prend vraiment beaucoup de temps pour s'exécuter, le processeur peut en profiter pour précharger l'instruction encore suivante, et ainsi de suite, jusqu'à une limite de 4/6 instructions (la limite dépend du processeur).

La ''prefetch input queue'' permet de précharger l'instruction suivante à condition qu'aucun autre accès mémoire n'ait lieu. Si l'instruction en cours d'exécution effectue des accès mémoire, ceux-ci sont prioritaires sur tout le reste, le préchargement de l'instruction suivante est alors mis en pause ou inhibé. Par contre, si la mémoire n'est pas utilisée par l'instruction en cours d'exécution, le processeur lit l'instruction suivante en RAM et la copie dans la ''prefetch input queue''. En conséquence, il arrive que la ''prefetch input queue'' n'ait pas préchargé l'instruction suivante, alors que le décodeur d'instruction est prêt pour la décoder. Dans ce cas, le décodeur doit attendre que l'instruction soit chargée.

Les instructions préchargées dans la ''Prefetch input queue'' y attendent que le processeur les lise et les décode. Les instructions préchargées sont conservées dans leur ordre d'arrivée, afin qu'elles soient exécutées dans le bon ordre, ce qui fait que la ''Prefetch input queue'' est une mémoire de type FIFO. L'étape de décodage pioche l'instruction à décoder dans la ''Prefetch input queue'', cette instruction étant par définition la plus ancienne, puis la retire de la file.

Le premier processeur commercial grand public à utiliser une ''prefetch input queue'' était le 8086. Il pouvait précharger à l'avance 6 octets d’instruction. L'Intel 8088 avait lui aussi une ''Prefetch input queue'', mais qui ne permettait que de précharger 4 instructions. Le 386 avait une ''prefetch input queue'' de 16 octets. La taille idéale de la FIFO dépend de nombreux paramètres. On pourrait croire que plus elle peut contenir d'instructions, mieux c'est, mais ce n'est pas le cas, pour des raisons que nous allons expliquer dans quelques paragraphes.

[[File:80186 arch.png|centre|vignette|700px|upright=2|Architecture du 8086, du 80186 et de ses variantes.]]

Vous remarquerez que j'ai exprimé la capacité de la ''prefetch input queue'' en octets et non en instructions. La raison est que sur les processeurs x86, les instructions sont de taille variable, avec une taille qui varie entre un octet et 6 octets. Cependant, le décodage des instructions se fait un octet à la fois : le décodeur lit un octet, puis éventuellement le suivant, et ainsi de suite jusqu'à atteindre la fin de l'instruction. En clair, le décodeur lit les instructions longues octet par octet dans la ''Prefetch input queue''.

Les instructions varient entre 1 et 6 octets, mais tous ne sont pas utiles au décodeur d'instruction. Par exemple, le décodeur d'instruction n'a pas besoin d'analyser les constantes immédiates intégrées dans une instruction, ni les adresses mémoires en adressage absolu. Il n'a besoin que de deux octets : l'opcode et l'octet Mod/RM qui précise le mode d'adressage. Le second est facultatif. En clair, le décodeur a besoin de lire deux octets maximum depuis la ''prefetch input queue'', avant de passer à l’instruction suivante. Les autres octets étaient envoyés ailleurs, typiquement dans le chemin de données.

Par exemple, prenons le cas d'une addition entre le registre AX et une constante immédiate. L'instruction fait trois octets : un opcode suivie par une constante immédiate codée sur deux octets. L'opcode était envoyé au décodeur, mais pas la constante immédiate. Elle était lue octet par octet et mémorisée dans un registre temporaire placé en entrée de l'ALU. Idem avec les adresses immédiates, qui étaient envoyées dans un registre d’interfaçage mémoire sans passer par le décodeur d'instruction. Pour cela, la ''prefetch input queue'' était connectée au bus interne du processeur ! Le décodeur dispose d'une micro-opération pour lire un octet depuis la ''prefetch input queue'' et le copier ailleurs dans le chemin de données. Par exemple, l'instruction d'addition entre le registre AX et une constante immédiate était composée de quatre micro-opérations : une qui lisait le premier octet de la constante immédiate, une seconde pour le second, une troisième micro-opération qui commande l'ALU et fait le calcul. 

Le décodeur devait attendre que qu'un moins un octet soit disponible dans la ''Prefetch input queue'', pour le lire. Il lisait alors cet octet et déterminait s'il contenait une instruction complète ou non. Si c'est une instruction complète, il la décodait et l''exécutait, puis passait à l'instruction suivante. Sinon, il lit un second octet depuis la ''Prefetch input queue'' et relance le décodage. Là encore, le décodeur vérifie s'il a une instruction complète, et lit un troisième octet si besoin, puis rebelote avec un quatrième octet lu, etc.

Un circuit appelé le ''loader'' synchronisait le décodeur d'instruction et la ''Prefetch input queue''. Il fournissait deux bits : un premier bit pour indiquer que le premier octet d'une instruction était disponible dans la ''Prefetch input queue'', un second bit pour le second octet. Le ''loader'' recevait aussi des signaux de la part du décodeur d'instruction. Le signal ''Run Next Instruction'' entrainait la lecture d'une nouvelle instruction, d'un premier octet, qui était alors dépilé de la ''Prefetch input queue''. Le décodeur d'instruction pouvait aussi envoyer un signal ''Next-to-last (NXT)'', un cycle avant que l'instruction en cours ne termine. Le ''loader'' réagissait en préchargeant l'octet suivant. En clair, ce signal permettait de précharger l'instruction suivante avec un cycle d'avance, si celle-ci n'était pas déjà dans la ''Prefetch input queue''.

Le bus de données du 8086 faisait 16 bits, alors que celui du 8088 ne permettait que de lire un octet à la fois. Et cela avait un impact sur la ''prefetch input queue''. La ''prefetch input queue'' du 8088 était composée de 4 registres de 8 bits, avec un port d'écriture de 8 bits pour précharger les instructions octet par octet, et un port de lecture de 8 bits pour alimenter le décodeur. En clair, tout faisait 8 bits. Le 8086, lui utilisait des registres de 16 bits et un port d'écriture de 16 bits. le port de lecture restait de 8 bits, grâce à un multiplexeur sélectionnait l'octet adéquat dans un registre 16 bits. Sa ''prefetch input queue'' préchargeait les instructions par paquets de 2 octets, non octet par octet, alors que le décodeur consommait les instructions octet par octet. Il s’agissait donc d'une sorte d'intermédiaire entre ''prefetch input queue'' à la 8088 et tampon de préchargement.

Le 386 était dans un cas à part. C'était un processeur 32 bits, sa ''prefetch input queue'' contenait 4 registres de 32 bits, un port d'écriture de 32 bits. Mais il ne lisait pas les instructions octet par cotet. A la place, son décodeur d'instruction avait une entrée de 32 bits. Cependant, il gérait des instructions de 8 et 16 bits. Il fallait alors dépiler des instructions de 8, 16 et 32 bits dans la ''prefetch input queue''. De plus, les instructions préchargées n'étaient pas parfaitement alignées sur 32 bits : une instruction pouvait être à cheval sur deux registres 32 bits. Le processeur incorporait donc des circuits d'alignement, semblables à ceux utilisés pour gérer des instructions de longueur variable avec un registre d'instruction.

Les branchements posent des problèmes avec la ''prefetch input queue'' : à cause d'eux, on peut charger à l'avance des instructions qui sont zappées par un branchement et ne sont pas censées être exécutées. Si un branchement est chargé, toutes les instructions préchargées après sont potentiellement invalides. Si le branchement est non-pris, les instructions chargées sont valides, elles sont censées s’exécuter. Mais si le branchement est pris, elles ont été chargées à tort et ne doivent pas s’exécuter. 

Pour éviter cela, la ''prefetch input queue'' est vidée quand le processeur détecte un branchement. Pour cela, le décodeur d'instruction dispose d'une micro-opération qui vide la ''Prefetch input queue'', elle invalide les instructions préchargées.  Cette détection ne peut se faire qu'une fois le branchement décodé, qu'une fois que l'on sait que l'instruction décodée est un branchement. En clair, le décodeur invalide la ''Prefetch input queue'' quand il détecte un branchement. Les interruptions posent le même genre de problèmes. Il faut impérativement vider la ''Prefetch input queue'' quand une interruption survient, avant de la traiter.

Il faut noter qu'une ''Prefetch input queue'' interagit assez mal avec le ''program counter''. En effet, la ''Prefetch input queue'' précharge les instructions séquentiellement. Pour savoir où elle en est rendue, elle mémorise l'adresse de la prochaine instruction à charger dans un '''registre de préchargement''' dédié. Il serait possible d'utiliser un ''program counter'' en plus du registre de préchargement, mais ce n'est pas la solution qui a été utilisée. Les processeurs Intel anciens ont préféré n'utiliser qu'un seul registre de préchargement en remplacement du ''program counter''. Après tout, le registre de préchargement n'est qu'un ''program counter'' ayant pris une avance de quelques cycles d'horloge, qui a été incrémenté en avance.

Et cela ne pose pas de problèmes, sauf avec certains branchements. Par exemple, certains branchements relatifs demandent de connaitre la véritable valeur du ''program counter'', pas celle calculée en avance. Idem avec les instructions d'appel de fonction, qui demandent de sauvegarder l'adresse de retour exacte, donc le vrai ''program counter''. De telles situations demandent de connaitre la valeur réelle du ''program counter'', celle sans préchargement. Pour cela, le décodeur d'instruction dispose d'une instruction pour reconstituer le ''program counter'', à savoir corriger le ''program coutner'' et éliminer l'effet du préchargement.

La micro-opération de correction se contente de soustraire le nombre d'octets préchargés au registre de préchargement. Le nombre d'octets préchargés est déduit à partir des deux pointeurs intégré à la FIFO, qui indiquent la position du premier et du dernier octet préchargé. Le bit qui indique si la FIFO est vide était aussi utilisé. Les deux pointeurs sont lus depuis la FIFO, et sont envoyés à un circuit qui détermine le nombre d'octets préchargés. Sur le 8086, ce circuit était implémenté non pas par un circuit combinatoire, mais par une mémoire ROM équivalente. La petite taille de la FIFO faisait que les pointeurs étaient très petits et la ROM l'était aussi.

Un autre défaut est que la ''Prefetch input queue'' se marie assez mal avec du code auto-modifiant. Un code auto-modifiant est un programme qui se modifie lui-même, en remplaçant certaines instructions par d'autres, en en retirant, en en ajoutant, lors de sa propre exécution. De tels programmes sont rares, mais la technique était utilisée dans quelques cas au tout début de l'informatique sur des ordinateurs rudimentaires. Ceux-ci avaient des modes d'adressages tellement limités que gérer des tableaux de taille variable demandait d'utiliser du code auto-modifiant pour écrire des boucles.

Le problème avec la ''Prefetch input queue'' survient quand des instructions sont modifiées immédiatement après avoir été préchargées. Les instructions dans la ''Prefetch input queue'' sont l'ancienne version, alors que la mémoire RAM contient les instructions modifiées. Gérer ce genre de cas est quelque peu complexe. Il faut en effet vider la ''Prefetch input queue'' si le cas arrive, ce qui demande d'identifier les écritures qui écrasent des instructions préchargées. C'est parfaitement possible, mais demande de transformer la ''Prefetch input queue'' en une mémoire hybride, à la fois mémoire associative et mémoire FIFO. Cela ne vaut que très rarement le coup, aussi les ingénieurs ne s’embêtent pas à mettre ce correctif en place, le code automodifiant est alors buggé.

Le décodeur d'instruction dispose aussi d'une micro-opération qui stoppe le préchargement des instructions dans la ''Prefetch input queue''.

: Pour ceux qui ont déjà lu un cours d'architecture des ordinateurs, la relation entre ''prefetch input queue'' et pipeline est quelque peu complexe. En apparence, la ''prefetch input queue'' permet une certaines forme de pipeline, en chargeant une instruction pendant que la précédente s'exécute. Les problématiques liées aux branchements ressemblent beaucoup à celles de la prédiction de branchement. Cependant, il est possible de dire qu'il s'agit plus d'une technique de préchargement que de pipeline. La différence entre les deux est assez subtile et les frontières sont assez floues, mais le fait est que l'instruction en cours d'exécution et le préchargement peuvent tout deux faire des accès mémoire et que l'instruction en cours a la priorité. Un vrai pipeline se débrouillerait avec une architecture Harvard, non avec un bus mémoire unique pour le chargement des instruction et la lecture/écriture des données.

===Le ''Zero-overhead looping''===

Nous avions vu dans le chapitre sur les instructions machines, qu'il existe des instructions qui permettent de grandement faciliter l'implémentation des boucles. Il s'agit de l'instruction REPEAT, utilisée sur certains processeurs de traitement de signal. Elle répète l'instruction suivante, voire une série d'instructions, un certain nombre de fois. Le nombre de répétitions est mémorisé dans un registre décrémenté à chaque itération de la boucle. Elle permet donc d'implémenter une boucle FOR facilement, sans recourir à des branchements ou des conditions.

Une technique en lien avec cette instruction permet de grandement améliorer les performances et la consommation d'énergie. L'idée est de mémoriser la boucle, les instructions à répéter, dans une petite mémoire cache située entre l'unité de chargement et le séquenceur. Le cache en question s'appelle un '''tampon de boucle''', ou encore un ''hardware loop buffer''. Grâce à lui, il n'y a pas besoin de charger les instructions à chaque fois qu'on les exécute, on les charge une bonne fois pour toute : c'est plus rapide. Bien sûr, il ne fonctionne que pour de petites boucles, mais il en est de même avec l'instruction REPEAT.

&lt;noinclude&gt;
{{NavChapitre | book=Fonctionnement d'un ordinateur
           | prev=Le chemin de données
           | prevText=Le chemin de données
           | next=L'unité de contrôle
           | nextText=L'unité de contrôle
}}
&lt;/noinclude&gt;</text>
      <sha1>lu50g3obx7oh5kyy3scsfhc3vbbasyv</sha1>
    </revision>
    <revision>
      <id>744095</id>
      <parentid>744094</parentid>
      <timestamp>2025-06-03T20:46:32Z</timestamp>
      <contributor>
        <username>Mewtow</username>
        <id>31375</id>
      </contributor>
      <minor />
      <comment>/* La prefetch input queue */</comment>
      <origin>744095</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="48441" sha1="2j2c0fl62nn1m9v81aqg2ixu2g94m57" xml:space="preserve">L'unité de contrôle s'occupe du chargement des instructions et de leur interprétation, leur décodage. Elle contient deux circuits : l''''unité de chargement''' qui charge l'instruction depuis la mémoire, et le '''séquenceur''' qui commande le chemin de données. Les deux circuits sont séparés, mais ils communiquent entre eux, notamment pour gérer les branchements. Dans ce chapitre, nous allons nous intéresser au chargement d'une instruction depuis la RAM/ROM, nous verrons l'étape de décodage de l'instruction au prochain chapitre.

==Le chargement d'une instruction==

[[File:Étape de chargement.png|vignette|upright=1|Étape de chargement.]]

L'étape de chargement (ou ''fetch'') doit faire deux choses : mettre à jour le ''program counter'' et lire l'instruction en mémoire RAM ou en ROM. Les deux étapes peuvent être faites en parallèle, dans des circuits séparés. Pendant que l'instruction est lue depuis la mémoire RAM/ROM, le ''program counter'' est incrémenté et/ou altéré par un branchement.

Pour lire l'instruction, on envoie le ''program counter'' sur le bus d'adresse et on récupère l'instruction sur le bus de données pour l'envoyer sur l'entrée du séquenceur. Et cela demande de connecter le séquenceur au bus mémoire, à travers l'interface mémoire. Et sur ce point, la situation est différente selon que l'on parler d'une architecture Harvard ou Von Neumann.

===Les interconnexions entre séquenceur et bus mémoire===

Sur les architectures Harvard, le séquenceur et le chemin de donnée utilisent des interfaces mémoire séparées. Le séquenceur est directement relié au bus mémoire de la ROM, alors que le chemin de données est connecté à la RAM.

[[File:Microarchitecture de l'interface mémoire d'une architecture Harvard.png|centre|vignette|upright=2|Microarchitecture de l'interface mémoire d'une architecture Harvard]]

Mais sur les architectures Von-Neumann et affiliées, le séquenceur et le chemin de donnée partagent la même interface mémoire. Et cela pose deux problèmes.

Le premier problème est que le bus mémoire doit être libéré une fois l'instruction chargée, pour un éventuel accès mémoire. Mais le séquenceur doit conserver une copie de l'instruction chargée, sans quoi il ne peut pas décoder l'instruction correctement. Par exemple, si l'instruction met plusieurs cycles à s'exécuter, le séquenceur doit conserver une copie de l'instruction durant ces plusieurs cycles. La solution à ce problème est un '''registre d'instruction''' situé juste avant le séquenceur, qui mémorise l'instruction chargée.

[[File:Registre d'instruction.png|centre|vignette|upright=2|Registre d'instruction.]]

Le second problème est de gérer le flot des instructions/données entre le bus mémoire, le chemin de données et le séquenceur. Le processeur doit connecter l'interface mémoire soit au séquenceur, soit au chemin de données et cela complique le réseau d'interconnexion interne au processeur.

Une première solution utilise un bus unique qui relie l'interface mémoire, le séquenceur et le chemin de données. Pour charger une instruction, le séquenceur copie le ''program counter'' sur le bus d'adresse, attend que l'instruction lue soit disponible sur le bus de données, puis la copie dans le registre d'instruction. Le bus mémoire est alors libre et peut être utilisé pour lire ou écrire des données, si le besoin s'en fait sentir.

Il faut noter que l'usage d'un bus unique a un impact sur l'organisation interne du chemin de données. Par exemple, le chapitre précédent nous a montré comment implémenter un chemin de données basique, avec des multiplexeurs et démultiplexeurs. Et bien ces chemins de données ne marchent pas vraiment avec un bus interne unique. Il est possible de les adapter, mais au prix d'une complexité largement supérieure. Un bus interne unique marche mieux quand le banc de registre est mono-port. C'est pourquoi il a été utilisé sur d'anciennes architectures appelées des architectures à accumulateur et à pile, que nous verrons dans quelques chapitres, qui utilisaient un banc de registre mono-port.

[[File:Microarchitecture de l'interface mémoire d'une architecture von neumann.png|centre|vignette|upright=2|Microarchitecture de l'interface mémoire d'une architecture von neumann]]

Une autre solution utilise deux bus interne séparés : un connecté au bus d'adresse, l'autre au bus de données. Le ''program counter'' est alors connecté au bus interne d'adresse, le séquenceur est relié au bus interne de données. Notons que la technique marche bien si le ''program counter'' est dans le banc de registre : les interconnexions utilisées pour gérer l'adressage indirect permettent d'envoyer le ''program counter'' sur le bus d'adresse sans ajout de circuit.

Le tout peut être amélioré en remplaçant les deux bus par des multiplexeurs et démultiplexeurs. Le bus d'adresse est précédé par un multiplexeur, qui permet de faire le choix entre ''Program Counter'', adresse venant du chemin de données, ou adresse provenant du séquenceur (adressage absolu). De même, le bus de données est suivi par un démultiplexeur qui envoie la donnée/instruction lue soit au registre d'instruction, soit au chemin de données. Le tout se marie très bien avec les chemins de donnée vu dans le chapitre précédent. Au passage, il faut noter que cette solution nécessite un banc de registre multi-port.

[[File:Connexion du program counter sur les bus avec PC isolé.png|centre|vignette|upright=2|Connexion du program counter sur les bus avec PC isolé]]

===Le chargement des instructions de longueur variable===

Le chargement des instructions de longueur variable pose de nombreux problèmes. Le premier est que mettre à jour le ''program counter'' demande de connaitre la longueur de l'instruction chargée, pour l'ajouter au ''program counter''. Si la longueur d'une instruction est variable, on doit connaitre cette longueur d'une manière où d'une autre. La solution la plus simple indique la longueur de l'instruction dans une partie de l'opcode ou de la représentation en binaire de l'instruction. Mais les processeurs haute performance de nos PC utilisent d'autres solutions, qui n'encodent pas explicitement la taille de l'instruction.

Les processeurs récents utilisent un registre d'instruction de grande taille, capable de mémoriser l'instruction la plus longue du processeur. Par exemple, si un processeur supporte des instructions allant de 1 à 8 octets, comme les CPU x86, le registre d'instruction fera 8 octets. Le décodeur d'instruction vérifie à chaque cycle le contenu du registre d'instruction. Si une instruction est détectée dedans, son décodage commence, peu importe la taille de l'instruction. Une fois l'instruction exécutée, elle est retirée du registre d'instruction. Reste à alimenter le registre d'instruction, à charger des instructions dedans. Et pour cela deux solutions : soit on charge l'instruction en plusieurs fois, soit d'un seul coup.

La solution la plus simple charge les instructions par mots de 8, 16, 32, 64 bits. Ils sont accumulés dans le registre d'instruction jusqu'à détecter une instruction complète. La technique marche nettement mieux si les instructions sont très longues. Par exemple, les CPU x86 ont des instructions qui vont de 1 à 15 octets, ce qui fait qu'ils utilisent cette technique. Précisément, elle marche si les instructions les plus longues sont plus grandes que le bus mémoire.

Une autre solution charge un bloc de mots mémoire aussi grand que la plus grande instruction. Par exemple, si le processeur gère des instructions allant de 1 à 4 octets, il charge 4 octets d'un seul coup dans le registre d'instruction. Il va de soit que cette solution ne marche que si les instructions du processeur sont assez courtes, au plus aussi courtes que le bus mémoire. Ainsi, on est sûr de charger obligatoirement au moins une instruction complète, et peut-être même plusieurs. Le contenu du registre d'instruction est alors découpé en instructions au fil de l'eau. 

Utiliser un registre d'instruction large pose problème avec des instructions à cheval entre deux blocs. Il se peut qu'on n'ait pas une instruction complète lorsque l'on arrive à la fin du bloc, mais seulement un morceau. Le problème se manifeste peu importe que l'instruction soit chargée d'un seul coup ou bien en plusieurs fois.

[[File:Instructions non alignées.png|centre|vignette|upright=2|Instructions non alignées.]]

Dans ce cas, on doit décaler le morceau de bloc pour le mettre au bon endroit (au début du registre d'instruction), et charger le prochain bloc juste à côté. On a donc besoin d'un circuit qui décale tous les bits du registre d'instruction, couplé à un circuit qui décide où placer dans le registre d'instruction ce qui a été chargé, avec quelques circuits autour pour configurer les deux circuits précédents.

[[File:Décaleur d’instruction.png|centre|vignette|upright=2|Décaleur d’instruction.]]

Une autre solution se passe de registre d'instruction en utilisant à la place l'état interne du séquenceur. Là encore, elle charge l'instruction morceau par morceau, typiquement par blocs de 8, 16 ou 32 bits. Les morceaux ne sont pas accumulés dans le registre d'instruction, la solution utilise à la place l'état interne du séquenceur. Les mots mémoire de l'instruction sont chargés à chaque cycle, faisant passer le séquenceur d'un état interne à un autre à chaque mot mémoire. Tant qu'il n'a pas reçu tous les mots mémoire de l'instruction, chaque mot mémoire non terminal le fera passer d'un état interne à un autre, chaque état interne encodant les mots mémoire chargés auparavant. S'il tombe sur le dernier mot mémoire d'une instruction, il rentre dans un état de décodage.

==L'incrémentation du ''program counter''==

À chaque chargement, le ''program counter'' est mis à jour afin de pointer sur la prochaine instruction à charger. Sur la quasi-totalité des processeurs, les instructions sont placées dans l'ordre d’exécution dans la RAM. En faisant ainsi, on peut mettre à jour le ''program counter'' en lui ajoutant la longueur de l'instruction courante. Déterminer la longueur de l'instruction est simple quand les instructions ont toutes la même taille, mais certains processeurs ont des instructions de taille variable, ce qui complique le calcul. Dans ce qui va suivre, nous allons supposer que les instructions sont de taille fixe, ce qui fait que le ''program counter'' est toujours incrémenté de la même valeur.

Il existe deux méthodes principales pour incrémenter le ''program counter'' : soit le ''program counter'' a son propre additionneur, soit le ''program counter'' est mis à jour par l'ALU. Pour ce qui est de l'organisation des registres, soit le ''program counter'' est un registre séparé des autres, soit il est regroupé avec d'autres registres dans un banc de registre. En tout, cela donne quatre organisations possibles.
* Un ''program counter'' séparé relié à un incrémenteur séparé.
* Un ''program counter'' séparé des autres registres, incrémenté par l'ALU.
* Un ''program counter'' intégré au banc de registre, relié à un incrémenteur séparé.
* Un ''program counter'' intégré au banc de registre, incrémenté par l'ALU.

[[File:Calcul du program counter.png|centre|vignette|upright=2|les différentes méthodes de calcul du program counter.]]

Les processeurs haute performance modernes utilisent tous la première méthode. Les autres méthodes étaient surtout utilisées sur les processeurs 8 ou 16 bits, elles sont encore utilisées sur quelques microcontrôleurs de faible puissance. Nous auront l'occasion de donner des exemples quand nous parlerons des processeurs 8 bits anciens, dans le chapitre sur les architectures à accumulateur et affiliées.

===Le ''program counter'' mis à jour par l'ALU===

Sur certains processeurs, le calcul de l'adresse de la prochaine instruction est effectué par l'ALU. L'avantage de cette méthode est qu'elle économise un incrémenteur dédié au ''program counter''. Ce qui explique que cette méthode était utilisée sur les processeurs assez anciens, à une époque où un additionneur pouvait facilement prendre 10 à 20% des transistors disponibles. Le désavantage principal est une augmentation de la complexité du séquenceur, qui doit gérer la mise à jour du ''program counter''. De plus, la mise à jour du ''program counter'' ne peut pas se faire en même temps qu'une opération arithmétique, ce qui réduit les performances.

Si on incrémente le ''program counter'' avec l'ALU, il est intéressant de le placer dans le banc de registres. Un désavantage est qu'on perd un registre. Par exemple, avec un banc de registre de 16 registres, on ne peut adresser que 15 registres généraux. De plus ce n'est pas l'idéal pour le décodage des instructions et pour le séquenceur. Si le processeur dispose de plusieurs bancs de registres, le ''program counter'' est généralement placé dans le banc de registre dédié aux adresses. Sinon, il est placé avec les nombres entiers/adresses.

D'anciens processeurs incrémentaient le ''program counter'' avec l'ALU, mais utilisaient bien un registre séparé pour le ''program counter''. Cette méthode est relativement simple à implémenter : il suffit de connecter/déconnecter le ''program counter'' du bus interne suivant les besoins. Le ''program counter'' est déconnecté pendant l’exécution d'une instruction, il est connecté au bus interne pour l'incrémenter. C'est le séquenceur qui gère le tout. L'avantage de cette séparation est qu'elle est plus facile à gérer pour le séquenceur. De plus, on gagne un registre général/entier dans le banc de registre.

===Le compteur programme===

Dans la quasi-totalité des processeurs modernes, le ''program counter'' est un vulgaire compteur comme on en a vu dans les chapitres sur les circuits, ce qui fait qu'il passe automatiquement d'une adresse à la suivante. Dans ce qui suit, nous allons appeler ce registre compteur : le '''compteur ordinal'''. L'usage d'un compteur simplifie fortement la conception du séquenceur. Le séquenceur n'a pas à gérer la mise à jour du ''program counter'', sauf en cas de branchements. De plus, il est possible d'incrémenter le ''program counter'' pendant que l'unité de calcul effectue une opération arithmétique, ce qui améliore grandement les performances. Le seul désavantage est qu'elle demande d'ajouter un incrémenteur dédié au ''program counter''.

Sur les processeurs très anciens, les instructions faisaient toutes un seul mot mémoire et le compteur ordinal était un circuit incrémenteur des plus basique. Sur les processeurs modernes, le compteur est incrémenté par pas de 4 si les instructions sont codées sur 4 octets, 8 si les instructions sont codées sur 8 octets, etc. Concrètement, le compteur est un circuit incrémenteur auquel on aurait retiré quelques bits de poids faible. Par exemple, si les instructions sont codées sur 4 octets, on coupe les 2 derniers bits du compteur. Si les instructions sont codées sur 8 octets, on coupe les 3 derniers bits du compteur. Et ainsi de suite.

Il a existé quelques processeurs pour lesquelles le ''program counter'' était non pas un compteur binaire classique, mais un ''linear feedback shift register''. L'avantage est que le circuit d'incrémentation utilisait bien moins de portes logiques, l'économie était substantielle. Mais un défaut est que des instructions consécutives dans le programme n'étaient pas consécutives en mémoire. Il existait cependant une table de correspondance pour dire : la première instruction est à telle adresse, la seconde à telle autre, etc. Un exemple de processeur de ce type est le TMS 1000 de Texas Instrument, un des premiers microcontrôleur 4 bits datant des années 70.

Une amélioration de la solution précédente utilise un circuit incrémenteur partagé entre le ''program counter'' et d'autres registres. L'incrémenteur est utilisé pour incrémenter le ''program counter'', mais aussi pour effectuer d'autres calculs d'adresse. Par exemple, sur les architectures avec une pile d'adresse de retour, il est possible de partager l'incrémenteur/décrémenteur avec le pointeur de pile ( la technique ne marche pas avec une pile d'appel). Un autre exemple est celui des processeurs qui gèrent automatiquement le rafraichissement mémoire, grâce à, un compteur intégré dans le processeur. Il est possible de partager l'incrémenteur du ''program counter'' avec le compteur de rafraichissement mémoire, qui mémorise la prochaine adresse mémoire à rafraichir. Nous avions déjà abordé ce genre de partage dans le chapitre sur le chemin de données, dans l'annexe sur le pointeur de pile, mais nous verrons d'autres exemples dans le chapitre sur les architectures hybride accumulateur-registre 8/16 bits.

===Quand est mis à jour le ''program counter'' ?===

Le ''program counter'' est mis à jour quand il faut charger une nouvelle instruction. Reste qu'il faut savoir quand le mettre à jour. Incrémenter le ''program counter'' à intervalle régulier, par exemple à chaque cycle d’horloge, fonctionne sur les processeurs où toutes les instructions mettent le même temps pour s’exécuter. Mais de tels processeurs sont très rares. Sur la quasi-totalité des processeurs, les instructions ont une durée d’exécution variable, elles ne prennent pas le même nombre de cycle d'horloge pour s’exécuter. Le temps d’exécution d'une instruction varie selon l'instruction, certaines sont plus longues que d'autres. Tout cela amène un problème : comment incrémenter le ''program counter'' avec des instructions avec des temps d’exécution variables ?

La réponse est que la mise à jour du ''program counter'' démarre quand l'instruction précédente a terminée de s’exécuter, plus précisément un cycle avant. C'est un cycle avant pour que l'instruction chargée soit disponible au prochain cycle pour le décodeur. Pour cela, le séquenceur doit déterminer quand l'instruction est terminée et prévenir le ''program counter'' au bon moment. Il faut donc une interaction entre séquenceur et circuit de chargement. Le circuit de chargement contient une entrée Enable, qui autorise la mise à jour du ''program counter''. Le séquenceur met à 1 cette entrée pour prévenir au ''program counter'' qu'il doit être incrémenté au cycle suivant ou lors du cycle courant. Cela permet de gérer simplement le cas des instructions multicycles. 

[[File:Commande de la mise à jour du program counter.png|centre|vignette|upright=2|Commande de la mise à jour du program counter.]]

Toute la difficulté est alors reportée dans le séquenceur, qui doit déterminer la durée d'une instruction. Pour gérer la mise à jour du ''program counter'', le séquenceur doit déterminer la durée d'une instruction. Cela est simple pour les instructions arithmétiques et logiques, qui ont un nombre de cycles fixe, toujours le même. Une fois l'instruction identifiée par le séquenceur, il connait son nombre de cycles et peut programmer un compteur interne au séquenceur, qui compte le nombre de cycles de l'instruction, et fournit le signal Enable au ''program counter''. Mais cette technique ne marche pas vraiment pour les accès mémoire, dont la durée n'est pas connue à l'avance, surtout sur les processeurs avec des mémoires caches. Pour cela, le séquenceur détermine quand l'instruction mémoire est finie et prévient le ''program counter'' quand c'est le cas.

Il existe quelques processeurs pour lesquels le temps de calcul dépend des opérandes de l'instruction. On peut par exemple avoir une division qui prend 10 cycles avec certaines opérandes, mais 40 cycles avec d'autres opérandes. Mais ces processeurs sont rares et cela est surtout valable pour les opérations de multiplication/division, guère plus. Le problème est alors le même qu'avec les accès mémoire et la solution est la même : l'ALU prévient le séquenceur quand le résultat est disponible.

==Les branchements et le ''program counter''==

Un branchement consiste juste à écrire l'adresse de destination dans le ''program counter''. L'implémentation des branchements demande d'extraire l'adresse de destination et d'altérer le ''program counter'' quand un branchement est détecté. Pour cela, le décodeur d'instruction détecte si l'instruction exécutée est un branchement ou non, et il en déduit où trouver l'adresse de destination.

L'adresse de destination se trouve à un endroit qui dépend du mode d'adressage du branchement. Pour rappel, on distingue quatre modes d'adressage pour les branchements : direct, indirect, relatif et implicite. Pour les branchements directs, l'adresse est intégrée dans l'instruction de branchement elle-même et est extraite par le séquenceur. Pour les branchements indirects, l'adresse de destination est dans le banc de registre. Pour les branchements relatifs, il faut ajouter un décalage au ''program counter'', décalage extrait de l'instruction par le séquenceur. Enfin, les instructions de retour de fonction lisent l'adresse de destination depuis la pile. L'implémentation de ces quatre types de branchements est très différente.

L'altération du ''program counter'' dépend de si le ''program counter'' est dans un compteur séparé ou s'il est dans le banc de registre. Nous avons vu plus haut qu'il y a quatre cas différents, mais nous n'allons voir que deux cas : celui où le ''program counter'' est dans le banc de registre et est incrémenté par l'unité de calcul, celui avec un ''program counter'' séparé avec son propre incrémenteur. Les deux autres cas ne sont utilisés que sur des architectures à accumulateur ou à pile spécifiques, que nous n'avons pas encore vu à ce stade du cours et que nous verrons en temps voulu dans le chapitre sur ces architectures.

===L’implémentation des branchements avec un ''program counter'' intégré au banc de registres===

Le cas le plus simple est celui où le ''program counter'' est intégré au banc de registre, avec une incrémentation faite par l'unité de calcul. Charger une instruction revient alors à effectuer une instruction LOAD en adressage indirect, à deux différences près : le registre sélectionné est le ''program counter'', l’instruction est copiée dans le registre d'instruction et non dans le banc de registre. L'incrémentation du ''porgram counter'' est implémenté avec des micro-opérations qui agissent sur le chemin de données, au même titre que les branchements indirects, relatifs et directs.
* Les branchements indirects copient un registre dans le ''program counter'', ce qui revient simplement à faire une opération MOV entre deux registres, dont le ''program counter'' est la destination.
* L'opération inverse d'un branchement indirect, qui copie le ''program counter'' dans un registre général, est utile pour sauvegarder l'adresse de retour d'une fonction.
* Les branchements directs copient une adresse dans le ''program counter'', ce qui les rend équivalents à une opération MOV avec une constante immédiate, dont le ''program counter'' est la destination.
* Les branchements relatifs sont une opération arithmétique entre le ''program counter'' et un opérande en adressage immédiat.

En clair, à partir du moment où le chemin de données supporte les instructions MOV et l'addition, avec les modes d'adressage adéquat, il supporte les branchements. Aucune modification du chemin de données n'est nécessaire, le séquenceur gére le chargement d'une instruction avec les micro-instructions adéquates : une micro-opération ADD pour incrémenter le ''program counter'', une micro-opération LOAD pour le chargement de l'instruction.

Notons que sur certaines architectures, le ''program counter'' est adressable au même titre que les autres registres du banc de registre. Les instructions de branchement sont alors remplacées par des instructions MOV ou des instructions arithmétique équivalentes, comme décrit plus haut.

===L’implémentation des branchements avec un ''program counter'' séparé===

Étudions maintenant le cas où le ''program counter'' est dans un registre/compteur séparé. Rappelons que tout compteur digne de ce nom possède une entrée de réinitialisation, qui remet le compteur à zéro. De plus, on peut préciser à quelle valeur il doit être réinitialisé. Ici, la valeur à laquelle on veut réinitialiser le compteur n'est autre que l'adresse de destination du branchement. Implémenter un branchement est donc simple : l'entrée de réinitialisation est commandée par le circuit de détection des branchements, alors que la valeur de réinitialisation est envoyée sur l'entrée adéquate. En clair, nous partons du principe que le ''program counter'' est implémenté avec ce type de compteur :

[[File:Fonctionnement d'un compteur (décompteur), schématique.jpg|centre|vignette|upright=1.5|Fonctionnement d'un compteur (décompteur), schématique]]

Toute la difficulté est de présenter l'adresse de destination au ''program counter''. Pour les branchements directs, l'adresse de destination est fournie par le séquenceur. L'adresse de destination du branchement sort du séquenceur et est présentée au ''program counter'' sur l'entrée adéquate. Voici donc comment sont implémentés les branchements directs avec un ''program counter'' séparé du banc de registres. Le schéma ci-dessous marche peu importe que le ''program counter'' soit incrémenté par l'ALU ou par un additionneur dédié.

[[File:Unité de détection des branchements dans le décodeur.png|centre|vignette|upright=2|Unité de détection des branchements dans le décodeur]]

Les branchements relatifs sont ceux qui font sauter X instructions plus loin dans le programme. Leur implémentation demande d'ajouter une constante au ''program counter'', la constante étant fournie dans l’instruction. Là encore, deux solutions sont possibles : réutiliser l'ALU pour calculer l'adresse, ou utiliser un additionneur séparé. L'additionneur séparé peut être fusionné avec l'additionneur qui incrémente le ''program counter'' pour passer à l’instruction suivante.

[[File:Unité de chargement qui gère les branchements relatifs.png|centre|vignette|upright=2|Unité de chargement qui gère les branchements relatifs.]]

Pour les branchements indirects, il suffit de lire le registre voulu et d'envoyer le tout sur l'entrée adéquate du ''program counter''. Il faut alors rajouter un multiplexeur pour que l'entrée de réinitialisationr ecoive la bonne adresse de destination.

[[File:Unité de chargement qui gère les branchements directs.png|centre|vignette|upright=2|Unité de chargement qui gère les branchements directs et indirects.]]

Toute la difficulté de l'implémentation des branchements est de configurer les multiplexeurs, ce qui est réalisé par le séquenceur en fonction du mode d'adressage du branchement.

==Les optimisations du chargement des instructions==

Charger une instruction est techniquement une forme d'accès mémoire un peu particulier. En clair, charger une instruction prend au minimum un cycle d'horloge, et cela peut rapidement monter à 3-5 cycles, si ce n'est plus. L'exécution des instructions est alors fortement ralentit par la mémoire. Par exemple, imaginez que la mémoire mette 3 cycles d'horloges pour charger une instruction, alors qu'une instruction s’exécute en 1 cycle (si les opérandes sont dans les registres). La perte de performance liée au chargement des instructions est alors substantielle. Heureusement, il est possible de limiter la casse en utilisant des mémoires caches, ainsi que d'autres optimisations, que nous allons voir dans ce qui suit.

===Le tampon de préchargement===

La technique dite du '''préchargement''' est utilisée dans le cas où la mémoire a un temps d'accès important. Mais si la latence de la RAM est un problème, le débit ne l'est pas. Il est possible d'avoir une RAM lente, mais à fort débit. Par exemple, supposons que la mémoire puisse charger 4 instructions (de taille fixe) en 3 cycles. Le processeur peut alors charger 4 instructions en un seul accès mémoire, et les exécuter l'une après l'autre, une par cycle d'horloge. Les temps d'attente sont éliminés : le processeur peut décoder une nouvelle instruction à chaque cycle. Et quand la dernière instruction préchargée est exécutée, la mémoire est de nouveau libre, ce qui masque la latence des accès mémoire.

[[File:Tampon de préchargement d'instruction.png|vignette|Tampon de préchargement d'instruction]]

La seule contrainte est de mettre les instructions préchargées en attente. La solution pour cela est d'utiliser un registre d'instruction très large, capable de mémoriser plusieurs instructions à la fois. Ce registre est de plus connecté à un multiplexeur qui permet de sélectionner l'instruction adéquate dans ce registre. Ce multiplexeur est commandé par le ''program counter'' et quelques circuits annexes. Ce super-registre d'instruction est appelé un '''tampon de préchargement'''.

La méthode a une implémentation nettement plus simple avec des instructions de taille fixe, alignées en mémoire. La commande du multiplexeur de sélection de l'instruction est alors beaucoup plus simple : il suffit d'utiliser les bits de poids fort du ''program counter''. Par exemple, prenons le cas d'un registre d'instruction de 32 octets pour des instructions de 4 octets, soit 8 instructions. Le choix de l'instruction à sélectionner se fait en utilisant les 3 bits de poids faible du ''program counter''. 

Mais cette méthode ajoute de nouvelles contraintes d'alignement, similaires à celles vues dans le chapitre sur l'alignement et le boutisme, sauf que l'alignement porte ici sur des blocs d'instructions de même taille que le tampon de préchargement. Si on prend l'exemple d'un tampon de préchargement de 128 bits, les instructions devront être alignées par blocs de 128 bits. C'est à dire qu'idéalement, les fonctions et autres blocs de code isolés doivent commencer à des adresses multiples de 128, pour pouvoir charger un bloc d'instruction en une seule fois. Sans cela, les performances seront sous-optimales.

: Il arrive que le tampon de préchargement ait la même taille qu'une ligne de cache.

Lorsque l'on passe d'un bloc d'instruction à un autre, le tampon de préchargement est mis à jour. Par exemple, si on prend un tampon de préchargement de 4 instructions, on doit changer son contenu toutes les 4 instructions. La seule exception est l'exécution d'un branchement. En effet, lors d'un branchement, la destination du branchement n'est pas dans le tampon de préchargement et elle doit être chargée dedans (sauf si le branchement pointe vers une instruction très proche, ce qui est improbable). Pour cela, le tampon de préchargement est mis à jour précocement quand le processeur détecte un branchement.

Le même problème survient avec du code auto-modifiant. Un code auto-modifiant est un programme qui se modifie lui-même, en remplaçant certaines instructions par d'autres, en en retirant, en en ajoutant, lors de sa propre exécution. De tels programmes sont rares, mais la technique était utilisée dans quelques cas au tout début de l'informatique sur des ordinateurs rudimentaires. Ceux-ci avaient des modes d'adressages tellement limités que gérer des tableaux de taille variable demandait d'utiliser du code auto-modifiant pour écrire des boucles. Le problème survient quand des instructions sont modifiées immédiatement après avoir été préchargées. Les instructions dans le tampon de préchargement sont l'ancienne version, alors que la mémoire RAM contient les instructions modifiées. Gérer ce genre de cas demande de vider le tampon de préchargement si le cas arrive, mais ça ne vaut que très rarement le coup, aussi les ingénieurs ne s’embêtent pas à mettre ce correctif en place. Le code automodifiant est alors buggé.

===La ''prefetch input queue''===

La ''prefetch input queue'' est une sorte de cousine du tampon de préchargement, qui a été utilisée sur les processeurs Intel 8 et 16 bits, ainsi que sur le 286 et le 386. L'idée est là encore de précharger des instructions en avance. Sauf que cette fois-ci, on ne charge pas plusieurs instructions à la fois. Au contraire, les instructions sont préchargées séquentiellement, un ou deux octet à la fois. En conséquence, le tampon de préchargement est remplacé par une mémoire FIFO appelée la '''''Prefetch Input Queue''''', terme abrévié en PIQ. Les instructions sont accumulées une par une dans la PIQ, elles en sortent une par une au fur et à mesure pour alimenter le décodeur d'instruction.

Pendant que le processeur exécute une instruction, on précharge la suivante. Sans ''prefetch input queue'', le processeur chargeait une instruction, la décodait et l'exécutait, puis chargeait la suivante, et ainsi de suite. Avec un tampon de préchargement, le processeur chargeait plusieurs instruction en une seule fois, puis les exécutait les unes après les autres. Avec la ''prefetch input queue'', pendant qu'une instruction est en cours de décodage/exécution, le processeur précharge l'instruction suivante. Si une instruction prend vraiment beaucoup de temps pour s'exécuter, le processeur peut en profiter pour précharger l'instruction encore suivante, et ainsi de suite, jusqu'à une limite de 4/6 instructions (la limite dépend du processeur).

La ''prefetch input queue'' permet de précharger l'instruction suivante à condition qu'aucun autre accès mémoire n'ait lieu. Si l'instruction en cours d'exécution effectue des accès mémoire, ceux-ci sont prioritaires sur tout le reste, le préchargement de l'instruction suivante est alors mis en pause ou inhibé. Par contre, si la mémoire n'est pas utilisée par l'instruction en cours d'exécution, le processeur lit l'instruction suivante en RAM et la copie dans la ''prefetch input queue''. En conséquence, il arrive que la ''prefetch input queue'' n'ait pas préchargé l'instruction suivante, alors que le décodeur d'instruction est prêt pour la décoder. Dans ce cas, le décodeur doit attendre que l'instruction soit chargée.

Les instructions préchargées dans la ''Prefetch input queue'' y attendent que le processeur les lise et les décode. Les instructions préchargées sont conservées dans leur ordre d'arrivée, afin qu'elles soient exécutées dans le bon ordre, ce qui fait que la ''Prefetch input queue'' est une mémoire de type FIFO. L'étape de décodage pioche l'instruction à décoder dans la ''Prefetch input queue'', cette instruction étant par définition la plus ancienne, puis la retire de la file.

Le premier processeur commercial grand public à utiliser une ''prefetch input queue'' était le 8086. Il pouvait précharger à l'avance 6 octets d’instruction. L'Intel 8088 avait lui aussi une ''Prefetch input queue'', mais qui ne permettait que de précharger 4 instructions. Le 386 avait une ''prefetch input queue'' de 16 octets. La taille idéale de la FIFO dépend de nombreux paramètres. On pourrait croire que plus elle peut contenir d'instructions, mieux c'est, mais ce n'est pas le cas, pour des raisons que nous allons expliquer dans quelques paragraphes.

[[File:80186 arch.png|centre|vignette|700px|upright=2|Architecture du 8086, du 80186 et de ses variantes.]]

Vous remarquerez que j'ai exprimé la capacité de la ''prefetch input queue'' en octets et non en instructions. La raison est que sur les processeurs x86, les instructions sont de taille variable, avec une taille qui varie entre un octet et 6 octets. Cependant, le décodage des instructions se fait un octet à la fois : le décodeur lit un octet, puis éventuellement le suivant, et ainsi de suite jusqu'à atteindre la fin de l'instruction. En clair, le décodeur lit les instructions longues octet par octet dans la ''Prefetch input queue''.

Les instructions varient entre 1 et 6 octets, mais tous ne sont pas utiles au décodeur d'instruction. Par exemple, le décodeur d'instruction n'a pas besoin d'analyser les constantes immédiates intégrées dans une instruction, ni les adresses mémoires en adressage absolu. Il n'a besoin que de deux octets : l'opcode et l'octet Mod/RM qui précise le mode d'adressage. Le second est facultatif. En clair, le décodeur a besoin de lire deux octets maximum depuis la ''prefetch input queue'', avant de passer à l’instruction suivante. Les autres octets étaient envoyés ailleurs, typiquement dans le chemin de données.

Par exemple, prenons le cas d'une addition entre le registre AX et une constante immédiate. L'instruction fait trois octets : un opcode suivie par une constante immédiate codée sur deux octets. L'opcode était envoyé au décodeur, mais pas la constante immédiate. Elle était lue octet par octet et mémorisée dans un registre temporaire placé en entrée de l'ALU. Idem avec les adresses immédiates, qui étaient envoyées dans un registre d’interfaçage mémoire sans passer par le décodeur d'instruction. Pour cela, la ''prefetch input queue'' était connectée au bus interne du processeur ! Le décodeur dispose d'une micro-opération pour lire un octet depuis la ''prefetch input queue'' et le copier ailleurs dans le chemin de données. Par exemple, l'instruction d'addition entre le registre AX et une constante immédiate était composée de quatre micro-opérations : une qui lisait le premier octet de la constante immédiate, une seconde pour le second, une troisième micro-opération qui commande l'ALU et fait le calcul. 

Le décodeur devait attendre que qu'un moins un octet soit disponible dans la ''Prefetch input queue'', pour le lire. Il lisait alors cet octet et déterminait s'il contenait une instruction complète ou non. Si c'est une instruction complète, il la décodait et l''exécutait, puis passait à l'instruction suivante. Sinon, il lit un second octet depuis la ''Prefetch input queue'' et relance le décodage. Là encore, le décodeur vérifie s'il a une instruction complète, et lit un troisième octet si besoin, puis rebelote avec un quatrième octet lu, etc.

Un circuit appelé le ''loader'' synchronisait le décodeur d'instruction et la ''Prefetch input queue''. Il fournissait deux bits : un premier bit pour indiquer que le premier octet d'une instruction était disponible dans la ''Prefetch input queue'', un second bit pour le second octet. Le ''loader'' recevait aussi des signaux de la part du décodeur d'instruction. Le signal ''Run Next Instruction'' entrainait la lecture d'une nouvelle instruction, d'un premier octet, qui était alors dépilé de la ''Prefetch input queue''. Le décodeur d'instruction pouvait aussi envoyer un signal ''Next-to-last (NXT)'', un cycle avant que l'instruction en cours ne termine. Le ''loader'' réagissait en préchargeant l'octet suivant. En clair, ce signal permettait de précharger l'instruction suivante avec un cycle d'avance, si celle-ci n'était pas déjà dans la ''Prefetch input queue''.

Le bus de données du 8086 faisait 16 bits, alors que celui du 8088 ne permettait que de lire un octet à la fois. Et cela avait un impact sur la ''prefetch input queue''. La ''prefetch input queue'' du 8088 était composée de 4 registres de 8 bits, avec un port d'écriture de 8 bits pour précharger les instructions octet par octet, et un port de lecture de 8 bits pour alimenter le décodeur. En clair, tout faisait 8 bits. Le 8086, lui utilisait des registres de 16 bits et un port d'écriture de 16 bits. le port de lecture restait de 8 bits, grâce à un multiplexeur sélectionnait l'octet adéquat dans un registre 16 bits. Sa ''prefetch input queue'' préchargeait les instructions par paquets de 2 octets, non octet par octet, alors que le décodeur consommait les instructions octet par octet. Il s’agissait donc d'une sorte d'intermédiaire entre ''prefetch input queue'' à la 8088 et tampon de préchargement.

Le 386 était dans un cas à part. C'était un processeur 32 bits, sa ''prefetch input queue'' contenait 4 registres de 32 bits, un port d'écriture de 32 bits. Mais il ne lisait pas les instructions octet par cotet. A la place, son décodeur d'instruction avait une entrée de 32 bits. Cependant, il gérait des instructions de 8 et 16 bits. Il fallait alors dépiler des instructions de 8, 16 et 32 bits dans la ''prefetch input queue''. De plus, les instructions préchargées n'étaient pas parfaitement alignées sur 32 bits : une instruction pouvait être à cheval sur deux registres 32 bits. Le processeur incorporait donc des circuits d'alignement, semblables à ceux utilisés pour gérer des instructions de longueur variable avec un registre d'instruction.

Les branchements posent des problèmes avec la ''prefetch input queue'' : à cause d'eux, on peut charger à l'avance des instructions qui sont zappées par un branchement et ne sont pas censées être exécutées. Si un branchement est chargé, toutes les instructions préchargées après sont potentiellement invalides. Si le branchement est non-pris, les instructions chargées sont valides, elles sont censées s’exécuter. Mais si le branchement est pris, elles ont été chargées à tort et ne doivent pas s’exécuter. 

Pour éviter cela, la ''prefetch input queue'' est vidée quand le processeur détecte un branchement. Pour cela, le décodeur d'instruction dispose d'une micro-opération qui vide la ''Prefetch input queue'', elle invalide les instructions préchargées.  Cette détection ne peut se faire qu'une fois le branchement décodé, qu'une fois que l'on sait que l'instruction décodée est un branchement. En clair, le décodeur invalide la ''Prefetch input queue'' quand il détecte un branchement. Les interruptions posent le même genre de problèmes. Il faut impérativement vider la ''Prefetch input queue'' quand une interruption survient, avant de la traiter.

Il faut noter qu'une ''Prefetch input queue'' interagit assez mal avec le ''program counter''. En effet, la ''Prefetch input queue'' précharge les instructions séquentiellement. Pour savoir où elle en est rendue, elle mémorise l'adresse de la prochaine instruction à charger dans un '''registre de préchargement''' dédié. Il serait possible d'utiliser un ''program counter'' en plus du registre de préchargement, mais ce n'est pas la solution qui a été utilisée. Les processeurs Intel anciens ont préféré n'utiliser qu'un seul registre de préchargement en remplacement du ''program counter''. Après tout, le registre de préchargement n'est qu'un ''program counter'' ayant pris une avance de quelques cycles d'horloge, qui a été incrémenté en avance.

Et cela ne pose pas de problèmes, sauf avec certains branchements. Par exemple, certains branchements relatifs demandent de connaitre la véritable valeur du ''program counter'', pas celle calculée en avance. Idem avec les instructions d'appel de fonction, qui demandent de sauvegarder l'adresse de retour exacte, donc le vrai ''program counter''. De telles situations demandent de connaitre la valeur réelle du ''program counter'', celle sans préchargement. Pour cela, le décodeur d'instruction dispose d'une instruction pour reconstituer le ''program counter'', à savoir corriger le ''program coutner'' et éliminer l'effet du préchargement.

La micro-opération de correction se contente de soustraire le nombre d'octets préchargés au registre de préchargement. Le nombre d'octets préchargés est déduit à partir des deux pointeurs intégré à la FIFO, qui indiquent la position du premier et du dernier octet préchargé. Le bit qui indique si la FIFO est vide était aussi utilisé. Les deux pointeurs sont lus depuis la FIFO, et sont envoyés à un circuit qui détermine le nombre d'octets préchargés. Sur le 8086, ce circuit était implémenté non pas par un circuit combinatoire, mais par une mémoire ROM équivalente. La petite taille de la FIFO faisait que les pointeurs étaient très petits et la ROM l'était aussi.

Un autre défaut est que la ''Prefetch input queue'' se marie assez mal avec du code auto-modifiant. Un code auto-modifiant est un programme qui se modifie lui-même, en remplaçant certaines instructions par d'autres, en en retirant, en en ajoutant, lors de sa propre exécution. De tels programmes sont rares, mais la technique était utilisée dans quelques cas au tout début de l'informatique sur des ordinateurs rudimentaires. Ceux-ci avaient des modes d'adressages tellement limités que gérer des tableaux de taille variable demandait d'utiliser du code auto-modifiant pour écrire des boucles.

Le problème avec la ''Prefetch input queue'' survient quand des instructions sont modifiées immédiatement après avoir été préchargées. Les instructions dans la ''Prefetch input queue'' sont l'ancienne version, alors que la mémoire RAM contient les instructions modifiées. Gérer ce genre de cas est quelque peu complexe. Il faut en effet vider la ''Prefetch input queue'' si le cas arrive, ce qui demande d'identifier les écritures qui écrasent des instructions préchargées. C'est parfaitement possible, mais demande de transformer la ''Prefetch input queue'' en une mémoire hybride, à la fois mémoire associative et mémoire FIFO. Cela ne vaut que très rarement le coup, aussi les ingénieurs ne s’embêtent pas à mettre ce correctif en place, le code automodifiant est alors buggé.

Le décodeur d'instruction dispose aussi d'une micro-opération qui stoppe le préchargement des instructions dans la ''Prefetch input queue''.

: Pour ceux qui ont déjà lu un cours d'architecture des ordinateurs, la relation entre ''prefetch input queue'' et pipeline est quelque peu complexe. En apparence, la ''prefetch input queue'' permet une certaines forme de pipeline, en chargeant une instruction pendant que la précédente s'exécute. Les problématiques liées aux branchements ressemblent beaucoup à celles de la prédiction de branchement. Cependant, il est possible de dire qu'il s'agit plus d'une technique de préchargement que de pipeline. La différence entre les deux est assez subtile et les frontières sont assez floues, mais le fait est que l'instruction en cours d'exécution et le préchargement peuvent tout deux faire des accès mémoire et que l'instruction en cours a la priorité. Un vrai pipeline se débrouillerait avec une architecture Harvard, non avec un bus mémoire unique pour le chargement des instruction et la lecture/écriture des données.

===Le ''Zero-overhead looping''===

Nous avions vu dans le chapitre sur les instructions machines, qu'il existe des instructions qui permettent de grandement faciliter l'implémentation des boucles. Il s'agit de l'instruction REPEAT, utilisée sur certains processeurs de traitement de signal. Elle répète l'instruction suivante, voire une série d'instructions, un certain nombre de fois. Le nombre de répétitions est mémorisé dans un registre décrémenté à chaque itération de la boucle. Elle permet donc d'implémenter une boucle FOR facilement, sans recourir à des branchements ou des conditions.

Une technique en lien avec cette instruction permet de grandement améliorer les performances et la consommation d'énergie. L'idée est de mémoriser la boucle, les instructions à répéter, dans une petite mémoire cache située entre l'unité de chargement et le séquenceur. Le cache en question s'appelle un '''tampon de boucle''', ou encore un ''hardware loop buffer''. Grâce à lui, il n'y a pas besoin de charger les instructions à chaque fois qu'on les exécute, on les charge une bonne fois pour toute : c'est plus rapide. Bien sûr, il ne fonctionne que pour de petites boucles, mais il en est de même avec l'instruction REPEAT.

&lt;noinclude&gt;
{{NavChapitre | book=Fonctionnement d'un ordinateur
           | prev=Le chemin de données
           | prevText=Le chemin de données
           | next=L'unité de contrôle
           | nextText=L'unité de contrôle
}}
&lt;/noinclude&gt;</text>
      <sha1>2j2c0fl62nn1m9v81aqg2ixu2g94m57</sha1>
    </revision>
  </page>
  <page>
    <title>Les cartes graphiques/La microarchitecture des processeurs de shaders</title>
    <ns>0</ns>
    <id>81538</id>
    <revision>
      <id>744012</id>
      <parentid>742652</parentid>
      <timestamp>2025-06-02T20:53:04Z</timestamp>
      <contributor>
        <username>Mewtow</username>
        <id>31375</id>
      </contributor>
      <minor />
      <comment>/* L'Operand Collector et les caches de register reuse */</comment>
      <origin>744012</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="49535" sha1="5gwz4ih26rnqkmbbh9yzwk89bzloa7i" xml:space="preserve">La conception interne (aussi appelée microarchitecture) des processeurs de ''shaders'' possède quelques particularités idiosyncratiques. La microarchitecture des processeurs de ''shaders'' est particulièrement simple. On n'y retrouve pas les fioritures des CPU modernes, tant utiles pour du calcul séquentiel : pas d’exécution dans le désordre, de renommage de registres, et autres techniques avancées. En conséquence, les unités de décodage et/ou de contrôle sont relativement simples, peu complexes. La majeure partie du processeur est dédié aux unités de calcul. 

[[File:Cpu-gpu.svg|centre|vignette|upright=2.0|Comparaison entre l'architecture d'un processeur généraliste et d'un processeur de shaders.]]

==Les unités de calcul d'un processeur de shader SIMD==

Pour rappel, un processeur de shader supporte plusieurs types d'instructions. Au minimum, il supporte des ''instructions SIMD''. Mais il peut aussi gérer des ''instructions scalaires'', à savoir qu'elles travaillent sur des entiers/flottants isolés, non-regroupés dans un vecteur SIMD. Typiquement, il y a plusieurs types d'instructions scalaires : les calculs entiers, les calculs flottants simples, les calculs flottants complexes dit transcendantaux (calculs trigonométriques, des exponentielles, des logarithmes, des racines carrées ou racines carrées inverse).

Et ces différentes instructions ont toutes des unités de calcul dédiées, ce qui fait qu'un processeur de shader contient un grand nombre d'unités de calcul très différentes. Le cœur est une unité de calcul SIMD, qui se charge des instructions SIMD. Mais d'autres unités de calcul sont présentes, surtout sur les architectures modernes. Il n'est pas rare de trouver une unité de calcul entière, ou des unités de calcul flottantes spécialisées pour les opérations transcendantales.

===Les unités de calcul SIMD===

[[File:SIMD2.svg|vignette|Une unité de calcul SIMD.]]

Un processeur de shader incorpore une unité de calcul SIMD, qui effectue plusieurs calculs en parallèle. Elle regroupe plusieurs ALU flottantes regroupées ensemble et avec quelques circuits pour gérer les débordements et d'autres situations. En théorie, une unité de calcul SIMD regroupe autant d'unité de calcul qu'il y a d'entiers/flottants dans un vecteur. Par exemple, pour additionner deux vecteurs contenant chacun 16 flottants, il faut utilise 16 additionneurs flottants. Ce qui fait qu'une opération sur un vecteur est traité en une seule fois, en un cycle d'horloge. Une contrainte importante est que toutes les sous-ALU effectuent la même opération : ce ne sont pas des ALU séparées qu'on peut commander indépendamment, mais une seule ALU regroupant des circuits de calcul distinct.

Le cout en circuit est d'autant plus grand que les vecteurs sont longs et le cout est approximativement proportionnel à la taille des vecteurs. Entre des vecteurs de 128 et 256 bits, l'unité de calcul utilisera globalement deux fois plus de circuits avec 256 bits qu'avec 128. Même chose pour les registres, mais c'est là un cout commun à toutes les architectures. 

Il y a quelques unités de calcul SIMD où le calcul se fait en deux fois, car on n'a que la moitié des unités de calcul. Par exemple, pour un vecteur de 32 flottants, on peut utiliser 16 unités de calcul, mais le temps de calcul se fait en deux cycles d'horloge. Les opérations sur les vecteurs sont donc faites en deux fois : une première passe pour les 16 premiers éléments, une seconde passe pour les 16 restants. L'implémentation demande cependant qu'une instruction de calcul soit décodée en deux micro-opérations. Par exemple, une instruction SIMD sur des vecteurs de 32 éléments est exécutée par deux micro-instructions travaillant sur des vecteurs de 16 éléments. On économise ainsi pas mal de circuits, mais cela se fait au détriment de la performance globale.

L'avantage est que cela se marie bien avec l'abandon des opérations pour lesquelles masques dont tous les bits sont à 0. Par exemple, prenons une instruction travaillant sur 16 flottants, exécutée en deux fois sur 8 flottants. Si le masque dit que les 8 premières opérations ne sont pas à exécuter, alors l'ALU ne fera que le calcul des 8 derniers flottants. Pour cela, le décodeur doit lire le registre de masque lors du décodage pour éliminer une micro-instruction si besoin, voire les deux si le masque est coopératif.

===Plusieurs unités SIMD, liées au format des données===

Il faut préciser qu'il y a une séparation entre unités SIMD flottantes simple et double précision. Pour le dire plus clairement, il y a des unités SIMD pour les flottants 32 bits, d'autres pour les flottants 64 bits, et même d'autres pour les flottants 16 bits. Les flottants 64 bits sont utilisés dans les applications GPGPU, les flottants 16 et 32 bits le sont dans le rendu 3D, et les flottants 16 bits pour tout ce qui lié à l'IA. Malheureusement, on doit utiliser des ALU flottantes séparées pour chaque taille, le format des flottants n'aidant pas.

Depuis plus d'une décennie, les cartes graphiques ont des unités SIMD à la fois pour les calculs entiers et flottants. Elles sont censées être séparées. Pour NVIDIA, avant l'architecture Turing, les unités SIMD entières et flottantes sont décrites comme séparées dans leurs ''white papers'', avec des unités INT32 et FLOAT32 séparées, combinées à d'autres unités de calcul. L'architecture Volta a notamment des unités INT32, FLOAT32  et FLOAT64 séparées. A partir de l'architecture Ampere, il semblerait que les unités SIMD soient devenues capables de faire à la fois des calculs flottants et entiers, pour la moitié d'entre elles. Mais il se pourrait simplement qu'elles soient physiquement séparées, mais reliées aux reste du processeur de manière à ne pas être utilisables en même temps.

Il est cependant possible que sur d'anciennes architectures, les unités entières et flottantes partagent des circuits, notamment pour ce qui est de la multiplication. En effet, une unité de calcul flottante contient des circuits pour faire des calculs entiers pour additionner/multiplier les mantisses et les exposants. Il est possible d'utiliser ce circuit  Un exemple est le cas de l'architecture GT200 d'NVIDIA, sur laquelle les &quot;pseudo-ALU&quot; entières SIMD étaient limitées à des multiplications d'opérandes 24 bits, ce qui correspond à la taille d'une mantisse d'un flottant 32 bits. Le design exact des ALU n'est pas connu.

===Les unités de calcul scalaires===

Les GPU modernes incorporent une '''unité de calcul entière scalaire''', séparée de l'unité de calcul SIMD. Elle gère des calculs scalaires, à savoir qu'elle ne travaille pas sur des vecteurs. Elle gère divers calculs, comme des additions, soustractions, comparaisons, opérations bit à bit, etc. Elle exécute les instructions de calcul entière sur des nombres entiers isolés, de plus en plus fréquentes dans les shaders.

Elle est parfois accompagnée d'une unité de calcul pour les branchements. Par branchements, on veut parler des vrais branchements similaires à ceux des CPU, qui effectuent des tests sur des entiers et effectuent des branchements conditionnels. Ils n'ont rien à voir avec les instructions à prédicat qui elles sont spécifiques à l'unité de calcul vectorielles. Ce sont des instructions séparées, totalement distinctes

Les processeurs de shaders incorporent aussi une '''unité de calcul flottante scalaire''', utilisée pour faire des calculs sur des flottants isolés. L'unité de calcul gère généralement des calculs simples, comme les additions, soustractions, multiplications et divisions. Il s'agit typiquement d'une unité de calcul spécialisée dans l’opération ''Multiply-And-Add'' (une multiplication suivie d'une addition, opération très courante en 3D, notamment dans le calcul de produits scalaires), qui ne gère pas la division.

L'unité de calcul flottante est souvent accompagnée d'une unité de calcul spécialisée qui gère les calculs transcendantaux, avec une gestion des calculs trigonométriques, de produits scalaires ou d'autres opérations. Elle porte le nom d''''unité de calcul spéciale''' (''Special Function Unit''), ou encore d'unité de calcul transcendantale, et elle a d'autres appellations. Elle est composée de circuits de calculs accompagnés par une table contenant des constantes nécessaires pour faire les calculs.

Rappelons que les registres SIMD et les registres scalaires sont séparés et ne sont pas adressés par les mêmes instructions. Les registres scalaires sont placés dans un banc de registre physiquement séparé du banc de registres SIMD. Le banc de registre scalaire est relié à sa propre ALU scalaire, il y a vraiment une séparation physique entre registres scalaires et SIMD. Il existe cependant un système d'interconnexion qui permet d'envoyer un scalaire aux unités SIMD, ce qui est utile pour les opérations de produits scalaire ou autres.

===L'unité de texture/lecture/écriture===

L'unité d'accès mémoire s'occupe des lectures et écriture en général, et elle prend en charge les accès aux textures, le filtrage de textures et tout un tas de fonctionnalités liées aux textures. La seule différence entre un accès aux textures et une lecture/écriture en mémoire est que les circuits de filtrage de texture sont contournés dans une lecture/écriture normale. Dans ce qui suit, nous allons l'appeler l'unité de texture par souci de simplification.

==La gestion des dépendances de données==

Un processeur de ''shaders'' SIMD contient donc beaucoup d'unité de calcul, qui peuvent en théorie fonctionner en parallèle. Il est en théorie possible d'exécuter des instructions séparés dans des unités de calcul séparées. Par exemple, reprenons l'exemple de l'unité de vertices de la Geforce 6800, mentionné au-dessus. Elle dispose d'une unité de calcul SIMD MAD, et d'une unité de texture, ainsi que d'une unité de calcul scalaire transcendantale. Il en en théorie possible de faire, en même temps, un calcul dans chaque ALU. Pendant que l'unité transcendantale fait un calcul trigonométrique quelconque, l'autre ALU effectue des calculs SIMD sur d'autres données.

Pour cela, une possibilité est d'utiliser des instructions à ''co-issue''. Le problème est que ces instructions sont surtout utiles pour exécuter des instructions scalaires en parallèle d'instruction SIMD, mais guère plus. Aussi, nous allons mettre la ''co-issue'' de côté. Dans ce qui suit, nous allons partir du principe que le processeur peut démarrer une nouvelle instruction par cycle d'horloge. Et cela permet malgré tout d’exécuter plusieurs instructions en même temps dans des unités de calcul séparées. La raison est que la plupart des instructions prend plusieurs cycles d'horloge à s’exécuter. Ainsi, pendant qu'une instruction en est à son second ou troisième cycle dans une ALU, il est possible de démarrer une nouvelle instruction dans une ALU inoccupée, s'il y en a une. La seule contrainte est que les deux instructions soient indépendantes.

Les processeurs de ''shaders'' en sont capables, tout comme les CPU. Mais les CPU utilisent au mieux cette possibilité. Ils intègrent des circuits d'exécution dans le désordre, de renommage de registre, et bien d'autres. Mais leur implémentation demande un budget en transistors conséquent, que les GPU ne peuvent pas se permettre. A la place, ils utilisent une technique appelée le '''''multithreading'' matériel''', une technique qui vient du monde des processeurs, où cette technique a été appliquée à de nombreuses reprises. Vous connaissez sans doute l'''hyperthreading'' d'Intel ? C'est une version basique du ''multithreading'' matériel.

L'idée est d'exécuter plusieurs programmes en même temps sur le même processeur, le processeur commutant de l'un à l'autre suivant les besoins. Par exemple, si un ''thread'' est bloqué par un accès mémoire, d'autres ''threads'' exécutent des calculs dans l'unité de calcul en parallèle de l'accès mémoire. Les programmes en question sont appelés des ''threads'', l'équivalent sur un GPU est un ''warp'', ni plus ni moins. Un processeur de ''shader'' commute donc régulièrement d'un ''warp'' à l'autre, suivant les besoins. Dans ce qui va suivre, nous allons voir dans quelles situations un processeur de 'shader'' change de ''thread''/''warp'' en cours d'exécution. Suivant le GPU, les situations ne sont pas les mêmes.

===Les lectures non-bloquantes avec ''multithreading'' matériel===

Les processeurs de ''shader'' sont connectés à une mémoire vidéo très lente, avec un temps d'accès élevé, qui se rattrape avec un débit binaire important. La conséquence est qu'un accès à une texture, c'est long : si celle-ci est lue depuis la mémoire vidéo, le temps d'attente est d'une bonne centaine de cycles d'horloges. Pour limiter la casse, les unités de texture incorporent un cache de texture, mais cela ne suffit pas toujours à alimenter les processeurs de ''shaders'' en données. Et cs derniers ne peuvent pas recourir à des techniques avancées communes sur les CPU, comme l’exécution dans le désordre : le cout en circuit serait trop important. Fort heureusement, les processeurs de ''shaders'' disposent d'optimisations pour remplir ces temps d'attente avec des calculs indépendants de la texture lue.

Les anciennes cartes graphiques d'avant les années 2000 géraient une forme particulière de '''lectures non-bloquantes'''. L'idée est simple : pendant qu'on effectue une lecture dans l'unité de texture, on peut faire des calculs en parallèle dans les ALU de calcul. Mais la technique n'est possible que si les instructions de calcul n'ont pas comme opérande un texel en cours de lecture. Il ne faut pas qu'il y a ai une dépendance entre les instructions exécutées dans l'ALU et un texel pas encore lu. Pour cela, la carte graphique fait des vérifications sur les registres. La lecture charge le texel dans un registre, appelé le registre de destination (sous entendu, de destination de la lecture). Les instructions qui n'utilisent pas ce registre peuvent s'exécuter sans problèmes : elles sont indépendantes de la lecture. Mais les autres ont une dépendance et ne sont pas exécutées. 

Détecter les dépendances demande juste de mémoriser le registre de destination dans un registre temporaire, et de faire des comparaisons. Pour cela, le processeur de ''shader'' incorpore un circuit situé juste après le décodeur d'instruction, appelé l'unité d'émission. Elle compare les registres utilisés par l'instruction avec le registre de destination. Si il y a correspondance, l'instruction est mise en attente. La mise en attente bloque alors toutes les instructions suivantes. En clair, dès qu'on tombe sur une instruction dépendante, le processeur cesse d'émettre des instructions dans l'ALU, et attend la fin de la lecture. Il n'a pas vraiment le choix. Faire autrement serait possible, mais demanderait d'implémenter des techniques d'exécution dans le désordre très gourmandes en circuits.

Depuis l'époque de Direct X 9, les GPU combinent les lectures non-bloquantes avec le ''multithreading'' matériel. L'idée est que si un ''thread'' effectue un accès mémoire, le ''thread'' est mis en pause pendant l'accès mémoire et laisse la place à un autre. Le ''thread'' est réveillé une fois que l'accès mémoire est terminé. L'avantage est que si un ''thread'' est mis en pause par une lecture, les autres ''threads'' récupèrent les cycles d'horloge du ''thread'' mis en pause. Par exemple, sur un processeur qui gère 16 ''threads'' concurrents, si l'un d'eux est mis en pause, le processeur changera de ''thread'' tous les 15 cycles au lieu de 16. Ou encore, un ''thread'' aura droit à deux cycles consécutifs pour s’exécuter. Faire ainsi marche assez bien si on a beaucoup de ''threads'' dont peu d'entre eux font des lectures/écritures.

L'avantage est que si un thread est mis en pause par une lecture, les autres threads récupèrent les cycles d'horloge du thread mis en pause. Par exemple, sur un processeur qui gère 16 threads concurrents, si l'un d'eux est mis en pause, le processeur changera de thread tous les 15 cycles au lieu de 16. Ou encore, un thread aura droit à deux cycles consécutifs pour s’exécuter. Faire ainsi marche assez bien si on a beaucoup de threads dont peu d'entre eux font des lectures/écritures.

L'implémentation de cette technique est assez simple au premier abord. L'unité de chargement a plusieurs ''program counter'', un par ''thread''. Un circuit dédié sait quels ''threads'' sont mis en pause, et en envoie un aux unités de calculs. La technique impose cependant que les registres soient dupliqués, pour que chaque ''thread'' ait ses propres registres rien qu'à lui. Sans cela, impossible de passer rapidement d'un ''thread'' à l'autre à chaque cycle. Un processeur de ''shader'' peut exécuter entre 16 et 32 ''thrads''/''warps'', ce qui multiplie le nombre de registres par 16/32. Et il y a la même chose avec d'autres structures matérielles, comme les files de lecture/écriture de l'unité d'accès mémoire.

[[File:Aperçu de l'architecture d'un processeur multithreadé.png|centre|vignette|upright=2|Aperçu de l'architecture d'un processeur multithreadé]]

===Le ''scoreboard'' des GPU des années 2000-2010===

Les lectures non-bloquantes permettent de gérer le cas des instructions d'accès mémoire. Mais il y a d'autres instructions qui prennent plus d'un cycle d'horloge pour s'exécuter. Les instructions de calcul basiques d'un GPU prennent 2 à 3 cycles d'horloge dans le meilleur des cas, parfois plus d'une dizaine. De telles instructions sont autant d'opportunités pour exécuter plusieurs instructions en même temps. Pendant qu'une instruction multicycle occupe une ALU, les autres ALU peuvent accepter d'autres instructions. 

Les processeurs de ''shaders'' SIMD peuvent démarrer une nouvelle instruction scalaire/SIMD par cycle, si les conditions sont réunies. Le problème est alors le suivant : deux instructions démarrées l'une après l'autre doivent occuper des ALU différentes, mais en plus elles doivent manipuler des données différentes.

Prenons un exemple simple : une instruction calcule un résultat, qui est utilisé comme opérande par une seconde instruction. La seconde ne doit pas démarrer tant que la première n'a pas enregistré son résultat dans les registres. Il s'agit d'une dépendance dite RAW (''Read After Write'') typique, que la carte graphique doit gérer automatiquement. Il existe aussi d'autres dépendances liées au fait que deux instructions utilisent les mêmes registres, mais laissons-les de côté pour le moment. Il faut dire qu'avec 4096 registres par ''shader'', elles sont plus rares. Les dépendances en question sont regroupées sous le terme de '''dépendances de données'''.

S'il y a une dépendance de données entre deux instructions, on ne peut pas les exécuter en parallèle dans des unités de calcul séparées. Sur les cartes graphiques des années 2000-2010, un circuit dédié appelé le '''''scoreboard''''' détectait ces dépendances. Pour cela, il vérifie si deux instructions utilisent les mêmes registres.

: Précisons que le grand nombre de registres et de ''threads'' fait qu'un ''scoreboard'' classique, tel que décrit dans les cours d'architecture des ordinateurs, devient rapidement impraticable. Aussi, une implémentation alternative est utilisée, bien que les détails ne soient pas connus à ce jour. Quelques brevets donnent des détails d'implémentation, mais on ne sait pas s'ils sont à jour. Les curieux peuvent tenter de lire le brevet américain numéro #7,634,621, nommé ''&quot;Register File Allocation&quot;'', déposé par NVIDIA durant décembre 2009.

A chaque cycle, le ''scoreboard'' reçoit une instruction provenant du décodeur et vérifie si elle peut être exécutée. Il vérifie les dépendances de données, mais aussi d'autres formes de dépendances. Notamment, il vérifie qu'il y a une unité de calcul libre pour exécuter l'instruction.S'il n'y a pas de dépendance, elle est envoyée à une unité de calcul inoccupée, s'il y en a une. Mais s'il y a une dépendance de donnée, le processeur de ''shader'' met en pause le ''thread''/''warp'' et bascule sur un autre ''thread''. Le ''thread'' est mis en pause tant que la dépendance n'est pas résolue. A chaque cycle, le processeur détecte les dépendances et choisit une instruction parmi celles qui peuvent s'exécuter, peu importe leur ''thread''.

L'implémentation sépare le processeur de ''shader'' en deux sections séparées par une mémoire tampon qui met en attente les instructions SIMD. Les instructions SIMD sont chargées et décodées, puis sont placées dans une ou plusieurs '''files d'instruction'''. Le cas le plus simple à comprendre utilise une file d'instruction par ''thread''. Les instructions attendent leur tour dans la file d'instruction. L'unité d'émission vérifie à chaque cycle quelles instructions sont prêtes à s'exécuter, dans chaque file d'instruction. L'unité d'émission choisit un ''thread'' et envoie l'instruction la plus ancienne dans la file d'instruction aux unités de calcul. Les instructions qui ont besoin d'un résultat pas encore calculé ou lu depuis la mémoire attendent juste.

[[File:FGMT sur un processeur de shaders.png|centre|vignette|upright=2|FGMT sur un processeur de shaders]]

Mais pour cela, il faut que ces derniers aient des instructions en attente dans la file d'instruction. Le processeur doit avoir chargé assez d'instructions en avance, il faut que chaque ''thread'' ait assez de réserve pour exécuter plusieurs instructions consécutives. Pour éviter ce problème, le processeur profite du fait que le chargement des instructions depuis la mémoire et leur exécution se font en même temps : le processeur charge des instructions pendant qu'il en exécute d'autres. Plus haut, nous avions dit que l'unité de chargement mémorise plusieurs ''program counter'', un par ''thread'', et choisit à chaque cycle l'un d'entre eux pour charger une instruction. Le choix en question est synchronisé avec l'émission des instructions. Si un ''thread'' émet une instruction, ce même ''thread'' charge une instruction au même moment. Sauf si la file d'instruction du ''thread'' est déjà pleine, auquel cas un autre ''thread'' est choisit.

===L'encodage explicite des dépendances sur les GPU post-2010===

Depuis environ 2010, les GPU n'utilisent plus de ''scoreboard'' proprement dit. A la place, les GPU modernes déportent la détection des dépendances de données à la compilation. L'idée est que chaque instruction contient quelques bits pour dire au processeur : tu peux lancer 1, 2, 3 instructions à la suite sans problème. La technique porte le nom d''''anticipation de dépendances explicite''' (''Explicit-Dependence lookahead''). Un exemple historique assez ancien est le processeur Tera MTA (''MultiThreaded Architecture''), qui utilisait cette technique.

Les GPU NVIDIA modernes utilisent plusieurs bits par instruction pour gérer les dépendances de données. Un premire mécanisme est utilisé pour bloquer l'émission d'une nouvelle instruction pendant x cycles. Il utilise un '''''stall counter''''', qui mémorise le nombre de cycles d'attente. Une instruction peut initialiser le ''stall counter'' avec une valeur de base, qui indique combien de cycles attendre. Le ''stall counter'' est décrémenté à chaque cycle d'horloge et une nouvelle instruction s'exécute seulement quand le compteur atteint 0. Il est utilisé quand une instruction productrice prenant X cycles est suivie par une instruction consommatrice. Le ''stall counter'' est alors initialisé à la valeur X.

La méthode précédente ne vaut cependant que pour les instructions dont le compilateur peut prédire la durée. En clair, les accès mémoire et certaines instructions spéciales ne sont pas prises en charge. Pour les gérer, les GPU modernes utilisent un autre mécanisme, basé sur des '''compteurs de dépendances'''. Il y en a plusieurs par ''thread'', entre 5 et 10 selon le GPU. Une instruction productrice réserve un de ces compteur, l'incrémente quand elle démarre son exécution/est émise, le décrémente quand la dépendance est résolue. Les instructions consommatrices doivent attendre que le compteur tombe à zéro pour s'exécuter. Elles précisent quels compteurs regarder avec un '''masque de compteurs de dépendance''', encodé directement dans l'instruction elle-même. Le masque est composé de bits à 0/1, un par compteur.

Précisément, chaque instruction productrice se réserve deux compteurs, pour gérer les trois types de dépendances de données (RAW, WAR et WAW). Le premier compteur est décrémenté quand le résultat est écrit dans les registres, ce qui gère naturellement les dépendances RAW et WAW. Le second est décrémenté quand l'instruction a lu ses opérandes, ce qui gère les dépendances WAR. Les autres instructions regarde l'un ou l'autre des compteurs selon leur situation.

Il arrive même que le switch de ''thread'' soit géré par des bits intégrés dans l'instruction. Par exemple, sur les GPU NVIDIA modernes, chaque instruction contient un bit '''''yield''''' qui indique qu'il faut changer de ''thread'' une fois l'instruction émise. En clair, il indique que l'instruction risque de durer longtemps, a des dépendances avec la mémoire ou autre chose qui fait qu'il est préférable de changer de ''thread''.

==Le banc de registres d'un processeur de ''shader''==

Les GPU disposent d'un grand nombre de registres. Les normes de DirectX et Open GL imposent que les shaders modernes gèrent au moins 4096 registres généraux par instance de shader, avec des registres spécialisés en plus. En soi, 4096 est énorme ! Mais au-delà de ces normes, le FGMT implique de dupliquer des registres par le nombre de ''threads hardware'' simultanés. Avec le FGMT, les registres devront être dupliqués pour que chaque ''thread'' ait ses propres registres rien qu'à lui. Sans cela, impossible de passer rapidement d'un ''thread'' à l'autre à chaque cycle.

Maintenant, faisons quelques calculs d'épiciers. Un processeur de ''shader'' peut exécuter entre 16 et 32 ''threads''/''warps'', ce qui multiplie le nombre de registres par 16/32. En multipliant par les 4096 registres nécessaires, cela fait 128 kilooctets de mémoire rien que pour les registres. Et c'est pour un seul cœur ! Si on multiplie par le nombre de cœurs, on trouve que les cartes graphiques modernes ayant plusieurs processeurs de ''shaders'' ont facilement entre 32 768 et 65 536 registres de 32 bits, ce qui est énorme ! Il y a plus de mémoire gaspillée dans les registres que dans le cache L1 ou L2 !

Et ce grand nombre de registres par cœur pose quelques problèmes. Les registres sont regroupés dans une petite mémoire SRAM, adressable, appelée le '''banc de registre'''. Et comme toutes les mémoires, plus ce banc de registres est grand, plus il est lent. En conséquence, lire un opérande dans les registres prend beaucoup de temps. Du moins, c'est le cas sans optimisations. Et les GPU implémentent de nombreuses parades pour limiter le nombre de registres réellement présents dans leur silicium.

===L'allocation dynamique/statique des registres par ''thread''===

Les GPU modernes n'implémentent pas le nombre maximal de registres demandés. Par exemple, si je prends les GPU AMD de type RDNA 4, il peuvent gérer 16 ''threads'' hardware simultanés, chacun ayant accès à 256 registres, registres faisant 128 octets chacun. On s'attend à avoir un banc de registre de 16 * 256 * 128 octets, soit 512 Kilo-octets. En somme, un banc de registre de la taille du cache L1. Sauf que les GPUs en question intègrent moins de registres que prévu ! Ils ont précisément une taille de 192 kilo-octets, soit 96 registres pour chacun des 16 ''threads''.

En effet, 256 registres est un nombre maximal, que la plupart des ''shaders'' n'utilise pas totalement. La plupart des ''shaders'' utilise entre 64 et 128 registres, rarement moins, rarement plus. Aussi, le GPU partitionne le banc de registres à la demande entre les ''threads'', en leur donnant seulement une partie des registres. Le partitionnement peut être pseudo-statique, à savoir que le banc de registre est découpé en parts égales pour chaque ''thread'', ou dynamique avec un nombre de registre variant d'un ''thread'' à l'autre, selon les besoins.

Prenons l'exemple d'un '''partitionnement pseudo-statique''', avec l'exemple des GPU AMD RDNA 1 et 2. Leur banc de registre fait 1024 registres, de 128 octets chacun, soit 128 KB au total. Le GPU gère 16 ''threads'' simultanés maximum. Avec un seul ''thread'' d'exécuté, le ''thread'' unique peut utiliser les 1024 registres du banc de registre pour lui tout seul. Avec deux ''threads'', chacun aura droit à 512 registres, soit la moitié du cas précédent. Avec 16 ''thread'' simultanés, chaque ''thread'' a accès à 64 registres, pas plus. Et ainsi de suite : le nombre de registre par ''thread'' est égal à la taille du banc de registre divisée par le nombre de ''threads''.

A l'heure où j'écris ces lignes, courant 2025, les GPU Intel se contentent d'un partitionnement statique très limité. Avant les GPU d'architecture Battlemage, il n'y avait pas de partitionnement du banc de registre, tous les ''threads'' avaient 128 registre à leur disposition. Les GPU Battlemage  et ses successeurs ont introduit un partitionnement limité, avec deux modes : un mode sans partitionnement où tous les ''threads'' ont accès à 128 registres, un mode avec partitionnement qui divise le nombre de ''thread'' par deux et leur donne chacun 256 registres. Pas de possibilité de diviser plus le nombre de ''threads''.

Les GPU AMD et NVIDIA sont eux plus compétents niveau partitionnement statique. Par exemple, les GPU RDNA 4 supportent les partitionnements suivants :
* 16 ''threads'' avec 96 registres chacun ;
* 12 ''threads'' avec 120 registres chacun ;
* 10 ''threads'' avec 144 registres chacun ;
* 9 ''threads'' avec 168 registres chacun ;
* 8 ''threads'' avec 192 registres chacun ;
* 7 ''threads'' avec 216 registres chacun ;
* 6 ''threads'' avec 240 registres chacun ;
* 5 ''threads'' avec 256 registres chacun.

Le partitionnement pseudo-statique est simple à implémenter, il ne demande pas beaucoup de circuits pour fonctionner. Il est rapide et a de bonnes performances pour le rendu graphique en rastérisation. La raison est qu'en rastérisation, les différents ''threads'' sont souvent des copies/instances d'un même ''shader'' qui travaillent sur des données différentes. Leur donner le même nombre de registres colle bien avec cet état de fait.

Cependant, si les différents ''threads'' sont des ''shaders'' différents, les choses ne sont pas optimales. Un ''shader'' utilisera plus de registres que l'autre, leur donner le même nombre de registres n'est pas optimal. Par exemple, imaginons que l'on a deux shaders, nommés shaders 1 et 2, aux besoins différents, l'un étant gourmand en registres et l'autre très économe. Dans ce cas, il faudrait partitionner le banc de registre pour donner plus de registre au premier et moins au second. Il s'agit là d'un '''partitionnement dynamique'''.

Le partitionnement dynamique est plus optimal pour gérer des ''shaders'' déséquilibrés niveau registres, mais a une implémentation matérielle plus complexe. Il a été introduit assez tard, car il a fallu attendre que le rayctracing se démocratise. En effet, le partitionnement dynamique du banc de registre est surtout utile pour le raytracing. Exécuter simultanément des shaders déséquilibrés en registres est peu fréquent avec la rastérisation, beaucoup plus courant avec le raytracing.

NVIDIA et AMD ont des implémentations différentes du partitionnement dynamique. Les GPU AMD RDNA 4 allouent un nombre minimal de registre à chaque ''thread'', mais ils peuvent demander d'avoir accès à plus de registres si besoin. Quand un ''thread'' a besoin de plus de registres, il exécute une instruction dédiée, qui sert à demander plus de registres, ou au contraire à en libérer s'ils sont inutilisés. La demande d'allocation de nouveaux registres se fait par blocs de 16 à 32 registres, suivant comment est configuré le processeur. Précisons que l'instruction d'allocation n'est disponible que pour les ''compute shaders'' et pas les ''shaders'' graphiques.

L'instruction d'allocation de registre précédent peut échouer dans certains cas. Si assez de registres sont disponibles, à savoir inutilisés par d'autres ''threads'', l'instruction réussit. Dans le cas contraire, elle échoue et le ''shader'' est mis en pause avant de retenter cette demande plus tard. Le résultat de l'instruction, échec ou réussite, est mémorisé dans le registre d'état. La technique a pour défaut que certaines situations peuvent mener à un blocage complet du processeur, où chaque ''thread'' ne peut plus poursuivre son exécution, faute de registres disponibles. Des méthodes pour éviter cette situation sont implémentés sur ces GPU, mais la documentation n'est pas très explicite.

Sur les GPU NVIDIA, il y a aussi une instruction d'allocation de registre, mais elle fonctionne différemment. Elle permet d'échanger des registres entre ''threads''. Une première différence est que tous les ''threads'' commencent avec une allocation égale des registres. Les ''threads'' démarrent tous avec le même nombre de registres. Un ''thread'' peut libérer des registres, qui sont alors alloués à un autre ''thread'', le ''thread'' en question pouvant être choisit par le ''thread'' qui libère les registres.

===Le banc de registre est multiport de type externe===

Le banc de registre doit permettre de lire deux vecteurs SIMD par opération, soit deux lectures simultanées. Pour cela, le banc de registre contient deux ports de lecture, chacun permettant de lire un opérande dans le banc de registre. Mais plus le nombre de ports augmente, plus la consommation énergétique du banc de registre augmente, sans compter que celui-ci devient plus lent. 

Les processeurs peuvent utilisent des bancs de registres ayant réellement deux ports par banc de registre. Un port de lecture est implémenté avec un composant appelé un multiplexeur, connecté à tous les registres.

[[File:Mémoire multiport faite avec des MUX-DEMUX.png|centre|vignette|upright=2|Mémoire multiport faite avec des MUX-DEMUX]]

Les GPU ne peuvent pas se permettre un tel luxe. Leur banc de registre doit alimenter plusieurs unités de calcul en même temps, en parallèle. Le nombre de ports serait plus proche de 4 à 10 ports de lectures. La solution précédente aurait un budget en transistor et un budget thermique trop important. À la place, ils utilisent une autre méthode : ils simulent un banc de registre à plusieurs ports avec un ou plusieurs bancs de registres à un port. On parle alors de '''multiport externe'''.

[[File:Mémoire multiport à multiportage externe.png|centre|vignette|upright=2.5|Mémoire multiport à multiportage externe.]]

Il existe plusieurs méthodes de multiport externe. Mais celle utilisée sur les GPU simule un banc de registre multiport à partir de plusieurs bancs de registres à un port. Le banc de registre est en réalité formé de plusieurs banques, de plusieurs bancs de registre séparés, chacun mono-port. L'idée est que si l'on accède à deux banques en même temps, on peut lire deux opérandes, une par port/banc de registre. Par contre, si les deux opérandes à lire sont la même banque, il y a un '''conflit d'accès aux banques'''.

[[File:Mémoire à multiports par banques.png|centre|vignette|upright=2|Mémoire à multiports par banques.]]

===L'''Operand Collector'' et les caches de ''register reuse''===

Sans conflit d'accès à une banque, les deux opérandes sont disponibles immédiatement. Par contre, en cas de conflit d'accès aux banques, les deux opérandes sont lus l'une après l'autre. En clair, le premier opérande doit être mis en attente quelque part pendant que la seconde est en cours de lecture. Et le problème survient souvent, surtout avec les opérations FMA qui utilisent trois opérandes, encore plus avec les rares opérations qui demandent 4 à 5 opérandes.

Pour gérer les conflits d'accès aux banques, les GPU utilise un circuit dédié, appelé le '''collecteur d'opérandes''' (''operand collector''). Le rôle du collecteur d'opérandes est d'accumuler les opérandes en attente, son nom est assez transparent. Il accumule les opérandes en attente, puis les envoie aux unités de calcul quand elles sont toutes prêtes, toutes lues depuis le banc de registres. Les opérandes sont mis en attente dans des entrées, qui contiennent la donnée, l'identifiant du ''thread''/''warp'' pour ne pas confondre des opérandes entre ''threads'', et deux bits d'occupation. Les deux bits d'occupation indiquent si l'entrée est vide, réservée pour un opérande en cours de lecture ou occupée par un opérande.

Le collecteur d'opérande est souvent accompagné de '''registres temporaires''', qui mémorisent le résultat d'une instruction précédente. Il y a un registre temporaire par ALU, le résultat fournit par une ALU est mémorisé dans le registre temporaire associé. Une instruction peut lire une opérande dans un registre temporaire, ce qui permet de lire le résultat d'une instruction précédente sans passer par le banc de registres. Le collecteur d'opérande est alors configuré pour récupérer les opérandes adéquats dans les registres temporaires adéquats. 

: Pour faire une comparaison avec les processeurs modernes, ces registres sont une forme de ''data forwarding'', de contournement, mais qui est rendue explicite pour le logiciel.

Une optimisation des GPU récent vise à réduire les accès aux bancs de registres en utilisant une mémoire cache spécialisée. Il s'agit de l'''operand reuse cache'', aussi appelés '''''register reuse cache'''''. L'idée est que quand un opérande est lu depuis le banc de registres, elle peut être stockée dans ce cache pour des utilisations ultérieures. Les architectures Volta, Pascal et Maxwell disposent de 4 caches de ce type, chacun stockant 8 données/opérandes/résultats

Il s'agit en réalité de pseudo-caches, car ils sont partiellement commandés par le logiciel. Une instruction précise qu'un opérande doit être stocké dans un ''register reuse cache'', pour une utilisation ultérieure. Pour cela, elle incorpore quelques bits pour préciser qu'elle doit être placée dans le cache. Les bits font en quelque sorte partie du mode d'adressage. Si l'instruction immédiatement suivante lit ce registre dans le même ''slot'' d'opérande lira l'opérande dans le cache. La technique est donc assez limitée, mais elle a des résultats pas négligeables.

Les ''register reuse cache'' et le collecteur opérandes sont sans doute fusionnés en un seul circuit, plutôt que d'utiliser deux circuits séparés. La raison est que les deux doivent mémoriser des opérandes les mettre en attente pour une utilisation ultérieure, et sont placés juste après le banc de registre. NVIDIA a publié deux brevets à propos de ces deux techniques, mais rien n'indique que c'est exactement cette technique qui utilisée dans les cartes modernes. Il faut dire que le nombre de banques a changé suivant les cartes graphiques.
* [https://patents.google.com/patent/US7834881B2/en Operand collector architecture ]
* [https://patents.google.com/patent/US20130159628A1/en Methods and apparatus for source operand collector caching ]

==Les processeurs de shaders VLIW==

Une autre forme d'émission multiple est l'usage d'un jeu d'instruction VLIW et/ou d'instructions en ''co-issue'', abordés dans les chapitres précédents. Pour rappel, un processeur VLIW regroupe plusieurs opérations en une seule instruction machine. L'instruction encode les calculs à faire en parallèle, en ''co-issue''. Elle précise les registres, l'opcode de l'instruction, et tout ce qu'il faut pour faire les calculs, et attribue implicitement une unité de calcul à chaque opération.

Les opérations regroupées sont garanties indépendantes par le compilateur, ce qui fait que le décodeur d'instruction envoie chaque opération à l'unité de calcul associée, sans avoir à faire la moindre vérification de dépendances entre instructions. L'unité d'émission est donc grandement simplifiée, elle n'a pas à découvrir les dépendances entre instructions.

Au passage, cela explique pourquoi les premières cartes graphiques étaient de type VLIW, alors que les modernes sont de type SIMD. Les anciennes cartes graphiques préféraient se passer de ''scoreboard''. Mieux valait utiliser le peu de transistors dont elles disposaient pour des unités de calcul. De plus, DirectX 8 et 9 profitaient pas mal de la présence de ''co-issue''. Par contre, il fallait un compilateur performant pour en profiter, ce qui n'était pas vraiment le cas. Les compilateurs n'exploitaient pas beaucoup la ''co-issue'', ce qui fait que les fabricant de GPU ont préféré déléguer cette tâche à un ''scoreboard'' matériel.

===Les architectures VLIW pures, sans unité SIMD===

Un processeur VLIW contient un grand nombre d'unités de calcul. En théorie, il incorpore plusieurs unités de calcul scalaires séparés et n'a pas d'unité de calcul SIMD. Il y a cependant quelques exceptions, mais nous les verrons plus tard. Pour le moment, concentrons-nous sur les processeurs de shaders VLIW sans aucune unité de calcul SIMD.

Un exemple est celui des anciennes cartes graphiques AMD, d'architecture TeraScale/VLIW-5, à savoir les Radeon HD 2000/3000/4000/5000/6000. L'architecture était une architecture VLIW, pas SIMD, d'où la distinction. Il n'y avait pas d'unité de calcul SIMD, mais plusieurs unités de calcul scalaires. Un point important est que les unités de calculs scalaires pouvaient faire des opérations différentes. Par exemple, la première pouvait faire une addition flottante, la seconde une addition entière, la troisième une soustraction, etc. 

Elles disposaient de six unités de calcul : cinq unités de calcul scalaires, et une unité de calcul dédiée aux branchements. Sur les 5 unités de calcul, une était une unité de calcul hybride scalaire/transcendentale. Nous allons donc faire la distinction entre unité de calcul spéciale et les 4 unités de calcul basiques.

Toutes les unités de calculs pouvaient faire les opérations suivantes, sur des flottants et entiers sur 32 bits : comparaisons, additions, soustractions, opérations logiques, décalages, opérations bit à bit et instructions CMOV. Les unités de calcul basiques gèrent aussi les multiplications, opérations MAD et produits vectoriels/scalaires, mais seulement pour des opérandes flottantes. L'unité de calcul spéciale gérait des multiplications et division entières sur des opérandes 32 bits, ainsi que des instructions transcendantales entières/flottantes. 

Par la suite, avec l'architecture VLIW-4, l'unité de calcul transcendantale a été retirée. Mais les calculs transcendantaux n'ont pas disparus. En effet, il ne resta que 4 ALU flottantes, qui ont été augmentées pour gérer partiellement les opérations transcendantales. Tout se passait comme si l'ALU transcendantale avait été éclatée en morceaux répartis dans chaque ALU flottante/entière. Et c'est globalement ce qui s'est passé : les diverses tables matérielles utilisées pour les calculs transcendantaux ont été dispersés dans les ALU, afin de faire des calculs transcendantaux  approchés. En combinant les résultats approchés, on pouvait calculer le résultat exact.

===Les hybrides SIMD/VLIW et les instructions à ''co-issue''===

La gestion des instructions en ''co-issue'' peut aussi utiliser les techniques des processeurs VLIW. Pour rappel, l'exemple typique d'instruction en ''co-issue'' regroupe une opération SIMD avec une opération scalaire, pour profiter de la présence d'une ALU scalaire séparée de l'ALU SIMD. Les cartes graphiques modernes gérent la ''co-issue'' aisni, avec la possibilité de ''co-issue'' une opération scalaire et une opération vectorielle. L'opération scalaire est souvent une opération entière, éventuellement flottante. Les processeurs de shaders qui supportent de telles instructions sont un hybride entre VLIW et SIMD.

Sur les anciennes cartes graphiques disposant d'une unité SIMD, la ''co-issue'' fonctionnait différemment, car les unités de calcul entières n'étaient pas présentes. De plus, le faible budget en transistor faisait que l'on ajoutait pas d'unité flottante scalaire, ce qui ne servait pas à grand-chose. Par contre, l'unité de calcul transcendantale était systématiquement présente, car très utile. Aussi, une forme plus limitée de ''co-issue'' était possible : on pouvait exécuter une opération transcendantale en parallèle d'une instruction SIMD. Le cas le plus simple est le processeur de vertices de la Geforce 3, avec une unité SIMD et une unité transcendantale. Il n'y avait pas d'unité de calcul scalaire entière, ni même flottante.

Un autre exemple est le processeur de ''vertex shader'' de la Geforce 6800, illustré ci-dessous. On voit que le processeur contient une unité d'accès mémoire/textures, avec deux unités de calcul. La première est une unité de calcul scalaire flottante, qui gère les opérations flottantes transcendantales. Elle travaille sur des opérandes de 32 bits. À côté, on trouve une unité de calcul SIMD, qui gère des vecteurs de 4 nombres flottants 32 bits. Elle permet de faire des additions, des multiplications, des opérations MAD, des produits vectoriels, et quelques autres opérations comme le calcul du maximum/minimum de deux nombres. Il n'y a aucune gestion d'instructions flottantes scalaires ou d'opérations entières, la carte graphique est trop ancienne pour cela.

[[File:GeForce 6800 Vertex processor block.png|centre|vignette|upright=2.0|Processeur de shader (vertex shader) d'une GeForce 6800. On voit clairement que celui-ci contient, outre les traditionnelles unités de calcul et registres temporaires, un &quot;cache&quot; d'instructions, des registres d'entrée et de sortie, ainsi que des registres de constante.]]

Le processeur de pixel shader de la même carte graphique était lui aussi un hybride entre VLIW et SIMD. Cependant, il lorgnait plus du côté VLIW que SIMD. Il pouvait faire soit une opération SIMD le vecteur, soit couper le vecteur en deux et effectuer deux opérations différentes sur chaque morceau. Par exemple, il pouvait faire une opération sur 3 pixels, et une opération scalaire sur le quatrième, ou deux opérations vectoriels chacune sur deux pixels. Le processeur travaille sur des blocs de 4 pixels, appelés des ''quads''. Chaque pixel est codé avec 4 flottants 32 bits, cela fait en tout 4 vecteurs de 4 flottants, avec ''co-issue'' à l'intérieur de chaque vecteur. Précisons que les registres temporaires du processeur mémorisent chacun un vecteur de 4 flottants, un pixel, par un ''quad''.

Niveau unités de calcul, le tout était assez complexe. Il contenait tout d'abord une unité de texture, et plusieurs unités VLIW/SIMD. Elles sont appelées &quot;unités SIMD&quot; dans les schémas qui vont suivre, mais elles sont en réalité un mix entre unité SIMD véritable et unités scalaires du VLIW. La documentation NVIDIA elle-même parle d'unité vectorielle, mais le terme est quelque peu trompeur, car elles sont plus flexibles que de simples unités SIMD.

Il y en a deux, la première envoyant son résultat à la seconde. La première est capable de faire des opérations de multiplications/MAD, mais elle peut aussi être utilisée pour la correction de perspective grâce à son support des opérations 1/x. Elle peut aussi normaliser des nombres flottants sur 16 bits. Il faut noter que la première unité SIMD/VLIW ne peut pas être utilisée si un accès mémoire/texture est en cours. La seconde unité SIMD/VLIW est capable de faire des opérations de MAD, et un produit vectoriel/scalaire DOT4.

Le résultat de la seconde ALU est ensuite envoyé à une unité de branchement qui décide s'il faut ré-exécuter une autre passe d'instructions ou non. Il s'agit vraisemblablement d'une unité qui gère la prédication des résultats. Une fois le fragment/pixel final calculé, il est envoyé à une unité de calcul du brouillard, qui est une unité de calcul spécialisée travaillant sur des nombres entiers (en réalité, en virgule fixe, mais c'est pareil). 

[[File:Processeur de pixel shader de la Geforce 6800.png|centre|vignette|upright=2.0|Processeur de pixel shader de la Geforce 6800]]

{{NavChapitre | book=Les cartes graphiques
           | prev=La répartition du travail sur les unités de shaders
           | prevText=La répartition du travail sur les unités de shaders
           | next=La mémoire unifiée et la mémoire vidéo dédiée
           | netxText=La mémoire unifiée et la mémoire vidéo dédiée
}}{{autocat}}</text>
      <sha1>5gwz4ih26rnqkmbbh9yzwk89bzloa7i</sha1>
    </revision>
  </page>
  <page>
    <title>Discussion Wikilivres:Le Bistro/2025</title>
    <ns>5</ns>
    <id>82063</id>
    <revision>
      <id>744027</id>
      <parentid>743745</parentid>
      <timestamp>2025-06-02T23:54:47Z</timestamp>
      <contributor>
        <username>MediaWiki message delivery</username>
        <id>36013</id>
      </contributor>
      <comment>/* Actualités techniques n° 2025-23 */ nouvelle section</comment>
      <origin>744027</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="152698" sha1="qgex8flrsb47gflskeqyjz3562vdqeh" xml:space="preserve">== Actualités techniques n° 2025-03 ==

&lt;section begin=&quot;technews-2025-W03&quot;/&gt;&lt;div class=&quot;plainlinks&quot;&gt;
Dernières '''[[m:Special:MyLanguage/Tech/News|actualités techniques]]''' de la communauté technique de Wikimedia. N’hésitez pas à informer les autres utilisateurs de ces changements. Certains changements ne vous concernent pas. [[m:Special:MyLanguage/Tech/News/2025/03|D’autres traductions]] sont disponibles.

'''En lumière cette semaine'''
* Le système de connexion utilisateur unique (SUL) va être mis à jour durant les prochains mois. Il permet aux utilisateurs et utilisatrices d’être connectés sur tous les sites en même temps après avoir renseigné leurs identifiants sur un site Wikimedia. La mise à jour est nécessaire car les navigateurs restreignent de plus en plus les témoins de connexion inter-domaines. Pour s’adapter à ces restrictions, les pages de  connexion et de création de compte seront déplacées vers un domaine central, mais cela apparaitra toujours comme si vous étiez sur le wiki d’origine. Le code mis à jour sera activé cette semaine pour les utilisations sur les wikis de test. Ce changement devrait être déployé pour tous durant février et mars. Consultez [[mw:Special:MyLanguage/MediaWiki Platform Team/SUL3#Deployment|la page du projet SUL3]] pour plus d’informations et un calendrier.

'''Actualités pour la contribution'''
* Sur les wikis ayant [[mw:Special:MyLanguage/Extension:PageAssessments|PageAssessments]] (évaluation des pages) installée, vous pouvez désormais [[mw:Special:MyLanguage/Extension:PageAssessments#Search|filtrer les résultats de recherche]] aux pages dans un projet donné à l’aide du mot-clé &lt;code dir=ltr&gt;inproject:&lt;/code&gt;. (Ces wikis : {{int:project-localized-name-arwiki/fr}}{{int:comma-separator/fr}}{{int:project-localized-name-enwiki/fr}}{{int:comma-separator/fr}}{{int:project-localized-name-enwikivoyage/fr}}{{int:comma-separator/fr}}{{int:project-localized-name-frwiki/fr}}{{int:comma-separator/fr}}{{int:project-localized-name-huwiki/fr}}{{int:comma-separator/fr}}{{int:project-localized-name-newiki/fr}}{{int:comma-separator/fr}}{{int:project-localized-name-trwiki/fr}}{{int:comma-separator/fr}}{{int:project-localized-name-zhwiki/fr}}.) [https://phabricator.wikimedia.org/T378868] 
* Un nouveau wiki a été créé : une Wikipédia en [[d:Q34129|tigré]] ([[w:tig:|&lt;code&gt;w:tig:&lt;/code&gt;]]) [https://phabricator.wikimedia.org/T381377]
* [[File:Octicons-sync.svg|12px|link=|class=skin-invert|Sujet récurrent]] Voir {{PLURAL:35|la tâche soumise|les {{formatnum:35}} tâches soumises}} par la communauté [[m:Special:MyLanguage/Tech/News/Recently resolved community tasks|résolue{{PLURAL:35||s}} la semaine dernière]]. Par exemple, il y avait un beugue de mise à jour du compteur de modifications de quelqu’un effectuant une annulation d’une autre modification : cela est maintenant corrigé. [https://phabricator.wikimedia.org/T382592]

'''Actualités pour la contribution technique'''
* [[File:Octicons-tools.svg|12px|link=|class=skin-invert|Sujet technique]] Les utilisateurs et utilisatrices de l’API REST de Wikimedia (par exemple pour des robots ou des outils) peuvent être impactés par des mises à jour en cours. À partir de la semaine du 13 janvier, nous commencerons à rediriger [[phab:T374683|certains points terminaux de contenu de page]] depuis RESTbase vers les nouveaux points terminaux de l’API REST de MediaWiki pour tous les projets wiki. Ce changement était disponible sur testwiki, et ne devrait pas affecter les fonctionnalités existantes, mais les utilisateurs actifs des points terminaux concernés peuvent signaler directement à l’[[phab:project/view/6931/|équipe des interfaces de MediaWiki]] tout problème qui arriverait.
* Les personnes maintenant des outils sur Toolforge peuvent désormais partager leurs retour sur Toolforge UI, un projet visant à fournir une plateforme web pour la création et la gestion d’outils Toolforge depuis une interface graphique, en plus des processus existant par ligne de commande. Ce projet vise à simplifier les tâches des mainteneurs et mainteneuses actifs, ainsi qu’à rendre l’inscription et les procédures de déploiement plus accessibles aux nouveaux et nouvelles créatrices d’outils. Le projet en est encore à ses balbutiements et l’équipe des services en infonuage recueille des retours de la communauté Toolforge pour aiderà concevoir la solution correspondant à leurs besoins. [[wikitech:Wikimedia Cloud Services team/EnhancementProposals/Toolforge UI|En savoir plus et donner son avis sur Toolforge UI]]. 
* [[File:Octicons-tools.svg|12px|link=|class=skin-invert|Sujet technique]] &lt;span class=&quot;mw-translate-fuzzy&quot;&gt;Pour le développement d’outil et bibliothèque qui utilisent le système OAuth : le point terminal d’identité utilisé pour [[mw:Special:MyLanguage/OAuth/For Developers#Identifying the user|OAuth 1]] et [[mw:Special:MyLanguage/OAuth/For Developers#Identifying the user 2|OAuth 2]] retournait un objet JSON avec un entier dans le sous-champ, ce qui était incorrect (le champ doit toujours être une chaine de caractère); Cela a été corrigé ; le correctif sera déployé sur les wikis Wikimedia la semaine du 13 janvier.&lt;/span&gt; [https://phabricator.wikimedia.org/T382139]
* De nombreux wikis utilisent actuellement le [[:mw:Parsoid/Parser Unification/Cite CSS|CSS de Cite]] pour insérer des marqueurs de note de bas de page personnalisés dans la sortie de Parsoid. À partir du 20 janvier, ces règles seront désactivées, mais les développeurs vous demandent de ''ne pas'' nettoyer votre &lt;bdi lang=&quot;en&quot; dir=&quot;ltr&quot;&gt;[[MediaWiki:Common.css]]&lt;/bdi&gt; avant le 20 février pour éviter des problèmes pendant la migration. Vos wikis rencontreront peut-être des petits changements dans les marqueurs de notes de bas page dans l’éditeur visuel ou en utilisant le mode de lecture expérimental Parsoid, mais s’il y a des changements, ils devraient garder le rendu cohérent avec la sortie de l’analyseur classique. [https://phabricator.wikimedia.org/T370027]

'''Rencontres et évènements'''
* Les prochaines réunions de la série des [[c:Special:MyLanguage/Commons:WMF support for Commons/Commons community calls|Discussions communautaires entre Wikimedia Foundation et la communauté de Wikimedia Commons]] aura lieu le [[m:Special:MyLanguage/Event:Commons community discussion - 15 January 2025 08:00 UTC|15 janvier à 8 h UTC]] et [[m:Special:MyLanguage/Event:Commons community discussion - 15 January 2025 16:00 UTC|à 16 h UTC]]. Le sujet de cette conférence porte sur la définition des priorités d’investissement en outils pour Commons. Les contributeurs et contributrices de tous les wikis sont les bienvenus pour participer, notamment celles et ceux qui maintiennent des outils pour Commons.

'''''[[m:Special:MyLanguage/Tech/News|Actualités techniques]]''' préparées par les [[m:Special:MyLanguage/Tech/News/Writers|rédacteurs des actualités techniques]] et postées par [[m:Special:MyLanguage/User:MediaWiki message delivery|robot]]. [[m:Special:MyLanguage/Tech/News#contribute|Contribuer]]&amp;nbsp;• [[m:Special:MyLanguage/Tech/News/2025/03|Traduire]]&amp;nbsp;• [[m:Tech|Obtenir de l’aide]]&amp;nbsp;• [[m:Talk:Tech/News|Donner son avis]]&amp;nbsp;• [[m:Global message delivery/Targets/Tech ambassadors|S’abonner ou se désabonner]].''
&lt;/div&gt;&lt;section end=&quot;technews-2025-W03&quot;/&gt;

&lt;bdi lang=&quot;en&quot; dir=&quot;ltr&quot;&gt;[[User:MediaWiki message delivery|MediaWiki message delivery]]&lt;/bdi&gt; 14 janvier 2025 à 02:42 (CET)
&lt;!-- Message envoyé par User:Quiddity (WMF)@metawiki en utilisant la liste sur https://meta.wikimedia.org/w/index.php?title=Global_message_delivery/Targets/Tech_ambassadors&amp;oldid=28048614 --&gt;

== Launching! Join Us for Wiki Loves Ramadan 2025! ==

Dear All,

We’re happy to announce the launch of [[m:Wiki Loves Ramadan 2025|Wiki Loves Ramadan 2025]], an annual international campaign dedicated to celebrating and preserving Islamic cultures and history through the power of Wikipedia. As an active contributor to the Local Wikipedia, you are specially invited to participate in the launch. 

This year’s campaign will be launched for you to join us write, edit, and improve articles that showcase the richness and diversity of Islamic traditions, history, and culture.

* Topic: [[m:Event:Wiki Loves Ramadan 2025 Campaign Launch|Wiki Loves Ramadan 2025 Campaign Launch]]
* When: Jan 19, 2025 
* Time: 16:00 Universal Time UTC and runs throughout Ramadan (starting February 25, 2025).
* Join Zoom Meeting: https://us02web.zoom.us/j/88420056597?pwd=NdrpqIhrwAVPeWB8FNb258n7qngqqo.1 
* Zoom meeting hosted by [[m:Wikimedia Bangladesh|Wikimedia Bangladesh]]

To get started, visit the [[m:Wiki Loves Ramadan 2025|campaign page]] for details, resources, and guidelines: Wiki Loves Ramadan 2025.

Add [[m:Wiki Loves Ramadan 2025/Participant|your community here]], and organized Wiki Loves Ramadan 2025 in your local language.

Whether you’re a first-time editor or an experienced Wikipedian, your contributions matter. Together, we can ensure Islamic cultures and traditions are well-represented and accessible to all.

Feel free to invite your community and friends too. Kindly reach out if you have any questions or need support as you prepare to participate.

Let’s make Wiki Loves Ramadan 2025 a success!

For the [[m:Wiki Loves Ramadan 2025/Team|International Team]] 16 janvier 2025 à 13:08 (CET)
&lt;!-- Message envoyé par User:ZI Jony@metawiki en utilisant la liste sur https://meta.wikimedia.org/w/index.php?title=Distribution_list/Non-Technical_Village_Pumps_distribution_list&amp;oldid=27568454 --&gt;

== Actualités techniques n° 2025-04 ==

&lt;section begin=&quot;technews-2025-W04&quot;/&gt;&lt;div class=&quot;plainlinks&quot;&gt;
Dernières '''[[m:Special:MyLanguage/Tech/News|actualités techniques]]''' de la communauté technique de Wikimedia. N’hésitez pas à informer les autres utilisateurs de ces changements. Certains changements ne vous concernent pas. [[m:Special:MyLanguage/Tech/News/2025/04|D’autres traductions]] sont disponibles.

'''Actualités pour la contribution'''
* &lt;span lang=&quot;en&quot; dir=&quot;ltr&quot; class=&quot;mw-content-ltr&quot;&gt;Administrators can mass-delete multiple pages created by a user or IP address using [[mw:Special:MyLanguage/Extension:Nuke|Extension:Nuke]]. It previously only allowed deletion of pages created in the last 30 days. It can now delete pages from the last 90 days, provided it is targeting a specific user or IP address.&lt;/span&gt; [https://phabricator.wikimedia.org/T380846]
* &lt;span lang=&quot;en&quot; dir=&quot;ltr&quot; class=&quot;mw-content-ltr&quot;&gt;On [[phab:P72148|wikis that use]] the [[mw:Special:MyLanguage/Help:Patrolled edits|Patrolled edits]] feature, when the rollback feature is used to revert an unpatrolled page revision, that revision will now be marked as &quot;manually patrolled&quot; instead of &quot;autopatrolled&quot;, which is more accurate. Some editors that use [[mw:Special:MyLanguage/Help:New filters for edit review/Filtering|filters]] on Recent Changes may need to update their filter settings.&lt;/span&gt; [https://phabricator.wikimedia.org/T302140]
* [[File:Octicons-sync.svg|12px|link=|class=skin-invert|Sujet récurrent]] Voir {{PLURAL:31|la tâche soumise|les {{formatnum:31}} tâches soumises}} par la communauté [[m:Special:MyLanguage/Tech/News/Recently resolved community tasks|résolue{{PLURAL:31||s}} la semaine dernière]]. &lt;span lang=&quot;en&quot; dir=&quot;ltr&quot; class=&quot;mw-content-ltr&quot;&gt;For example, the Visual Editor's &quot;Insert link&quot; feature did not always suggest existing pages properly when an editor started typing, which has now been [[phab:T383497|fixed]].&lt;/span&gt;

'''Actualités pour la contribution technique'''
* &lt;span lang=&quot;en&quot; dir=&quot;ltr&quot; class=&quot;mw-content-ltr&quot;&gt;The Structured Discussion extension (also known as Flow) is being progressively removed from the wikis. This extension is unmaintained and causes issues. It will be replaced by [[mw:Special:MyLanguage/Help:DiscussionTools|DiscussionTools]], which is used on any regular talk page. [[mw:Special:MyLanguage/Structured Discussions/Deprecation#Deprecation timeline|The last group of wikis]] ({{int:project-localized-name-cawikiquote/en}}{{int:comma-separator/en}}{{int:project-localized-name-fiwikimedia/en}}{{int:comma-separator/en}}{{int:project-localized-name-gomwiki/en}}{{int:comma-separator/en}}{{int:project-localized-name-kabwiki/en}}{{int:comma-separator/en}}{{int:project-localized-name-ptwikibooks/en}}{{int:comma-separator/en}}{{int:project-localized-name-sewikimedia/en}}) will soon be contacted. If you have questions about this process, please ping [[m:User:Trizek (WMF)|Trizek (WMF)]] at your wiki.&lt;/span&gt; [https://phabricator.wikimedia.org/T380912]
* &lt;span lang=&quot;en&quot; dir=&quot;ltr&quot; class=&quot;mw-content-ltr&quot;&gt;The latest quarterly [[mw:Technical_Community_Newsletter/2025/January|Technical Community Newsletter]] is now available. This edition includes: updates about services from the Data Platform Engineering teams, information about Codex from the Design System team, and more.&lt;/span&gt;

'''''[[m:Special:MyLanguage/Tech/News|Actualités techniques]]''' préparées par les [[m:Special:MyLanguage/Tech/News/Writers|rédacteurs des actualités techniques]] et postées par [[m:Special:MyLanguage/User:MediaWiki message delivery|robot]]. [[m:Special:MyLanguage/Tech/News#contribute|Contribuer]]&amp;nbsp;• [[m:Special:MyLanguage/Tech/News/2025/04|Traduire]]&amp;nbsp;• [[m:Tech|Obtenir de l’aide]]&amp;nbsp;• [[m:Talk:Tech/News|Donner son avis]]&amp;nbsp;• [[m:Global message delivery/Targets/Tech ambassadors|S’abonner ou se désabonner]].''
&lt;/div&gt;&lt;section end=&quot;technews-2025-W04&quot;/&gt;

&lt;bdi lang=&quot;en&quot; dir=&quot;ltr&quot;&gt;[[User:MediaWiki message delivery|MediaWiki message delivery]]&lt;/bdi&gt; 21 janvier 2025 à 02:36 (CET)
&lt;!-- Message envoyé par User:Quiddity (WMF)@metawiki en utilisant la liste sur https://meta.wikimedia.org/w/index.php?title=Global_message_delivery/Targets/Tech_ambassadors&amp;oldid=28129769 --&gt;

== Universal Code of Conduct annual review: provide your comments on the UCoC and Enforcement Guidelines ==

&lt;div lang=&quot;en&quot; dir=&quot;ltr&quot; class=&quot;mw-content-ltr&quot;&gt;
My apologies for writing in English.
{{Int:Please-translate}}.

I am writing to you to let you know the annual review period for the Universal Code of Conduct and Enforcement Guidelines is open now. You can make suggestions for changes through 3 February 2025. This is the first step of several to be taken for the annual review.
[[m:Special:MyLanguage/Universal_Code_of_Conduct/Annual_review|Read more information and find a conversation to join on the UCoC page on Meta]].

The [[m:Special:MyLanguage/Universal_Code_of_Conduct/Coordinating_Committee|Universal Code of Conduct Coordinating Committee]] (U4C) is a global group dedicated to providing an equitable and consistent implementation of the UCoC. This annual review was planned and implemented by the U4C. For more information and the responsibilities of the U4C, [[m:Special:MyLanguage/Universal_Code_of_Conduct/Coordinating_Committee/Charter|you may review the U4C Charter]].

Please share this information with other members in your community wherever else might be appropriate.

-- In cooperation with the U4C, [[m:User:Keegan (WMF)|Keegan (WMF)]] ([[m:User talk:Keegan (WMF)|talk]]) 24 janvier 2025 à 02:10 (CET)
&lt;/div&gt;
&lt;!-- Message envoyé par User:Keegan (WMF)@metawiki en utilisant la liste sur https://meta.wikimedia.org/w/index.php?title=Distribution_list/Global_message_delivery&amp;oldid=27746256 --&gt;

== Actualités techniques n° 2025-05 ==

&lt;section begin=&quot;technews-2025-W05&quot;/&gt;&lt;div class=&quot;plainlinks&quot;&gt;
Dernières '''[[m:Special:MyLanguage/Tech/News|actualités techniques]]''' de la communauté technique de Wikimedia. N’hésitez pas à informer les autres utilisateurs de ces changements. Certains changements ne vous concernent pas. [[m:Special:MyLanguage/Tech/News/2025/05|D’autres traductions]] sont disponibles.

'''En lumière cette semaine'''
* &lt;span lang=&quot;en&quot; dir=&quot;ltr&quot; class=&quot;mw-content-ltr&quot;&gt;Patrollers and admins - what information or context about edits or users could help you to make patroller or admin decisions more quickly or easily? The Wikimedia Foundation wants to hear from you to help guide its upcoming annual plan. Please consider sharing your thoughts on this and [[m:Special:MyLanguage/Wikimedia Foundation Annual Plan/2025-2026/Product &amp; Technology OKRs|13 other questions]] to shape the technical direction for next year.&lt;/span&gt;

'''Actualités pour la contribution'''
* &lt;span lang=&quot;en&quot; dir=&quot;ltr&quot; class=&quot;mw-content-ltr&quot;&gt;iOS Wikipedia App users worldwide can now access a [[mw:Special:MyLanguage/Wikimedia Apps/Team/iOS/Personalized Wikipedia Year in Review/How your data is used|personalized Year in Review]] feature, which provides insights based on their reading and editing history on Wikipedia. This project is part of a broader effort to help welcome new readers as they discover and interact with encyclopedic content.&lt;/span&gt;
* [[File:Octicons-gift.svg|12px|link=|class=skin-invert|Concerne un souhait]] &lt;span lang=&quot;en&quot; dir=&quot;ltr&quot; class=&quot;mw-content-ltr&quot;&gt;Edit patrollers now have a new feature available that can highlight potentially problematic new pages. When a page is created with the same title as a page which was previously deleted, a tag ('Recreated') will now be added, which users can filter for in [[{{#special:RecentChanges}}]] and [[{{#special:NewPages}}]].&lt;/span&gt; [https://phabricator.wikimedia.org/T56145]
* &lt;span lang=&quot;en&quot; dir=&quot;ltr&quot; class=&quot;mw-content-ltr&quot;&gt;Later this week, there will be a new warning for editors if they attempt to create a redirect that links to another redirect (a [[mw:Special:MyLanguage/Help:Redirects#Double redirects|double redirect]]). The feature will recommend that they link directly to the second redirect's target page. Thanks to the user SomeRandomDeveloper for this improvement.&lt;/span&gt; [https://phabricator.wikimedia.org/T326056]
* [[File:Octicons-tools.svg|12px|link=|class=skin-invert|Sujet technique]] &lt;span lang=&quot;en&quot; dir=&quot;ltr&quot; class=&quot;mw-content-ltr&quot;&gt;Wikimedia wikis allow [[w:en:WebAuthn|WebAuthn]]-based second factor checks (such as hardware tokens) during login, but the feature is [[m:Community Wishlist Survey 2023/Miscellaneous/Fix security key (WebAuthn) support|fragile]] and has very few users. The MediaWiki Platform team is temporarily disabling adding new WebAuthn keys, to avoid interfering with the rollout of [[mw:MediaWiki Platform Team/SUL3|SUL3]] (single user login version 3). Existing keys are unaffected.&lt;/span&gt; [https://phabricator.wikimedia.org/T378402]
* [[File:Octicons-sync.svg|12px|link=|class=skin-invert|Sujet récurrent]] Voir {{PLURAL:30|la tâche soumise|les {{formatnum:30}} tâches soumises}} par la communauté [[m:Special:MyLanguage/Tech/News/Recently resolved community tasks|résolue{{PLURAL:30||s}} la semaine dernière]].

'''Actualités pour la contribution technique'''

* &lt;span lang=&quot;en&quot; dir=&quot;ltr&quot; class=&quot;mw-content-ltr&quot;&gt;For developers that use the [[wikitech:Data Platform/Data Lake/Edits/MediaWiki history dumps|MediaWiki History dumps]]: The Data Platform Engineering team has added a couple of new fields to these dumps, to support the [[mw:Special:MyLanguage/Trust and Safety Product/Temporary Accounts|Temporary Accounts]] initiative. If you maintain software that reads those dumps, please review your code and the updated documentation, since the order of the fields in the row will change. There will also be one field rename: in the &lt;bdi lang=&quot;zxx&quot; dir=&quot;ltr&quot;&gt;&lt;code&gt;mediawiki_user_history&lt;/code&gt;&lt;/bdi&gt; dump, the &lt;bdi lang=&quot;zxx&quot; dir=&quot;ltr&quot;&gt;&lt;code&gt;anonymous&lt;/code&gt;&lt;/bdi&gt; field will be renamed to &lt;bdi lang=&quot;zxx&quot; dir=&quot;ltr&quot;&gt;&lt;code&gt;is_anonymous&lt;/code&gt;&lt;/bdi&gt;. The changes will take effect with the next release of the dumps in February.&lt;/span&gt; [https://lists.wikimedia.org/hyperkitty/list/wikitech-l@lists.wikimedia.org/thread/LKMFDS62TXGDN6L56F4ABXYLN7CSCQDI/] 

'''''[[m:Special:MyLanguage/Tech/News|Actualités techniques]]''' préparées par les [[m:Special:MyLanguage/Tech/News/Writers|rédacteurs des actualités techniques]] et postées par [[m:Special:MyLanguage/User:MediaWiki message delivery|robot]]. [[m:Special:MyLanguage/Tech/News#contribute|Contribuer]]&amp;nbsp;• [[m:Special:MyLanguage/Tech/News/2025/05|Traduire]]&amp;nbsp;• [[m:Tech|Obtenir de l’aide]]&amp;nbsp;• [[m:Talk:Tech/News|Donner son avis]]&amp;nbsp;• [[m:Global message delivery/Targets/Tech ambassadors|S’abonner ou se désabonner]].''
&lt;/div&gt;&lt;section end=&quot;technews-2025-W05&quot;/&gt;

&lt;bdi lang=&quot;en&quot; dir=&quot;ltr&quot;&gt;[[User:MediaWiki message delivery|MediaWiki message delivery]]&lt;/bdi&gt; 27 janvier 2025 à 23:14 (CET)
&lt;!-- Message envoyé par User:Quiddity (WMF)@metawiki en utilisant la liste sur https://meta.wikimedia.org/w/index.php?title=Global_message_delivery/Targets/Tech_ambassadors&amp;oldid=28149374 --&gt;

== Reminder: first part of the annual UCoC review closes soon ==

&lt;div lang=&quot;en&quot; dir=&quot;ltr&quot; class=&quot;mw-content-ltr&quot;&gt;
My apologies for writing in English.
{{Int:Please-translate}}.

This is a reminder that the first phase of the annual review period for the Universal Code of Conduct and Enforcement Guidelines will be closing soon. You can make suggestions for changes through [[d:Q614092|the end of day]], 3 February 2025. This is the first step of several to be taken for the annual review.
[[m:Special:MyLanguage/Universal_Code_of_Conduct/Annual_review|Read more information and find a conversation to join on the UCoC page on Meta]]. After review of the feedback, proposals for updated text will be published on Meta in March for another round of community review. 

Please share this information with other members in your community wherever else might be appropriate.

-- In cooperation with the U4C, [[m:User:Keegan (WMF)|Keegan (WMF)]] ([[m:User talk:Keegan (WMF)|talk]]) 3 février 2025 à 01:48 (CET)
&lt;/div&gt;
&lt;!-- Message envoyé par User:Keegan (WMF)@metawiki en utilisant la liste sur https://meta.wikimedia.org/w/index.php?title=Distribution_list/Global_message_delivery&amp;oldid=28198931 --&gt;

== &lt;span lang=&quot;en&quot; dir=&quot;ltr&quot;&gt;Tech News: 2025-06&lt;/span&gt; ==

&lt;div lang=&quot;en&quot; dir=&quot;ltr&quot;&gt;
&lt;section begin=&quot;technews-2025-W06&quot;/&gt;&lt;div class=&quot;plainlinks&quot;&gt;
Latest '''[[m:Special:MyLanguage/Tech/News|tech news]]''' from the Wikimedia technical community. Please tell other users about these changes. Not all changes will affect you. [[m:Special:MyLanguage/Tech/News/2025/06|Translations]] are available.

'''Updates for editors'''
* Editors who use the &quot;Special characters&quot; editing-toolbar menu can now see the 32 special characters you have used most recently, across editing sessions on that wiki. This change should help make it easier to find the characters you use most often. The feature is in both the 2010 wikitext editor and VisualEditor. [https://phabricator.wikimedia.org/T110722]
* Editors using the 2010 wikitext editor can now create sublists with correct indentation by selecting the line(s) you want to indent and then clicking the toolbar buttons.[https://phabricator.wikimedia.org/T380438] You can now also insert &lt;code&gt;&lt;nowiki&gt;&lt;code&gt;&lt;/nowiki&gt;&lt;/code&gt; tags using a new toolbar button.[https://phabricator.wikimedia.org/T383010] Thanks to user stjn for these improvements.
* Help is needed to ensure the [[mw:Special:MyLanguage/Citoid/Enabling Citoid on your wiki|citation generator]] works properly on each wiki.
** (1) Administrators should update the local versions of the page &lt;code dir=ltr&gt;MediaWiki:Citoid-template-type-map.json&lt;/code&gt; to include entries for &lt;code dir=ltr&gt;preprint&lt;/code&gt;, &lt;code dir=ltr&gt;standard&lt;/code&gt;, and &lt;code dir=ltr&gt;dataset&lt;/code&gt;; Here are example diffs to replicate [https://en.wikipedia.org/w/index.php?title=MediaWiki%3ACitoid-template-type-map.json&amp;diff=1189164774&amp;oldid=1165783565 for 'preprint'] and [https://en.wikipedia.org/w/index.php?title=MediaWiki%3ACitoid-template-type-map.json&amp;diff=1270832208&amp;oldid=1270828390 for 'standard' and 'dataset'].
** (2.1) If the citoid map in the citation template used for these types of references is missing, [[mediawikiwiki:Citoid/Enabling Citoid on your wiki#Step 2.a: Create a 'citoid' maps value for each citation template|one will need to be added]]. (2.2) If the citoid map does exist, the TemplateData will need to be updated to include new field names. Here are example updates [https://en.wikipedia.org/w/index.php?title=Template%3ACitation%2Fdoc&amp;diff=1270829051&amp;oldid=1262470053 for 'preprint'] and [https://en.wikipedia.org/w/index.php?title=Template%3ACitation%2Fdoc&amp;diff=1270831369&amp;oldid=1270829480 for 'standard' and 'dataset']. The new fields that may need to be supported are &lt;code dir=ltr&gt;archiveID&lt;/code&gt;, &lt;code dir=ltr&gt;identifier&lt;/code&gt;, &lt;code dir=ltr&gt;repository&lt;/code&gt;, &lt;code dir=ltr&gt;organization&lt;/code&gt;, &lt;code dir=ltr&gt;repositoryLocation&lt;/code&gt;, &lt;code dir=ltr&gt;committee&lt;/code&gt;, and &lt;code dir=ltr&gt;versionNumber&lt;/code&gt;. [https://phabricator.wikimedia.org/T383666]
* One new wiki has been created: a {{int:project-localized-name-group-wikipedia/en}} in [[d:Q15637215|Central Kanuri]] ([[w:knc:|&lt;code&gt;w:knc:&lt;/code&gt;]]) [https://phabricator.wikimedia.org/T385181]
* [[File:Octicons-sync.svg|12px|link=|class=skin-invert|Recurrent item]] View all {{formatnum:27}} community-submitted {{PLURAL:27|task|tasks}} that were [[m:Special:MyLanguage/Tech/News/Recently resolved community tasks|resolved last week]]. For example, the [[mediawikiwiki:Special:MyLanguage/Help:Extension:Wikisource/Wikimedia OCR|OCR (optical character recognition) tool]] used for Wikisource now supports a new language, Church Slavonic. [https://phabricator.wikimedia.org/T384782]

'''''[[m:Special:MyLanguage/Tech/News|Tech news]]''' prepared by [[m:Special:MyLanguage/Tech/News/Writers|Tech News writers]] and posted by [[m:Special:MyLanguage/User:MediaWiki message delivery|bot]]&amp;nbsp;• [[m:Special:MyLanguage/Tech/News#contribute|Contribute]]&amp;nbsp;• [[m:Special:MyLanguage/Tech/News/2025/06|Translate]]&amp;nbsp;• [[m:Tech|Get help]]&amp;nbsp;• [[m:Talk:Tech/News|Give feedback]]&amp;nbsp;• [[m:Global message delivery/Targets/Tech ambassadors|Subscribe or unsubscribe]].''
&lt;/div&gt;&lt;section end=&quot;technews-2025-W06&quot;/&gt;
&lt;/div&gt;

&lt;bdi lang=&quot;en&quot; dir=&quot;ltr&quot;&gt;[[User:MediaWiki message delivery|MediaWiki message delivery]]&lt;/bdi&gt; 4 février 2025 à 01:08 (CET)
&lt;!-- Message envoyé par User:Quiddity (WMF)@metawiki en utilisant la liste sur https://meta.wikimedia.org/w/index.php?title=Global_message_delivery/Targets/Tech_ambassadors&amp;oldid=28203495 --&gt;

== &lt;span lang=&quot;en&quot; dir=&quot;ltr&quot;&gt;Tech News: 2025-07&lt;/span&gt; ==

&lt;div lang=&quot;en&quot; dir=&quot;ltr&quot;&gt;
&lt;section begin=&quot;technews-2025-W07&quot;/&gt;&lt;div class=&quot;plainlinks&quot;&gt;
Latest '''[[m:Special:MyLanguage/Tech/News|tech news]]''' from the Wikimedia technical community. Please tell other users about these changes. Not all changes will affect you. [[m:Special:MyLanguage/Tech/News/2025/07|Translations]] are available.

'''Weekly highlight'''

* The Product and Technology Advisory Council (PTAC) has published [[m:Special:MyLanguage/Product and Technology Advisory Council/February 2025 draft PTAC recommendation for feedback|a draft of their recommendations]] for the Wikimedia Foundation's Product and Technology department. They have recommended focusing on [[m:Special:MyLanguage/Product and Technology Advisory Council/February 2025 draft PTAC recommendation for feedback/Mobile experiences|mobile experiences]], particularly contributions. They request community [[m:Talk:Product and Technology Advisory Council/February 2025 draft PTAC recommendation for feedback|feedback at the talk page]] by 21 February.

'''Updates for editors'''
* The &quot;Special pages&quot; portlet link will be moved from the &quot;Toolbox&quot; into the &quot;Navigation&quot; section of the main menu's sidebar by default. This change is because the Toolbox is intended for tools relating to the current page, not tools relating to the site, so the link will be more logically and consistently located. To modify this behavior and update CSS styling, administrators can follow the instructions at [[phab:T385346|T385346]]. [https://phabricator.wikimedia.org/T333211]
* As part of this year's work around improving the ways readers discover content on the wikis, the Web team will be running an experiment with a small number of readers that displays some suggestions for related or interesting articles within the search bar. Please check out [[mw:Special:MyLanguage/Reading/Web/Content Discovery Experiments#Experiment 1: Display article recommendations in more prominent locations, search|the project page]] for more information.
* [[File:Octicons-tools.svg|12px|link=|class=skin-invert|Advanced item]] Template editors who use TemplateStyles can now customize output for users with specific accessibility needs by using accessibility related media queries (&lt;code dir=ltr&gt;[https://developer.mozilla.org/en-US/docs/Web/CSS/@media/prefers-reduced-motion prefers-reduced-motion]&lt;/code&gt;, &lt;code dir=ltr&gt;[https://developer.mozilla.org/en-US/docs/Web/CSS/@media/prefers-reduced-transparency prefers-reduced-transparency]&lt;/code&gt;, &lt;code dir=ltr&gt;[https://developer.mozilla.org/en-US/docs/Web/CSS/@media/prefers-contrast prefers-contrast]&lt;/code&gt;, and &lt;code dir=ltr&gt;[https://developer.mozilla.org/en-US/docs/Web/CSS/@media/forced-colors forced-colors]&lt;/code&gt;). Thanks to user Bawolff for these improvements. [https://phabricator.wikimedia.org/T384175]
* [[File:Octicons-sync.svg|12px|link=|class=skin-invert|Recurrent item]] View all {{formatnum:22}} community-submitted {{PLURAL:22|task|tasks}} that were [[m:Special:MyLanguage/Tech/News/Recently resolved community tasks|resolved last week]]. For example, the global blocks log will now be shown directly on the {{#special:CentralAuth}} page, similarly to global locks, to simplify the workflows for stewards. [https://phabricator.wikimedia.org/T377024]

'''Updates for technical contributors'''
* Wikidata [[d:Special:MyLanguage/Help:Default values for labels and aliases|now supports a special language as a &quot;default for all languages&quot;]] for labels and aliases. This is to avoid excessive duplication of the same information across many languages. If your Wikidata queries use labels, you may need to update them as some existing labels are getting removed. [https://phabricator.wikimedia.org/T312511]
* The function &lt;code dir=&quot;ltr&quot;&gt;getDescription&lt;/code&gt; was invoked on every Wiki page read and accounts for ~2.5% of a page's total load time. The calculated value will now be cached, reducing load on Wikimedia servers. [https://phabricator.wikimedia.org/T383660]
* As part of the RESTBase deprecation [[mw:RESTBase/deprecation|effort]], the &lt;code dir=&quot;ltr&quot;&gt;/page/related&lt;/code&gt; endpoint has been blocked as of February 6, 2025, and will be removed soon. This timeline was chosen to align with the deprecation schedules for older Android and iOS versions. The stable alternative is the &quot;&lt;code dir=&quot;ltr&quot;&gt;morelike&lt;/code&gt;&quot; action API in MediaWiki, and [[gerrit:c/mediawiki/services/mobileapps/+/982154/13/pagelib/src/transform/FooterReadMore.js|a migration example]] is available. The MediaWiki Interfaces team [[phab:T376297|can be contacted]] for any questions. [https://lists.wikimedia.org/hyperkitty/list/wikitech-l@lists.wikimedia.org/thread/GFC2IJO7L4BWO3YTM7C5HF4MCCBE2RJ2/]

'''In depth'''

* The latest quarterly [[mw:Special:MyLanguage/Wikimedia Language and Product Localization/Newsletter/2025/January|Language and Internationalization newsletter]] is available. It includes: Updates about the &quot;Contribute&quot; menu; details on some of the newest language editions of Wikipedia; details on new languages supported by the MediaWiki interface; updates on the Community-defined lists feature; and more. 
* The latest [[mw:Extension:Chart/Project/Updates#January 2025: Better visibility into charts and tabular data usage|Chart Project newsletter]] is available. It includes updates on the progress towards bringing better visibility into global charts usage and support for categorizing pages in the Data namespace on Commons.

'''''[[m:Special:MyLanguage/Tech/News|Tech news]]''' prepared by [[m:Special:MyLanguage/Tech/News/Writers|Tech News writers]] and posted by [[m:Special:MyLanguage/User:MediaWiki message delivery|bot]]&amp;nbsp;• [[m:Special:MyLanguage/Tech/News#contribute|Contribute]]&amp;nbsp;• [[m:Special:MyLanguage/Tech/News/2025/07|Translate]]&amp;nbsp;• [[m:Tech|Get help]]&amp;nbsp;• [[m:Talk:Tech/News|Give feedback]]&amp;nbsp;• [[m:Global message delivery/Targets/Tech ambassadors|Subscribe or unsubscribe]].''
&lt;/div&gt;&lt;section end=&quot;technews-2025-W07&quot;/&gt;
&lt;/div&gt;

&lt;bdi lang=&quot;en&quot; dir=&quot;ltr&quot;&gt;[[User:MediaWiki message delivery|MediaWiki message delivery]]&lt;/bdi&gt; 11 février 2025 à 01:11 (CET)
&lt;!-- Message envoyé par User:Quiddity (WMF)@metawiki en utilisant la liste sur https://meta.wikimedia.org/w/index.php?title=Global_message_delivery/Targets/Tech_ambassadors&amp;oldid=28231022 --&gt;

== Actualités techniques n° 2025-08 ==

&lt;section begin=&quot;technews-2025-W08&quot;/&gt;&lt;div class=&quot;plainlinks&quot;&gt;
Dernières '''[[m:Special:MyLanguage/Tech/News|actualités techniques]]''' de la communauté technique de Wikimedia. N’hésitez pas à informer les autres utilisateurs de ces changements. Certains changements ne vous concernent pas. [[m:Special:MyLanguage/Tech/News/2025/08|D’autres traductions]] sont disponibles.

'''En lumière cette semaine'''
* Les communautés utilisant les outils de croissance peuvent désormais mettre en avant un évènement pour les nouveaux contributeurs sur la &lt;code&gt;{{#special:Homepage}}&lt;/code&gt;. Cette fonctionnalité aidera les nouveaux venus à être informés des activités d'édition auxquels ils peuvent participer. Les administrateurs peuvent ajouter un nouvel évènement à mettre en avant sur &lt;code&gt;{{#special:CommunityConfiguration}}&lt;/code&gt;. Pour en apprendre davantage sur cette nouvelle fonctionnalité, vous pouvez lire [[diffblog:2025/02/12/community-updates-module-connecting-newcomers-to-your-initiatives/|l'annonce sur Diff]], la [[mw:Special:MyLanguage/Help:Growth/Tools/Community updates module|documentation]] ou [[mw:Talk:Growth|contacter l'équipe Croissance]].

'''Actualités pour la contribution'''
[[File:Page Frame Features on desktop.png|thumb|Mise en évidence des améliorations aux pages de discussion]]
* À partir de la semaine prochaine, les pages de discussions des wikis suivants recevront [[diffblog:2024/05/02/making-talk-pages-better-for-everyone/|une nouvelle présentation]] : {{int:project-localized-name-eswiki/fr}}{{int:comma-separator/fr}}{{int:project-localized-name-frwiki/fr}}{{int:comma-separator/fr}}{{int:project-localized-name-itwiki/fr}}{{int:comma-separator/fr}}{{int:project-localized-name-jawiki/fr}}. Ce changement a été largement testé en tant que fonctionnalité beta et il s'agit de la dernière étape des [[mw:Special:MyLanguage/Talk pages project/Feature summary|améliorations aux pages de discussion]]. [https://phabricator.wikimedia.org/T379102]
* Vous pouvez désormais visualiser une page de redirection directement depuis ses pages d'action, comme la page d'historique. Auparavant, vous étiez automatiquement redirigé vers la page cible et deviez manuellement revenir à la page de redirection. Ce changement devrait aider les rédacteurs travaillant avec les redirections. Merci à stjn pour cette amélioration. [https://phabricator.wikimedia.org/T5324]
* Quand une référence est utilisée de nombreuses fois, les wikis affichent actuellement des nombres comme 1.23 ou des marqueurs avec des lettres comme a, b, c dans la liste de références. Avant, quand le nombre de références était trop important et que toutes les lettres avaient été utilisées, un [[MediaWiki:Cite error references no backlink label|message d'erreur]] était affiché. Dans le cadre des travaux pour la [[phab:T383036|modernisation de la personnalisation des références]], ces erreurs ne seront plus affichées et des marqueurs numériques comme 1.27 seront utilisés par défaut après épuisement des marqueurs alphabétiques.
* Les entrées de journal pour chaque changement aux groupes utilisateur d'un éditeur ont été clarifiés pour indiquer exactement ce qui a été modifié. Elles contenaient auparavant les deux listes des groupes avant et après le changement. Les traducteurs sont invités à [[phab:T369466|aider à traduire les messages système associés]]. Merci à Msz2001 pour ces améliorations.
* Un nouveau filtre a été ajouté à [[{{#special:Nuke}}]] — outil permettant aux administrateurs de supprimer en masse des pages — pour permettre aux utilisateurs de filtrer les pages en fonction de leur taille en octets. Cela permet par exemple de supprimer uniquement des pages inférieures à une certaine taille. [https://phabricator.wikimedia.org/T378488]
* Les non-administrateurs peuvent maintenant voir quelles pages peuvent être supprimées à l'aide de [[{{#special:Nuke}}]]. Merci à MolecularPilot pour cette amélioration et les précédentes. [https://phabricator.wikimedia.org/T376378]
* [[File:Octicons-sync.svg|12px|link=|class=skin-invert|Sujet récurrent]] Voir {{PLURAL:25|la tâche soumise|les {{formatnum:25}} tâches soumises}} par la communauté [[m:Special:MyLanguage/Tech/News/Recently resolved community tasks|résolue{{PLURAL:25||s}} la semaine dernière]]. Par exemple, un bug a été corrigé dans la configuration du format de fichier vidéo AV1, ce qui permet à ces fichiers d'être lus à nouveau. [https://phabricator.wikimedia.org/T382193]

'''Actualités pour la contribution technique'''
* Parsoid Read Views sera déployé sur la plupart des Wiktionnaires dans les prochaines semaines, à la suite de la transition avec succès des Wikivoyage à Parsoid l'année dernière. Pour davantage d'informations, voir la page du projet [[mw:Special:MyLanguage/Parsoid/Parser Unification|Parsoid/Parser Unification]]. [https://phabricator.wikimedia.org/T385923][https://phabricator.wikimedia.org/T371640]
* Les développeurs d'outils sur wiki sont informés que &lt;code dir=ltr&gt;mw.Uri&lt;/code&gt; est obsolète. Les outils nécessitant &lt;code dir=ltr&gt;mw.Uri&lt;/code&gt; doivent déclarer explicitement &lt;code dir=ltr&gt;mediawiki.Uri&lt;/code&gt; comme une dépendance de ResourceLoader, et devraient migrer vers l'API &lt;code dir=ltr&gt;URL&lt;/code&gt; native du navigateur prochainement. [https://phabricator.wikimedia.org/T384515]

'''''[[m:Special:MyLanguage/Tech/News|Actualités techniques]]''' préparées par les [[m:Special:MyLanguage/Tech/News/Writers|rédacteurs des actualités techniques]] et postées par [[m:Special:MyLanguage/User:MediaWiki message delivery|robot]]. [[m:Special:MyLanguage/Tech/News#contribute|Contribuer]]&amp;nbsp;• [[m:Special:MyLanguage/Tech/News/2025/08|Traduire]]&amp;nbsp;• [[m:Tech|Obtenir de l’aide]]&amp;nbsp;• [[m:Talk:Tech/News|Donner son avis]]&amp;nbsp;• [[m:Global message delivery/Targets/Tech ambassadors|S’abonner ou se désabonner]].''
&lt;/div&gt;&lt;section end=&quot;technews-2025-W08&quot;/&gt;

&lt;bdi lang=&quot;en&quot; dir=&quot;ltr&quot;&gt;[[User:MediaWiki message delivery|MediaWiki message delivery]]&lt;/bdi&gt; 17 février 2025 à 22:16 (CET)
&lt;!-- Message envoyé par User:Quiddity (WMF)@metawiki en utilisant la liste sur https://meta.wikimedia.org/w/index.php?title=Global_message_delivery/Targets/Tech_ambassadors&amp;oldid=28275610 --&gt;

== &lt;span lang=&quot;en&quot; dir=&quot;ltr&quot;&gt; Upcoming Language Community Meeting (Feb 28th, 14:00 UTC) and Newsletter&lt;/span&gt; ==

&lt;div lang=&quot;en&quot; dir=&quot;ltr&quot;&gt;
&lt;section begin=&quot;message&quot;/&gt;
Hello everyone!
[[File:WP20Symbols WIKI INCUBATOR.svg|right|frameless|150x150px|alt=An image symbolising multiple languages]]
We’re excited to announce that the next '''Language Community Meeting''' is happening soon, '''February 28th at 14:00 UTC'''! If you’d like to join, simply sign up on the '''[[mw:Wikimedia_Language_and_Product_Localization/Community_meetings#28_February_2025|wiki page]]'''.

This is a participant-driven meeting where we share updates on language-related projects, discuss technical challenges in language wikis, and collaborate on solutions. In our last meeting, we covered topics like developing language keyboards, creating the Moore Wikipedia, and updates from the language support track at Wiki Indaba.

'''Got a topic to share?''' Whether it’s a technical update from your project, a challenge you need help with, or a request for interpretation support, we’d love to hear from you! Feel free to '''reply to this message''' or add agenda items to the document '''[[etherpad:p/language-community-meeting-feb-2025|here]]'''.

Also, we wanted to highlight that the sixth edition of the Language &amp; Internationalization newsletter (January 2025) is available here: [[:mw:Special:MyLanguage/Wikimedia Language and Product Localization/Newsletter/2025/January|Wikimedia Language and Product Localization/Newsletter/2025/January]]. This newsletter provides updates from the October–December 2024 quarter on new feature development, improvements in various language-related technical projects and support efforts, details about community meetings, and ideas for contributing to projects. To stay updated, you can subscribe to the newsletter on its wiki page: [[:mw:Wikimedia Language and Product Localization/Newsletter|Wikimedia Language and Product Localization/Newsletter]].

We look forward to your ideas and participation at the language community meeting, see you there!
&lt;section end=&quot;message&quot;/&gt;
&lt;/div&gt;

&lt;bdi lang=&quot;en&quot; dir=&quot;ltr&quot;&gt;[[User:MediaWiki message delivery|MediaWiki message delivery]]&lt;/bdi&gt; 22 février 2025 à 09:28 (CET)
&lt;!-- Message envoyé par User:SSethi (WMF)@metawiki en utilisant la liste sur https://meta.wikimedia.org/w/index.php?title=Distribution_list/Global_message_delivery&amp;oldid=28217779 --&gt;

== Actualités techniques n° 2025-09 ==

&lt;section begin=&quot;technews-2025-W09&quot;/&gt;&lt;div class=&quot;plainlinks&quot;&gt;
Dernières '''[[m:Special:MyLanguage/Tech/News|actualités techniques]]''' de la communauté technique de Wikimedia. N’hésitez pas à informer les autres utilisateurs de ces changements. Certains changements ne vous concernent pas. [[m:Special:MyLanguage/Tech/News/2025/09|D’autres traductions]] sont disponibles.

'''Actualités pour la contribution'''
* Les administrateurs peuvent désormais personnaliser la manière dont les catégories de [[m:Special:MyLanguage/User language|Babel]] sont créées en utilisant [[{{#special:CommunityConfiguration/Babel}}]]. Ils peuvent renommer les catégories de langues, choisir si elles doivent être créées automatiquement et ajuster d'autres paramètres. [https://phabricator.wikimedia.org/T374348]
* Le portail &lt;bdi lang=&quot;en&quot; dir=&quot;ltr&quot;&gt;[https://www.wikimedia.org/ wikimedia.org]&lt;/bdi&gt; a été mis à jour pour moderniser et améliorer l'accessibilité de nos pages de portail. Il dispose désormais d'un meilleur support pour les mises en page mobiles, de meilleures formulations et liens et d'un support linguistique amélioré. De plus, tous les portails du projet Wikimedia, comme &lt;bdi lang=&quot;en&quot; dir=&quot;ltr&quot;&gt;[https://wikibooks.org wikibooks.org]&lt;/bdi&gt;, prennent maintenant en charge le mode sombre lorsqu'un lecteur utilise ce paramètre système. [https://phabricator.wikimedia.org/T373204][https://phabricator.wikimedia.org/T368221][https://meta.wikimedia.org/wiki/Project_portals]
* Un nouveau wiki a été créé : un {{int:project-localized-name-group-wiktionary/fr}} en [[d:Q33965|Santali]] ([[wikt:sat:|&lt;code&gt;wikt:sat:&lt;/code&gt;]]) [https://phabricator.wikimedia.org/T386619]
* [[File:Octicons-sync.svg|12px|link=|class=skin-invert|Sujet récurrent]] Voir {{PLURAL:30|la tâche soumise|les {{formatnum:30}} tâches soumises}} par la communauté [[m:Special:MyLanguage/Tech/News/Recently resolved community tasks|résolue{{PLURAL:30||s}} la semaine dernière]]. Par exemple, un bogue qui empêchait de cliquer sur les résultats de recherche de l'interface web sur certaines configurations mobiles avec Firefox a été corrigé. [https://phabricator.wikimedia.org/T381289]

'''Rencontres et évènements'''
* La prochaine rencontre de la communauté linguistique aura lieu le 28 février à [https://zonestamp.toolforge.org/1740751200 14:00 UTC]. La rencontre de cette semaine couvrira : les points importants et mises-à-jour techniques pour les langues samis, les contributions à translatewiki.net de la part de la communauté Bahasa Lampung en Indonésie et une FAQ technique. Si vous souhaitez participer, inscrivez-vous sur la [[mw:Wikimedia Language and Product Localization/Community meetings#28 February 2025|page wiki]].

'''''[[m:Special:MyLanguage/Tech/News|Actualités techniques]]''' préparées par les [[m:Special:MyLanguage/Tech/News/Writers|rédacteurs des actualités techniques]] et postées par [[m:Special:MyLanguage/User:MediaWiki message delivery|robot]]. [[m:Special:MyLanguage/Tech/News#contribute|Contribuer]]&amp;nbsp;• [[m:Special:MyLanguage/Tech/News/2025/09|Traduire]]&amp;nbsp;• [[m:Tech|Obtenir de l’aide]]&amp;nbsp;• [[m:Talk:Tech/News|Donner son avis]]&amp;nbsp;• [[m:Global message delivery/Targets/Tech ambassadors|S’abonner ou se désabonner]].''
&lt;/div&gt;&lt;section end=&quot;technews-2025-W09&quot;/&gt;

&lt;bdi lang=&quot;en&quot; dir=&quot;ltr&quot;&gt;[[User:MediaWiki message delivery|MediaWiki message delivery]]&lt;/bdi&gt; 25 février 2025 à 01:41 (CET)
&lt;!-- Message envoyé par User:Quiddity (WMF)@metawiki en utilisant la liste sur https://meta.wikimedia.org/w/index.php?title=Global_message_delivery/Targets/Tech_ambassadors&amp;oldid=28296129 --&gt;

== Actualités techniques n° 2025-10 ==

&lt;section begin=&quot;technews-2025-W10&quot;/&gt;&lt;div class=&quot;plainlinks&quot;&gt;
Dernières '''[[m:Special:MyLanguage/Tech/News|actualités techniques]]''' de la communauté technique de Wikimedia. N’hésitez pas à informer les autres utilisateurs de ces changements. Certains changements ne vous concernent pas. [[m:Special:MyLanguage/Tech/News/2025/10|D’autres traductions]] sont disponibles.

'''Actualités pour la contribution'''
* Les utilisateurs et utilisatrices connectés utilisant l’affichage mobile peuvent désormais modifier une page complète. Le lien « {{int:Minerva-page-actions-editfull}} » est accessible dans le menu « {{int:minerva-page-actions-overflow}} » de la barre d’outils. Ce lien était auparavant disponible uniquement lorsque le [[mw:Special:MyLanguage/Reading/Web/Advanced mobile contributions|mode avancé]] était activé. [https://phabricator.wikimedia.org/T387180]
* Les admins d’interface peuvent désormais retirer les utilisations de la classe CSS « &lt;code dir=&quot;ltr&quot;&gt;mw-ref&lt;/code&gt; » de leur &lt;bdi lang=&quot;en&quot; dir=&quot;ltr&quot;&gt;[[MediaWiki:Common.css]]&lt;/bdi&gt; local. Cette classe de l’extension &lt;span lang=&quot;en&quot;&gt;Cite&lt;/span&gt; est obsolète. La liste des wikis l’utilisant peut être trouvée par [https://global-search.toolforge.org/?q=mw-ref%5B%5E-a-z%5D&amp;regex=1&amp;namespaces=8&amp;title=.*css cette recherche globale] et dans [https://ace.wikipedia.org/w/index.php?title=MediaWiki:Common.css&amp;oldid=145662#L-139--L-144 cet exemple]. D’autres informations sur les manières d’aider sont données sur la [[mw:Parsoid/Parser Unification/Cite CSS|page du projet de migration du CSS]]. Les appels de note (&lt;code dir=&quot;ltr&quot;&gt;[1]&lt;/code&gt;) sont désormais rendus par [[mw:Special:MyLanguage/Parsoid|Parsoid]] ; le CSS obsolète n’est plus nécessaire. Le CSS pour les rétroliens « &lt;code dir=&quot;ltr&quot;&gt;mw:referencedBy&lt;/code&gt; » doit rester en place pour le moment. Ce nettoyage ne devrait pas avoir d’effet visible pour les lecteurs et lectrices. Merci d’aider à retirer ce code avant le 30 mars, après quoi l’équipe de développement le fera pour vous.
* Lorsque les contributeurs ajoutent un fichier (par exemple &lt;code&gt;&lt;nowiki&gt;[[File:MediaWiki.png]]&lt;/nowiki&gt;&lt;/code&gt;) sur une page protégée par une protection en cascade, le logiciel ne restreindra plus les modifications à la page de description du fichier, mais uniquement aux nouveaux téléchargements de fichiers. [https://phabricator.wikimedia.org/T24521] A l’inverse, la transclusion d’une page de description de fichier (par exemple &lt;code&gt;&lt;nowiki&gt;{{:File:MediaWiki.png}}&lt;/nowiki&gt;&lt;/code&gt;) dans une page protégée en cascade provoquera désormais une restriction des modifications à la page.[https://phabricator.wikimedia.org/T62109]
* Remettre un fichier dans une version antérieure nécessitera désormais les mêmes autorisations que le téléchargement d'une nouvelle version du fichier. Le logiciel vérifie désormais la possession des droits « &lt;i lang=&quot;en&quot;&gt;reupload&lt;/i&gt; » ou « &lt;i lang=&quot;en&quot;&gt;reuplod-own&lt;/i&gt; » [https://phabricator.wikimedia.org/T304474], et respecte la protection en cascade. [https://phabricator.wikimedia.org/T140010]
* Lorsque les admins listent des pages à supprimer avec l’outil Nuke, ils peuvent désormais également répertorier les pages de discussion associées et les redirections à supprimer, en plus des pages créées par la cible, plutôt que de devoir supprimer manuellement ces pages. [https://phabricator.wikimedia.org/T95797]
* La mise à jour [[m:Special:MyLanguage/Tech/News/2025/03|mentionnée précédemment]] de la connexion utilisateur unifiée, qui prendra en compte les restrictions du navigateur sur les cookies inter-domaines en déplaçant la connexion et la création de compte vers un domaine central, sera déployée pour tous les utilisateurs et utilisatrices en mars et avril. L'équipe prévoit de l'activer pour toutes les nouvelles créations de compte sur les wikis du [[wikitech:Deployments/Train#Tuesday|groupe 0]] cette semaine. Consultez la [[mw:Special:MyLanguage/MediaWiki Platform Team/SUL3#Deployment|page du projet SUL3]] pour plus de détails et un calendrier mis à jour.
* Depuis la semaine dernière, un bogue cause l'affichage de certaines icônes d'interface sous forme de carrés noirs jusqu'à ce que la page soit entièrement chargée. Cela sera corrigé cette semaine. [https://phabricator.wikimedia.org/T387351]
* Un nouveau wiki a été créé : une {{int:project-localized-name-group-wikipedia/fr}} en [[d:Q2044560|sylheti]] ([[w:syl:|&lt;code&gt;w:syl:&lt;/code&gt;]]) [https://phabricator.wikimedia.org/T386441]
* [[File:Octicons-sync.svg|12px|link=|class=skin-invert|Sujet récurrent]] Voir {{PLURAL:23|la tâche soumise|les {{formatnum:23}} tâches soumises}} par la communauté [[m:Special:MyLanguage/Tech/News/Recently resolved community tasks|résolue{{PLURAL:23||s}} la semaine dernière]]. Par exemple, un bogue avec le chargement d'images dans de très anciennes versions du navigateur Firefox sur mobile a été corrigé. [https://phabricator.wikimedia.org/T386400]

'''Actualités pour la contribution technique'''
* [[File:Octicons-sync.svg|12px|link=|class=skin-invert|Sujet récurrent]] Détail des mises-à-jour à venir cette semaine : [[mw:MediaWiki 1.44/wmf.19|MediaWiki]]

'''''[[m:Special:MyLanguage/Tech/News|Actualités techniques]]''' préparées par les [[m:Special:MyLanguage/Tech/News/Writers|rédacteurs des actualités techniques]] et postées par [[m:Special:MyLanguage/User:MediaWiki message delivery|robot]]. [[m:Special:MyLanguage/Tech/News#contribute|Contribuer]]&amp;nbsp;• [[m:Special:MyLanguage/Tech/News/2025/10|Traduire]]&amp;nbsp;• [[m:Tech|Obtenir de l’aide]]&amp;nbsp;• [[m:Talk:Tech/News|Donner son avis]]&amp;nbsp;• [[m:Global message delivery/Targets/Tech ambassadors|S’abonner ou se désabonner]].''
&lt;/div&gt;&lt;section end=&quot;technews-2025-W10&quot;/&gt;

&lt;bdi lang=&quot;en&quot; dir=&quot;ltr&quot;&gt;[[User:MediaWiki message delivery|MediaWiki message delivery]]&lt;/bdi&gt; 4 mars 2025 à 03:30 (CET)
&lt;!-- Message envoyé par User:Quiddity (WMF)@metawiki en utilisant la liste sur https://meta.wikimedia.org/w/index.php?title=Global_message_delivery/Targets/Tech_ambassadors&amp;oldid=28334563 --&gt;

== Universal Code of Conduct annual review: proposed changes are available for comment ==

&lt;div lang=&quot;en&quot; dir=&quot;ltr&quot; class=&quot;mw-content-ltr&quot;&gt;
My apologies for writing in English.
{{Int:Please-translate}}.

I am writing to you to let you know that [[m:Special:MyLanguage/Universal_Code_of_Conduct/Annual_review/Proposed_Changes|proposed changes]] to the [[foundation:Special:MyLanguage/Policy:Universal_Code_of_Conduct/Enforcement_guidelines|Universal Code of Conduct (UCoC) Enforcement Guidelines]] and [[m:Special:MyLanguage/Universal_Code_of_Conduct/Coordinating_Committee/Charter|Universal Code of Conduct Coordinating Committee (U4C) Charter]] are open for review. '''[[m:Special:MyLanguage/Universal_Code_of_Conduct/Annual_review/Proposed_Changes|You can provide feedback on suggested changes]]''' through the [[d:Q614092|end of day]] on Tuesday, 18 March 2025. This is the second step in the annual review process, the final step will be community voting on the proposed changes.
[[m:Special:MyLanguage/Universal_Code_of_Conduct/Annual_review|Read more information and find relevant links about the process on the UCoC annual review page on Meta]].

The [[m:Special:MyLanguage/Universal_Code_of_Conduct/Coordinating_Committee|Universal Code of Conduct Coordinating Committee]] (U4C) is a global group dedicated to providing an equitable and consistent implementation of the UCoC. This annual review was planned and implemented by the U4C. For more information and the responsibilities of the U4C, [[m:Special:MyLanguage/Universal_Code_of_Conduct/Coordinating_Committee/Charter|you may review the U4C Charter]].

Please share this information with other members in your community wherever else might be appropriate.

-- In cooperation with the U4C, [[m:User:Keegan (WMF)|Keegan (WMF)]] 7 mars 2025 à 19:50 (CET)

&lt;/div&gt;
&lt;!-- Message envoyé par User:Keegan (WMF)@metawiki en utilisant la liste sur https://meta.wikimedia.org/w/index.php?title=Distribution_list/Global_message_delivery&amp;oldid=28307738 --&gt;

== Actualités techniques n° 2025-11 ==

&lt;section begin=&quot;technews-2025-W11&quot;/&gt;&lt;div class=&quot;plainlinks&quot;&gt;
Dernières '''[[m:Special:MyLanguage/Tech/News|actualités techniques]]''' de la communauté technique de Wikimedia. N’hésitez pas à informer les autres utilisateurs de ces changements. Certains changements ne vous concernent pas. [[m:Special:MyLanguage/Tech/News/2025/11|D’autres traductions]] sont disponibles.

'''Actualités pour la contribution'''
* Les contributeurs qui utilisent des gestionnaires de mots de passe sur plusieurs wikis peuvent remarquer des changements à l’avenir. La manière dont nos wikis fournissent des informations aux gestionnaires de mots de passe sur la réutilisation des mots de passe entre les domaines a été récemment mise à jour, de sorte que certains gestionnaires de mots de passe peuvent maintenant vous proposer des identifiants de connexion que vous avez sauvegardés pour un autre site Wikimedia. Certains gestionnaires de mots de passe l'ont déjà fait, et le font maintenant pour d'autres domaines de Wikimedia. Cela fait partie du projet [[mw:Special:MyLanguage/MediaWiki Platform Team/SUL3|SUL3]] qui vise à améliorer le fonctionnement de notre connexion unifiée et à la rendre compatible avec les changements en cours dans les navigateurs web que nous utilisons. [https://phabricator.wikimedia.org/T385520][https://phabricator.wikimedia.org/T384844]
* L'équipe des applications Wikipédia invite les utilisateurs intéressés à contribuer à l'amélioration de l'utilisation de Wikipédia hors ligne ou en internet limité. Après les discussions de [[m:Afrika Baraza|Afrika Baraza]] et la dernière [[m:Special:MyLanguage/ESEAP Hub/Meetings|conférence ESEAP]], des défis clés comme la recherche, la modification et l'accès hors ligne sont explorés, avec des groupes de discussion à venir pour approfondir ces sujets. Toutes les langues sont les bienvenues et des interprètes seront disponibles. Vous souhaitez partager vos idées ? [[mw:Special:MyLanguage/Wikimedia Apps/Improving Wikipedia Mobile Apps for Offline &amp; Limited Internet Use|Participez à la discussion]] ou envoyez un courriel à &lt;bdi lang=&quot;en&quot; dir=&quot;ltr&quot;&gt;aramadan@wikimedia.org&lt;/bdi&gt; !
* Tous les wikis seront en lecture seule pendant quelques minutes le 19 mars, à [https://zonestamp.toolforge.org/1742392800 14 h UTC]. De plus amples informations seront publiées dans les ''Actualités techniques'' et seront également publiées sur chaque wiki dans les semaines à venir.
* [[File:Octicons-sync.svg|12px|link=|class=skin-invert|Sujet récurrent]] Voir {{PLURAL:27|la tâche soumise|les {{formatnum:27}} tâches soumises}} par la communauté [[m:Special:MyLanguage/Tech/News/Recently resolved community tasks|résolue{{PLURAL:27||s}} la semaine dernière]].

'''Actualités pour la contribution technique'''
* [[File:Octicons-sync.svg|12px|link=|class=skin-invert|Sujet récurrent]] Détail des mises-à-jour à venir cette semaine : [[mw:MediaWiki 1.44/wmf.20|MediaWiki]]

'''En détails'''
* La dernière [[mw:Special:MyLanguage/Growth/Newsletters/33|infolettre trimestrielle du département Croissance]] est disponible. Elle présente : le lancement du module Actualités de la communauté, les dernières modifications de la configuration communautaire et le test à venir des suggestions d'articles pour les personnes contribuant pour la première fois.
* Une ancienne API utilisée dans l'application Android Wikipedia sera supprimée à la fin du mois de mars. Il n'y a pas d'utilisation logicielle en cours, mais les utilisateurs de l'application dont la version date de plus de 6 mois au moment de la suppression (2025-03-31), n'auront plus accès à la fonction Suggested Edits, jusqu'à ce qu'ils mettent à jour leur application. Vous pouvez [[diffblog:2025/02/24/sunset-of-wikimedia-recommendation-api/|lire plus de détails sur ce changement]].

'''''[[m:Special:MyLanguage/Tech/News|Actualités techniques]]''' préparées par les [[m:Special:MyLanguage/Tech/News/Writers|rédacteurs des actualités techniques]] et postées par [[m:Special:MyLanguage/User:MediaWiki message delivery|robot]]. [[m:Special:MyLanguage/Tech/News#contribute|Contribuer]]&amp;nbsp;• [[m:Special:MyLanguage/Tech/News/2025/11|Traduire]]&amp;nbsp;• [[m:Tech|Obtenir de l’aide]]&amp;nbsp;• [[m:Talk:Tech/News|Donner son avis]]&amp;nbsp;• [[m:Global message delivery/Targets/Tech ambassadors|S’abonner ou se désabonner]].''
&lt;/div&gt;&lt;section end=&quot;technews-2025-W11&quot;/&gt;

&lt;bdi lang=&quot;en&quot; dir=&quot;ltr&quot;&gt;[[User:MediaWiki message delivery|MediaWiki message delivery]]&lt;/bdi&gt; 11 mars 2025 à 00:09 (CET)
&lt;!-- Message envoyé par User:Quiddity (WMF)@metawiki en utilisant la liste sur https://meta.wikimedia.org/w/index.php?title=Global_message_delivery/Targets/Tech_ambassadors&amp;oldid=28372257 --&gt;

== Votre wiki sera bientôt en lecture seule ==

&lt;section begin=&quot;server-switch&quot;/&gt;&lt;div class=&quot;plainlinks&quot;&gt;

[[:m:Special:MyLanguage/Tech/Server switch|Lire ce message dans une autre langue]] • [https://meta.wikimedia.org/w/index.php?title=Special:Translate&amp;group=page-Tech%2FServer+switch&amp;language=&amp;action=page&amp;filter= {{int:please-translate}}]

La [[foundation:|Fondation Wikimedia]] va basculer le trafic entre ses centres de données. Cela permettra de s’assurer que Wikipédia et les autres wikis de Wikimedia peuvent rester en ligne même après une catastrophe.

Le trafic sera basculé le '''{{#time:j xg|2025-03-19|fr}}'''. La bascule débutera à '''[https://zonestamp.toolforge.org/{{#time:U|2025-03-19T14:00|en}} {{#time:H:i e|2025-03-19T14:00}}]'''.

Malheureusement, en raison de certaines limites de [[mw:Special:MyLanguage/Manual:What is MediaWiki?|MediaWiki]], toutes les modifications de pages devront être arrêtées durant le passage d’un centre de données à l’autre. Nous nous excusons pour ce dérangement, que nous nous efforçons de réduire pour le futur. 

Une bannière sera affichée sur tous les wikis 30 minutes avant le début de l’opération. Cette bannière restera visible jusqu’à la fin de l’opération. 

'''Pendant une courte période, vous pourrez lire les wikis mais pas les modifier.'''

*Vous ne pourrez pas effectuer de modification pendant une durée pouvant aller jusqu’à une heure, le {{#time:l j xg Y|2025-03-19|fr}}.
*Si vous essayez de faire une modification ou de sauvegarder pendant cette période, vous verrez un message d’erreur. Nous espérons qu’aucune modification ne sera perdue durant ce temps, mais nous ne pouvons le garantir. Si vous voyez un message d’erreur, merci de patienter jusqu’au retour à la normale. Vous pourrez alors enregistrer votre modification. Nous vous conseillons cependant de faire une copie de votre modification avant, au cas où.

''Autres conséquences :''

*Les tâches de fond seront ralenties et certaines pourraient être stoppées. Les liens rouges ne seront pas mis à jour aussi vite que d’habitude. Si vous créez un article qui est déjà lié depuis une autre page, le lien rouge pourrait rester rouge plus longtemps que d’habitude. Certains scripts ayant un long temps d’exécution devront être stoppés.
* Le déploiement de code devrait se dérouler comme chaque semaine. Cependant, certains codes particuliers pourraient être gelés si l’opération le nécessitait.
* [[mw:Special:MyLanguage/GitLab|GitLab]] sera indisponible durant environ 90 minutes.

Ce projet pourra être reporté si nécessaire. Vous pouvez [[wikitech:Switch_Datacenter|consulter le calendrier sur wikitech.wikimedia.org]]. Tout changement sera annoncé dans le calendrier. 

'''Merci de partager ces informations avec votre communauté.'''&lt;/div&gt;&lt;section end=&quot;server-switch&quot;/&gt;

&lt;bdi lang=&quot;en&quot; dir=&quot;ltr&quot;&gt;[[User:MediaWiki message delivery|MediaWiki message delivery]]&lt;/bdi&gt; 15 mars 2025 à 00:14 (CET)
&lt;!-- Message envoyé par User:Quiddity (WMF)@metawiki en utilisant la liste sur https://meta.wikimedia.org/w/index.php?title=Distribution_list/Non-Technical_Village_Pumps_distribution_list&amp;oldid=28307742 --&gt;

== &lt;span lang=&quot;en&quot; dir=&quot;ltr&quot;&gt;Tech News: 2025-12&lt;/span&gt; ==

&lt;div lang=&quot;en&quot; dir=&quot;ltr&quot;&gt;
&lt;section begin=&quot;technews-2025-W12&quot;/&gt;&lt;div class=&quot;plainlinks&quot;&gt;
Latest '''[[m:Special:MyLanguage/Tech/News|tech news]]''' from the Wikimedia technical community. Please tell other users about these changes. Not all changes will affect you. [[m:Special:MyLanguage/Tech/News/2025/12|Translations]] are available.

'''Weekly highlight'''
* Twice a year, around the equinoxes, the Wikimedia Foundation's Site Reliability Engineering (SRE) team performs [[m:Special:MyLanguage/Tech/Server switch|a datacenter server switchover]], redirecting all traffic from one primary server to its backup. This provides reliability in case of a crisis, as we can always fall back on the other datacenter. [http://listen.hatnote.com/ Thanks to the Listen to Wikipedia] tool, you can hear the switchover take place: Before it begins, you'll hear the steady stream of edits; Then, as the system enters a brief read-only phase, the sound stops for a couple of minutes, before resuming after the switchover. You can [[diffblog:2025/03/12/hear-that-the-wikis-go-silent-twice-a-year/|read more about the background and details of this process on the Diff blog]]. If you want to keep an ear out for the next server switchover, listen to the wikis on [https://zonestamp.toolforge.org/1742392800 March 19 at 14:00 UTC].

'''Updates for editors'''

* The [https://test.wikipedia.org/w/index.php?title=Special:ContentTranslation&amp;filter-type=automatic&amp;filter-id=previous-edits&amp;active-list=suggestions&amp;from=en&amp;to=es improved Content Translation tool dashboard] is now available in [[phab:T387820|10 Wikipedias]] and will be available for all Wikipedias [[phab:T387821|soon]]. With [[mw:Special:MyLanguage/Content translation#Improved translation experience|the unified dashboard]], desktop users can now: Translate new sections of an article; Discover and access topic-based [https://ig.m.wikipedia.org/w/index.php?title=Special:ContentTranslation&amp;active-list=suggestions&amp;from=en&amp;to=ig&amp;filter-type=automatic&amp;filter-id=previous-edits article suggestion filters] (initially available only for mobile device users); Discover and access the [[mw:Special:MyLanguage/Translation suggestions: Topic-based &amp; Community-defined lists|Community-defined lists]] filter, also known as &quot;Collections&quot;, from wiki-projects and campaigns.
* On Wikimedia Commons, a [[c:Commons:WMF support for Commons/Upload Wizard Improvements#Improve category selection|new system to select the appropriate file categories]] has been introduced: if a category has one or more subcategories, users will be able to click on an arrow that will open the subcategories directly within the form, and choose the correct one. The parent category name will always be shown on top, and it will always be possible to come back to it. This should decrease the amount of work for volunteers in fixing/creating new categories. The change is also available on mobile. These changes are part of planned improvements to the UploadWizard.
* The Community Tech team is seeking wikis to join a pilot for the [[m:Special:MyLanguage/Community Wishlist Survey 2023/Multiblocks|Multiblocks]] feature and a refreshed Special:Block page in late March. Multiblocks enables administrators to impose multiple different types of blocks on the same user at the same time. If you are an admin or steward and would like us to discuss joining the pilot with your community, please leave a message on the [[m:Talk:Community Wishlist Survey 2023/Multiblocks|project talk page]].
* Starting March 25, the Editing team will test a new feature for Edit Check at [[phab:T384372|12 Wikipedias]]: [[mw:Special:MyLanguage/Help:Edit check#Multi-check|Multi-Check]]. Half of the newcomers on these wikis will see all [[mw:Special:MyLanguage/Help:Edit check#ref|Reference Checks]] during their edit session, while the other half will continue seeing only one. The goal of this test is to see if users are confused or discouraged when shown multiple Reference Checks (when relevant) within a single editing session. At these wikis, the tags used on edits that show References Check will be simplified, as multiple tags could be shown within a single edit. Changes to the tags are documented [[phab:T373949|on Phabricator]]. [https://phabricator.wikimedia.org/T379131]
* The [[m:Special:MyLanguage/Global reminder bot|Global reminder bot]], which is a service for notifying users that their temporary user-rights are about to expire, now supports using the localized name of the user-rights group in the message heading. Translators can see the [[m:Global reminder bot/Translation|listing of existing translations and documentation]] to check if their language needs updating or creation.
* The [[Special:GlobalPreferences|GlobalPreferences]] gender setting, which is used for how the software should refer to you in interface messages, now works as expected by overriding the local defaults. [https://phabricator.wikimedia.org/T386584]
* [[File:Octicons-sync.svg|12px|link=|class=skin-invert|Recurrent item]] View all {{formatnum:26}} community-submitted {{PLURAL:26|task|tasks}} that were [[m:Special:MyLanguage/Tech/News/Recently resolved community tasks|resolved last week]]. For example, the Wikipedia App for Android had a bug fixed for when a user is browsing and searching in multiple languages. [https://phabricator.wikimedia.org/T379777]

'''Updates for technical contributors'''
* Later this week, the way that Codex styles are loaded will be changing. There is a small risk that this may result in unstyled interface message boxes on certain pages. User generated content (e.g. templates) is not impacted. Gadgets may be impacted. If you see any issues [[phab:T388847|please report them]]. See the linked task for details, screenshots, and documentation on how to fix any affected gadgets.
* [[File:Octicons-sync.svg|12px|link=|class=skin-invert|Recurrent item]] Detailed code updates later this week: [[mw:MediaWiki 1.44/wmf.21|MediaWiki]]

'''''[[m:Special:MyLanguage/Tech/News|Tech news]]''' prepared by [[m:Special:MyLanguage/Tech/News/Writers|Tech News writers]] and posted by [[m:Special:MyLanguage/User:MediaWiki message delivery|bot]]&amp;nbsp;• [[m:Special:MyLanguage/Tech/News#contribute|Contribute]]&amp;nbsp;• [[m:Special:MyLanguage/Tech/News/2025/12|Translate]]&amp;nbsp;• [[m:Tech|Get help]]&amp;nbsp;• [[m:Talk:Tech/News|Give feedback]]&amp;nbsp;• [[m:Global message delivery/Targets/Tech ambassadors|Subscribe or unsubscribe]].''
&lt;/div&gt;&lt;section end=&quot;technews-2025-W12&quot;/&gt;
&lt;/div&gt;

&lt;bdi lang=&quot;en&quot; dir=&quot;ltr&quot;&gt;[[User:MediaWiki message delivery|MediaWiki message delivery]]&lt;/bdi&gt; 18 mars 2025 à 00:48 (CET)
&lt;!-- Message envoyé par User:Quiddity (WMF)@metawiki en utilisant la liste sur https://meta.wikimedia.org/w/index.php?title=Global_message_delivery/Targets/Tech_ambassadors&amp;oldid=28412594 --&gt;

== Actualités techniques n° 2025-13 ==

&lt;section begin=&quot;technews-2025-W13&quot;/&gt;&lt;div class=&quot;plainlinks&quot;&gt;
Dernières '''[[m:Special:MyLanguage/Tech/News|actualités techniques]]''' de la communauté technique de Wikimedia. N’hésitez pas à informer les autres utilisateurs de ces changements. Certains changements ne vous concernent pas. [[m:Special:MyLanguage/Tech/News/2025/13|D’autres traductions]] sont disponibles.

'''En lumière cette semaine'''
* La Fondation Wikimédia souhaite recueillir vos commentaires sur les [[m:Special:MyLanguage/Wikimedia Foundation Annual Plan/2025-2026/Product &amp; Technology OKRs|ébauches des objectifs et des résultats-clés qui façonneront les priorités de la Fondation en matière de produits et de technologies]] pour la prochaine année fiscale (commençant en juillet). Les objectifs sont des domaines généraux et les résultats-clés permettent de mesurer leur réalisation. N'hésitez pas à partager vos commentaires sur la page de discussion, dans n'importe quelle langue, idéalement avant fin avril.

'''Actualités pour la contribution'''
* L'extension [[mw:Special:MyLanguage/Help:Extension:CampaignEvents|CampaignEvents]] sera déployée sur plusieurs wikis (voir le [[m:Special:MyLanguage/CampaignEvents/Deployment status#Global Deployment Plan|plan de déploiement]] pour plus de détails) en avril 2025, et l'équipe a commencé le processus d'engagement des communautés sur les wikis identifiés. L'extension fournit des outils pour organiser, gérer et promouvoir des activités collaboratives (comme des événements, des edit-a-thons et des WikiProjects) sur les wikis. L'extension comporte trois outils : [[m:Special:MyLanguage/Event Center/Registration|Inscription à l'événement]], [[m:Special:MyLanguage/CampaignEvents/Collaboration list|Liste de collaboration]] et [[m:Special:MyLanguage/Campaigns/Foundation Product Team/Invitation list|Liste d'invitation]]. Elle est actuellement présente sur 13 Wikipédias, dont la Wikipédia en anglais, la Wikipédia en français et la Wikipédia en espagnol, ainsi que sur Wikidata. Les questions ou demandes peuvent être adressées sur la [[mw:Help talk:Extension:CampaignEvents|page de discussion de l'extension]] ou sur Phabricator (avec l'étiquette &lt;bdi lang=&quot;en&quot; dir=&quot;ltr&quot; style=&quot;white-space: nowrap;&quot;&gt;#campaigns-product-team&lt;/bdi&gt;).
* À partir de la semaine du 31 mars, les wikis pourront définir quels groupes d'utilisateurs peuvent voir les inscriptions privées dans [[m:Special:MyLanguage/Event Center/Registration|Inscription à l'événement]], dans le cadre de l'extension [[mw:Special:MyLanguage/Help:Extension:CampaignEvents|CampaignEvents]]. Par défaut, les organisateurs d'événements et les administrateurs du wiki local pourront voir les inscriptions privées. Il s'agit d'un changement par rapport au réglage actuel qui permet seulement aux organisateurs de l'événement de voir les inscriptions privées. Les wikis peuvent modifier la configuration par défaut en demandant un changement de configuration dans Phabricator (et en ajoutant l'étiquette &lt;bdi lang=&quot;en&quot; dir=&quot;ltr&quot; style=&quot;white-space: nowrap;&quot;&gt;#campaigns-product-team&lt;/bdi&gt;). Les participants aux événements passés peuvent annuler leur inscription à tout moment.
* Les administrateurs des wikis qui disposent d'une barre latérale &lt;bdi lang=&quot;en&quot; dir=&quot;ltr&quot;&gt;[[MediaWiki:Sidebar]]&lt;/bdi&gt; personnalisée doivent vérifier si elle contient une entrée pour la liste {{int:specialpages}}. Si ce n'est pas le cas, ils doivent l'ajouter en utilisant &lt;code dir=ltr style=&quot;white-space: nowrap;&quot;&gt;* specialpages-url|specialpages&lt;/code&gt;. Les wikis disposant d'une barre latérale par défaut verront le lien déplacé de la boîte à outils de la page vers le menu de la barre latérale en avril. [https://phabricator.wikimedia.org/T388927]
* L'habillage Minerva (web mobile) combine les notifications d'avis et d'alertes dans l'icône de cloche ([[File:OOjs UI icon bell.svg|16px|link=|class=skin-invert]]). Il existait depuis longtemps un bogue qui faisait qu'une indication de nouvelles notifications n'était affichée que si vous aviez des alertes que vous n'avez pas vues. Ce problème est désormais résolu. À l'avenir, les utilisateurs de Minerva remarqueront un compteur au-dessus de l'icône de la cloche lorsque vous avez un ou plusieurs notifications et/ou alertes non vues. [https://phabricator.wikimedia.org/T344029]
* [[File:Octicons-sync.svg|12px|link=|class=skin-invert|Sujet récurrent]] Voir {{PLURAL:23|la tâche soumise|les {{formatnum:23}} tâches soumises}} par la communauté [[m:Special:MyLanguage/Tech/News/Recently resolved community tasks|résolue{{PLURAL:23||s}} la semaine dernière]].

'''Actualités pour la contribution technique'''
* VisualEditor a introduit un [[mw:VisualEditor/Hooks|nouveau hook côté client]] pour les développeurs à utiliser lors de l'intégration avec le cycle de vie de la cible VisualEditor. Ce hook devrait remplacer les hooks existants liés au cycle de vie et être plus cohérent entre les différentes plateformes. De plus, le nouveau hook s'appliquera aux utilisations de VisualEditor en dehors de l'édition complète d'articles, permettant aux gadgets d'interagir avec l'éditeur dans DiscussionTools également. L'équipe d'édition a l'intention de déprécier et éventuellement de supprimer les hooks de l'ancien cycle de vie, donc tous les cas d'utilisation que ce nouveau hook ne couvre pas seraient intéressants pour l'équipe et peuvent être [[phab:T355555|partagés dans la tâche]].
* Les développeurs qui utilisent la bibliothèque JavaScript &lt;code dir=ltr&gt;mw.Api&lt;/code&gt; peuvent désormais identifier l'outil qui l'utilise avec le paramètre &lt;code dir=ltr&gt;userAgent&lt;/code&gt; : &lt;code dir=ltr&gt;var api = new mw.Api( { userAgent: 'GadgetNameHere/1.0.1' } );&lt;/code&gt;. Si vous gérez un gadget ou un script utilisateur, veuillez définir un agent utilisateur, car cela facilite la maintenance de la bibliothèque et du serveur et permet de différencier le trafic légitime du trafic illégitime. [https://phabricator.wikimedia.org/T373874][https://foundation.wikimedia.org/wiki/Policy:Wikimedia_Foundation_User-Agent_Policy]
* [[File:Octicons-sync.svg|12px|link=|class=skin-invert|Sujet récurrent]] Détail des mises-à-jour à venir cette semaine : [[mw:MediaWiki 1.44/wmf.22|MediaWiki]]

'''''[[m:Special:MyLanguage/Tech/News|Actualités techniques]]''' préparées par les [[m:Special:MyLanguage/Tech/News/Writers|rédacteurs des actualités techniques]] et postées par [[m:Special:MyLanguage/User:MediaWiki message delivery|robot]]. [[m:Special:MyLanguage/Tech/News#contribute|Contribuer]]&amp;nbsp;• [[m:Special:MyLanguage/Tech/News/2025/13|Traduire]]&amp;nbsp;• [[m:Tech|Obtenir de l’aide]]&amp;nbsp;• [[m:Talk:Tech/News|Donner son avis]]&amp;nbsp;• [[m:Global message delivery/Targets/Tech ambassadors|S’abonner ou se désabonner]].''
&lt;/div&gt;&lt;section end=&quot;technews-2025-W13&quot;/&gt;

&lt;bdi lang=&quot;en&quot; dir=&quot;ltr&quot;&gt;[[User:MediaWiki message delivery|MediaWiki message delivery]]&lt;/bdi&gt; 24 mars 2025 à 23:42 (CET)
&lt;!-- Message envoyé par User:Quiddity (WMF)@metawiki en utilisant la liste sur https://meta.wikimedia.org/w/index.php?title=Global_message_delivery/Targets/Tech_ambassadors&amp;oldid=28443127 --&gt;

== Actualités techniques n° 2025-14 ==

&lt;section begin=&quot;technews-2025-W14&quot;/&gt;&lt;div class=&quot;plainlinks&quot;&gt;
Dernières '''[[m:Special:MyLanguage/Tech/News|actualités techniques]]''' de la communauté technique de Wikimedia. N’hésitez pas à informer les autres utilisateurs de ces changements. Certains changements ne vous concernent pas. [[m:Special:MyLanguage/Tech/News/2025/14|D’autres traductions]] sont disponibles.

'''Actualités pour la contribution'''
* L'équipe Contribution travaille sur une nouvelle [[mw:Special:MyLanguage/Edit Check|vérification des modifications]] : le [[mw:Special:MyLanguage/Edit check#26 March 2025|contrôle des éloges]]. L'objectif de cette vérification est d’identifier les termes non neutres saisis lors de la modification d’une page Wikipédia, afin d’informer l’auteur ou autrice que son texte devrait peut-être être modifié avant publication. Ce projet n’en est qu’à ses débuts ; l’équipe a besoin de l’avis des communautés. Dans [[phab:T389445|cette tâche Phabricator]], l’équipe rassemble les recommendations internes des wikis, les modèles utilisés pour étiqueter les articles non neutres et les termes (jargon et mots-clés) utilisés dans les résumés de modification pour les langues étudiées actuellement. Vous pouvez participer en modifiant le tableau sur Phabricator, en commentant la tâche ou en envoyant directement un message à [[m:user:Trizek (WMF)|Trizek (WMF)]].
* La [[mw:Special:MyLanguage/MediaWiki Platform Team/SUL3|connexion utilisateur unique]] (SUL) a été mise à jour sur tous les wikis afin de déplacer la connexion et la création de compte vers un domaine central. Cela rend la connexion des contributeurs compatible avec les restrictions des navigateurs sur les cookies inter-domaines, qui ont empêché les utilisateurs de certains navigateurs de rester connectés.
* [[File:Octicons-sync.svg|12px|link=|class=skin-invert|Sujet récurrent]] Voir {{PLURAL:35|la tâche soumise|les {{formatnum:35}} tâches soumises}} par la communauté [[m:Special:MyLanguage/Tech/News/Recently resolved community tasks|résolue{{PLURAL:35||s}} la semaine dernière]].

'''Actualités pour la contribution technique'''
* À partir du 31 mars, l'équipe MediaWiki Interfaces va lancer une version limitée des spécifications OpenAPI générées et une expérience de bac à sable basée sur SwaggerUI pour [[mw:Special:MyLanguage/API:REST API|MediaWiki REST APIs]]. L'équipe invite les développeurs d'un groupe limité de communautés Wikipédia non anglophones (arabe, allemand, français, hébreu, interlingua, néerlandais, chinois) à consulter la documentation et à expérimenter le bac à sable dans leur langue de choix. En plus de ces projets Wikipédia spécifiques, le bac à sable et la spécification OpenAPI seront disponibles sur la [[testwiki:Special:RestSandbox|page spéciale test wiki REST Sandbox]] pour les développeurs dont l'anglais est la langue préférée. Pendant la période de prévisualisation, l'équipe MediaWiki Interfaces invite également les développeurs à [[mw:MediaWiki Interfaces Team/Feature Feedback/REST Sandbox|partager leur retour d'expérience]]. L'aperçu durera environ 2 semaines, après quoi le bac à sable et les spécifications OpenAPI seront mis à la disposition de tous les projets wiki.
* [[File:Octicons-sync.svg|12px|link=|class=skin-invert|Sujet récurrent]] Détail des mises-à-jour à venir cette semaine : [[mw:MediaWiki 1.44/wmf.23|MediaWiki]]

'''En détails'''
* Parfois, un petit changement de code d'une ligne peut avoir une grande importance : dans ce cas, cela signifie que pour la première fois depuis des années, nous sommes en mesure de faire fonctionner toute la pile qui sert &lt;bdi lang=&quot;en&quot; dir=&quot;ltr&quot;&gt;[http://maps.wikimedia.org/ maps.wikimedia.org]&lt;/bdi&gt; - un hôte dédié à servir nos wikis et leurs besoins en cartes multilingues - à partir d'un seul centre de données, ce que nous testons à chaque fois que nous effectuons un [[m:Special:MyLanguage/Tech/Server switch|basculement de centre de données]]. C'est important car cela signifie que si l'un de nos centres de données est affecté par une catastrophe, nous serons toujours en mesure de servir le site. Ce changement est le résultat d'un [[phab:T216826|travail intensif]] de deux développeurs sur le portage du dernier composant de la pile de cartes sur [[w:fr:Kubernetes|kubernetes]], où nous pouvons allouer des ressources plus efficacement qu'auparavant, ce qui nous permet de supporter plus de trafic dans un seul centre de données. Ce travail a nécessité beaucoup d'étapes compliquées car ce logiciel et les bibliothèques logicielles qu'il utilise nécessitaient de nombreuses mises à jour attendues depuis longtemps. Ce type de travail rend l'infrastructure de Wikimedia plus durable.

'''Rencontres et évènements'''
* La [[mw:Special:MyLanguage/MediaWiki Users and Developers Workshop Spring 2025|Conférence des utilisateurs et développeurs de MediaWiki printemps 2025]] se déroulera à Sandusky, aux États-Unis, et en ligne, du 14 au 16 mai 2025. La conférence proposera des discussions autour de l'utilisation du logiciel MediaWiki par et au sein d'entreprises de différents secteurs, et inspirera et embarquera de nouveaux utilisateurs. L'inscription et l'enregistrement des présentations sont maintenant disponibles sur le site web de la conférence.

'''''[[m:Special:MyLanguage/Tech/News|Actualités techniques]]''' préparées par les [[m:Special:MyLanguage/Tech/News/Writers|rédacteurs des actualités techniques]] et postées par [[m:Special:MyLanguage/User:MediaWiki message delivery|robot]]. [[m:Special:MyLanguage/Tech/News#contribute|Contribuer]]&amp;nbsp;• [[m:Special:MyLanguage/Tech/News/2025/14|Traduire]]&amp;nbsp;• [[m:Tech|Obtenir de l’aide]]&amp;nbsp;• [[m:Talk:Tech/News|Donner son avis]]&amp;nbsp;• [[m:Global message delivery/Targets/Tech ambassadors|S’abonner ou se désabonner]].''
&lt;/div&gt;&lt;section end=&quot;technews-2025-W14&quot;/&gt;

&lt;bdi lang=&quot;en&quot; dir=&quot;ltr&quot;&gt;[[User:MediaWiki message delivery|MediaWiki message delivery]]&lt;/bdi&gt; 1 avril 2025 à 02:05 (CEST)
&lt;!-- Message envoyé par User:Quiddity (WMF)@metawiki en utilisant la liste sur https://meta.wikimedia.org/w/index.php?title=Global_message_delivery/Targets/Tech_ambassadors&amp;oldid=28473566 --&gt;

== Final proposed modifications to the Universal Code of Conduct Enforcement Guidelines and U4C Charter now posted ==

&lt;div lang=&quot;en&quot; dir=&quot;ltr&quot; class=&quot;mw-content-ltr&quot;&gt;
The proposed modifications to the [[foundation:Special:MyLanguage/Policy:Universal_Code_of_Conduct/Enforcement_guidelines|Universal Code of Conduct Enforcement Guidelines]] and the U4C Charter [[m:Universal_Code_of_Conduct/Annual_review/2025/Proposed_Changes|are now on Meta-wiki for community notice]] in advance of the voting period. This final draft was developed from the previous two rounds of community review. Community members will be able to vote on these modifications starting on 17 April 2025. The vote will close on 1 May 2025, and results will be announced no later than 12 May 2025. The U4C election period, starting with a call for candidates, will open immediately following the announcement of the review results. More information will be posted on [[m:Special:MyLanguage//Universal_Code_of_Conduct/Coordinating_Committee/Election|the wiki page for the election]] soon.

Please be advised that this process will require more messages to be sent here over the next two months. 

The [[m:Special:MyLanguage/Universal_Code_of_Conduct/Coordinating_Committee|Universal Code of Conduct Coordinating Committee (U4C)]] is a global group dedicated to providing an equitable and consistent implementation of the UCoC. This annual review was planned and implemented by the U4C. For more information and the responsibilities of the U4C, you may [[m:Special:MyLanguage/Universal_Code_of_Conduct/Coordinating_Committee/Charter|review the U4C Charter]].

Please share this message with members of your community so they can participate as well.

-- In cooperation with the U4C, [[m:User:Keegan (WMF)|Keegan (WMF)]] ([[m:User_talk:Keegan (WMF)|talk]]) 4 avril 2025 à 04:04 (CEST)
&lt;/div&gt;
&lt;!-- Message envoyé par User:Keegan (WMF)@metawiki en utilisant la liste sur https://meta.wikimedia.org/w/index.php?title=Distribution_list/Global_message_delivery&amp;oldid=28469465 --&gt;

== Actualités techniques n° 2025-15 ==

&lt;section begin=&quot;technews-2025-W15&quot;/&gt;&lt;div class=&quot;plainlinks&quot;&gt;
Dernières '''[[m:Special:MyLanguage/Tech/News|actualités techniques]]''' de la communauté technique de Wikimedia. N’hésitez pas à informer les autres utilisateurs de ces changements. Certains changements ne vous concernent pas. [[m:Special:MyLanguage/Tech/News/2025/15|D’autres traductions]] sont disponibles.

'''Actualités pour la contribution'''
* Désormais, les [[m:Special:MyLanguage/Interface administrators|admins d’interface]] et [[m:Special:MyLanguage/Central notice administrators|admins des annonces centrales]] sont contraint techniquement d’activer l’[[m:Special:MyLanguage/Help:Two-factor authentication|authentification à deux facteurs]] avant de pouvoir utiliser leurs privilèges. À l’avenir, cela pourrait être étendu à d’autres groupes ayant des droits avancés. [https://phabricator.wikimedia.org/T150898]
* [[File:Octicons-sync.svg|12px|link=|class=skin-invert|Sujet récurrent]] Voir {{PLURAL:20|la tâche soumise|les {{formatnum:20}} tâches soumises}} par la communauté [[m:Special:MyLanguage/Tech/News/Recently resolved community tasks|résolue{{PLURAL:20||s}} la semaine dernière]].

'''Actualités pour la contribution technique'''
* L’équipe Système design prépare la sortie de la nouvelle version majeur de Codex (v2.0.0) pour le 29 avril. Les contributeurices et développeurs et développeuses qui utilisent du CSS de Codex devraient consulter la [[mw:Codex/Release Timeline/2.0|documentation sur l’arrivée de la v2]], elle inclut un guidage pour les ruptures introduites dans cette version, par exemple pour &lt;code dir=ltr style=&quot;white-space: nowrap;&quot;&gt;font-size&lt;/code&gt;, &lt;code dir=ltr style=&quot;white-space: nowrap;&quot;&gt;line-height&lt;/code&gt; et &lt;code dir=ltr style=&quot;white-space: nowrap;&quot;&gt;size-icon&lt;/code&gt;.
* Les résultats de [[mw:Developer Satisfaction Survey/2025|l’enquête 2025 sur la satisfaction des développeurs et développeuses]] est désormais disponible. Merci à tous les participants ! Ces résultats aident Wikimedia à décider ce sur quoi orienter le travail et à évaluer le travail récent.
* [[File:Octicons-sync.svg|12px|link=|class=skin-invert|Sujet récurrent]] Détail des mises-à-jour à venir cette semaine : [[mw:MediaWiki 1.44/wmf.24|MediaWiki]]

'''Rencontres et évènements'''
* Le [[mw:Special:MyLanguage/Wikimedia Hackathon 2025|Hackathon Wikimedia 2025]] aura lieu à Istanbul en Turquie, du 2 au 4 mai. Les inscriptions pour participer en présentiel ont lieu jusqu’au 13 avril. Avant de vous inscrire, sachez qu’il vous faudra peut-être un [https://www.mfa.gov.tr/turkish-representations.en.mfa visa] ou un [https://www.mfa.gov.tr/visa-information-for-foreigners.en.mfa e-visa] pour entrer dans le pays.

'''''[[m:Special:MyLanguage/Tech/News|Actualités techniques]]''' préparées par les [[m:Special:MyLanguage/Tech/News/Writers|rédacteurs des actualités techniques]] et postées par [[m:Special:MyLanguage/User:MediaWiki message delivery|robot]]. [[m:Special:MyLanguage/Tech/News#contribute|Contribuer]]&amp;nbsp;• [[m:Special:MyLanguage/Tech/News/2025/15|Traduire]]&amp;nbsp;• [[m:Tech|Obtenir de l’aide]]&amp;nbsp;• [[m:Talk:Tech/News|Donner son avis]]&amp;nbsp;• [[m:Global message delivery/Targets/Tech ambassadors|S’abonner ou se désabonner]].''
&lt;/div&gt;&lt;section end=&quot;technews-2025-W15&quot;/&gt;

&lt;bdi lang=&quot;en&quot; dir=&quot;ltr&quot;&gt;[[User:MediaWiki message delivery|MediaWiki message delivery]]&lt;/bdi&gt; 7 avril 2025 à 20:52 (CEST)
&lt;!-- Message envoyé par User:UOzurumba (WMF)@metawiki en utilisant la liste sur https://meta.wikimedia.org/w/index.php?title=Global_message_delivery/Targets/Tech_ambassadors&amp;oldid=28507470 --&gt;

== Wikidata and Sister Projects: An online community event ==

''(Apologies for posting in English)''

Hello everyone, I am excited to share news of an upcoming online event called '''[[d:Event:Wikidata_and_Sister_Projects|Wikidata and Sister Projects]]''' celebrating the different ways Wikidata can be used to support or enhance with another Wikimedia project. The event takes place over 4 days between '''May 29 - June 1st, 2025'''.

We would like to invite speakers to present at this community event, to hear success stories, challenges, showcase tools or projects you may be working on, where Wikidata has been involved in Wikipedia, Commons, WikiSource and all other WM projects.

If you are interested in attending, please [[d:Special:RegisterForEvent/1291|register here]].
If you would like to speak at the event, please fill out this Session Proposal template on the [[d:Event_talk:Wikidata_and_Sister_Projects|event talk page]], where you can also ask any questions you may have. 

I hope to see you at the event, in the audience or as a speaker, - [[Utilisateur:MediaWiki message delivery|MediaWiki message delivery]] ([[Discussion utilisateur:MediaWiki message delivery|discussion]]) 11 avril 2025 à 11:18 (CEST)
&lt;!-- Message envoyé par User:Danny Benjafield (WMDE)@metawiki en utilisant la liste sur https://meta.wikimedia.org/w/index.php?title=User:Danny_Benjafield_(WMDE)/MassMessage_Send_List&amp;oldid=28525705 --&gt;

== &lt;span lang=&quot;en&quot; dir=&quot;ltr&quot;&gt;Tech News: 2025-16&lt;/span&gt; ==

&lt;div lang=&quot;en&quot; dir=&quot;ltr&quot;&gt;
&lt;section begin=&quot;technews-2025-W16&quot;/&gt;&lt;div class=&quot;plainlinks&quot;&gt;
Latest '''[[m:Special:MyLanguage/Tech/News|tech news]]''' from the Wikimedia technical community. Please tell other users about these changes. Not all changes will affect you. [[m:Special:MyLanguage/Tech/News/2025/16|Translations]] are available.

'''Weekly highlight'''
* Later this week, the default thumbnail size will be increased from 220px to 250px. This changes how pages are shown in all wikis and has been requested by some communities for many years, but wasn't previously possible due to technical limitations. [https://phabricator.wikimedia.org/T355914]
* File thumbnails are now stored in discrete sizes. If a page specifies a thumbnail size that's not among the standard sizes (20, 40, 60, 120, 250, 330, 500, 960), then MediaWiki will pick the closest larger thumbnail size but will tell the browser to downscale it to the requested size. In these cases, nothing will change visually but users might load slightly larger images. If it doesn't matter which thumbnail size is used in a page, please pick one of the standard sizes to avoid the extra in-browser down-scaling step. [https://www.mediawiki.org/wiki/Special:MyLanguage/Help:Images#Thumbnail_sizes][https://phabricator.wikimedia.org/T355914]

'''Updates for editors'''
* The Wikimedia Foundation are working on a system called [[m:Edge Uniques|Edge Uniques]] which will enable [[:w:en:A/B testing|A/B testing]], help protect against [[:w:en:Denial-of-service attack|Distributed denial-of-service attacks]] (DDoS attacks), and make it easier to understand how many visitors the Wikimedia sites have. This is so that they can more efficiently build tools which help readers, and make it easier for readers to find what they are looking for.
* To improve security for users, a small percentage of logins will now require that the account owner input a one-time password [[mw:Special:MyLanguage/Help:Extension:EmailAuth|emailed to their account]]. It is recommended that you [[Special:Preferences#mw-prefsection-personal-email|check]] that the email address on your account is set correctly, and that it has been confirmed, and that you have an email set for this purpose. [https://phabricator.wikimedia.org/T390662]
* &quot;Are you interested in taking a short survey to improve tools used for reviewing or reverting edits on your Wiki?&quot; This question will be [[phab:T389401|asked at 7 wikis starting next week]], on Recent Changes and Watchlist pages. The [[mw:Special:MyLanguage/Moderator Tools|Moderator Tools team]] wants to know more about activities that involve looking at new edits made to your Wikimedia project, and determining whether they adhere to your project's policies.
* On April 15, the full Wikidata graph will no longer be supported on &lt;bdi lang=&quot;zxx&quot; dir=&quot;ltr&quot;&gt;[https://query.wikidata.org/ query.wikidata.org]&lt;/bdi&gt;. After this date, scholarly articles will be available through &lt;bdi lang=&quot;zxx&quot; dir=&quot;ltr&quot; style=&quot;white-space:nowrap;&quot;&gt;[https://query-scholarly.wikidata.org/ query-scholarly.wikidata.org]&lt;/bdi&gt;, while the rest of the data hosted on Wikidata will be available through the &lt;bdi lang=&quot;zxx&quot; dir=&quot;ltr&quot;&gt;[https://query.wikidata.org/ query.wikidata.org]&lt;/bdi&gt; endpoint. This is part of the scheduled split of the Wikidata Graph, which was [[d:Special:MyLanguage/Wikidata:SPARQL query service/WDQS backend update/September 2024 scaling update|announced in September 2024]]. More information is [[d:Wikidata:SPARQL query service/WDQS graph split|available on Wikidata]].
* The latest quarterly [[m:Special:MyLanguage/Wikimedia Apps/Newsletter/First quarter of 2025|Wikimedia Apps Newsletter]] is now available. It covers updates, experiments, and improvements made to the Wikipedia mobile apps.
* [[File:Octicons-sync.svg|12px|link=|class=skin-invert|Recurrent item]] View all {{formatnum:30}} community-submitted {{PLURAL:30|task|tasks}} that were [[m:Special:MyLanguage/Tech/News/Recently resolved community tasks|resolved last week]].

'''Updates for technical contributors'''
* The latest quarterly [[mw:Technical Community Newsletter/2025/April|Technical Community Newsletter]] is now available. This edition includes: an invitation for tool maintainers to attend the Toolforge UI Community Feedback Session on April 15th; recent community metrics; and recent technical blog posts.
* [[File:Octicons-sync.svg|12px|link=|class=skin-invert|Recurrent item]] Detailed code updates later this week: [[mw:MediaWiki 1.44/wmf.25|MediaWiki]]

'''''[[m:Special:MyLanguage/Tech/News|Tech news]]''' prepared by [[m:Special:MyLanguage/Tech/News/Writers|Tech News writers]] and posted by [[m:Special:MyLanguage/User:MediaWiki message delivery|bot]]&amp;nbsp;• [[m:Special:MyLanguage/Tech/News#contribute|Contribute]]&amp;nbsp;• [[m:Special:MyLanguage/Tech/News/2025/16|Translate]]&amp;nbsp;• [[m:Tech|Get help]]&amp;nbsp;• [[m:Talk:Tech/News|Give feedback]]&amp;nbsp;• [[m:Global message delivery/Targets/Tech ambassadors|Subscribe or unsubscribe]].''
&lt;/div&gt;&lt;section end=&quot;technews-2025-W16&quot;/&gt;
&lt;/div&gt;

&lt;bdi lang=&quot;en&quot; dir=&quot;ltr&quot;&gt;[[User:MediaWiki message delivery|MediaWiki message delivery]]&lt;/bdi&gt; 15 avril 2025 à 02:24 (CEST)
&lt;!-- Message envoyé par User:Quiddity (WMF)@metawiki en utilisant la liste sur https://meta.wikimedia.org/w/index.php?title=Global_message_delivery/Targets/Tech_ambassadors&amp;oldid=28540654 --&gt;

== Vote now on the revised UCoC Enforcement Guidelines and U4C Charter ==

&lt;div lang=&quot;en&quot; dir=&quot;ltr&quot; class=&quot;mw-content-ltr&quot;&gt;

The voting period for the revisions to the Universal Code of Conduct Enforcement Guidelines (&quot;UCoC EG&quot;) and the UCoC's Coordinating Committee Charter is open now through the end of 1 May (UTC) ([https://zonestamp.toolforge.org/1746162000 find in your time zone]). [[m:Special:MyLanguage/Universal_Code_of_Conduct/Annual_review/2025/Voter_information|Read the information on how to participate and read over the proposal before voting]] on the UCoC page on Meta-wiki.

The [[m:Special:MyLanguage/Universal_Code_of_Conduct/Coordinating_Committee|Universal Code of Conduct Coordinating Committee (U4C)]] is a global group dedicated to providing an equitable and consistent implementation of the UCoC. This annual review of the EG and Charter was planned and implemented by the U4C. Further information will be provided in the coming months about the review of the UCoC itself. For more information and the responsibilities of the U4C, you may [[m:Special:MyLanguage/Universal_Code_of_Conduct/Coordinating_Committee/Charter|review the U4C Charter]].

Please share this message with members of your community so they can participate as well.

In cooperation with the U4C -- [[m:User:Keegan (WMF)|Keegan (WMF)]] ([[m:User_talk:Keegan (WMF)|talk]]) 17 avril 2025 à 02:34 (CEST)
&lt;/div&gt;
&lt;!-- Message envoyé par User:Keegan (WMF)@metawiki en utilisant la liste sur https://meta.wikimedia.org/w/index.php?title=Distribution_list/Global_message_delivery&amp;oldid=28469465 --&gt;

== Actualités techniques n° 2025-17 ==

&lt;section begin=&quot;technews-2025-W17&quot;/&gt;&lt;div class=&quot;plainlinks&quot;&gt;
Dernières '''[[m:Special:MyLanguage/Tech/News|actualités techniques]]''' de la communauté technique de Wikimedia. N’hésitez pas à informer les autres utilisateurs de ces changements. Certains changements ne vous concernent pas. [[m:Special:MyLanguage/Tech/News/2025/17|D’autres traductions]] sont disponibles.

'''Actualités pour la contribution'''
* [[f:Special:MyLanguage/Wikifunctions:Main Page|Wikifunctions]] est désormais intégré à la [[w:dag:Solɔɣu|Wikipédia en dagbani]] depuis le 15 avril. C'est le premier projet qui pourra appeler des [[f:Special:MyLanguage/Wikifunctions:Introduction|fonctions de Wikifonctions]] et les intégrer dans des articles. Une fonction est quelque chose qui prend une ou plusieurs entrées et les transforme en un résultat souhaité, comme l'addition de deux nombres, la conversion de miles en mètres, le calcul du temps écoulé depuis un événement, ou la déclinaison d'un mot en une casse. Les Wikifonctions permettront aux utilisateurs de faire cela par un simple appel d'[[f:Special:MyLanguage/Wikifunctions:Catalogue|une fonction stable et globale]], plutôt que par l'intermédiaire d'un modèle local. [https://www.wikifunctions.org/wiki/Special:MyLanguage/Wikifunctions:Status_updates/2025-04-16]
* Un nouveau type d'erreur ''lint'' a été créé : [[Special:LintErrors/empty-heading|{{int:linter-category-empty-heading}}]] ([[mw:Special:MyLanguage/Help:Lint errors/empty-heading|documentation]]). L'objectif de l'extension [[mw:Special:MyLanguage/Help:Extension:Linter|Linter]] est d'identifier les éléments de wikitexte qui doivent ou peuvent être corrigés dans les pages et de fournir des conseils sur les problèmes posés par ces éléments et sur la manière de les corriger. [https://phabricator.wikimedia.org/T368722]
* [[File:Octicons-sync.svg|12px|link=|class=skin-invert|Sujet récurrent]] Voir {{PLURAL:37|la tâche soumise|les {{formatnum:37}} tâches soumises}} par la communauté [[m:Special:MyLanguage/Tech/News/Recently resolved community tasks|résolue{{PLURAL:37||s}} la semaine dernière]].

'''Actualités pour la contribution technique'''
* À la suite de sa publication sur ''HuggingFace'', l'ensemble de données « ''Structured Contents'' », développé par Wikimedia Enterprise, est [https://enterprise.wikimedia.com/blog/kaggle-dataset/ maintenant également disponible sur Kaggle]. Cette initiative bêta vise à rendre les données de Wikimedia plus lisibles par les machines pour les réutilisateurs de gros volumes. Cette version bêta est publiée à un emplacement déjà utilisé par les communautés de données ouvertes, afin de recueillir des commentaires qui permettront d'améliorer le produit en vue d'une future diffusion à plus grande échelle. Vous pouvez en savoir plus sur le projet ''[https://enterprise.wikimedia.com/blog/structured-contents-snapshot-api/#open-datasets Structured Contents]'', et sur la [https://enterprise.wikimedia.com/blog/structured-contents-wikipedia-infobox/ première version librement utilisable].
* Il n'y a pas de nouvelle version de MediaWiki cette semaine.

'''Rencontres et évènements'''
* Les équipes de rédaction et d'apprentissage automatique (''Editing and Machine Learning Teams'') invitent les bénévoles intéressés à une visioconférence pour discuter de la [[mw:Special:MyLanguage/Edit check/Peacock check|vérification « ''peacock'' »]] &lt;small&gt;(NdT : litt. « paon » mais également une expression idiomatique pour le langage vaniteux, prétentieux)&lt;/small&gt;, qui est la dernière [[mw:Special:MyLanguage/Edit check|vérification de modification]] qui détectera le langage « trop promotionnel » ou « non neutre » pendant qu'un rédacteur est en train de taper. Les rédacteurs qui travaillent avec les nouveaux arrivants, ou qui aident à corriger ce type d'écriture, ou qui sont intéressés par la manière dont nous utilisons l'intelligence artificielle dans nos projets, sont invités à participer à cette réunion. La [[mw:Special:MyLanguage/Editing team/Community Conversations#Next Conversation|réunion aura lieu le 28 avril 2025]] à [https://zonestamp.toolforge.org/1745863200 18:00-19:00 UTC] et sera hébergée sur Zoom.

'''''[[m:Special:MyLanguage/Tech/News|Actualités techniques]]''' préparées par les [[m:Special:MyLanguage/Tech/News/Writers|rédacteurs des actualités techniques]] et postées par [[m:Special:MyLanguage/User:MediaWiki message delivery|robot]]. [[m:Special:MyLanguage/Tech/News#contribute|Contribuer]]&amp;nbsp;• [[m:Special:MyLanguage/Tech/News/2025/17|Traduire]]&amp;nbsp;• [[m:Tech|Obtenir de l’aide]]&amp;nbsp;• [[m:Talk:Tech/News|Donner son avis]]&amp;nbsp;• [[m:Global message delivery/Targets/Tech ambassadors|S’abonner ou se désabonner]].''
&lt;/div&gt;&lt;section end=&quot;technews-2025-W17&quot;/&gt;

&lt;bdi lang=&quot;en&quot; dir=&quot;ltr&quot;&gt;[[User:MediaWiki message delivery|MediaWiki message delivery]]&lt;/bdi&gt; 21 avril 2025 à 23:00 (CEST)
&lt;!-- Message envoyé par User:Quiddity (WMF)@metawiki en utilisant la liste sur https://meta.wikimedia.org/w/index.php?title=Global_message_delivery/Targets/Tech_ambassadors&amp;oldid=28578245 --&gt;

== Actualités techniques n° 2025-18 ==

&lt;section begin=&quot;technews-2025-W18&quot;/&gt;&lt;div class=&quot;plainlinks&quot;&gt;
Dernières '''[[m:Special:MyLanguage/Tech/News|actualités techniques]]''' de la communauté technique de Wikimedia. N’hésitez pas à informer les autres utilisateurs de ces changements. Certains changements ne vous concernent pas. [[m:Special:MyLanguage/Tech/News/2025/18|D’autres traductions]] sont disponibles.

'''Actualités pour la contribution'''
* &lt;span lang=&quot;en&quot; dir=&quot;ltr&quot; class=&quot;mw-content-ltr&quot;&gt;Event organizers who host collaborative activities on [[m:Special:MyLanguage/CampaignEvents/Deployment status#Global Deployment Plan|multiple wikis]], including Bengali, Japanese, and Korean Wikipedias, will have access to the [[mw:Special:MyLanguage/Extension:CampaignEvents|CampaignEvents extension]] this week. Also, admins in the Wikipedia where the extension is enabled will automatically be granted the event organizer right soon. They won't have to manually grant themselves the right before they can manage events as [[phab:T386861|requested by a community]].&lt;/span&gt;
* [[File:Octicons-sync.svg|12px|link=|class=skin-invert|Sujet récurrent]] Voir {{PLURAL:19|la tâche soumise|les {{formatnum:19}} tâches soumises}} par la communauté [[m:Special:MyLanguage/Tech/News/Recently resolved community tasks|résolue{{PLURAL:19||s}} la semaine dernière]].

'''Actualités pour la contribution technique'''
* &lt;span lang=&quot;en&quot; dir=&quot;ltr&quot; class=&quot;mw-content-ltr&quot;&gt;The release of the next major version of [[mw:Special:MyLanguage/Codex|Codex]], the design system for Wikimedia, is scheduled for 29 April 2025. Technical editors will have access to the release by the week of 5 May 2025. This update will include a number of [[mw:Special:MyLanguage/Codex/Release_Timeline/2.0#Breaking_changes|breaking changes]] and minor [[mw:Special:MyLanguage/Codex/Release_Timeline/2.0#Visual_changes|visual changes]]. Instructions on handling the breaking and visual changes are documented on [[mw:Special:MyLanguage/Codex/Release Timeline/2.0#|this page]]. Pre-release testing is reported in [[phab:T386298|T386298]], with post-release issues tracked in [[phab:T392379|T392379]] and [[phab:T392390|T392390]].&lt;/span&gt;
* &lt;span lang=&quot;en&quot; dir=&quot;ltr&quot; class=&quot;mw-content-ltr&quot;&gt;Users of [[wikitech:Special:MyLanguage/Help:Wiki_Replicas|Wiki Replicas]] will notice that the database views of &lt;code dir=&quot;ltr&quot;&gt;ipblocks&lt;/code&gt;, &lt;code dir=&quot;ltr&quot;&gt;ipblocks_ipindex&lt;/code&gt;, and &lt;code dir=&quot;ltr&quot;&gt;ipblocks_compat&lt;/code&gt; are [[phab:T390767|now deprecated]]. Users can query the &lt;code dir=&quot;ltr&quot;&gt;[[mw:Special:MyLanguage/Manual:Block_table|block]]&lt;/code&gt; and &lt;code dir=&quot;ltr&quot;&gt;[[mw:Special:MyLanguage/Manual:Block_target_table|block_target]]&lt;/code&gt; new views that mirror the new tables in the production database instead. The deprecated views will be removed entirely from Wiki Replicas in June, 2025.&lt;/span&gt;
* [[File:Octicons-sync.svg|12px|link=|class=skin-invert|Sujet récurrent]] Détail des mises-à-jour à venir cette semaine : [[mw:MediaWiki 1.44/wmf.27|MediaWiki]]

'''En détails'''
* &lt;span lang=&quot;en&quot; dir=&quot;ltr&quot; class=&quot;mw-content-ltr&quot;&gt;The latest quarterly [[mw:Special:MyLanguage/Wikimedia Language and Product Localization/Newsletter/2025/April|Language and Internationalization Newsletter]] is now available.&lt;/span&gt; &lt;span lang=&quot;en&quot; dir=&quot;ltr&quot; class=&quot;mw-content-ltr&quot;&gt;This edition includes an overview of the improved [https://test.wikipedia.org/w/index.php?title=Special:ContentTranslation&amp;campaign=contributionsmenu&amp;to=es&amp;filter-type=automatic&amp;filter-id=previous-edits&amp;active-list=suggestions&amp;from=en#/ Content Translation Dashboard Tool], [[mw:Special:MyLanguage/Wikimedia Language and Product Localization/Newsletter/2025/April#Language Support for New and Existing Languages|support for new languages]], [[mw:Special:MyLanguage/Wikimedia Language and Product Localization/Newsletter/2025/April#Wiki Loves Ramadan Articles Made In Content Translation Mobile Workflow|highlights from the Wiki Loves Ramadan campaign]], [[m:Special:MyLanguage/Research:Languages Onboarding Experiment 2024 - Executive Summary|results from the Language Onboarding Experiment]], an analysis of topic diversity in articles, and information on upcoming community meetings and events.&lt;/span&gt;

'''Rencontres et évènements'''
* &lt;span lang=&quot;en&quot; dir=&quot;ltr&quot; class=&quot;mw-content-ltr&quot;&gt;The [[Special:MyLanguage/Grants:Knowledge_Sharing/Connect/Calendar|Let's Connect Learning Clinic]] will take place on [https://zonestamp.toolforge.org/1745937000 April 29 at 14:30 UTC]. This edition will focus on &quot;Understanding and Navigating Conflict in Wikimedia Projects&quot;. You can [[m:Special:MyLanguage/Event:Learning Clinic %E2%80%93 Understanding and Navigating Conflict in Wikimedia Projects (Part_1)|register now]] to attend.&lt;/span&gt;
* &lt;span lang=&quot;en&quot; dir=&quot;ltr&quot; class=&quot;mw-content-ltr&quot;&gt;The [[mw:Special:MyLanguage/Wikimedia Hackathon 2025|2025 Wikimedia Hackathon]], which brings the global technical community together to connect, brainstorm, and hack existing projects, will take place from May 2 to 4th, 2025, at Istanbul, Turkey.&lt;/span&gt;

'''''[[m:Special:MyLanguage/Tech/News|Actualités techniques]]''' préparées par les [[m:Special:MyLanguage/Tech/News/Writers|rédacteurs des actualités techniques]] et postées par [[m:Special:MyLanguage/User:MediaWiki message delivery|robot]]. [[m:Special:MyLanguage/Tech/News#contribute|Contribuer]]&amp;nbsp;• [[m:Special:MyLanguage/Tech/News/2025/18|Traduire]]&amp;nbsp;• [[m:Tech|Obtenir de l’aide]]&amp;nbsp;• [[m:Talk:Tech/News|Donner son avis]]&amp;nbsp;• [[m:Global message delivery/Targets/Tech ambassadors|S’abonner ou se désabonner]].''
&lt;/div&gt;&lt;section end=&quot;technews-2025-W18&quot;/&gt;

&lt;bdi lang=&quot;en&quot; dir=&quot;ltr&quot;&gt;[[User:MediaWiki message delivery|MediaWiki message delivery]]&lt;/bdi&gt; 28 avril 2025 à 21:31 (CEST)
&lt;!-- Message envoyé par User:UOzurumba (WMF)@metawiki en utilisant la liste sur https://meta.wikimedia.org/w/index.php?title=Global_message_delivery/Targets/Tech_ambassadors&amp;oldid=28585685 --&gt;

== Vote sur les modifications proposées aux lignes directrices de l'UCoC et à la charte de l'U4C ==

&lt;section begin=&quot;announcement-content&quot; /&gt;
La période de vote pour les révisions des directives d'application du Code de conduite universel et de la Charte U4C se termine le 1er mai 2025 à 23:59 UTC ([https://zonestamp.toolforge.org/1746162000 trouver dans votre fuseau horaire]). [[m:Special:MyLanguage/Universal Code of Conduct/Annual review/2025/Voter information|Lisez les informations sur la façon de participer et lisez la proposition avant de voter]] sur la page UCoC de Méta-wiki.

Le [[m:Special:MyLanguage/Universal Code of Conduct/Coordinating Committee|Comité de coordination du code de conduite universel (U4C)]] est un groupe mondial qui se consacre à la mise en œuvre équitable et cohérente de l'UCoC. Cet examen annuel a été planifié et mis en œuvre par l'U4C. Pour plus d'informations et pour connaître les responsabilités de l'U4C, vous pouvez [[m:Special:MyLanguage/Universal Code of Conduct/Coordinating Committee/Charter|réviser la charte U4C]].

Veuillez partager ce message avec les membres de votre communauté dans votre langue, le cas échéant, afin qu'ils puissent également y participer.

En coopération avec l'U4C -- &lt;section end=&quot;announcement-content&quot; /&gt;

&lt;div lang=&quot;en&quot; dir=&quot;ltr&quot; class=&quot;mw-content-ltr&quot;&gt;
[[m:User:Keegan (WMF)|Keegan (WMF)]] ([[m:User talk:Keegan (WMF)|talk]]) 29 avril 2025 à 05:40 (CEST)&lt;/div&gt;
&lt;!-- Message envoyé par User:Keegan (WMF)@metawiki en utilisant la liste sur https://meta.wikimedia.org/w/index.php?title=Distribution_list/Global_message_delivery&amp;oldid=28618011 --&gt;

== Actualités techniques n° 2025-19 ==

&lt;section begin=&quot;technews-2025-W19&quot;/&gt;&lt;div class=&quot;plainlinks&quot;&gt;
Dernières '''[[m:Special:MyLanguage/Tech/News|actualités techniques]]''' de la communauté technique de Wikimedia. N’hésitez pas à informer les autres utilisateurs de ces changements. Certains changements ne vous concernent pas. [[m:Special:MyLanguage/Tech/News/2025/19|D’autres traductions]] sont disponibles.

'''En lumière cette semaine'''
* La Wikimedia Foundation a partagé le dernier projet de mise à jour de son [[m:Special:MyLanguage/Wikimedia Foundation Annual Plan/2025-2026|plan annuel]] pour l'année prochaine (juillet 2025-juin 2026). Cela comprend un [[m:Special:MyLanguage/Wikimedia Foundation Annual Plan/2025-2026|résumé exécutif]] (également sur [[diffblog:2025/04/25/sharing-the-wikimedia-foundations-2025-2026-draft-annual-plan/|Diff]]), des détails sur les trois principaux [[m:Special:MyLanguage/Wikimedia Foundation Annual Plan/2025-2026/Goals|objectifs]] ([[m:Special:MyLanguage/Wikimedia Foundation Annual Plan/2025-2026/Product &amp; Technology OKRs|Infrastructure]], [[m:Special:MyLanguage/Wikimedia Foundation Annual Plan/2025-2026/Goals/Volunteer Support|Soutien aux bénévoles]] et [[m:Special:MyLanguage/Wikimedia Foundation Annual Plan/2025-2026/Goals/Effectiveness|Efficacité]]), [[m:Special:MyLanguage/Wikimedia Foundation Annual Plan/2025-2026/Global Trends|tendances mondiales]], ainsi que le [[m:Special:MyLanguage/Wikimedia Foundation Annual Plan/2025-2026/Budget Overview|budget]] et le [[m:Special:MyLanguage/Wikimedia Foundation Annual Plan/2025-2026/Financial Model|modèle financier]]. Les réactions et les questions sont les bienvenues sur la [[m:Talk:Wikimedia Foundation Annual Plan/2025-2026|page de discussion]] jusqu'à la fin du mois de mai.

'''Actualités pour la contribution'''
* Pour les wikis qui ont l'extension [[m:Special:MyLanguage/CampaignEvents/Deployment status|CampaignEvents]] activée, deux nouvelles améliorations de fonctionnalités ont été publiées :
** Les administrateurs peuvent désormais choisir les espaces de noms autorisés pour [[m:Special:MyLanguage/Event Center/Registration|Inscription à un événement]] via [[mw:Special:MyLanguage/Community Configuration|Configuration de la communauté]] ([[mw:Special:MyLanguage/Help:Extension:CampaignEvents/Registration/Permitted namespaces|documentation]]). Par défaut, l'enregistrement d'un événement est autorisé dans l'espace de noms Event, mais d'autres espaces de noms (tels que l'espace de noms du projet ou l'espace de noms WikiProject) peuvent désormais être ajoutés. Grâce à cette modification, les communautés telles que les WikiProjets peuvent désormais utiliser plus facilement l'enregistrement d'événements pour leurs activités collaboratives.
** Les éditeurs peuvent désormais [[mw:Special:MyLanguage/Transclusion|transclure]] la liste de collaboration sur une page wiki ([[mw:Special:MyLanguage/Help:Extension:CampaignEvents/Collaboration list/Transclusion|documentation]]). La liste de collaboration est une liste automatisée d'événements et de wikiprojets sur les wikis, accessible via {{#special:AllEvents}} ([[w:en:Special:AllEvents|exemple]]). Désormais, la liste de collaboration peut être ajoutée à toutes sortes de pages wiki, telles que : une page principale wiki, une page WikiProjet, une page d'affiliation, une page d'événement, ou même une page d'utilisateur.
* [[File:Octicons-sync.svg|12px|link=|class=skin-invert|Sujet récurrent]] Voir {{PLURAL:27|la tâche soumise|les {{formatnum:27}} tâches soumises}} par la communauté [[m:Special:MyLanguage/Tech/News/Recently resolved community tasks|résolue{{PLURAL:27||s}} la semaine dernière]].

'''Actualités pour la contribution technique'''
* Les développeurs qui utilisent la bibliothèque &lt;code dir=ltr&gt;moment&lt;/code&gt; dans les gadgets et les scripts utilisateur doivent réviser leur code pour utiliser des alternatives comme la bibliothèque &lt;code dir=ltr&gt;Intl&lt;/code&gt; ou la nouvelle bibliothèque &lt;code dir=ltr&gt;mediawiki.DateFormatter&lt;/code&gt;. La bibliothèque &lt;code dir=ltr&gt;moment&lt;/code&gt; a été dépréciée et commencera à enregistrer des messages dans la console du développeur. Vous pouvez voir une recherche globale pour les utilisations actuelles, et [[phab:T392532|posez des questions connexes dans cette tâche Phabricator]].
* Les développeurs qui maintiennent un outil qui interroge les tables de stockage de termes de Wikidata (&lt;code dir=ltr style=&quot;white-space: nowrap;&quot;&gt;wbt_*&lt;/code&gt;) doivent mettre à jour leur code pour se connecter à une grappe de base de données séparée. Ces tables sont réparties dans une grappe de base de données distincte. Les outils qui interrogent ces tables via les répliques du wiki doivent être adaptés pour se connecter à la nouvelle grappe. [[wikitech:News/2025 Wikidata term store database split|La documentation et des liens connexes sont à votre disposition]]. [https://phabricator.wikimedia.org/T390954]
* [[File:Octicons-sync.svg|12px|link=|class=skin-invert|Sujet récurrent]] Détail des mises-à-jour à venir cette semaine : [[mw:MediaWiki 1.44/wmf.28|MediaWiki]]

'''En détails'''
* La dernière [[mw:Special:MyLanguage/Extension:Chart/Project/Updates|lettre d’information du projet Chart]] est disponible. Il comprend des mises à jour sur la préparation de l'extension du déploiement à d'autres wikis dès cette semaine (à partir du 6 mai) et sur la mise à l'échelle au cours des semaines suivantes, ainsi que sur l'exploration du filtrage et de la transformation des données sources.

'''''[[m:Special:MyLanguage/Tech/News|Actualités techniques]]''' préparées par les [[m:Special:MyLanguage/Tech/News/Writers|rédacteurs des actualités techniques]] et postées par [[m:Special:MyLanguage/User:MediaWiki message delivery|robot]]. [[m:Special:MyLanguage/Tech/News#contribute|Contribuer]]&amp;nbsp;• [[m:Special:MyLanguage/Tech/News/2025/19|Traduire]]&amp;nbsp;• [[m:Tech|Obtenir de l’aide]]&amp;nbsp;• [[m:Talk:Tech/News|Donner son avis]]&amp;nbsp;• [[m:Global message delivery/Targets/Tech ambassadors|S’abonner ou se désabonner]].''
&lt;/div&gt;&lt;section end=&quot;technews-2025-W19&quot;/&gt;

&lt;bdi lang=&quot;en&quot; dir=&quot;ltr&quot;&gt;[[User:MediaWiki message delivery|MediaWiki message delivery]]&lt;/bdi&gt; 6 mai 2025 à 02:14 (CEST)
&lt;!-- Message envoyé par User:Quiddity (WMF)@metawiki en utilisant la liste sur https://meta.wikimedia.org/w/index.php?title=Global_message_delivery/Targets/Tech_ambassadors&amp;oldid=28665011 --&gt;

== We will be enabling the new Charts extension on your wiki soon! ==

''(Apologies for posting in English)''

Hi all! We have good news to share regarding the ongoing problem with graphs and charts affecting all wikis that use them.

As you probably know, the [[:mw:Special:MyLanguage/Extension:Graph|old Graph extension]] was disabled in 2023 [[listarchive:list/wikitech-l@lists.wikimedia.org/thread/EWL4AGBEZEDMNNFTM4FRD4MHOU3CVESO/|due to security reasons]]. We’ve worked in these two years to find a solution that could replace the old extension, and provide a safer and better solution to users who wanted to showcase graphs and charts in their articles. We therefore developed the [[:mw:Special:MyLanguage/Extension:Chart|Charts extension]], which will be replacing the old Graph extension and potentially also the [[:mw:Extension:EasyTimeline|EasyTimeline extension]].

After successfully deploying the extension on Italian, Swedish, and Hebrew Wikipedia, as well as on MediaWiki.org, as part of a pilot phase, we are now happy to announce that we are moving forward with the next phase of deployment, which will also include your wiki.

The deployment will happen in batches, and will start from '''May 6'''. Please, consult [[:mw:Special:MyLanguage/Extension:Chart/Project#Deployment Timeline|our page on MediaWiki.org]] to discover when the new Charts extension will be deployed on your wiki. You can also [[:mw:Special:MyLanguage/Extension:Chart|consult the documentation]] about the extension on MediaWiki.org.

If you have questions, need clarifications, or just want to express your opinion about it, please refer to the [[:mw:Special:MyLanguage/Extension_talk:Chart/Project|project’s talk page on Mediawiki.org]], or ping me directly under this thread. If you encounter issues using Charts once it gets enabled on your wiki, please report it on the [[:mw:Extension_talk:Chart/Project|talk page]] or at [[phab:tag/charts|Phabricator]].

Thank you in advance! -- [[User:Sannita (WMF)|User:Sannita (WMF)]] ([[User talk:Sannita (WMF)|talk]]) 6 mai 2025 à 17:07 (CEST)
&lt;!-- Message envoyé par User:Sannita (WMF)@metawiki en utilisant la liste sur https://meta.wikimedia.org/w/index.php?title=User:Sannita_(WMF)/Mass_sending_test&amp;oldid=28663781 --&gt;

== Actualités techniques n° 2025-20 ==

&lt;section begin=&quot;technews-2025-W20&quot;/&gt;&lt;div class=&quot;plainlinks&quot;&gt;
Dernières '''[[m:Special:MyLanguage/Tech/News|actualités techniques]]''' de la communauté technique de Wikimedia. N’hésitez pas à informer les autres utilisateurs de ces changements. Certains changements ne vous concernent pas. [[m:Special:MyLanguage/Tech/News/2025/20|D’autres traductions]] sont disponibles.

'''En lumière cette semaine'''
* Le lien [[m:Special:MyLanguage/Wikimedia URL Shortener|« Obtenir une URL raccourcie »]] dans la barre latérale inclut désormais un [[phab:T393309|code QR]]. Les utilisateurs des sites Wikimedia peuvent maintenant l’utiliser en le scannant ou en le téléchargeant pour partager et accéder rapidement au contenu partagé des sites Wikimedia, de manière pratique.

'''Actualités pour la contribution'''
* La Wikimedia Foundation travaille sur un système appelé [[m:Edge Uniques|« ''Edge Uniques'' »]], qui permettra de réaliser des [[w:en:A/B testing|tests A/B]], d’aider à se protéger contre les [[w:en:Denial-of-service attack|attaques par déni de service distribué]] (attaques DDoS), et de mieux comprendre combien de visiteurs les sites Wikimedia reçoivent. Cela vise à construire plus efficacement des outils utiles aux lecteurs, et de les aider à trouver ce qu'ils cherchent. Les Actualités techniques en ont [[m:Special:MyLanguage/Tech/News/2025/16|déjà parlé]]. Le déploiement sera progressif. Certains pourraient voir le cookie « ''Edge Uniques'' » à partir de la semaine du 19 mai. Vous pouvez en discuter sur la [[m:Talk:Edge Uniques|page de discussion]].
* À partir du 19 mai 2025, les organisateurs d’événements sur les wikis disposant de l’[[mw:Special:MyLanguage/Help:Extension:CampaignEvents|extension « CampaignEvents »]] pourront utiliser l’[[m:Special:MyLanguage/Event Center/Registration|inscription aux événements]] dans l’espace de noms du projet (par exemple, l’espace Wikipédia, l’espace Wikidata). Avec ce changement, les communautés n’ont plus besoin d’administrateurs pour utiliser cette fonctionnalité. Toutefois, les wikis qui ne souhaitent pas ce changement peuvent retirer et ajouter les espaces de noms autorisés sur [[Special:CommunityConfiguration/CampaignEvents]].
* Le projet Wikipédia dispose désormais d’un {{int:project-localized-name-group-wikipedia/fr}} en [[d:Q36720|nupe]] ([[w:nup:|&lt;code&gt;w:nup:&lt;/code&gt;]]). Il s’agit d’une langue principalement parlée dans la région du centre-nord du Nigeria. Les locuteurs de cette langue sont invités à contribuer à la [[w:nup:Tatacin feregi|nouvelle Wikipédia]].
* [[File:Octicons-sync.svg|12px|link=|class=skin-invert|Sujet récurrent]] Voir {{PLURAL:27|la tâche soumise|les {{formatnum:27}} tâches soumises}} par la communauté [[m:Special:MyLanguage/Tech/News/Recently resolved community tasks|résolue{{PLURAL:27||s}} la semaine dernière]].

'''Actualités pour la contribution technique'''
* Les développeurs peuvent désormais accéder à la Wikipédia néerlandaise pré-analysée, parmi d’autres (anglais, allemand, français, espagnol, italien et portugais), via les [https://enterprise.wikimedia.com/docs/snapshot/#structured-contents-snapshot-bundle-info-beta instantanés « ''Structured Contents'' » (bêta)]. Le contenu comprend des résumés Wikipédia analysés, des descriptions, des images principales, des infoboxes, des sections d’articles et des références.
* Le point de terminaison de l’API REST &lt;code dir=&quot;ltr&quot;&gt;/page/data-parsoid&lt;/code&gt; n’est plus utilisé et sera obsolète. Il est [[phab:T393557|prévu qu’il soit désactivé]] le 7 juin 2025.
* [[File:Octicons-sync.svg|12px|link=|class=skin-invert|Sujet récurrent]] Détail des mises-à-jour à venir cette semaine : [[mw:MediaWiki 1.45/wmf.1|MediaWiki]]

'''En détails'''
* Le [https://wikitech.wikimedia.org/wiki/News/2025_Cloud_VPS_VXLAN_IPv6_migration support IPv6] est un nouveau réseau virtuel Cloud qui améliore considérablement l’évolutivité, la sécurité et la préparation des plateformes Wikimedia pour l’avenir. Si vous êtes un contributeur technique curieux d’en savoir plus, consultez [https://techblog.wikimedia.org/2025/05/06/wikimedia-cloud-vps-ipv6-support/ ce billet de blogue] pour un aperçu détaillé de la transition vers l’IPv6.

'''Rencontres et évènements'''
* La deuxième édition de 2025 de [[m:Special:MyLanguage/Afrika Baraza|« Afrika Baraza »]], une plateforme virtuelle permettant aux Wikimédiens africains de se connecter, aura lieu le [https://zonestamp.toolforge.org/1747328400 15 mai à 17 h UTC]. Cette édition sera axée sur des discussions concernant la [[m:Special:MyLanguage/Wikimedia Foundation Annual Plan/2025-2026|planification annuelle et les avancées de Wikimedia]].
* La [[m:Special:MyLanguage/MENA Connect Community Call|« ''MENA Connect Community Call'' »]], une réunion virtuelle permettant aux Wikimédiens de la [[w:fr:MENA|région Moyen-Orient et Afrique du Nord]] (MENA) de se rencontrer, aura lieu le [https://zonestamp.toolforge.org/1747501200 17 mai à 17 h UTC]. Vous pouvez [[m:Event:MENA Connect (Wiki_Diwan) APP Call|vous inscrire dès maintenant]] pour y assister.

'''''[[m:Special:MyLanguage/Tech/News|Actualités techniques]]''' préparées par les [[m:Special:MyLanguage/Tech/News/Writers|rédacteurs des actualités techniques]] et postées par [[m:Special:MyLanguage/User:MediaWiki message delivery|robot]]. [[m:Special:MyLanguage/Tech/News#contribute|Contribuer]]&amp;nbsp;• [[m:Special:MyLanguage/Tech/News/2025/20|Traduire]]&amp;nbsp;• [[m:Tech|Obtenir de l’aide]]&amp;nbsp;• [[m:Talk:Tech/News|Donner son avis]]&amp;nbsp;• [[m:Global message delivery/Targets/Tech ambassadors|S’abonner ou se désabonner]].''
&lt;/div&gt;&lt;section end=&quot;technews-2025-W20&quot;/&gt;

&lt;bdi lang=&quot;en&quot; dir=&quot;ltr&quot;&gt;[[User:MediaWiki message delivery|MediaWiki message delivery]]&lt;/bdi&gt; 13 mai 2025 à 00:37 (CEST)
&lt;!-- Message envoyé par User:UOzurumba (WMF)@metawiki en utilisant la liste sur https://meta.wikimedia.org/w/index.php?title=Global_message_delivery/Targets/Tech_ambassadors&amp;oldid=28714188 --&gt;

== Appel aux candidatures pour le Comité de Coordination du Code de Conduite Universel (U4C). ==

&lt;section begin=&quot;announcement-content&quot; /&gt;
Les résultats du vote sur les directives d'application et la charte du Comité de Coordination du Code de Conduite Universel (U4C) sont disponibles [[m:Special:MyLanguage/Universal Code of Conduct/Annual review/2025#Results|sur Méta-wiki]].

Vous pouvez désormais [[m:Special:MyLanguage/Universal Code of Conduct/Coordinating Committee/Election/2025/Candidates|soumettre votre candidature pour siéger à l'U4C]] &lt;s&gt;à partir du 29 mai 2025 à 12:00 UTC&lt;/s&gt;. Des informations sur [[m:Special:MyLanguage/Universal Code of Conduct/Coordinating Committee/Election/2025|l'éligibilité, le processus, et la chronologie sont disponibles sur Méta-wiki]]. Le vote sur les candidats sera ouvert le 1&lt;sup&gt;er&lt;/sup&gt; juin 2025 et durera deux semaines, se finissant donc le 15 juin 2025 à 12:00 UTC.

Si vous avez des questions, vous pouvez les poser sur [[m:Talk:Universal Code of Conduct/Coordinating Committee/Election/2025|la page de discussion pour l'élection]]. -- en coopération avec l'U4C, &lt;/div&gt;&lt;section end=&quot;announcement-content&quot; /&gt;

&lt;bdi lang=&quot;en&quot; dir=&quot;ltr&quot;&gt;[[m:User:Keegan (WMF)|Keegan (WMF)]] ([[m:User_talk:Keegan (WMF)|discussion]])&lt;/bdi&gt; 16 mai 2025 à 00:06 (CEST)
&lt;!-- Message envoyé par User:Keegan (WMF)@metawiki en utilisant la liste sur https://meta.wikimedia.org/w/index.php?title=Distribution_list/Global_message_delivery&amp;oldid=28618011 --&gt;
:Rectification : Vous pouvez désormais [[m:Special:MyLanguage/Universal Code of Conduct/Coordinating Committee/Election/2025/Candidates|soumettre votre candidature pour siéger à l'U4C]] du 14 mai au 28 mai.
:{{BlocCitation|You can submit your candidacy from May 14 until May 28, 2025}}
:--&amp;nbsp;◄&amp;nbsp;[[Utilisateur:DavidL|'''D'''avid&amp;nbsp;'''L''']]&amp;nbsp;•&amp;nbsp;[[Discussion Utilisateur:DavidL|discuter]]&amp;nbsp;► 16 mai 2025 à 16:36 (CEST)

== &lt;span lang=&quot;en&quot; dir=&quot;ltr&quot;&gt;Tech News: 2025-21&lt;/span&gt; ==

&lt;div lang=&quot;en&quot; dir=&quot;ltr&quot;&gt;
&lt;section begin=&quot;technews-2025-W21&quot;/&gt;&lt;div class=&quot;plainlinks&quot;&gt;
Latest '''[[m:Special:MyLanguage/Tech/News|tech news]]''' from the Wikimedia technical community. Please tell other users about these changes. Not all changes will affect you. [[m:Special:MyLanguage/Tech/News/2025/21|Translations]] are available.

'''Weekly highlight'''
* The Editing Team and the Machine Learning Team are working on a new check for newcomers: [[mw:Edit check/Peacock check|Peacock check]]. Using a prediction model, this check will encourage editors to improve the tone of their edits, using artificial intelligence. We invite volunteers to review the first version of the Peacock language model for the following languages: Arabic, Spanish, Portuguese, English, and Japanese. Users from these wikis interested in reviewing this model are [[mw:Edit check/Peacock check/model test|invited to sign up at MediaWiki.org]]. The deadline to sign up is on May 23, which will be the start date of the test.

'''Updates for editors'''

* From May 20, 2025, [[m:Special:MyLanguage/Oversight policy|oversighters]] and [[m:Special:MyLanguage/Meta:CheckUsers|checkusers]] will need to have their accounts secured with two-factor authentication (2FA) to be able to use their advanced rights. All users who belong to these two groups and do not have 2FA enabled have been informed. In the future, this requirement may be extended to other users with advanced rights. [[m:Special:MyLanguage/Mandatory two-factor authentication for users with some extended rights|Learn more]].
* [[File:Octicons-gift.svg|12px|link=|class=skin-invert|Wishlist item]]  [[m:Special:MyLanguage/Community Wishlist Survey 2023/Multiblocks|Multiblocks]] will begin mass deployment by the end of the month: all non-Wikipedia projects plus Catalan Wikipedia will adopt Multiblocks in the week of May 26, while all other Wikipedias will adopt it in the week of June 2. Please [[m:Talk:Community Wishlist Survey 2023/Multiblocks|contact the team]] if you have concerns. Administrators can test the new user interface now on your own wiki by browsing to [{{fullurl:Special:Block|usecodex=1}} {{#special:Block}}?usecodex=1], and can test the full multiblocks functionality [[testwiki:Special:Block|on testwiki]]. Multiblocks is the feature that makes it possible for administrators to impose different types of blocks on the same user at the same time. See the [[mw:Special:MyLanguage/Help:Manage blocks|help page]] for more information. [https://phabricator.wikimedia.org/T377121]
* Later this week, the [[{{#special:SpecialPages}}]] listing of almost all special pages will be updated with a new design. This page has been [[phab:T219543|redesigned]] to improve the user experience in a few ways, including: The ability to search for names and aliases of the special pages, sorting, more visible marking of restricted special pages, and a more mobile-friendly look. The new version can be [https://meta.wikimedia.beta.wmflabs.org/wiki/Special:SpecialPages previewed] at Beta Cluster now, and feedback shared in the task. [https://phabricator.wikimedia.org/T219543]
* The [[mw:Special:MyLanguage/Extension:Chart|Chart extension]] is being enabled on more wikis. For a detailed list of when the extension will be enabled on your wiki, please read the [[mw:Special:MyLanguage/Extension:Chart/Project#Deployment Timeline|deployment timeline]].
* [[f:Special:MyLanguage/Wikifunctions:Main Page|Wikifunctions]] will be deployed on May 27 on five Wiktionaries: [[wikt:ha:|Hausa]], [[wikt:ig:|Igbo]], [[wikt:bn:|Bengali]], [[wikt:ml:|Malayalam]], and [[wikt:dv:|Dhivehi/Maldivian]]. This is the second batch of deployment planned for the project. After deployment, the projects will be able to call [[f:Special:MyLanguage/Wikifunctions:Introduction|functions from Wikifunctions]] and integrate them in their pages. A function is something that takes one or more inputs and transforms them into a desired output, such as adding up two numbers, converting miles into metres, calculating how much time has passed since an event, or declining a word into a case. Wikifunctions will allow users to do that through a simple call of [[f:Special:MyLanguage/Wikifunctions:Catalogue|a stable and global function]], rather than via a local template.
* Later this week, the Wikimedia Foundation will publish a hub for [[diffblog:2024/07/09/on-the-value-of-experimentation/|experiments]]. This is to showcase and get user feedback on product experiments. The experiments help the Wikimedia movement [[diffblog:2023/07/13/exploring-paths-for-the-future-of-free-knowledge-new-wikipedia-chatgpt-plugin-leveraging-rich-media-social-apps-and-other-experiments/|understand new users]], how they interact with the internet and how it could affect the Wikimedia movement. Some examples are [[m:Special:MyLanguage/Future Audiences/Generated Video|generated video]], the [[m:Special:MyLanguage/Future Audiences/Roblox game|Wikipedia Roblox speedrun game]] and [[m:Special:MyLanguage/Future Audiences/Discord bot|the Discord bot]].
* [[File:Octicons-sync.svg|12px|link=|class=skin-invert|Recurrent item]] View all {{formatnum:29}} community-submitted {{PLURAL:29|task|tasks}} that were [[m:Special:MyLanguage/Tech/News/Recently resolved community tasks|resolved last week]]. For example, there was a bug with creating an account using the API, which has now been fixed. [https://phabricator.wikimedia.org/T390751]

'''Updates for technical contributors'''
* Gadgets and user scripts that interact with [[{{#special:Block}}]] may need to be updated to work with the new [[mw:Special:MyLanguage/Help:Manage blocks|manage blocks interface]]. Please review the [[mw:Help:Manage blocks/Developers|developer guide]] for more information. If you need help or are unable to adapt your script to the new interface, please let the team know on the [[mw:Help talk:Manage blocks/Developers|talk page]]. [https://phabricator.wikimedia.org/T377121]
* The &lt;code dir=ltr&gt;mw.title&lt;/code&gt; object allows you to get information about a specific wiki page in the [[w:en:Wikipedia:Lua|Lua]] programming language. Starting this week, a new property will be added to the object, named &lt;code dir=ltr&gt;isDisambiguationPage&lt;/code&gt;. This property allows you to check if a page is a disambiguation page, without the need to write a custom function. [https://phabricator.wikimedia.org/T71441]
* [[File:Octicons-tools.svg|15px|link=|class=skin-invert|Advanced item]] User script developers can use a [[toolforge:gitlab-content|new reverse proxy tool]] to load javascript and css from [[gitlab:|gitlab.wikimedia.org]] with &lt;code dir=ltr&gt;mw.loader.load&lt;/code&gt;. The tool's author hopes this will enable collaborative development workflows for user scripts including linting, unit tests, code generation, and code review on &lt;bdi lang=&quot;zxx&quot; dir=&quot;ltr&quot;&gt;gitlab.wikimedia.org&lt;/bdi&gt; without a separate copy-and-paste step to publish scripts to a Wikimedia wiki for integration and acceptance testing. See [[wikitech:Tool:Gitlab-content|Tool:Gitlab-content on Wikitech]] for more information.
* [[File:Octicons-sync.svg|12px|link=|class=skin-invert|Recurrent item]] Detailed code updates later this week: [[mw:MediaWiki 1.45/wmf.2|MediaWiki]]

'''Meetings and events'''
* The 12th edition of [[m:Special:MyLanguage/Wiki Workshop 2025|Wiki Workshop 2025]], a forum that brings together researchers that explore all aspects of Wikimedia projects, will be held virtually on 21-22 May. Researchers can [https://pretix.eu/wikimedia/wikiworkshop2025/ register now].

'''''[[m:Special:MyLanguage/Tech/News|Tech news]]''' prepared by [[m:Special:MyLanguage/Tech/News/Writers|Tech News writers]] and posted by [[m:Special:MyLanguage/User:MediaWiki message delivery|bot]]&amp;nbsp;• [[m:Special:MyLanguage/Tech/News#contribute|Contribute]]&amp;nbsp;• [[m:Special:MyLanguage/Tech/News/2025/21|Translate]]&amp;nbsp;• [[m:Tech|Get help]]&amp;nbsp;• [[m:Talk:Tech/News|Give feedback]]&amp;nbsp;• [[m:Global message delivery/Targets/Tech ambassadors|Subscribe or unsubscribe]].''
&lt;/div&gt;&lt;section end=&quot;technews-2025-W21&quot;/&gt;
&lt;/div&gt;

&lt;bdi lang=&quot;en&quot; dir=&quot;ltr&quot;&gt;[[User:MediaWiki message delivery|MediaWiki message delivery]]&lt;/bdi&gt; 20 mai 2025 à 01:12 (CEST)
&lt;!-- Message envoyé par User:Quiddity (WMF)@metawiki en utilisant la liste sur https://meta.wikimedia.org/w/index.php?title=Global_message_delivery/Targets/Tech_ambassadors&amp;oldid=28724712 --&gt;

== RfC ongoing regarding Abstract Wikipedia (and your project) ==

&lt;div lang=&quot;en&quot; dir=&quot;ltr&quot; class=&quot;mw-content-ltr&quot;&gt;
''(Apologies for posting in English, if this is not your first language)''

Hello all! We opened a discussion on Meta about a very delicate issue for the development of [[:m:Special:MyLanguage/Abstract Wikipedia|Abstract Wikipedia]]: where to store the abstract content that will be developed through functions from Wikifunctions and data from Wikidata. Since some of the hypothesis involve your project, we wanted to hear your thoughts too. 

We want to make the decision process clear: we do not yet know which option we want to use, which is why we are consulting here. We will take the arguments from the Wikimedia communities into account, and we want to consult with the different communities and hear arguments that will help us with the decision. The decision will be made and communicated after the consultation period by the Foundation.

You can read the various hypothesis and have your say at [[:m:Abstract Wikipedia/Location of Abstract Content|Abstract Wikipedia/Location of Abstract Content]]. Thank you in advance! -- [[User:Sannita (WMF)|Sannita (WMF)]] ([[User talk:Sannita (WMF)|&lt;span class=&quot;signature-talk&quot;&gt;{{int:Talkpagelinktext}}&lt;/span&gt;]]) 22 mai 2025 à 17:26 (CEST)
&lt;/div&gt;
&lt;!-- Message envoyé par User:Sannita (WMF)@metawiki en utilisant la liste sur https://meta.wikimedia.org/w/index.php?title=User:Sannita_(WMF)/Mass_sending_test&amp;oldid=28768453 --&gt;

== Actualités techniques n° 2025-22 ==

&lt;section begin=&quot;technews-2025-W22&quot;/&gt;&lt;div class=&quot;plainlinks&quot;&gt;
Dernières '''[[m:Special:MyLanguage/Tech/News|actualités techniques]]''' de la communauté technique de Wikimedia. N’hésitez pas à informer les autres utilisateurs de ces changements. Certains changements ne vous concernent pas. [[m:Special:MyLanguage/Tech/News/2025/22|D’autres traductions]] sont disponibles.

'''En lumière cette semaine'''
* Une discussion communautaire à l’échelle du mouvement est désormais ouverte sur Meta au sujet d’un point très délicat pour le développement de [[m:Special:MyLanguage/Abstract Wikipedia|« Abstract Wikipedia »]] : où stocker le contenu abstrait qui sera développé à partir des fonctions de Wikifunctions et des données de Wikidata. La discussion est ouverte jusqu’au 12 juin sur [[m:Special:MyLanguage/Abstract Wikipedia/Location of Abstract Content|Abstract Wikipedia/Location of Abstract Content]], et tous les avis sont les bienvenus. La décision sera prise et communiquée par la Fondation à l’issue de la période de consultation.

'''Actualités pour la contribution'''
* Depuis la semaine dernière, sur tous les wikis excepté [[phab:T388604|les vingt plus grands]], les utilisateurs de l’éditeur visuel mobile disposent de [[phab:T385851|nouveaux outils dans la barre de menu]], accessibles via le nouveau bouton de la barre d’outils &lt;code&gt;+&lt;/code&gt;. Pour commencer, le nouveau menu proposera des options pour ajouter : des références, des hiéroglyphes et des blocs de code. Le déploiement sur les autres wikis est [[phab:T388605|prévu]] pour le mois de juin.
* [[File:Octicons-tools.svg|12px|link=|class=skin-invert|Sujet technique]] La fonction d’analyse &lt;code dir=ltr&gt;[[mw:Special:MyLanguage/Help:Extension:ParserFunctions##ifexist|#ifexist]]&lt;/code&gt; ne créera plus de lien vers sa page cible. Cela améliorera l’utilité de [[{{#special:WantedPages}}]], qui ne listera à terme que les pages réellement ciblées par un lien rouge. Ce changement se fera progressivement à mesure que les pages sources seront mises à jour. [https://phabricator.wikimedia.org/T14019]
* Cette semaine, l’équipe des outils de modération va lancer [[mw:Special:MyLanguage/2025 RecentChanges Language Agnostic Revert Risk Filtering|un nouveau filtre dans les modifications récentes]], en commençant par la Wikipédia en indonésien. Ce nouveau filtre met en évidence les modifications susceptibles d’être annulées. L’objectif est d’aider les patrouilleurs des modifications récentes à repérer les contributions potentiellement problématiques. D’autres wikis bénéficieront de ce filtre à l’avenir.
* Lorsqu’ils cliquent sur une barre de recherche vide, les utilisateurs non connectés verront des suggestions d’articles à lire. Cette fonctionnalité sera disponible à la fois sur ordinateur et sur mobile. Les lecteurs des Wikipédias en catalan, hébreu et italien ainsi que de certains projets frères recevront ce changement entre le 21 mai et la mi-juin. Les lecteurs des autres wikis le recevront plus tard. L’objectif est d’encourager les utilisateurs à lire davantage les wikis. [[mw:Special:MyLanguage/Reading/Web/Content Discovery Experiments/Search Suggestions|En savoir plus]].
* Certains utilisateurs de l’application Wikipédia sur Android peuvent utiliser une nouvelle fonctionnalité destinée aux lecteurs : [[mw:Special:MyLanguage/Wikimedia Apps/Team/Android/TrivaGame|« WikiGames »]], un jeu quotidien de quiz basé sur des événements historiques réels. Le déploiement a commencé sous forme de test A/B, disponible pour 50 % des utilisateurs dans les langues suivantes : anglais, français, portugais, russe, espagnol, arabe, chinois et turc.
* L’[[mw:Special:MyLanguage/Extension:Newsletter|extension « Newsletter »]] disponible sur MediaWiki.org permet la création de [[mw:Special:Newsletters|divers bulletins d’information]] à destination des utilisateurs de tous les wikis. L’extension peut désormais publier de nouveaux numéros sous forme de liens vers des sections sur une page existante, au lieu de nécessiter une nouvelle page pour chaque numéro. [https://phabricator.wikimedia.org/T393844]
* [[File:Octicons-sync.svg|12px|link=|class=skin-invert|Sujet récurrent]] Voir {{PLURAL:32|la tâche soumise|les {{formatnum:32}} tâches soumises}} par la communauté [[m:Special:MyLanguage/Tech/News/Recently resolved community tasks|résolue{{PLURAL:32||s}} la semaine dernière]].

'''Actualités pour la contribution technique'''
* Les champs &lt;code dir=ltr&gt;[[mw:Special:MyLanguage/Manual:Ipblocks table|ipblocks]]&lt;/code&gt;, précédemment déclarés obsolètes, seront supprimés début juin dans les [[wikitech:Help:Wiki Replicas|Wiki Replicas]]. Il est recommandé aux utilisateurs d’interroger les nouveaux champs &lt;code dir=ltr&gt;[[mw:Special:MyLanguage/Manual:Block table|block]]&lt;/code&gt; et &lt;code dir=ltr&gt;[[mw:Special:MyLanguage/Manual:Block target table|block_target]]&lt;/code&gt; à la place.
* [[File:Octicons-sync.svg|12px|link=|class=skin-invert|Sujet récurrent]] Détail des mises-à-jour à venir cette semaine : [[mw:MediaWiki 1.45/wmf.3|MediaWiki]]

'''Rencontres et évènements'''
* [[d:Special:MyLanguage/Event:Wikidata and Sister Projects|« Wikidata et les projets frères »]] est un événement en ligne de plusieurs jours qui portera sur l’intégration de Wikidata à Wikipédia et aux autres projets Wikimedia. L’événement se déroulera du 29 mai au 1&lt;sup&gt;er&lt;/sup&gt; juin. Vous pouvez [[d:Special:MyLanguage/Event:Wikidata and Sister Projects#Sessions|consulter le programme]] et [[d:Special:RegisterForEvent/1291|vous inscrire]].

'''''[[m:Special:MyLanguage/Tech/News|Actualités techniques]]''' préparées par les [[m:Special:MyLanguage/Tech/News/Writers|rédacteurs des actualités techniques]] et postées par [[m:Special:MyLanguage/User:MediaWiki message delivery|robot]]. [[m:Special:MyLanguage/Tech/News#contribute|Contribuer]]&amp;nbsp;• [[m:Special:MyLanguage/Tech/News/2025/22|Traduire]]&amp;nbsp;• [[m:Tech|Obtenir de l’aide]]&amp;nbsp;• [[m:Talk:Tech/News|Donner son avis]]&amp;nbsp;• [[m:Global message delivery/Targets/Tech ambassadors|S’abonner ou se désabonner]].''
&lt;/div&gt;&lt;section end=&quot;technews-2025-W22&quot;/&gt;

&lt;bdi lang=&quot;en&quot; dir=&quot;ltr&quot;&gt;[[User:MediaWiki message delivery|MediaWiki message delivery]]&lt;/bdi&gt; 26 mai 2025 à 22:04 (CEST)
&lt;!-- Message envoyé par User:UOzurumba (WMF)@metawiki en utilisant la liste sur https://meta.wikimedia.org/w/index.php?title=Global_message_delivery/Targets/Tech_ambassadors&amp;oldid=28788673 --&gt;

== Sélection 2025 du conseil d'administration de la fondation Wikimédia et appel à questions ==

&lt;section begin=&quot;announcement-content&quot; /&gt;
:''[[m:Special:MyLanguage/Wikimedia Foundation elections/2025/Announcement/Selection announcement|{{int:interlanguage-link-mul}}]] • [https://meta.wikimedia.org/w/index.php?title=Special:Translate&amp;group=page-{{urlencode:Wikimedia Foundation elections/2025/Announcement/Selection announcement}}&amp;language=&amp;action=page&amp;filter= {{int:please-translate}}]''

Chers tous et toutes,

Cette année, le mandat de deux administrateurs sélectionnés par la communauté et les affiliés au conseil d'administration de la Fondation Wikimédia prendra fin [1]. Le conseil invite l'ensemble du mouvement à participer au processus de sélection de cette année et à voter pour pourvoir ces sièges.

Le Comité des élections supervisera ce processus avec le soutien du personnel de la Fondation [2]. Le Comité de gouvernance, composé de membres du Conseil d'administration non-candidats au processus de sélection des membres du Conseil d'administration 2025 sélectionnés par la communauté et les affiliés (Raju Narisetti, Shani Evenstein Sigalov, Lorenzo Losa, Kathy Collins, Victoria Doronina et Esra'a Al Shafei) [3], est chargé de superviser le processus de sélection des membres du Conseil d'administration 2025 et de tenir le Conseil d'administration au courant de la situation. Pour plus de détails sur les rôles de la commission des élections, du conseil d'administration et du personnel, cliquez ici [4].

En voici les dates clés :

* 22 mai - 5 juin : Annonce ( la présente communication) et période d'appel à questions. [6]
* 17 juin - 1er juillet 2025 : Appel à candidatures
* Juillet 2025 : Si nécessaire, les affiliés votent pour présélectionner les candidats si 10 d'entre eux ou plus se présentent [5].
* Août 2025 : Période de la campagne
* Août - septembre 2025 : Période de vote communautaire de deux semaines
* Octobre - novembre 2025 : Vérification des antécédents des candidats sélectionnés
* Réunion du conseil d'administration en décembre 2025 : Installation des nouveaux membres du conseil d'administration

Pour en savoir plus sur le processus de sélection de 2025 - y compris le calendrier détaillé, le processus de candidature, les règles de la campagne et les critères d'éligibilité des électeurs -, veuillez consulter cette page Meta-wiki. [[m:Special:MyLanguage/Wikimedia_Foundation_elections/2025|[link]]].

'''Appel à questions'''

Lors de chaque processus de sélection, la communauté a la possibilité de soumettre des questions auxquelles les candidats au conseil d'administration devront répondre. Le comité électoral sélectionne les questions à partir de la liste établie par la communauté pour que les candidats y répondent. Les candidats doivent répondre à toutes les questions posées dans le dossier de candidature pour être éligibles, faute de quoi leur candidature sera rejetée. Cette année, le comité électoral sélectionnera 5 questions auxquelles les candidats devront répondre. Les questions sélectionnées peuvent être une combinaison de celles qui ont été soumises par la communauté, si elles sont similaires ou liées. [[m:Special:MyLanguage/Wikimedia_Foundation_elections/2025/Questions_for_candidates|[link]]]

'''Bénévoles des élections'''

Une autre façon de participer au processus de sélection de 2025 est de devenir bénévole des élections. Les bénévoles électoraux constituent un pont entre le comité électoral et leur communauté respective. Ils veillent à ce que leur communauté soit représentée et les incitent à voter. Pour en savoir plus sur le programme et les modalités d'adhésion, consultez cette page Meta-wiki. [[m:Wikimedia_Foundation_elections/2025/Election_volunteers|[link]]].

Je vous remercie !

[1] https://meta.wikimedia.org/wiki/Wikimedia_Foundation_elections/2022/Results

[2] https://foundation.wikimedia.org/wiki/Committee:Elections_Committee_Charter

[3] https://foundation.wikimedia.org/wiki/Resolution:Committee_Membership,_December_2024

[4] https://meta.wikimedia.org/wiki/Wikimedia_Foundation_elections_committee/Roles

[5] https://meta.wikimedia.org/wiki/Wikimedia_Foundation_elections/2025/FAQ

[6] https://meta.wikimedia.org/wiki/Wikimedia_Foundation_elections/2025/Questions_for_candidates

Bien à vous,

Victoria Doronina

Liaison du conseil d'administration avec le comité des élections

Comité de gouvernance&lt;section end=&quot;announcement-content&quot; /&gt;

[[Utilisateur:MediaWiki message delivery|MediaWiki message delivery]] ([[Discussion utilisateur:MediaWiki message delivery|discussion]]) 28 mai 2025 à 05:07 (CEST)
&lt;!-- Message envoyé par User:RamzyM (WMF)@metawiki en utilisant la liste sur https://meta.wikimedia.org/w/index.php?title=Distribution_list/Global_message_delivery&amp;oldid=28618011 --&gt;

== Actualités techniques n° 2025-23 ==

&lt;section begin=&quot;technews-2025-W23&quot;/&gt;&lt;div class=&quot;plainlinks&quot;&gt;
Dernières '''[[m:Special:MyLanguage/Tech/News|actualités techniques]]''' de la communauté technique de Wikimedia. N’hésitez pas à informer les autres utilisateurs de ces changements. Certains changements ne vous concernent pas. [[m:Special:MyLanguage/Tech/News/2025/23|D’autres traductions]] sont disponibles.

'''En lumière cette semaine'''
* L'[[mw:Special:MyLanguage/Extension:Chart|extension Chart]] est maintenant disponible sur tous les wikis Wikimedia. Les éditeurs peuvent utiliser cette nouvelle extension pour créer des visualisations de données interactives comme des diagrammes à barres, à lignes, avec des zones, et circulaires. Chart a été créée pour remplacer la plupart des utilisations de l'ancienne [[mw:Special:MyLanguage/Extension:Graph|extension Graph]].

'''Actualités pour la contribution'''
* Il est maintenant plus simple de configurer les citations automatiques pour votre wiki dans le [[mw:Special:MyLanguage/Citoid/Enabling Citoid on your wiki|générateur de citations]] de l'éditeur visuel. Les administrateurs peuvent maintenant définir un modèle par défaut en utilisant la clé &lt;code dir=ltr&gt;_default&lt;/code&gt; dans la page locale &lt;bdi lang=&quot;en&quot; dir=&quot;ltr&quot;&gt;[[MediaWiki:Citoid-template-type-map.json]]&lt;/bdi&gt; ([[mw:Special:Diff/6969653/7646386|exemple de modification]]). Définir ce réglage par défaut permettra aussi de pérenniser vos configurations existantes lorsque de [[phab:T347823|nouveaux types d'objets]] seront ajoutés à l'avenir. Vous pouvez toujours définir des modèles pour des types d'objets individuels et ils seront prioritaires par rapport au modèle par défaut. [https://phabricator.wikimedia.org/T384709]
* [[File:Octicons-sync.svg|12px|link=|class=skin-invert|Sujet récurrent]] Voir {{PLURAL:20|la tâche soumise|les {{formatnum:20}} tâches soumises}} par la communauté [[m:Special:MyLanguage/Tech/News/Recently resolved community tasks|résolue{{PLURAL:20||s}} la semaine dernière]].

'''Actualités pour la contribution technique'''
* À partir de la semaine du 2 juin, les robots qui utilisent &lt;code dir=ltr&gt;action=login&lt;/code&gt; ou &lt;code dir=ltr&gt;action=clientlogin&lt;/code&gt; pour s'authentifier auront un taux d'échec plus fréquent. Cela est dû à des protections plus fortes contre les connexions suspectes. Les robots qui utilisent des [[mw:Special:MyLanguage/Manual:Bot passwords|mots de passe de robots]] ou une authentification sans connexion telle que [[mw:Special:MyLanguage/OAuth/Owner-only consumers|OAuth]] ne seront pas affectés. Si votre bot n'utilise aucun des deux, vous devriez le mettre à jour ; utiliser &lt;code dir=ltr&gt;action=login&lt;/code&gt; sans un mot de passe de robot a été rendu désuet [[listarchive:list/wikitech-l@lists.wikimedia.org/message/3EEMN7VQX5G7WMQI5K2GP5JC2336DPTD/|en 2016]]. Pour la plupart des robots, cela nécessite seulement de changer quel mot de passe ce dernier utilise. [https://phabricator.wikimedia.org/T395205]
* À partir de cette semaine, les wikis Wikimedia permettront des fonctionnalités ES2017 dans le code JavaScript pour le code officiel, les gadgets et les scripts utilisateurs. La fonctionnalité la plus visible d'ES2017 est la syntaxe &lt;bdi lang=&quot;zxx&quot; dir=&quot;ltr&quot;&gt;&lt;code&gt;async&lt;/code&gt;/&lt;code&gt;await&lt;/code&gt;&lt;/bdi&gt;, ce qui permet un code plus facile à lire. Jusqu'à cette semaine, la plateforme ne permettait que jusqu'à ES2016, et quelques mois plus tôt, jusqu'à ES2015. [https://phabricator.wikimedia.org/T381537]
* [[File:Octicons-sync.svg|12px|link=|class=skin-invert|Sujet récurrent]] Détail des mises-à-jour à venir cette semaine : [[mw:MediaWiki 1.45/wmf.4|MediaWiki]]

'''Rencontres et évènements'''
* Les demandes de bourse d'études pour participer à la [[m:Special:MyLanguage/GLAM Wiki 2025|conférence GLAM 2025]] sont maintenant ouvertes. La conférence aura lieu du 30 octobre au 1er novembre, à Lisbonne, au Portugal. Les contributeurs GLAM qui n'ont pas les moyens de financer leur participation peuvent [[m:Special:MyLanguage/GLAM Wiki 2025/Scholarships|faire une demande ici]]. La date limite de candidature est le 7 juin.

'''''[[m:Special:MyLanguage/Tech/News|Actualités techniques]]''' préparées par les [[m:Special:MyLanguage/Tech/News/Writers|rédacteurs des actualités techniques]] et postées par [[m:Special:MyLanguage/User:MediaWiki message delivery|robot]]. [[m:Special:MyLanguage/Tech/News#contribute|Contribuer]]&amp;nbsp;• [[m:Special:MyLanguage/Tech/News/2025/23|Traduire]]&amp;nbsp;• [[m:Tech|Obtenir de l’aide]]&amp;nbsp;• [[m:Talk:Tech/News|Donner son avis]]&amp;nbsp;• [[m:Global message delivery/Targets/Tech ambassadors|S’abonner ou se désabonner]].''
&lt;/div&gt;&lt;section end=&quot;technews-2025-W23&quot;/&gt;

&lt;bdi lang=&quot;en&quot; dir=&quot;ltr&quot;&gt;[[User:MediaWiki message delivery|MediaWiki message delivery]]&lt;/bdi&gt; 3 juin 2025 à 01:54 (CEST)
&lt;!-- Message envoyé par User:Quiddity (WMF)@metawiki en utilisant la liste sur https://meta.wikimedia.org/w/index.php?title=Global_message_delivery/Targets/Tech_ambassadors&amp;oldid=28819186 --&gt;</text>
      <sha1>qgex8flrsb47gflskeqyjz3562vdqeh</sha1>
    </revision>
  </page>
  <page>
    <title>Wikilivres:Requêtes aux administrateurs/2025</title>
    <ns>4</ns>
    <id>82066</id>
    <revision>
      <id>744185</id>
      <parentid>742838</parentid>
      <timestamp>2025-06-05T23:24:39Z</timestamp>
      <contributor>
        <username>Samuele2002</username>
        <id>53231</id>
      </contributor>
      <comment>/* Vandalism user:Sophiedecaen140 */ nouvelle section</comment>
      <origin>744185</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="7148" sha1="httnhf0mdo166je7kckwmcbijyfq4xj" xml:space="preserve">{{Wikilivres:Groupes}}
{{Wikilivres:Requêtes aux administrateurs/En-tête}}

== Transfert WIKIPEDIA --&gt; WIKILIVRES ==

Bonjour
j'ai écris une page récemment dans WIKIPEDIA sur le mini-shogi.
On m'a demandé de faire un transfert dans WIKILIVRES; car cet article n'est pas de nature encyclopédique.
J'ai modifié l’Entêté de la page avec {{Pour Wikibooks}}.
Je dois ensuite demander un transfert de la page vers WIKILIVRES à un administrateur mais je n'ai pas trouvé comment faire.
Je voudrais donc connaitre la procédure à suivre.
Merci [[Utilisateur:Didier1963|Didier1963]] ([[Discussion utilisateur:Didier1963|discussion]]) 16 janvier 2025 à 13:02 (CET)
:Bonjour Didier1963,
:Il suffit juste de faire une demande ici.
:Le transfert est en cours.
:--&amp;nbsp;◄&amp;nbsp;[[Utilisateur:DavidL|'''D'''avid&amp;nbsp;'''L''']]&amp;nbsp;•&amp;nbsp;[[Discussion Utilisateur:DavidL|discuter]]&amp;nbsp;► 18 janvier 2025 à 11:42 (CET)
::La page a été importée ici : [[Utilisateur:Didier1963/Brouillon]]
::Pour en faire un livre, il faut diviser le contenu en plusieurs pages wiki (chapitres) liées à la page principale de présentation du livre.
::* Voir [[Wikilivres:Conventions sur les titres]] et [[Wikilivres/Organisation d'un wikilivre]]
::* Exemple de livres similaires : [[Jeu de Go]], [[Jeu de rôle sur table — Jouer, créer]]
::--&amp;nbsp;◄&amp;nbsp;[[Utilisateur:DavidL|'''D'''avid&amp;nbsp;'''L''']]&amp;nbsp;•&amp;nbsp;[[Discussion Utilisateur:DavidL|discuter]]&amp;nbsp;► 18 janvier 2025 à 11:52 (CET)
:::Bonjour, on m'a pingué sur Wikipédia en parallèle et j'avais importé cette page ici en parallèle : [[Mini-shōgi]]. Du coup j'ai supprimé le brouillon. [[Utilisateur:JackPotte|JackPotte]] ([[Discussion utilisateur:JackPotte|&lt;span style=&quot;color:#FF6600&quot;&gt;$&lt;/span&gt;♠]]) 19 janvier 2025 à 11:36 (CET)
::::Bonjour
::::je n'arrive pas a comprendre le fonctionnement de ma demande de transfert de ma page WKIPEDIA  dans Didier1963/Brouillon &quot;mini-shogi&quot;
::::En premier lieu, j'a été &quot;signalé&quot; (par vous apparent) à cause d'un brouillon &quot;gâteau aux excréments&quot; apparu dans mes sessions .Que signifie exactement cette notion de &quot;signalement&quot; ?
::::Cette 'fausse&quot; page est bien sur ridicule,.... Je ne suis n&quot;y absolument pour rien, c'est-ce un vandalisme délibéré (par qu)i ?; mais je 'ai pas su tout traiter cette brutale intrusion, sinon de reprendre la rédaction de mon brouillon....
::::Comment se fait-il qu'il soit possible de vandaliser un brouillon qui par nature n'est pas public ?
::::En second lieu, suite a un avis reçu de WKIPEDIA  j'ai demandé de transfert de mon article dans WIKILIVRE
::::il me semble avoir compris que le transfert avait été fait mais la page aussitôt supprimée (par vous apparent) ?
::::Si c'est bien ça , il est assez  inadmissible (et incompréhensible) de procéder ainsi sans explications et sans aide.
::::s'il y a un problème de rédaction ou de forme, il suffit de l’écrire et éventuellement d'indiquer comment faire, surtout pour les débutants comme moi
::::cordialement [[Utilisateur:Didier1963|Didier1963]] ([[Discussion utilisateur:Didier1963|discussion]]) 22 janvier 2025 à 23:05 (CET)
:::::je me répond à moi même...
:::::j'ai finalement trouvé la page transférée de WIKIPEDIA vers WIKILIVRE en passant par le moteur de recherche.
:::::je remercie les intervenants car j'en déduit que, finalement, tout s'est bien passé.
:::::cordialement [[Utilisateur:Didier1963|Didier1963]] ([[Discussion utilisateur:Didier1963|discussion]]) 24 janvier 2025 à 22:31 (CET)

{{État de la requête|état=traitée}}

== Import du modèle:mesure de WP ==

'''Auteur :''' [[Utilisateur:Cdang|Cdang]] ([[Discussion utilisateur:Cdang|discussion]])

'''Date :''' 22 janvier 2025 à 09:40 (CET)

'''Modèle :''' [[:modèle:chiffrage mesure]]

'''Requête :'''

Bonjour,

serait-il possible d'importer le ''[[w:modèle:mesure]]'' pour remplacer l'actuel ''[[:modèle:chiffrage mesure]]'', bien moins complet ?

Je préconise de garder le nom ''chiffrage mesure'', moins ambigu.

Le ''modèle:chiffrage mesure'' est actuellement utilisé dans les wikilivres ''[[Introduction à LilyPond]]'', ''[[Formation musicale]]'' et ''[[LaTeX/Écrire de la musique]]''.

{{État de la requête|état=traitée}}

'''Discussions :'''
:{{fait}} [[Utilisateur:JackPotte|JackPotte]] ([[Discussion utilisateur:JackPotte|&lt;span style=&quot;color:#FF6600&quot;&gt;$&lt;/span&gt;♠]]) 26 janvier 2025 à 22:33 (CET)

== Page Conjuguer au conditionnel présent ==

Bonjour,

Je me présente, je m'appelle Nathalie BALON.  Je suis logopède, psychopédagogue et formatrice en langage écrit (à savoir : orthographe, rédaction d'ouvrages, écriture thérapeutique et écrits professionnels).  
Par hasard, je suis &quot;tombée&quot; sur la page concernant la conjugaison au conditionnel présent, car je conseille parfois des blogs, sites, voire wikilivre ou wikipédia.
Je n'ai pu m'empêcher de voir d'une part deux grosses erreurs qui font que la conjugaison sur cette page est fausse (cf. les deux premières personnes du pluriel).  Quant aux exemples, ils sont également erronés, l'auteur n'ayant apparemment pas compris les modifications de la nouvelle grammaire qui permettent d'envisager, selon le sens de la phrase, le conditionnel soit comme un temps de l'indicatif, soit comme un mode à part entière.

Dès lors, j'ai effectivement modifié la page de manière importante.  La mention expliquant la raison de la non publication de ma mise à jour fait mention d'une modification d'un bloc trop important ; ce qui est exact, mais selon moi, nécessaire. Si vous le souhaitez, je peux recommencer les modifications afin que la page soit correcte, ou une autre personne peut s'en charger.  

Évidemment, en qualité d'administrateur, vous êtes juge pour décider de la suite.  De mon côté, sans les modifications indispensables, je déconseillerai aux jeunes de consulter, en guise d'aide pour leur cours de français, les pages de wikilivre, car vous comprendrez aisément que ce ne serait pas une aide.

En vous souhaitant une très belle fin de journée, veuillez agréer mes sentiments les meilleurs,

Nathalie BALON
nat.balon@skynet.be
:Bonjour Nathalie,
:Les paramètres du filtre ont été corrigés.
:Désormais, les modifications devraient passer à condition d'utiliser des titres de sections avec la syntaxe standard (titre entre deux séries de égal de même quantité, comme pour cette page de discussion).
:--&amp;nbsp;◄&amp;nbsp;[[Utilisateur:DavidL|'''D'''avid&amp;nbsp;'''L''']]&amp;nbsp;•&amp;nbsp;[[Discussion Utilisateur:DavidL|discuter]]&amp;nbsp;► 7 mai 2025 à 00:22 (CEST)

== Vandalism [[user:Sophiedecaen140]] ==

'''Auteur :''' [[Utilisateur:Samuele2002|Samuele2002]] ([[Discussion utilisateur:Samuele2002|discussion]]) 

'''Date :''' 6 juin 2025 à 01:24 (CEST)

'''utilisateur:''' [[user:Sophiedecaen140]] &lt;!-- Ne gardez que la/les option(s) qui vous sont utiles. --&gt;

'''Requête :'''
Sorry for english. Please block and delete page created by [[User:Sophiedecaen140]], cross-wiki Vandalism. Thanks.
&lt;!-- Remplacez cette  ligne par votre requête. --&gt;

{{État de la requête|état=en attente}}

'''Discussions :'''</text>
      <sha1>httnhf0mdo166je7kckwmcbijyfq4xj</sha1>
    </revision>
    <revision>
      <id>744188</id>
      <parentid>744185</parentid>
      <timestamp>2025-06-06T05:34:20Z</timestamp>
      <contributor>
        <username>JackPotte</username>
        <id>5426</id>
      </contributor>
      <comment>/* Vandalism user:Sophiedecaen140 */</comment>
      <origin>744188</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="7443" sha1="pbzlxunzxz3t9cpds923whe84twz7kh" xml:space="preserve">{{Wikilivres:Groupes}}
{{Wikilivres:Requêtes aux administrateurs/En-tête}}

== Transfert WIKIPEDIA --&gt; WIKILIVRES ==

Bonjour
j'ai écris une page récemment dans WIKIPEDIA sur le mini-shogi.
On m'a demandé de faire un transfert dans WIKILIVRES; car cet article n'est pas de nature encyclopédique.
J'ai modifié l’Entêté de la page avec {{Pour Wikibooks}}.
Je dois ensuite demander un transfert de la page vers WIKILIVRES à un administrateur mais je n'ai pas trouvé comment faire.
Je voudrais donc connaitre la procédure à suivre.
Merci [[Utilisateur:Didier1963|Didier1963]] ([[Discussion utilisateur:Didier1963|discussion]]) 16 janvier 2025 à 13:02 (CET)
:Bonjour Didier1963,
:Il suffit juste de faire une demande ici.
:Le transfert est en cours.
:--&amp;nbsp;◄&amp;nbsp;[[Utilisateur:DavidL|'''D'''avid&amp;nbsp;'''L''']]&amp;nbsp;•&amp;nbsp;[[Discussion Utilisateur:DavidL|discuter]]&amp;nbsp;► 18 janvier 2025 à 11:42 (CET)
::La page a été importée ici : [[Utilisateur:Didier1963/Brouillon]]
::Pour en faire un livre, il faut diviser le contenu en plusieurs pages wiki (chapitres) liées à la page principale de présentation du livre.
::* Voir [[Wikilivres:Conventions sur les titres]] et [[Wikilivres/Organisation d'un wikilivre]]
::* Exemple de livres similaires : [[Jeu de Go]], [[Jeu de rôle sur table — Jouer, créer]]
::--&amp;nbsp;◄&amp;nbsp;[[Utilisateur:DavidL|'''D'''avid&amp;nbsp;'''L''']]&amp;nbsp;•&amp;nbsp;[[Discussion Utilisateur:DavidL|discuter]]&amp;nbsp;► 18 janvier 2025 à 11:52 (CET)
:::Bonjour, on m'a pingué sur Wikipédia en parallèle et j'avais importé cette page ici en parallèle : [[Mini-shōgi]]. Du coup j'ai supprimé le brouillon. [[Utilisateur:JackPotte|JackPotte]] ([[Discussion utilisateur:JackPotte|&lt;span style=&quot;color:#FF6600&quot;&gt;$&lt;/span&gt;♠]]) 19 janvier 2025 à 11:36 (CET)
::::Bonjour
::::je n'arrive pas a comprendre le fonctionnement de ma demande de transfert de ma page WKIPEDIA  dans Didier1963/Brouillon &quot;mini-shogi&quot;
::::En premier lieu, j'a été &quot;signalé&quot; (par vous apparent) à cause d'un brouillon &quot;gâteau aux excréments&quot; apparu dans mes sessions .Que signifie exactement cette notion de &quot;signalement&quot; ?
::::Cette 'fausse&quot; page est bien sur ridicule,.... Je ne suis n&quot;y absolument pour rien, c'est-ce un vandalisme délibéré (par qu)i ?; mais je 'ai pas su tout traiter cette brutale intrusion, sinon de reprendre la rédaction de mon brouillon....
::::Comment se fait-il qu'il soit possible de vandaliser un brouillon qui par nature n'est pas public ?
::::En second lieu, suite a un avis reçu de WKIPEDIA  j'ai demandé de transfert de mon article dans WIKILIVRE
::::il me semble avoir compris que le transfert avait été fait mais la page aussitôt supprimée (par vous apparent) ?
::::Si c'est bien ça , il est assez  inadmissible (et incompréhensible) de procéder ainsi sans explications et sans aide.
::::s'il y a un problème de rédaction ou de forme, il suffit de l’écrire et éventuellement d'indiquer comment faire, surtout pour les débutants comme moi
::::cordialement [[Utilisateur:Didier1963|Didier1963]] ([[Discussion utilisateur:Didier1963|discussion]]) 22 janvier 2025 à 23:05 (CET)
:::::je me répond à moi même...
:::::j'ai finalement trouvé la page transférée de WIKIPEDIA vers WIKILIVRE en passant par le moteur de recherche.
:::::je remercie les intervenants car j'en déduit que, finalement, tout s'est bien passé.
:::::cordialement [[Utilisateur:Didier1963|Didier1963]] ([[Discussion utilisateur:Didier1963|discussion]]) 24 janvier 2025 à 22:31 (CET)

{{État de la requête|état=traitée}}

== Import du modèle:mesure de WP ==

'''Auteur :''' [[Utilisateur:Cdang|Cdang]] ([[Discussion utilisateur:Cdang|discussion]])

'''Date :''' 22 janvier 2025 à 09:40 (CET)

'''Modèle :''' [[:modèle:chiffrage mesure]]

'''Requête :'''

Bonjour,

serait-il possible d'importer le ''[[w:modèle:mesure]]'' pour remplacer l'actuel ''[[:modèle:chiffrage mesure]]'', bien moins complet ?

Je préconise de garder le nom ''chiffrage mesure'', moins ambigu.

Le ''modèle:chiffrage mesure'' est actuellement utilisé dans les wikilivres ''[[Introduction à LilyPond]]'', ''[[Formation musicale]]'' et ''[[LaTeX/Écrire de la musique]]''.

{{État de la requête|état=traitée}}

'''Discussions :'''
:{{fait}} [[Utilisateur:JackPotte|JackPotte]] ([[Discussion utilisateur:JackPotte|&lt;span style=&quot;color:#FF6600&quot;&gt;$&lt;/span&gt;♠]]) 26 janvier 2025 à 22:33 (CET)

== Page Conjuguer au conditionnel présent ==

Bonjour,

Je me présente, je m'appelle Nathalie BALON.  Je suis logopède, psychopédagogue et formatrice en langage écrit (à savoir : orthographe, rédaction d'ouvrages, écriture thérapeutique et écrits professionnels).  
Par hasard, je suis &quot;tombée&quot; sur la page concernant la conjugaison au conditionnel présent, car je conseille parfois des blogs, sites, voire wikilivre ou wikipédia.
Je n'ai pu m'empêcher de voir d'une part deux grosses erreurs qui font que la conjugaison sur cette page est fausse (cf. les deux premières personnes du pluriel).  Quant aux exemples, ils sont également erronés, l'auteur n'ayant apparemment pas compris les modifications de la nouvelle grammaire qui permettent d'envisager, selon le sens de la phrase, le conditionnel soit comme un temps de l'indicatif, soit comme un mode à part entière.

Dès lors, j'ai effectivement modifié la page de manière importante.  La mention expliquant la raison de la non publication de ma mise à jour fait mention d'une modification d'un bloc trop important ; ce qui est exact, mais selon moi, nécessaire. Si vous le souhaitez, je peux recommencer les modifications afin que la page soit correcte, ou une autre personne peut s'en charger.  

Évidemment, en qualité d'administrateur, vous êtes juge pour décider de la suite.  De mon côté, sans les modifications indispensables, je déconseillerai aux jeunes de consulter, en guise d'aide pour leur cours de français, les pages de wikilivre, car vous comprendrez aisément que ce ne serait pas une aide.

En vous souhaitant une très belle fin de journée, veuillez agréer mes sentiments les meilleurs,

Nathalie BALON
nat.balon@skynet.be
:Bonjour Nathalie,
:Les paramètres du filtre ont été corrigés.
:Désormais, les modifications devraient passer à condition d'utiliser des titres de sections avec la syntaxe standard (titre entre deux séries de égal de même quantité, comme pour cette page de discussion).
:--&amp;nbsp;◄&amp;nbsp;[[Utilisateur:DavidL|'''D'''avid&amp;nbsp;'''L''']]&amp;nbsp;•&amp;nbsp;[[Discussion Utilisateur:DavidL|discuter]]&amp;nbsp;► 7 mai 2025 à 00:22 (CEST)

== Vandalism [[user:Sophiedecaen140]] ==

'''Auteur :''' [[Utilisateur:Samuele2002|Samuele2002]] ([[Discussion utilisateur:Samuele2002|discussion]]) 

'''Date :''' 6 juin 2025 à 01:24 (CEST)

'''utilisateur:''' [[user:Sophiedecaen140]] &lt;!-- Ne gardez que la/les option(s) qui vous sont utiles. --&gt;

'''Requête :'''
Sorry for english. Please block and delete page created by [[User:Sophiedecaen140]], cross-wiki Vandalism. Thanks.
&lt;!-- Remplacez cette  ligne par votre requête. --&gt;

{{État de la requête|état=traitée}}

'''Discussions :'''
:Bonjour, [//fr.wikibooks.org/w/index.php?title=Sp%C3%A9cial:Journal&amp;type=delete&amp;page=Sophie+des+mjc+de+caen la page a été supprimée en global sysop]. [[Utilisateur:JackPotte|JackPotte]] ([[Discussion utilisateur:JackPotte|&lt;span style=&quot;color:#FF6600&quot;&gt;$&lt;/span&gt;♠]]) 6 juin 2025 à 07:34 (CEST)</text>
      <sha1>pbzlxunzxz3t9cpds923whe84twz7kh</sha1>
    </revision>
  </page>
  <page>
    <title>Jeu de rôle sur table — Jouer, créer/Créer un jeu de rôle</title>
    <ns>0</ns>
    <id>82237</id>
    <revision>
      <id>744047</id>
      <parentid>742095</parentid>
      <timestamp>2025-06-03T15:30:26Z</timestamp>
      <contributor>
        <username>Cdang</username>
        <id>1202</id>
      </contributor>
      <comment>testez !</comment>
      <origin>744047</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="3725" sha1="jecfeuk4lzvjpudfostnh4ww1tkaep6" xml:space="preserve">&lt;noinclude&gt;{{NavTitre|book={{BASEPAGENAME}}|prev=Créer un univers|next=Abréviations}}&lt;/noinclude&gt;


Nous avons vu :
* [[../Créer une nouvelle règle|comment créer des règles]] ;
* [[../Créer un univers|comment créer un univers]] ;
il est donc temps d'aborder la question de la création d'un jeu de rôle complet.

== Processus global ==
Donc vous avez un groupe de joueurs et joueuses régulières. Vous avez joué des parties régulières, soit en développant une campagne, soit par des parties indépendantes mais avec une logique récurrente : type de parties, univers… Au fur et à mesure, vous avez développé un univers et créé des règles spécifiques pour avoir des moments de jeux intéressants. Vous avez donc… déjà créé votre jeu de rôle. Vous voulez alors peut-être le partager, le diffuser, voire le vendre.

Ou alors : vous avez une idée de partie type et vous voulez créer un jeu pour concrétiser ce que vous avez en tête. Là, tout est à créer…

== L'hygiène de l'écrivain ==
Pour tenir sur le long terme, vous pouvez prendre des bonnes habitudes d'écriture&lt;ref&gt;{{lien web |url=https://blog.lulu.com/6-writing-habits/ |titre=6 Writing Habits to Write More |auteur=paul |site=Lulu blog |date=2020-09-18 |consulté le2025-04-19 |lang=en}}.&lt;/ref&gt; :
# Écrivez chaque jour — chisissez un moment et respectez-le !
# Définissez des objectifs d'écriture — imposez-vous un nombre de mot à écrire chaque jour.
# Dédiez du temps à l'écriture — réservez du temps, que ce soit 10 minutes ou une heure.
# Un lieu, un lieu, un lieu — dédiez un lieu qui soit votre « espace d'écriture ».
# Faite de l'édition plus tard — les fautes d'orthographe n'ont pas d'importance pour un premier jet.
# Créez et surveillez des éléments mesurables — suivez votre progression et ajustez vos buts.

{{...}}

== Testez, testez, testez… ==
{{citation bloc |1=''À propos du ''Butin des Gobelins'' pour le jeu de rôle ''Coureurs d’orage.''

: C'est qui est intéressant (et nouveau en ce qui me concerne) c'est que je me retrouve dans une position « à la @Johan Scipion » (toutes proportions gardées) avec ce micro-scénar.
: Cinquième fois que tu fais jouer la même proposition (règles + scénario), tu commences à repérer des trucs, des axes d'amélioration qui ne sautent pas forcément aux yeux sur seulement deux itérations (quand je playtestais mes modules ''CdO'', je les faisais jouer deux fois).
: Bref tu augmentes encore sensiblement ton niveau d'affinage parce que tu commences a avoir en tête un catalogue de réactions possibles basé sur du concret, du vu-et-joué, pas de la supputation.
:
: C'est une expérience que je recommande aux MJ un peu exigeants et qui veulent bosser leur « métier ».
— Islayre d'Argolh » mar. juin 03, 2025 1:45 pm
: Complètement d'accord. Le replay :
:
:+ Est un super outil de ''game design''.
:+ Bonifie la maîtrise donc l'expérience ludique de toute la table.
:+ Est supra fun.
:
: Ce sont les raisons pour lesquelles je lui ai récemment consacré un numéro de ''Sombre'' : https://www.terresetranges.net/forums/viewtopic.php?pid=21690#p21690
— Johan Scipion » mar. juin 03, 2025 4:09 pm
|3={{lien web |url=https://www.casusno.fr/viewtopic.php?p=2273179#p2273179 |titre=Re: Retours de partie : Il était une fois [Sondage en page 1]/Re: Sombre, la peur comme au cinéma |site=Casus Non Officiel |date=3 juin 2025 |consulté le=2025-06-03}}
}}

== Références ==
{{références}}

----
''[[../Créer un univers/]]'' &amp;lt; [[Jeu de rôle sur table — Jouer, créer|↑]] &amp;gt; ''[[../Abréviations/]]''

{{DEFAULTSORT:Creer un jeu de role}}
[[Catégorie:Jeu de rôle sur table — Jouer, créer (livre)]]</text>
      <sha1>jecfeuk4lzvjpudfostnh4ww1tkaep6</sha1>
    </revision>
  </page>
  <page>
    <title>Extension : Observatoire des politiques sur les savoirs ouverts, 2021-2024/Les programmes wikipédien(ne) en residence</title>
    <ns>0</ns>
    <id>82274</id>
    <revision>
      <id>744013</id>
      <parentid>743917</parentid>
      <timestamp>2025-06-02T22:20:41Z</timestamp>
      <contributor>
        <username>LodestarChariot2</username>
        <id>120009</id>
      </contributor>
      <minor />
      <comment>/* Ouvrages citées */</comment>
      <origin>744013</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="19024" sha1="a91045inf263uransnvjrr2x9wk3q4e" xml:space="preserve">''Cette observation a été rédigée par Caroline Winter et Talya Jesperson, pour le Electronic Textual Cultures Laboratory et le partenariat Implementing New Knowledge Environments.''

En règle générale, un wikipédien(ne)s en résidence sont des éditeurs de [https://fr.wikipedia.org/wiki/Wikip%C3%A9dia:Accueil_principal Wikipédia] qui agissent en tant que des liaisons entre la communauté Wikipédia et une institution, par exemple une université, un organisme de recherche, ou un galerie, bibliothèque, archive ou musée. Ces postes sont parfois connus sous le nom de wikimédien(ne) en résidence - faisant référence à l'organisation mère de Wikipédia, la [https://wikimediafoundation.org/ Wikimedia Foundation] - ou wikipédien(ne) résidents honoraires.

Le premier wikipédien en résidence, Liam Wyatt, s'est porté volontaire avec le [https://www.britishmuseum.org/ British Museum] pour fournir des informations sur ses collections sur Wikipédia dans le but de rendre ses collections plus accessibles à la communauté élargie («&amp;#8239;Wikipedians&amp;#8239;» 2010; Cohen 2010). Depuis lors, [https://w.wiki/Cx6 plus de 200] d’entre eux sont en liaison avec un large éventail d'institutions à travers le monde, y compris des bibliothèques nationales, universitaires et locales; sociétés savantes; instituts et organisations de recherche; organisations intergouvernementales et à but non lucratif; organisations de médias; musées nationaux et locaux; archives nationales et spécialisées; et jardins botaniques («&amp;#8239;Wikimedians&amp;#8239;» 2020).

Les postes peuvent prendre de nombreuses formes, allant des postes de bénévole à temps partiel à court terme à un emploi permanent à temps plein («&amp;#8239;Wikimedians&amp;#8239;» 2020; «&amp;#8239;Wikipedians&amp;#8239;» 2020).

Les tâches d'un wikipédien(ne) en résidence comprennent souvent une combinaison des éléments suivants&amp;nbsp;:
* Formation, comme l’enseignement le personnel des établissements et les membres de la communauté comment contribuer à Wikipédia ou sur des questions pertinentes telles que les droits d'auteur et les licences ou la numérisation
* Diriger des événements de sensibilisation tels que des edit-a-thons, au cours desquels les participants éditent et contribuent ensemble à Wikipédia ou à d'autres projets de la Fondation Wikimedia
* Numérisation des collections ou des fonds, ajout des images à Wikimedia Commons et des métadonnées à Wikidata
* Planification stratégique pour la sensibilisation et le partage des connaissances
* Contribution d'informations à Wikipédia («&amp;#8239;Wikimedia&amp;#8239;» 2020; «&amp;#8239;Wikipédia&amp;#8239;» 2020)

==Programmes de Wikipédien(ne)s en résidence et la communauté INKE==
En 2014, les bibliothèques de l’University of Victoria (UVic), l'Electronic Textual Cultures Lab (ETCL) et la Fédération des sciences humaines –– tous partenaires d'INKE –– ont annoncé le lancement d'un programme [https://etcl.uvic.ca/hrw/ wikipédien(ne) résident honoraire] à l'UVic. [https://www.ideas-idees.ca/media/media-releases/honorary-resident-wikipedian-professor-christian-vandendorpe Christian Vandendorpe] a été nommé premier Wikipédien résident honoraire de 2014 à 2016, suivi par membre du Partenariat INKE [https://www.uvic.ca/library/home/home/news/archive/Wikipedia-A-Thon.php Constance Crompton] de 2017 à 2018, [https://etcl.uvic.ca/2019/04/09/2019-20-honorary-resident-wikipedian-dr-erin-glass/ Erin Glass] de 2019 à 2020 et [https://etcl.uvic.ca/2020/10/08/2020-2021-honorary-resident-wikipedian-silvia-gutierrez-de-la-torre/ Silvia Gutiérrez De la Torre] de 2020 à 2021.

Le projet Cultural Data / Data for Culture de Crompton, basé au Humanities + Data Lab de l’Université d’Ottawa, examine les projets Wikimedia en tant que plates-formes de connaissances ouvertes. Le projet appelle également la communauté universitaire à apporter ses connaissances aux projets Wikimedia, la source de données culturelles et humaines structurées plus grande au monde, et lisible par des humains et par des machines. Il note que Wikipédia et les autres projects de Wikimedia a besoin des spécialistes du sectueur universitaire également des éditeurs non spécialisés. La communauté universitaire peut aider a démocratiser ces connaissances et contribuer à ce que les utilisations basées sur les données de Wikimedia (The Humanities Data Lab s.d.).

Crompton plaide en faveur de la valeur de la recherche Wikidata pour les sciences humaines dans «&amp;#8239;[https://popjournal.ca/issue02/crompton Familiar Wikidata: The Case for Building a Data Source We Can Trust]&amp;#8239;», sur la base d'une recherche partagée lors du rassemblement INKE 2020: [https://mcri.inke.ca/index.html%3Fp=2937.html Open scholarship for the 2020s] (2020).

Un [https://www.lib.sfu.ca/help/publish/scholarly-publishing/radical-access-blog article] sur le blog de la bibliothèque de l'Université Simon Fraser (SFU), soutient de la même manière que la participation sur Wikipédia par les contributeurs appartenant à la communauté universitaire parce qu’ils ont accès à des informations savantes de haute qualité et l'expertise du domaine nécessaire pour rendre des sujets plus complexes accessibles à un large public (Robinson-Clogg 2020).

Le [https://www.lib.sfu.ca/help/publish/dh/dhil/digital-pedagogy-network SFU-UVIC Digital Pedagogy Network], basé dans le [https://www.lib.sfu.ca/help/publish/dh/dhil Digital Humanities Innovation Lab] à la bibliothèque de SFU et en partenariat [https://etcl.uvic.ca/ avec l’Electronic Textual Cultures Lab (ETCL)] et [https://www.uvic.ca/library/ les bibliothèques d’UVi]c, entre autres, a inclus une [https://www.lib.sfu.ca/help/publish/dh/dhil/digital-pedagogy-network Indigenous Wikipedia Edit-a-thon] dans ses événements en 2016; les détails de l'événement peuvent être trouvés [https://en.wikipedia.org/wiki/Wikipedia:Meetup/IndigenousFilmandMedia en ligne].

==Wikipédien(ne)s en résidence dans la presse==
Plusieurs programmes wikipédien(ne)s en résidence ont été couverts dans les médias. La nomination inaugurale de Vandendorpe à l’UVic, par exemple, a été couverte par [http://www.cbc.ca/news/canada/british-columbia/university-of-victoria-announces-new-honorary-resident-wikipedian-1.2894838 CBC News] et le Victoria [http://www.timescolonist.com/business/on-the-street-insurance-brokerage-sold-1.1725881 ''Times Colonist''], ainsi que par [https://etcl.uvic.ca/hrw/ d’autres médias locaux]. La nomination d'Alex Jung par l'Université de Toronto en tant que premier wikipédien en résidence en 2018 a été couverte par le [https://www.thestar.com/news/gta/2018/11/01/u-of-t-libraries-hires-first-wikipedian-in-residence.html?rf ''Toronto Star''], et la nomination par l'Université Concordia d'Amber Berson en 2019 a été couverte par [https://www.cbc.ca/news/canada/montreal/wikipedia-in-residence-concordia-montreal-1.5200247 CBC News], [https://montreal.ctvnews.ca/concordia-university-s-wikipedian-in-residence-teaching-people-how-to-access-and-assess-information-1.4537133?cache=%3FclipId%3D89680 CTV News], [https://montreal.citynews.ca/video/2019/07/10/canadas-newest-wikipedian-in-residence/ City News] et le [https://montrealgazette.com/opinion/columnists/brownstein-concordias-wikipedian-in-residence-has-a-lot-on-her-plate ''Montreal Gazette''].

Les wikipédien(ne)s ont également attiré l'attention de la presse académique. En plus de la première location d'un par une université - par [https://www.timeshighereducation.com/news/berkeleys-wikipedian-helps-unlock-scholarly-silos/2012696.article l'Université de Californie à Berkeley] en 2014 - la presse académique a également couvert le programme de manière plus générale, abordant la question de [https://www.timeshighereducation.com/news/wikipedia-should-be-better-integrated-into-teaching/2018486.article Wikipédia en classe universitaire] et [https://www.timeshighereducation.com/news/wikipedian-residence-improves-public-access-science le succès des programmes pour améliorer la qualité des articles Wikipédia], par exemple.

En 2015, [https://www.timeshighereducation.com/news/university-hopes-wikipedian-residence-will-tackle-gender-gap ''Times Higher Education''] (''THE'') a couvert la création par le West Virginia University d'un poste de wikipédien(ne) en résidence chargé de combler l'écart entre les sexes de Wikipédia&amp;nbsp;: des enquêtes en 2011 et 2018 suggèrent qu'environ 90% des rédacteurs bénévoles de Wikipédia s'identifient comme des hommes («&amp;#8239;Gender Bias on Wikipedia&amp;#8239;» 2020 ; Straumsheim 2015).

De nombreux ces rôles sont basés dans des bibliothèques universitaires et, comme le souligne un article de 2019 dans [https://www.affairesuniversitaires.ca/actualites/actualites-article/wikipedia-au-service-du-milieu-universitaire/?_ga=2.61844268.1060067117.1611275827-1855156954.1605314527 ''University Affairs''], les bibliothèques universitaires et d'autres bibliothèques s'engagent également avec Wikipédia par d'autres moyens (Aschaiek 2019). S'adressant à la communauté des bibliothèques, la publication de l'American Libraries Association ''Leveraging Wikipedia, Connecting Communities of Knowledge'' (2018) met l'accent sur les objectifs communs des communautés de bibliothèques et de Wikipédia et offre des conseils sur la manière d'accroître l'engagement dans l'édition de Wikipédia dans les communautés de bibliothèques - les bibliothèques publiques également comme recherche - ce qui comprend l'embauche des wikipédien(ne)s en résidence (Proffitt 2018).

Ces programmes intéressent également la communauté au sens large. Un article de 2014 dans ''The Atlantic'' sur le programme de [https://www.theatlantic.com/technology/archive/2014/03/harvards-looking-for-a-wikipedian-in-residence/284373/ la bibliothèque de Houghton] relie le programme au mandat de la bibliothèque, en particulier son objectif de rendre ses informations et ses ressources accessibles à la communauté (Garber).

Un article publié en 2015 dans ''USA Today'' sur le programme wikipédien(ne) en résidence de West Virginia University note qu'il a été créé spécifiquement pour lutter contre [https://en.wikipedia.org/wiki/Gender_bias_on_Wikipedia les préjugés sexistes de Wikipédia], ce que d'autres postes ont également abordé depuis, notamment au Canada, la bibliothèque de l'Université Concordia wikipédienne en résidence [https://library.concordia.ca/about/wikipedian-in-residence/ Amber Berson] et l'Université de l'Alberta wikipédienne en residence [https://www.ualberta.ca/giving/giving-news/2020/august/ualbertas-first-wikipedian-in-residence.html Erin O'Neil]. De même, un article dans [https://www.macleans.ca/education/why-universities-are-hiring-wikipedeans-in-residence/ ''Macleans''] en 2019 souligne la nécessité pour les étudiants et autres utilisateurs et contributeurs de Wikipédia de réfléchir de manière critique à la plate-forme, notamment en demandant qui fournit des informations et en modérant les contributions, et quels sont les préjugés de la communauté (Hutchins).

Dans une interview publiée en 2019 dans [https://theconversation.com/on-the-job-with-a-wikipedian-in-residence-118494 ''The Conversation''], la wikipédienne en résidence pour le [https://www.sciencehistory.org/ Philadelphia’s Science History Institute], Mary Mark Ockerbloom, souligne que les positions peuvent être controversées au sein de la communauté Wikipédia, en particulier lorsqu'il s'agit de postes rémunérés, par souci de conflits d'intérêts. Ockerbloom note que ces conflits sont une préoccupation importante pour tous les éditeurs de Wikipédia, mais qu'être payé pour éditer du contenu n'est pas nécessairement un conflit, en particulier parce que Wikipédia, les institutions culturelles et les wikipédien(ne)s qu'ils utilisent partagent des objectifs communs (Hocquet 2019).

==Les reactions de la communauté universitaire==
L'émergence des programmes wikipédien(ne)s en résidence est le signe d'un changement d'attitude envers Wikipédia au sein de la communauté universitaire. Dans les années qui ont suivi le lancement de Wikipédia, de nombreux membres de la communauté académique l'ont rejeté comme inexact et peu fiable.

Maintenant, sachant que c'est là que de nombreux étudiants, membres de la communauté et chercheurs recherchent des informations, de nombreux membres de la communauté académique, y compris [https://etcl.uvic.ca/event/making-a-better-web-free-public-talk-lunch-wikipedia-edit-a-thon-with-dr-constance-crompton-university-of-ottawa/ Constance Crompton], ancienne résidente honoraire de l'Université de Victoria, demandent à la communauté d'améliorer la qualité et la fiabilité de ses informations et l'utiliser comme une plateforme pour partager la richesse des connaissances que possède la communauté (Hutchins).

==Les programmes wikipédien(ne) en résidence et la science ouverte==
En tant que ressource ouverte, collaborative, à but non lucratif et dirigée par la communauté qui vise à rendre les informations disponibles et accessibles en ligne, la mission et les objectifs de Wikipédia s'alignent étroitement avec ceux de la mouvement science ouverte.

Les programmes wikipédien(ne)s en résidence comblent souvent les lacunes de la base de connaissances de Wikipédia, en abordant et en sensibilisant aux problèmes liés aux inégalités d’accès aux connaissances et au partage des connaissances des communautés marginalisées.

De plus, Wikipédia et d'autres projets Wikimedia sont des composants importants de l'infrastructure mondiale des connaissances ouverte. Par exemple, Wikidata est un hub important pour les données ouvertes liées. Andy Mabbett, le wikipédien en résidence avec [https://orcid.org/ ORCID], note que les identifiants ORCID peuvent être utilisés comme identifiants persistants dans Wikipédia pour les universitaires, qui peuvent ne pas avoir d'identifiants [http://viaf.org/ VIAF (Virtual International Authority File]) ou d'autres identifiants persistants (voir «&amp;#8239;[[Observations fondamentales : Observatoire des politiques sur les savoirs ouverts, 2017-2020/ORCID : Connecter la recherche et les chercheurs|ORCID: Connecter la recherche et les chercheurs]]&amp;#8239;», «&amp;#8239;[[Observations fondamentales : Observatoire des politiques sur les savoirs ouverts, 2017-2020/Mise à jour ORCID : Intégration des identifiants ORCID dans les workflows de financement de la recherche|Mise à jour ORCID : Intégration des identifiants ORCID dans les workflows de financement de la recherche]]&amp;#8239;», «&amp;#8239;[[Observations fondamentales : Observatoire des politiques sur les savoirs ouverts, 2017-2020/Le Persistent Identifier (PID) Consortium de Royaume-Uni|Le «&amp;#8239;Persistent Identifier (PID) Consortium&amp;#8239;» de Royaume-Uni]]&amp;#8239;», et «&amp;#8239;[[Observations fondamentales : Observatoire des politiques sur les savoirs ouverts, 2017-2020/Wikidata dans les bibliothèques de recherche|Wikidata dans les bibliothèques de recherche]]&amp;#8239;»). De cette manière, Wikidata et Wikipédia peuvent être intégrés dans l'infrastructure de recherche numérique plus large.

==Ouvrages citées==
*Aschaiek, Sharon. 2019. «&amp;#8239;Wikipédia au service du milieu universitaire&amp;#8239;». ''Affaires Universitaires''. 26 février 2019. https://www.affairesuniversitaires.ca/actualites/actualites-article/wikipedia-au-service-du-milieu-universitaire/.

*Cohen, Noam. 2010. «&amp;#8239;Venerable British Museum Enlists in the Wikipedia Revolution&amp;#8239;». ''New York Times''. 4 juin 2010. [https://www.nytimes.com/2010/06/05/arts/design/05wiki.html https://www.nytimes.com/2010/06/05/arts/design/05wiki.html].

*Crabtree, Trent. 2015. «&amp;#8239;West Virginia University to Hire ‘Wikipedian in Residence’&amp;#8239;». ''USA Today''. 24 juillet 2015. [https://www.usatoday.com/story/college/2015/07/24/west-virginia-university-to-hire-wikipedian-in-residence/37404995/ https://www.usatoday.com/story/college/2015/07/24/west-virginia-university-to-hire-wikipedian-in-residence/37404995/].

*Crompton, Constance. 2020. «&amp;#8239;Familiar Wikidata: The Case for Building a Data Source we can Trust&amp;#8239;». 31 octobre 2020. [https://popjournal.ca/issue02/crompton https://popjournal.ca/issue02/crompton].

*Garber, Megan. 2014. «&amp;#8239;Harvard’s Looking for a ‘Wikipedian in Residence’&amp;#8239;». ''The Atlantic''. 12 mars 2014. [https://www.theatlantic.com/technology/archive/2014/03/harvards-looking-for-a-wikipedian-in-residence/284373/ https://www.theatlantic.com/technology/archive/2014/03/harvards-looking-for-a-wikipedian-in-residence/284373/].

*«&amp;#8239;Gender Bias on Wikipedia&amp;#8239;». 2020. Wikipedia. 11 decembre 2020. [https://en.wikipedia.org/wiki/Gender_bias_on_Wikipedia https://en.wikipedia.org/wiki/Gender_bias_on_Wikipedia].

*Hocquet, Alexandre. 2019. «&amp;#8239;On the Job with a ‘Wikipedian in Residence’&amp;#8239;». ''The Conversation''. 10 juillet 2019. [https://theconversation.com/on-the-job-with-a-wikipedian-in-residence-118494 https://theconversation.com/on-the-job-with-a-wikipedian-in-residence-118494].

*The Humanities Data Lab. n.d. ''Cultural Data/Data for Culture''. http://humanitiesdata.ca/projects/cultural-data/.

*Hutchins, Aaron. 2019. «&amp;#8239;Why Universities are Hiring ‘Wikipedeans-in-Residence’&amp;#8239;». ''Macleans''. 3 octobre 2019. https://www.macleans.ca/education/why-universities-are-hiring-wikipedeans-in-residence/.

*Meadows, Alice. 2016. «&amp;#8239;Meet our Wikipedian-in-Residence, Andy Mabbett!&amp;#8239;» ORCiD. 15 janvier 2016. [https://info.orcid.org/meet-our-wikipedian-in-residence-andy-mabbett/ https://info.orcid.org/meet-our-wikipedian-in-residence-andy-mabbett/].

*Proffitt, Merrilee. 2018. ''Leveraging Wikipedia: Connecting Communities of Knowledge. ''ALA Editions.

*Robinson-Clogg, Graeme. 2020. «&amp;#8239;Getting Started with Wikipedia&amp;#8239;». Radical Access: Scholarly Publishing + Open Access. Simon Fraser University Library. 7 octobre 2020. [https://www.lib.sfu.ca/help/publish/scholarly-publishing/radical-access/wikipedia-editing https://www.lib.sfu.ca/help/publish/scholarly-publishing/radical-access/wikipedia-editing].

*Straumsheim, Carl. 2015. «&amp;#8239;University Hopes ‘Wikipedian in Residence’ will Tackle Gender Gap&amp;#8239;». ''Times Higher Education''. 20 juillet 2015. https://www.timeshighereducation.com/news/university-hopes-wikipedian-residence-will-tackle-gender-gap.

*«&amp;#8239;Wikimedian in Residence&amp;#8239;». 2020. Wikimedia. 10 decembre 2020. https://meta.wikimedia.org/wiki/Wikimedian_in_residence.

*«&amp;#8239;Wikipedian in Residence&amp;#8239;». 2020. Wikipedia. 15 decembre 2020. https://en.wikipedia.org/wiki/Wikipedian_in_residence.

[[Catégorie:Extension : Observatoire des politiques sur les savoirs ouverts, 2021-2024 (livre)]]</text>
      <sha1>a91045inf263uransnvjrr2x9wk3q4e</sha1>
    </revision>
  </page>
  <page>
    <title>Extension : Observatoire des politiques sur les savoirs ouverts, 2021-2024/Les Fonds de recherche du Québec rejoignent la cOAlition S</title>
    <ns>0</ns>
    <id>82354</id>
    <revision>
      <id>744014</id>
      <parentid>742397</parentid>
      <timestamp>2025-06-02T22:23:36Z</timestamp>
      <contributor>
        <username>LodestarChariot2</username>
        <id>120009</id>
      </contributor>
      <minor />
      <comment>/* Ouvrages citées */</comment>
      <origin>744014</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="9737" sha1="8wq2sno25eajbhqfj4wlmvvic8k3zn5" xml:space="preserve">''Cette observation a été écrit par Caroline Winter (avec remerciements à Tanja Niemann et Simon Van Bellen pour ses commentaires et contributions), pour le Electronic Textual Cultures Laboratory et le partenariat Implementing New Knowledge Environments.''

En juin 2021, [https://frq.gouv.qc.ca/ les Fonds de recherche du Québec (FRQ)] ont annoncé qu’ils se joignent a la [https://www.coalition-s.org/about/ cOAlition S] et mettaient en oeuvre les principes du [https://www.coalition-s.org/why-plan-s/ Plan S], y compris libre accès complets et immédiat à tous la recherche qu’ils financent.

Les FRQ sont le premier organisme de financement canadien et le premier organisme de financement public en Amérique du Nord à se joindre à cOAlition S, qui a été fondée en 2018 en tant que groupe de 11 organismes de financement européens engagés à faire progresser libre accès, soutenu par le Conseil européen de la recherche et la Commission européenne (voir «&amp;#8239;[[Observations fondamentales : Observatoire des politiques sur les savoirs ouverts, 2017-2020/Plan S et cOAlition S|Plan S et cOAlition S]]&amp;#8239;»). Il s'est depuis élargi pour inclure des membres d'Afrique, du Moyen-Orient et des États-Unis (voir «&amp;#8239;[[Observations fondamentales : Observatoire des politiques sur les savoirs ouverts, 2017-2020/Mise à jour ORCID : Intégration des identifiants ORCID dans les workflows de financement de la recherche|Mise à jour du Plan S : l'élargissement de l'adhésion de la cOAlition S]]&amp;#8239;»).

Les FRQ comprendre les trois organismes subventionnaires de la recherche au Québec : [https://frq.gouv.qc.ca/nature-et-technologies/ Nature et technologies (FRQNT)], [https://frq.gouv.qc.ca/sante/ Santé (FRQS)] et [https://frq.gouv.qc.ca/societe-et-culture/ Société et culture (FRQSC)]. Représentant près du quart de la communauté de recherche au Canada, les FRQ ont administré 253 millions de dollars en financement de recherche en 2019-2020 à des chercheurs basés au Québec (Fondation européenne de la science, 2021). Les FRQ offrent également un Programme de soutien aux revues scientifiques, qui soutient la publication de recherches savantes en français, avec une priorité à la publication numérique et en libre accès (FRQ 2021). Leur [https://frq.gouv.qc.ca/app/uploads/2021/04/politique-libre-acces_avril19.pdf politique de libre accès existante], en place depuis 2019, exige que les publications soient en libre accès dans les 12 mois suivant la publication ; afin d'aligner cette politique sur le Plan S, à compter de mars 2023, cette période d'embargo sera supprimée (Gouvernement du Québec, 2021).

==Réponse de la communauté INKE==
Plan S et cOAlition S intéressent la communauté INKE depuis leur lancement, en reconnaissance de la nature mondiale de la science ouverte. Dans son rapport de 2020 ''Advancing Open: points de vue des spécialistes de la communication savante'', le groupe de travail sur les dépôts ouverts de l'Association des bibliothèques de recherche du Canada (ABRC), un partenaire d'INKE, exprime ses inquiétudes quant à la volonté du Canada d'adopter un «&amp;#8239;modèle transformateur de science ouverte&amp;#8239;» tel que le Plan S (MacCallum et al. 8). Le délai prolongé des FRQ pour lever leur période d'embargo – près de deux ans plutôt que la période habituelle – semble toutefois répondre à cette préoccupation. Comme le note le communiqué des FRQ, «&amp;#8239;Conscients des impacts que ce changement pourrait engendrer dans la communauté scientifique et étudiante, les FRQ déploieront graduellement les dix principes du Plan S et planifieront des mesures pour les accompagner&amp;#8239;» (Fondation européenne de la science 2021 ; Gouvernement du Québec 2021).

[https://www.erudit.org/fr/ Érudit], un partenaire d'INKE, collabore avec le FRQSC depuis 2006. Conformément à la politique du FRQ en libre accès, toutes les revues financées par le FRQSC sont en libre accès via Érudit (Érudit 2021).

==Les FRQ, la cOAlition S et la science ouverte==
En tant que premier organisme de financement canadien à se joindre à la cOAlition S, les FRQ ouvrent la voie à d'autres bailleurs de fonds publics canadiens et nord-américains pour se joindre au Plan S, qui est devenu une initiative mondiale.

Bien que la recherche financée par les FRQ ne soit pas nécessairement publiée en français, son adhésion au Plan S s'inscrit dans le cadre d'autres initiatives menées par le scientifique en chef du Québec, dont le lancement d'un [https://www.scientifique-en-chef.gouv.qc.ca/dossiers/conseil-scientifique-aux-gouvernements/reseau-francophone-en-conseil-scientifique/ réseau francophone] sur les avis scientifiques pour les politiques publiques, annoncé en septembre 2021. Le rapport accompagnant le lancement de ce réseau note que la recherche en langue française doit être accessible en libre accès à tous les chercheurs francophones (Scientifique en chef 2021, 48).[https://frq.gouv.qc.ca/app/uploads/2021/04/politique-libre-acces_avril19.pdf  La politique libre accès des FRQ] soutient également la recherche en français comme l'un de ses principes fondamentaux (FRQ 2019).

La nouvelle des FRQ rejoignant la cOAlition a été [https://quebec.consulfrance.org/Engagement-du-Quebec-en-faveur-de-la-science-ouverte partagée sur le site Web du Consulat général de France à Québec], soulignant le fait que la politique française de libre accès est un autre contexte important pour la décision des FRQ. Lui-même adopté dans le contexte de cadres européens plus larges, dont Horizon Europe, [https://www.ouvrirlascience.fr/deuxieme-plan-national-pour-la-science-ouverte/ ''le Deuxième Plan national pour la science ouverte : généraliser la science ouverte en France 2021-2024''] étend le premier plan de 2018 pour inclure le code ouvert, l'infrastructure pour soutenir le partage de données, et un accent mis sur la généralisation plus large du libre accès, notamment par la traduction de publications françaises pour améliorer leur accessibilité. Comme indiqué dans un article du [https://www.timeshighereducation.com/news/france-back-not-profit-diamond-journals ''Times Higher Ed''], cet Deuxième Plan est l'une des nouvelles politiques nationales visant à mettre l'accent sur le soutien à libre accès diamant, dans laquelle les revues ne facturent pas de frais de traitement d'article ni de frais d'abonnement (Matthews 2021). [https://anr.fr/fr/ L'Agence nationale de la recherche (ANR)], l'organisme national de financement de la recherche en France, est membre de la cOAlition S depuis sa création, et de nombreux chercheurs français publient probablement dans les revues francophones du Québec.

==Ouvrages citées==
*Érudit. 2021. ''Annual Report 2020–2021: Érudit Consortium''. [https://www.erudit.org/public/documents/AnnualReport_20-21.pdf https://www.erudit.org/public/documents/AnnualReport_20-21.pdf].

*Fondation européenne de la science. 2021. «&amp;#8239;cOAlition S Expands its Global Footprint as the Québec Research Funds adopt Plan S&amp;#8239;». ''Plan S: Making Full &amp; Immediate Open Access a Reality''. [https://www.coalition-s.org/coalition-s-expands-its-global-footprint-as-the-quebec-research-funds-adopt-plan-s/ https://www.coalition-s.org/coalition-s-expands-its-global-footprint-as-the-quebec-research-funds-adopt-plan-s/].

*FRQ (Fonds de recherche du Québec). 2019. ''Politique de diffusion en libre accès des Fonds de recherche du Québec''. Gouvernement du Québec, 15 avril 2019. [https://frq.gouv.qc.ca/app/uploads/2021/05/politique-libre-acces_en_avril19.pdf https://frq.gouv.qc.ca/app/uploads/2021/04/politique-libre-acces_avril19.pdf].

*FRQ (Fonds de recherche du Québec). 2021. ''Scientific Journal Support Program''. Gouvernement du Québec, mai 2021. [https://frq.gouv.qc.ca/app/uploads/2021/07/scientific-journal-support-program-frqsc.pdf https://frq.gouv.qc.ca/app/uploads/2021/07/scientific-journal-support-program-frqsc.pdf].

*Gouvernement du Québec. 2021. «&amp;#8239;Les Fonds de recherche du Québec appuient la science ouverte en joignant la cOAlition S&amp;#8239;». ''Québec'', 21 juin 2021. [https://www.scientifique-en-chef.gouv.qc.ca/nouvelles/les-fonds-de-recherche-du-quebec-appuient-la-science-ouverte-en-joignant-la-coalition-s/ https://www.scientifique-en-chef.gouv.qc.ca/nouvelles/les-fonds-de-recherche-du-quebec-appuient-la-science-ouverte-en-joignant-la-coalition-s/].

*MacCallum, Lindsey, Ann Barrett, Leah Vanderjagt et Amy Buckland. 2020. ''Advancing Open: points de vue de spécialistes de la communication savante''. Association des bibliothèques de recherche du Canada (ABRC), avril 2020, [https://www.carl-abrc.ca/wp-content/uploads/2020/04/GTDO_rapport3_Advancing_open_FR.pdf https://www.carl-abrc.ca/wp-content/uploads/2020/04/GTDO_rapport3_Advancing_open_FR.pdf].

*Matthews, David. 2021. «&amp;#8239;France to Back Not-for Profit Diamond Journals&amp;#8239;». ''Times Higher Ed'', 13 juillet 2021. [https://www.timeshighereducation.com/news/france-back-not-profit-diamond-journals https://www.timeshighereducation.com/news/france-back-not-profit-diamond-journals].

*Scientifique en chef du Québec. 2021. ''Vers un résearu francophone pour l’utilisation des science en soutien aux politiques publiques: Document pour consultation''. Gouvernement du Québec, septembre 2021. [https://www.scientifique-en-chef.gouv.qc.ca/wp-content/uploads/ConseilSci_Francophonie_version_Sept2021.pdf https://www.scientifique-en-chef.gouv.qc.ca/wp-content/uploads/ConseilSci_Francophonie_version_Sept2021.pdf].

[[Catégorie:Extension : Observatoire des politiques sur les savoirs ouverts, 2021-2024 (livre)]]</text>
      <sha1>8wq2sno25eajbhqfj4wlmvvic8k3zn5</sha1>
    </revision>
  </page>
  <page>
    <title>Extension : Observatoire des politiques sur les savoirs ouverts, 2021-2024/Renforcement des capacités de GDR au Canada et la série de rapports Insights de Portage</title>
    <ns>0</ns>
    <id>82355</id>
    <revision>
      <id>744015</id>
      <parentid>742403</parentid>
      <timestamp>2025-06-02T22:24:06Z</timestamp>
      <contributor>
        <username>LodestarChariot2</username>
        <id>120009</id>
      </contributor>
      <minor />
      <comment>/* Ouvrages citées */</comment>
      <origin>744015</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="22412" sha1="kohycmi76ieo0y7nxtwaamm415adf3g" xml:space="preserve">''Cette observation a été écrit par Caroline Winter (avec remerciements à Shahira Khair pour ses commentaires et contributions), pour le Electronic Textual Cultures Laboratory et le partenariat Implementing New Knowledge Environments.''

En mai 2018, les trois organismes du Canada ont publié une ébauche d’un Politique de gestion des données de recherche (GDR) aux fins de consultation, l'une des nombreuses politiques liées à la gestion des données, y compris la [https://www.science.gc.ca/eic/site/063.nsf/fra/h_F6765465.html Politique des trois organismes sur le libre accès aux publications] (2015) et la [https://www.science.gc.ca/eic/site/063.nsf/fra/h_83F7624E.html Déclaration de principes des trois organismes sur la gestion des données numériques] (2016) (voir «&amp;#8239;[[Observations fondamentales : Observatoire des politiques sur les savoirs ouverts, 2017-2020/Le politique des trois organismes sur la gestion des données de recherche|Le Politique des trois organismes sur la gestion des données de recherche]]&amp;#8239;»). La version finale de la [https://www.science.gc.ca/eic/site/063.nsf/fra/h_97610.html Politique des trois organismes sur la GDR] a été publiée en mars 2021 (voir «&amp;#8239;[[Extension : Observatoire des politiques sur les savoirs ouverts, 2021-2024/Mise à jour : Gestion des données de recherche au Canada|Mise à jour : Gestion des données de recherche au Canada]]&amp;#8239;»).

En vertu de la politique, les établissements de recherche qui administrent les fonds des trois organismes sont tenus d'élaborer des stratégies de GDR d'ici le 1er mars 2023 (Gouvernement du Canada 2021). Alors que les établissements commençaient à élaborer leurs politiques de GDR en réponse à l'ébauche de politique des trois organismes, le Groupe d'experts sur la recherche et l’intelligence (GERI) du réseau Portage a mené deux sondages pour déterminer dans quelle mesure les établissements étaient prêts à mettre en œuvre la Politique de GDR et quels services Portage et d'autres intervenants pourraient offrir en soutien.

==Sondage sur la stratégie institutionnelle de GDR==
Le [https://doi.org/10.5281/zenodo.3962885 sondage sur la stratégie institutionnelle de GDR de Portage] (Portage 2019) a été mené en juin 2019 et a reçu 88 réponses de 63 établissements. Il a révélé que la plupart des établissements répondants avaient entamé le processus d'élaboration d'une stratégie institutionnelle de GDR, même si bon nombre d'entre eux en étaient au stade de la planification. Parmi ceux-ci, beaucoup ont noté que le développement a l’arrêt, en attendant la publication de la politique finale de GDR des trois organismes. Sur la base des réponses à l'enquête, le GERI a suggéré des mesures à prendre pour aider les établissements à développer leurs stratégies, notamment en partageant les stratégies finales pour servir d'exemples, en facilitant les communautés de pratique pour aider les groupes de travail institutionnels à apprendre les uns des autres et en fournissant des conseils explicites sur la manière dont stratégies peuvent répondre aux exigences de la politique des trois organismes.

==L'enquête sur la capacité des services GDR institutionnels et les rapports d'analyse==
À l'automne 2019, le GERI a mené le ''Sondage sur la capacité des services institutionnels de gestion des données'' afin d'établir une référence pour la capacité des établissements de recherche au Canada à soutenir les activités de GDR décrites dans l'ébauche de la politique de GDR des trois organismes (Cooper et al. 2020). Il a reçu 85 réponses de 77 établissements, dont des universités, des collèges, des CEGEPs, des centres et établissements de recherche et des organismes gouvernementaux (2). Un résumé analytique a été publié en janvier 2020 (Cooper et al. 2020).

[https://doi.org/10.5281/zenodo.3906470 Le premier rapport Insights], publié en juin 2020, s'est concentré sur la capacité au sein des organisations, avec des conclusions clés liées à la politique, aux structures organisationnelles, aux budgets et aux collaborations internes et externes (Abel et al., 3). S'appuyant sur les résultats discutés dans le rapport initial, il a noté que les bibliothèques et les unités administratives de la recherche dirigeaient le plus souvent l'élaboration de stratégies et de politiques de GDR dans les universités et les collèges (4). En ce qui concerne les structures de travail, environ la moitié des établissements (principalement des universités) avaient des groupes de travail institutionnels formels sur la GDR, la plupart dirigés par des bibliothèques ou des groupes d'administration de la recherche (8).

En termes de structure de personnel, environ le tiers (33,8 %) des établissements, principalement des universités, avaient créé de nouveaux postes pour assumer des responsabilités de GDR et un peu moins du tiers (28,6 %) avaient réaffecté du personnel existant pour les assumer, mais un peu plus du tiers (37,7 %) n'avaient pas de personnel responsable de la GDR (9). Bien que le financement soit crucial pour le développement des capacités, une seule institution a fait état d'un budget institutionnel dédié à la GDR ; la forme de financement la plus courante consistait à utiliser les budgets opérationnels (27,3 %) et de nombreux établissements (37,7 %) ont déclaré ne pas avoir de budget dédié à la GDR (15–16). La plupart des établissements ont participé à des initiatives collaboratives nationales (65,6 %) ou régionales (72,1 %) de GDR (13).

[https://doi.org/10.5281/zenodo.4559991 Le deuxième rapport Insights], publié en février 2021, se concentre sur le personnel hautement qualifié (PHQ), l'infrastructure et les services (Cooper et al. 2021a). Il a examiné l'expertise en GDR dans 12 catégories de compétences (par exemple, la connaissance des politiques nationales, le développement de logiciels, la gestion des données, la création de métadonnées), organisées en étapes du cycle de vie des données, comme décrit dans [https://doi.org/10.5281/zenodo.4015589 ''L'introduction à gestion des données de recherche de Portage'']. Il a constaté que les universités avaient tendance à faire état d'une plus grande capacité que les collèges dans plusieurs catégories et que les établissements exprimaient le besoin d'un soutien plus qualifié dans toutes les catégories, avec un besoin particulier «&amp;#8239;en gestion des données sensibles, en curation de données, en développement de logiciels de recherche, en préservation des données, en gestion des données par les chercheurs et au regard des aspects techniques des infrastructures électroniques&amp;#8239;» (4). En termes d'infrastructure GDR, par rapport aux collèges, les universités ont signalé une plus grande connaissance et un soutien institutionnel pour le transfert de données (50 % ; 19 %), les données sensibles (40,4 % ; 33,3 %), le calcul haute performance (50 % ; 14,3 %) , logiciels commerciaux qualitatifs (55,8 % ; 28,6 %), logiciels quantitatifs (75 % ; 38,1 %) et outils de collaboration (26,9 % ; 9,5 %) (12–14). Dans de nombreux cas, cependant, les répondants ne savaient pas quels soutiens étaient disponibles.

En ce qui concerne les services de GDR, alors que plus de la moitié des répondants offrent une gamme complète de soutiens de GDR, l'étendue et le niveau de développement de ces services varient considérablement (16). Ces services sont généralement proposés au niveau institutionnel et dirigés par des bibliothèques, des départements informatiques ou des efforts conjoints (17–19). Les institutions avec des postes dédiés à la GDR et un soutien budgétaire dédié ont tendance à offrir davantage de soutiens institutionnels, tandis que celles dans lesquelles le soutien à la GDR est affecté à des postes existants ont tendance à faire appel à des ressources externes (20–21).

[https://doi.org/10.5281/zenodo.4892718 Le troisième rapport Insights], publié en février 2021 (Cooper et al. 2021b), examine quelles ressources GDR sont disponibles, comment elles sont allouées et comment elles pourraient mieux servir la communauté. Lorsqu'on leur a demandé de classer les ressources à privilégier pour soutenir la GDR, les répondants ont cité le plus souvent les ressources humaines (37,7 %), suivies des conseils sue les questions de politiques (22,1 %) et des ressources financières (16,9 %) et techniques (14,3 %) (5). En termes d'investissement, près de la moitié (46,8 %) des établissements n'avaient pas l'intention ou ne connaissaient pas de l'intention d'investir davantage dans les supports technologiques de GDR, et seulement 7,8 % prévoyaient de créer de nouveaux postes de GDR (6). Environ le quart des universités ont déclaré offrir du perfectionnement professionnel en GDR aux chercheurs (19,6 %) et au personnel (23,5 %), comparativement à seulement 5,3 % des collèges, qui ont déclaré offrir une formation aux chercheurs seulement (9). Interrogés sur les obstacles au soutien de la GDR, les répondants ont le plus souvent cité le manque de sensibilisation ou la résistance au partage des données, le manque de temps et le manque de financement et d’incitatifs (11). Lorsqu'on leur a demandé quels facteurs accéléreraient le plus efficacement le développement de la GDR, les répondants ont mentionné le plus souvent le financement, suivi des politiques, de la formation et de la collaboration (15).

Le troisième rapport Insights se termine par une liste de recommandations, certaines nouvelles et d'autres déjà mises en œuvre. De façon générale, cela comprend le développement de ressources pour soutenir la capacité de GDR, comme celles que Portage a créées pour soutenir le développement de [https://portagenetwork.ca/fr/outils-et-ressources/strategies-institutionnelles/ stratégies institutionnelles de GDR]. Ils comprennent également une collaboration accrue entre les organisations existantes, en particulier par l'intermédiaire de [https://alliancecan.ca/fr/ l'Alliance de recherche numérique du Canada] (l'Alliance, anciennement NOIRN), et la mise en relation des chercheurs avec les ressources existantes. Le rapport note également que l'Alliance continuera de fournir un soutien à la GDR au niveau national, permettant aux établissements de concentrer leur financement et d'autres ressources sur les besoins locaux (Cooper et al. 2021b, 21).

Pris ensemble, ces trois rapports montrent que les services et soutiens de GDR –– y compris la stratégie institutionnelle et, dans une moindre mesure, la politique ––sont en développement dans de nombreuses institutions canadiennes, souvent dirigées par des bibliothèques. Les établissements s'engagent dans des réseaux et des collaborations régionaux et nationaux, mais les soutiens à la GDR sont disponibles de manière inégale, les universités déclarant plus de ressources que les collèges. Certaines des priorités pour le renforcement des capacités de GDR comprennent le PHQ et les ressources humaines, le financement, l'infrastructure technologique et la connaissance des politiques (Cooper et al 2021b, 19).

==Renforcement des capacités de GDR et le Partenariat INKE==
La GDR est une question d'intérêt pour de nombreux membres du Partenariat INKE, dont beaucoup sont depuis longtemps impliqués dans le développement des capacités de GDR. Avant de se joindre à l'Alliance, Portage était à l'origine une initiative de [https://www.carl-abrc.ca/fr/ l'Association des bibliothèques de recherche du Canada (ABRC)] et, sous le nom de l'ABRC Portage, elle a développé [https://assistant.portagenetwork.ca/ l'Assistant PGD (plans de gestion des données)], un outil bilingue en ligne pour la planification de la gestion des données hébergé par l'Université d’Alberta. Il a également travaillé avec [https://www.canarie.ca/fr/ CANARIE] pour soutenir une extension nationale du service [https://dataverse.scholarsportal.info/fr/ Scholars Portal Dataverse], un dépôt de données de recherche soutenu par [https://ocul.on.ca/ l’Ontario Council of University Libraries (OCUL)] et hébergé par [https://onesearch.library.utoronto.ca/ les bibliothèques de l'Université de Toronto]. L'ABRC Portage et [https://www.computecanada.ca/?lang=fr Calcul Canada] se sont également associés à l'Alliance pour développer le [https://www.frdr-dfdr.ca/repo/?locale=fr Dépôt fédéré de données de recherche (DFDR)], un dépôt pour les grands ensembles de données (&gt; 1 To) et une plateforme de découverte qui fédère les données entre les dépôts canadiens.

Portage et un autre partenaire INKE, [https://www.crkn-rcdr.ca/fr le Réseau canadien de documentation pour la recherche (RCDR)], gèrent également [https://www.crkn-rcdr.ca/fr/consortium-datacite-canada le Consortium DataCite Canada], qui permet aux institutions canadiennes de créer et d'intégrer des DOI pour soutenir la GDR et améliorer la découvrabilité, l'accessibilité et la citabilité de la recherche.

En juin 2021, les bibliothèques de l'UVic ont organisé un événement virtuel intitulé [https://osf.io/6vepj/wiki/home/ Research Data Management for Digitally-Curious Humanists] qui a exploré le concept de données de recherche dans les sciences humaines et les stratégies de renforcement des capacités en GDR. [https://ospolicyobservatory.uvic.ca/draft-report-rdm/ Un projet de rapport basé sur les discussions lors de l'événement] a été partagé sur l'Open Scholarship Policy Observatory pour commentaires en novembre 2021.

==Renforcement des capacités de GDR et communauté universitaire élargie==
La série de rapports de la coopérative internationale de bibliothèques [https://www.oclc.org/fr/home.html OCLC], intitulée [https://www.oclc.org/research/publications/2017/oclcresearch-rdm-part-one-service-space-tour.html ''The Realities of Research Data Management''], présente des études de cas d'universités du Royaume-Uni, des États-Unis, d'Australie et des Pays-Bas. Les auteurs notent que l'augmentation exponentielle de l'échelle des données de recherche est un facteur important qui motive le besoin d'une plus grande capacité de GDR. L'avènement du Big Data et les techniques de recherche computationnelle dans les sciences humaines et sociales a changé le visage des données dans la recherche d’aujourd’hui, et les processus d'assemblage, de gestion et la conservation des données également (Bryant et al. 2017). Les données de recherche, en plus des publications qui en découlent, sont devenues une partie importante du dossier scientifique et un atout précieux, en particulier lorsqu'elles sont optimisées pour être réutilisées.

Au Canada, la politique de GDR des trois organismes à laquelle répondent le sondage et les rapports Insights de Portage fait partie des développements continus dans les écosystèmes nationaux de politiques et d'infrastructures qui visent à renforcer la capacité de GDR. Un article paru dans [https://www.affairesuniversitaires.ca/actualites/actualites-article/des-organismes-subventionnaires-priorisent-la-gestion-des-donnees-de-recherche/?_ga=2.122700619.1789151288.1643143466-1326693258.1641858361 ''Affaires universitaires''] note que bien que la GDR soit de plus en plus importante dans toutes les disciplines à mesure que la recherche devient plus intensive en données, ce n'est pas toujours une priorité pour les chercheurs, de sorte que le changement culturel est un facteur important pour faire progresser la capacité de GDR. Comme le note Jeff Moon, directeur de Portage, «&amp;#8239;Nous devons changer cette culture afin que des données, métadonnées et codes bien documentés soient jugés aussi précieux qu'un bon article publié dans une revue scientifique&amp;#8239;» (Voinigescu 2021). L'article pointe vers [https://portagenetwork.ca/fr/outils-et-ressources/ les ressources offertes par Portage] comme supports utiles pour les individus et les institutions.

Les efforts du Canada pour renforcer la capacité de GDR font partie de sa stratégie globale d'infrastructure de recherche numérique (IRN). L'Alliance a été créée dans le cadre de cette stratégie : une organisation nationale à but non lucratif pour soutenir le calcul informatique de recherche avancée et les logiciels de recherche en plus de la GDR et les intégrer dans un système national d'IRN (voir «&amp;#8239;[[Observations fondamentales : Observatoire des politiques sur les savoirs ouverts, 2017-2020/NOIRN et la stratégie canadienne d’infrastructure de recherche numérique|NOIRN et la stratégie canadienne d'infrastructure de recherche numérique]]&amp;#8239;»).

L'Alliance a publié [https://alliancecan.ca/assets/uploads/documents/NDRIO_GDR_E%CC%81xpose%CC%81deprincipe-1.pdf un rapport connexe] en septembre 2021, sondant l'environnement de la GDR au Canada (Khair et al. 2020; voir «&amp;#8239;[[Extension : Observatoire des politiques sur les savoirs ouverts, 2021-2024/État actuel de la gestion des données de recherche au Canada : un rapport par l’Alliance de recherche numérique du Canada|État actuel de la gestion des données de recherche au Canada : un rapport par l’Alliance de recherche numérique du Canada]]&amp;#8239;»). En décembre 2021, [https://alliancecan.ca/fr/dernier/new-research-data-management-resources-institutional-rdm-strategies-and-data-management-plans l'Alliance a annoncé de nouvelles ressources GDR] pour soutenir les établissements :
* [https://zenodo.org/record/5745923#.YfQtt_XMLm8 Modèle pour l’élaboration de stratégie institutionnelle de GDR]
* [https://zenodo.org/record/5745894#.YfQt0fXMLm8 Modèle d'évaluation de la maturité de la GDR au Canada (MAMIC)]
* [https://www.youtube.com/watch?v=epsYxaNlS40 Vidéo d'introduction] aux plans de gestion des données (PGD) et l’Assistant PGD

==Renforcement des capacités GDR et la science ouverte==
Bien que la politique de GDR des trois organismes indique explicitement qu'il «&amp;#8239;n’est pas une politique sur les données ouvertes&amp;#8239;» (Gouvernement du Canada 2021), et que toutes les données de recherche ne peuvent ou ne doivent pas être ouvertes, les pratiques et la capacité de GDR sont fondamentales pour les données ouvertes et la science ouverte. Les chercheurs peuvent utiliser des infrastructures GDR telles que DFDR, par exemple, pour améliorer la découvrabilité et la réutilisation de leurs données de recherche, par exemple (Voinigescu 2021). S'appuyer sur les soutiens GDR existants identifiés dans les rapports Insights de Portage améliorera également la capacité de l'écosystème de recherche canadien en matière de la science ouverte.

==Ouvrages citées==
*Abel, Jennifer, Alexandra Cooper, Dylanne Dearborn, Carol Perry, Andrea Szwajcer, et Minglu Wang. 2020. ''Sondage sur la capacité des services institutionnels de gestion des données de recherche, rapport INSIGHTS #1 Soutien à la GDR au sein des organisations: budget, structure et stratégies''. Juin 2020, Réseau Portage, Association des bibliothèques de recherche du Canada. [https://doi.org/10.5281/zenodo.3906470 https://doi.org/10.5281/zenodo.3906470].

*Bryant, Rebecca, Brian Lavoie, et Constance Malpas. 2017. ''The Realities of Research Data Management, Part One: A Tour of the Research Data Management (RDM) Service Space''. OCLC. [https://doi.org/10.25333/C3PG8J https://doi.org/10.25333/C3PG8J].

*Cooper, Alexandra, Carol Perry, Andrea Szwajecer, Minglu Wang, et Shahira Khair. 2020. ''Sondage sur la capacité des services institutionnels de gestion des données de recherche: Sommaire. ''Réseau Portage, Association des bibliothèque de recherche du Canada. [https://dx.doi.org/10.14288/1.0388723 https://dx.doi.org/10.14288/1.0388723].

*Cooper, Alexandra, Lucia Costanzo, Dylanne Dearborn, Shahira Khair, Carol Perry, Andrea Szwajcer, et Minglu Wang. 2021a. ''Sondage sur la capacité des services institutionnels de gestion des données de recherche, rapport INSIGHTS no2 '': ''Capacité des établissements au chapiter du personnel hautement qualifié, de l’infrastructure et des services''. [https://doi.org/10.5281/zenodo.4559991 https://doi.org/10.5281/zenodo.4559991].

*Cooper, Alexandra, Lucia Costanzo, Dylanne Dearborn, Shahira Khair, Carol Perry, Andrea Szwajcer, et Minglu Wang. 2021b. ''Sondage sur la capacité des services institutionnels de gestion de données de recherche, rapports INSIGHTS no3 : Avenir de soutien à la GDR pour les établissements : ressources priorisées, investissements, défis et accélérateurs''. [https://doi.org/10.5281/zenodo.4892718 https://doi.org/10.5281/zenodo.4892718].

*Gouvernement du Canada. 2021. ''Politique des trois organismes sur la gestion des données de recherche''. [https://www.science.gc.ca/eic/site/063.nsf/fra/h_97610.html https://www.science.gc.ca/eic/site/063.nsf/fra/h_97610.html].

*Groupe d’experts sur la recherche et l’intelligence du reseau Portage. 2019.'' Sondage sur la stratégie institutionelle de gestion des données de recherche (GDR) – Sommaire des résultats''. Novembre 2019. [https://doi.org/10.5281/zenodo.3962885 https://doi.org/10.5281/zenodo.3962885].

*Khair, Shahira, Rozita Dara, Susan Haigh, Mark Leggott, Ian Milligan, Jeff Moon, Karen Payne, Elodie Portales-Casamar, Ghilaine Roquet, et Lee Wilson. 2020. ''État actual de la gestion des données de recherche au Canada : Mise à jour de l’exposé de principe du CLIRN sur la gestion des données''. Novembre 2020. [https://alliancecan.ca/assets/uploads/documents/NDRIO_GDR_E%CC%81xpose%CC%81deprincipe-1.pdf https://alliancecan.ca/assets/uploads/documents/NDRIO_GDR_E%CC%81xpose%CC%81deprincipe-1.pdf].

*Voinigescu, Eva. 2021. «&amp;#8239;Des organismes subventionnaires priorisent la gestion des données de recherche&amp;#8239;». ''Affairs universitaires'', 15 juin 2021, [https://www.affairesuniversitaires.ca/actualites/actualites-article/des-organismes-subventionnaires-priorisent-la-gestion-des-donnees-de-recherche/ https://www.affairesuniversitaires.ca/actualites/actualites-article/des-organismes-subventionnaires-priorisent-la-gestion-des-donnees-de-recherche/].

[[Catégorie:Extension : Observatoire des politiques sur les savoirs ouverts, 2021-2024 (livre)]]</text>
      <sha1>kohycmi76ieo0y7nxtwaamm415adf3g</sha1>
    </revision>
  </page>
  <page>
    <title>Extension : Observatoire des politiques sur les savoirs ouverts, 2021-2024/La Stratégie canadienne de numérisation du patrimoine documentaire</title>
    <ns>0</ns>
    <id>82356</id>
    <revision>
      <id>744016</id>
      <parentid>743670</parentid>
      <timestamp>2025-06-02T22:30:43Z</timestamp>
      <contributor>
        <username>LodestarChariot2</username>
        <id>120009</id>
      </contributor>
      <minor />
      <comment>/* Ouvrages Citées */</comment>
      <origin>744016</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="27502" sha1="41tudw47r3bjms15b1gxxx1w9s55uqn" xml:space="preserve">''Cette observation a été écrit par Caroline Winter et JT Kern (avec remerciements à Jonathan Bengtson pour ses commentaires et contributions), pour le Electronic Textual Cultures Laboratory et le partenariat Implementing New Knowledge Environments.''

[https://snpd.ca/ La Stratégie canadienne de numérisation du patrimoine documentaire (SNPD)] fait partie d'une longue histoire de numérisation des matériaux du patrimoine culturel qui est en cours dans les communautés savantes et patrimoniales canadiennes depuis au moins les années 1960, évoluant au rythme des développements des technologies numériques, y compris le World Wide Web. Cette histoire comprend les stratégies de numérisation élaborées par l'Institut canadien de microreproductions historiques (ICMH) et [https://www.carl-abrc.ca/fr/ l'Association des bibliothèques de recherche du Canada (ABRC)] à partir des années 1970, l'initiative des bibliothèques numériques des années 1990, [https://www.crkn-rcdr.ca/fr le Réseau canadien de documentation pour la recherche (RCDR)] et [https://www.canadiana.ca/?usrlang=fr Canadiana] dans les années 2000.

[https://archive.org/details/toronto Internet Archive Canada] donne accès libre au matériel numérisé des institutions canadiennes depuis 2004, lorsqu'un centre de numérisation a été établi dans le cadre d'un projet pilote à l'Université de Toronto (Calamai 2007). Le centre a été agrandi en 2006 et a numérisé près de 350 000 textes en quelques années seulement, avec le soutien financier de l'Université de Toronto, d'Internet Archive, de Microsoft et du CRKN (Casey 2011). Le centre de numérisation a été considérablement réduit en 2011, mais à ce jour, Internet Archive Canada a collaboré avec plus de 250 institutions (Internet Archive s.d.).

En 2014, [https://rsc-src.ca/fr/node/3439 la Société royale du Canada (SRC)] a appelé à un programme national de numérisation pour faire entrer le patrimoine culturel et scientifique du Canada dans nouveau l'ère numérique (Beaudry 2014, p. 12). Un [https://www.rapports-cac.ca/reports/a-la-fine-pointe-du-monde-numerique-possibilites-pour-les-institutions-de-la-memoire-collective-au-canada/ rapport de 2015 du Conseil des académies canadiennes (CAC)] sur l'avenir numérique auquel sont confrontées les institutions de mémoire du Canada a noté que «&amp;#8239;le Canada prend du retard, et d’énormes quantités d'information produites sous forme numérique risquent d'être perdues parce que bien des outils traditionnels ne sont plus adéquats&amp;#8239;» (CCA 2015).

==Le SNPD==
En 2016, Guy Berthiaume, alors bibliothécaire et archiviste du Canada, a annoncé le lancement d'une Stratégie de numérisation du patrimoine documentaire (SNPD), éclairée par les rapports de la SRC et du CAC ainsi que par des consultations avec [http://www.cdncouncilarchives.ca/f-intro.html le Conseil canadien des archives] (BAC 2016b). La SNPD a établi ses objectifs pour ses 10 premières années, notamment la numérisation de
* la quasi-totalité (90 %) des documents patrimoniaux publiés avant 1917
* la moitié de toutes les monographies publiées avant 1940
* toutes les revues savantes publiées par les universités canadiennes avant 2000
* toutes les thèses des universités canadiennes avant 2000
* tous les microfilms et microfiches des institutions de mémoire canadiennes
* une sélection de documents audio et audiovisuels de grande valeur
* toutes les cartes historiques disponibles
* toutes les ressources généalogiques d'archives (BAC 2016a).

La SNPD était initialement dirigée par un comité directeur et un secrétariat à [https://www.bac-lac.gc.ca/fra/Pages/accueil.aspx Bibliothèque et Archives Canada (BAC)]. En novembre 2020, il a été annoncé que le secrétariat de la SNPD avait été transféré au [https://www.crkn-rcdr.ca/fr Réseau canadien de documentation pour la recherche (RCDR)] (SNPD 2020). À cette époque, le comité directeur de la SNPD a également été repensé en tant que [https://snpd.ca/le-comite-consultatif-de-la-snpd/ Comité consultatif] relevant d'un nouveau [https://snpd.ca/le-comite-de-direction-de-la-snpd/ Comité de direction] (SNPD 2021b).

==Les activités de la SNPD==
En 2017, la SNPD a mené un projet pilote appelé Digitizing Newspapers, avec le financement de la Salamander Foundation (SNPD s.d.-b). Avec le soutien des éditeurs et des rédacteurs en chef des journaux, les numéros de trois journaux autochtones datant de 1976 à 2017 ont été numérisés et mis en ligne.

En 2018, la SNPD a partagé sa [https://scnpd.files.wordpress.com/2018/03/snpd-strategie-de-contenu-ebauche.pdf Stratégie relative au contenu] et a lancé l'appel de financement pour [https://snpd.ca/2018/04/17/demande-de-financement-dans-le-cadre-de-la-snpd-pour-numeriser-vos-collections/ Numérisation des collections canadiennes], qui offrait jusqu'à 100 000 $ aux des archives, bibliothèques, musées, universités et collèges et autres des organismes du patrimoine culturel pour soutenir leurs projets de numérisation (SNPD 2018a). Il a reçu plus de 200 demandes de financement, totalisant 10 millions de dollars, une réponse qui «&amp;#8239;ont démontré qu’il y a un intérêt pour le programme de numérisation national&amp;#8239;» et a financé 21 projets (SNPD 2018b; 2018c).

Aussi en octobre 2018, la SNPD a co-organisé [https://www.crkn-rcdr.ca/fr/atelier-conjoint-sur-le-patrimoine-documentaire-de-la-snpd-et-du-rcdr l'Atelier conjoint sur le patrimoine documentaire de la SNPD et du RCDR]. Lors de [https://www.crkn-rcdr.ca/fr/2019-conference-du-rcdr-sur-lacces-au-savoir la Conférence du RCDR sur l'accès au savoir en 2019], le RCDR et le SNPD ont tenu des sessions conjointes sur [https://vimeo.com/373462141?embedded=true&amp;source=video_title&amp;owner=91739283 les stratégies de numérisation au Canada], le droit d'auteur, le droit d'auteur et [https://vimeo.com/375434364?embedded=true&amp;source=video_title&amp;owner=91739283 les déclarations des droits]. Des sessions de mise à jour de la stratégie du SNPD ont été offertes lors des conférences virtuelles [https://vimeo.com/485986493 2020] et [https://vimeo.com/648768588 2021] du RCDR.

La SNPD a également développé plusieurs [https://snpd.ca/ressources/ ressources], dont beaucoup en collaboration avec ses membres, notamment [https://scnpd.files.wordpress.com/2020/07/nhds-rightsstatements-report-2020.pdf un rapport sur le groupe de travail sur les déclarations des droits internationaux], [https://www.canada.ca/fr/reseau-information-patrimoine/services/preservation-numerique/recommandations-formats-fichier-preservation-numerique.html des recommandations sur les formats de fichiers pour la préservation numérique] de divers supports et [https://scnpd.files.wordpress.com/2019/05/snpd-pratiques-exemplaires-et-recommandations-2019.pdf un ensemble de meilleures pratiques pour la numérisation].

Le comité exécutif de la SNPD mène actuellement [https://snpd.ca/processus-de-planification-strategique-de-la-snpd/ un processus de planification stratégique] en cinq étapes. L'étape 1 impliquait une consultation, y compris un sondage communautaire et une série d'appels avec communautaires et des parties prenantes. À l'étape 2, actuellement en cours, le Comité de direction et le Comité consultatif et un groupe de travail technique s'appuieront sur le rapport des consultations pour identifier les objectifs, les priorités, les activités et les initiatives à inclure dans le nouveau plan stratégique. À l'étape 3, le Comité de direction élaborera un ébauche de plan stratégique qui, à l'étape 4, sera partagé avec la communauté pour consultation, rétroaction et révision. À l'étape 5, prévue pour 2022, le plan finalisé sera partagé (SNPD s.d.-c.).

==La SNPD dans la presse==
De nombreuses activités de la SNPD ont été couvertes dans la presse académique et populaire. Par exemple, [https://winnipeg.ctvnews.ca/province-digitizing-centuries-old-trading-post-records-to-mark-manitoba-150-1.4317365 un article de CTV News] met en lumière la numérisation [https://www.gov.mb.ca/chc/archives/hbca/index.fr.html des Archives de la Compagnie de la Baie d'Hudson], qui sont maintenant librement accessibles dans le cadre des Archives du Manitoba (Charron 2019). Un article de [https://www.cbc.ca/news/entertainment/digitization-culture-pandemic-1.6015861 CBC News] sur la façon dont la pandémie a conduit à une numérisation accrue des documents du patrimoine culturel mondial note que le gouvernement canadien soutient des initiatives de numérisation depuis des années, y compris la SNPD, et que le budget fédéral du Canada pour 2021 comprend un financement pour la numérisation des documents du patrimoine culturel (Panetta 2021).

Plusieurs projets financés par l'appel de financement Numérisation des collections canadiennes de la SNPD ont également été couverts dans la presse. Un article dans [https://www.affairesuniversitaires.ca/articles-de-fond/article/les-archives-a-lere-de-la-numerisation-et-de-la-decolonisation/?_ga=2.99724830.1629680361.1644268837-1326693258.1641858361 ''Affaires universitaires''] souligne des sérieux efforts des institutions canadiennes, y compris BAC et le SNPD, pour numériser les documents du patrimoine culturel, y compris le projet financé par le SNPD Healing and Education Through Digital Access (Thorkelson 2019). Il s'agit d'un partenariat entre [http://shingwauk.org/srsc/ le Shingwauk Residential Schools Centre] et [https://library.algomau.ca/ la bibliothèque de l'Université Algoma] qui a numérisé [http://archives.algomau.ca/main/?q=node%2F30854 les dossiers du Shingwauk Residential School], un bâtiment qui abrite maintenant l'Université Algoma. Soulignant le rôle important que les institutions de mémoire et les professionnels des bibliothèques et des archives doivent jouer dans la décolonisation, l'article note que rendre ce matériel librement disponible nous permet de demander des autres types de questions comme une communauté de professionnels de l’information sur ce que signifie partager ces éléments en contexte de l'histoire de la violence coloniale et l'utilisation abusive et le vol de matériel aux peuples autochtones (Thorkelson 2019).

Ce projet a également été couvert dans ''SooToday'', un site Web de nouvelles local de Sault Ste. Marie, et sur le blog de [https://www.feathersofhope.ca/digital-archives-project-results-released-national-heritage-digitization-strategy-provides-funding-to-shingwauk-residential-schools-centre/ Feathers of Hope], une initiative de soutien et d'autonomisation des jeunes des Premières Nations en Ontario, soulignant l'importance de ce projet de numérisation pour les communautés concernées.

Un article de [https://www.cbc.ca/news/canada/british-columbia/after-decades-in-boxes-vancouver-s-lgbtq-archive-now-has-a-home-1.5345714 CBC News] traite de la numérisation des [https://searcharchives.vancouver.ca/bc-gay-and-lesbian-archives BC Gay and Lesbian Archives], également financée dans le cadre de l'appel de financement Numérisation des collections canadiennes de la SNPD. Cette collection de milliers de photos, d'œuvres multimédias, d'affiches et d'autres matériaux recueillis par Ron Dutton pendant près de quatre décennies et donnés aux archives de la ville de Vancouver en 2013 (Ghoussoub 2019).

[https://www.cbc.ca/news/canada/prince-edward-island/pei-newspaper-archive-1.4874414 CBC News] a également mis en lumière le projet de numérisation des journaux de l'Université de l'Île-du-Prince-Édouard, financé dans le cadre du même appel. Grâce à ce projet, deux journaux du XIXe siècle, dont le premier journal français de l'Île-du-Prince-Édouard, ont été numérisés et ajoutés à [https://islandnewspapers.ca/nhds IslandNewspapers.ca] (Yarr 2019).

==SNPD et le partenariat INKE==
Le transfert du secrétariat de la SNPD au RCDR, un partenaire d'INKE, a été l'aboutissement d'un partenariat de longue date entre les deux organisations. Clare Appavoo, directrice générale du RCDR, siège aux comités directeurs de la SNPD depuis sa création, et la numérisation et la préservation du patrimoine documentaire canadien sont au cœur des travaux du RCDR, comme le montre de sa fusion avec Canadiana en 2018 (Bengtson et Shepstone 2020 ; voir également «&amp;#8239;[[Observations fondamentales : Observatoire des politiques sur les savoirs ouverts, 2017-2020/Plan Stratégique 2019–2024 du CRKN–RCDR|Plan stratégique 2019-2024 du CRKN–RCDR]]&amp;#8239;» et «&amp;#8239;[https://ospolicyobservatory.uvic.ca/reponse-des-partenaires-au-plan-strategique-2019-2024-du-crkn-rcdr/ Réponse des partenaires au plan stratégique 2019-2024 du CRKN–RCDR]&amp;#8239;»).

[https://www.carl-abrc.ca/fr/ L'ABRC] est un autre partenaire INKE qui entretient des liens étroits avec la SNPD. Parmi ses [https://www.carl-abrc.ca/wp-content/uploads/2016/03/CARL_Budget_2018_brief-final_fr.pdf recommandations pour le budget fédéral de 2018], le gouvernement «&amp;#8239;investir 30 M$ au cours des cinq prochaines années (2018-2022) afin d’appuyer une initiative nationale coordonnée de numérisation du riche patrimoine documentaire du Canada, et de concevoir l'infrastructure numérique requise pour rendre ce matériel accessible à tous les Canadiens&amp;#8239;» (ABRC 2017, 1). L'ABRC est actuellement représentée au SNPD par Jonathan Bengtson (Bibliothèques de l'Université de Victoria), qui est président de son comité exécutif (ABRC s.d.).

Bengtson a présenté une conférence intitulée «&amp;#8239;Five Years Makes All the Difference: Towards a Canadian National Heritage Digitalization Strategy&amp;#8239;» lors d'un panel présenté lors de [https://inke.ca/putting-open-social-scholarship-into-practice/abstracts/ Putting Open Social Scholarship into Practice], le rassemblement annuel du Partenariat INKE, en décembre 2021.

==Le SNPD et la communauté universitaire élargie==
Les stratégies de numérisation du Canada sont également un sujet d'intérêt pour l'ensemble de la communauté universitaire. En 2016, Michael Geist a fait valoir que l'incapacité du Canada à adopter une stratégie nationale de numérisation cohérente a été une source de frustration, donnant l’impression que le pays prend du retard. Il reproche au SNPD de ne pas en faire assez, comparant sa vision à une bibliothèque abandonnée avec des étagères vides de tout sauf de vieux livres. En comparant le SNPD à d'autres stratégies nationales de numérisation, Geist soutient que les obstacles juridiques et financiers qui sont souvent cités ne sont pas aussi insurmontables qu'ils le paraissent, et qu'une initiative dirigée par le gouvernement qui rassemble des ressources publiques et privées c’est le bonne voie à suivre (Geist 2016).

[https://allanamayer.tumblr.com/post/149368526957/the-national-heritage-defeatist-strategy Allana Mayer] a répondu aux critiques de Geist en soulignant que les risques financiers pour les bibliothèques et les archives liés à la numérisation et à la distribution d'œuvres potentiellement protégées par le droit d'auteur sont prohibitifs (voir également «&amp;#8239;[https://ospolicyobservatory.uvic.ca/la-prolongation-de-la-periode-de-protection-du-droit-dauteur-en-canada-en-vertu-de-laccord-canada-etats-unis-mexique-aceum/ La prolongation de la période de protection du droit d’auteur en Canada en vertu de l’Accord Canada–États-Unis–Mexique (ACEUM)]&amp;#8239;»), et que le partenariat avec le secteur privé comporte ses propres risques, tels que le «&amp;#8239;paywalling&amp;#8239;» des matériaux du patrimoine culturel public (2016). Mayer note que le budget fédéral de 2016 n'offrait aucune augmentation du financement de BAC, qui a été réduit de 10 millions de dollars de 2012 à 2015 (2016). En effet, les revenus du SNPD ne comprennent que les dons, et son travail est effectué par des membres bénévoles (SNPD s.d.-a).

L’article «&amp;#8239;[https://journals.lib.unb.ca/index.php/scl/article/view/26269/1882519038 Survival: Canadian Scholarship in a Digital Age]&amp;#8239;» de Susan Brown appelle également à un soutien national solide pour la numérisation et la préservation des documents du patrimoine canadien. Elle note que, bien que la situation au Québec soit moins désastreuse, en Canada anglais l'ABRC, le RCDR et BAC luttent pour coordonner une programme fédéral sans l'appui du gouvernement. Sans archives nationales dynamiques et bien soutenues, elle argumente, les archives de la culture canadienne seront dispersés et inégales (2018).

==Le SNPD et la science ouverte==
Les valeurs directrices du SNPD s'alignent bien sur le mouvement Science ouverte. Sa vision est «&amp;#8239;un avenir dans lequel l'accès Web au riche patrimoine documentaire numérique du Canada est complet et répandu tout en ayant des répercussions importantes sur la culture, l'éducation, la recherche et l'innovation canadiennes&amp;#8239;» et les principes comprennent l'accès, l'ouverture, la collaboration, la durabilité et la liberté intellectuelle (SNPD s.d-a, p. 2–3).

Le 15 octobre, lors de la session de mise à jour de la SNPD de la Conférence virtuelle 2021 du RCDR, Bengtson et Carole Urbain ont fait rapport sur les résultats de la consultation entreprise dans le cadre du processus de planification stratégique. Ils ont noté que l'accès était la plus grande priorité identifiée par la communauté et que les plus petites institutions et les sociétés historiques étaient particulièrement intéressées par les infrastructures et les meilleures pratiques (RCDR 2021). Bengtson a noté que d'autres thèmes découlant de la consultation communautaire sont également directement liés à la science ouverte, notamment la préservation, le partage des ressources et la coordination du travail, la création de normes, le financement et le renforcement de la diversité. Dans l'ensemble, Bengtson et Urbain ont mis l'accent sur l'élimination des obstacles à l'engagement avec la communauté au sens large comme un thème important pour guider les activités futures de la SNPD.

==Ouvrages Citées==
*ABRC (Association des bibliothèques de recherche du Canada). 2017. ''Budget fédéral de 2018 – Mémoire de l’ABRC au Comité permanent des finances de la Chambre des communes''. 4 août 2017. [https://www.carl-abrc.ca/wp-content/uploads/2016/03/CARL_Budget_2018_brief-final_fr.pdf https://www.carl-abrc.ca/wp-content/uploads/2016/03/CARL_Budget_2018_brief-final_fr.pdf].

*ABRC (Association des bibliothèques de recherche du Canada). n.d. «&amp;#8239;Partenaires et relations&amp;#8239;». [https://www.carl-abrc.ca/fr/a-propos-de-labrc/partenaires-et-relations/ https://www.carl-abrc.ca/fr/a-propos-de-labrc/partenaires-et-relations/].

*BAC (Bibliothèque et Archives Canada). 2016a. «&amp;#8239;Stratégie canadienne de numérisation du patrimoine documentaire&amp;#8239;». [https://www.bac-lac.gc.ca/fra/a-notre-sujet/Pages/strategie-canadienne-numerisation.aspx https://www.bac-lac.gc.ca/fra/a-notre-sujet/Pages/strategie-canadienne-numerisation.aspx].

*BAC (Bibliothèque et Archives Canada). 2016b. «&amp;#8239;Le bibliothècaire et archiviste du Canada annonce la création de la Stratégie nationale de numérisation du patrimoine documentaire&amp;#8239;». 4 juin 2016. ''Internet Archive''. [https://web.archive.org/web/20170224195940/http:/nouvelles.gc.ca/web/article-fr.do?nid=1079789 https://web.archive.org/web/20170224195940/http://nouvelles.gc.ca/web/article-fr.do?nid=1079789].

*Beaudry, Guylaine, et al. 2014. ''The Future Now: Canada’s Libraries, Archives, and Public Memory''. La Société royale du Canada. [https://rsc-src.ca/sites/default/files/L%26A_Report_EN_FINAL_Web.pdf https://rsc-src.ca/sites/default/files/L%26A_Report_EN_FINAL_Web.pdf].

*Bengtson, Jonathan, et Carol Shepstone. 2020. «&amp;#8239;‘Tourner en commun’: La fusion de Canadiana.org avec le Réseau canadien de documentation pour la recherche/Canadian Research Knowledge Network&amp;#8239;». ''Partnership'' 15, no. 1. [https://doi.org/10.21083/partnership.v15i1.6110 https://doi.org/10.21083/partnership.v15i1.6110].

*Brown, Susan. 2018. «&amp;#8239;Survival: Canadian Cultural Scholarship in a Digital Age&amp;#8239;». ''Studies in Canadian Literature / Études en littérature canadienne''. [https://journals.lib.unb.ca/index.php/SCL/article/view/26269/1882519038 https://journals.lib.unb.ca/index.php/SCL/article/view/26269/1882519038].

*CAC (Conseil des académies canadiennes). 2015. ''À la fine pointe du monde numérique : possibilités pour les institutions de la mémoire collective au Canada''. 4 février 2015. [https://www.rapports-cac.ca/reports/a-la-fine-pointe-du-monde-numerique-possibilites-pour-les-institutions-de-la-memoire-collective-au-canada/ https://www.rapports-cac.ca/reports/a-la-fine-pointe-du-monde-numerique-possibilites-pour-les-institutions-de-la-memoire-collective-au-canada/].

*Calamai, Peter. 2007. «&amp;#8239;Archivists Embrace Digital Page&amp;#8239;». ''Toronto Star'', 16 april 2007, [https://www.thestar.com/news/2007/04/16/archivists_embrace_digital_page.html https://www.thestar.com/news/2007/04/16/archivists_embrace_digital_page.html].

*Casey, Liam. 2011. «&amp;#8239;Toronto Online Book Archive Forced to Fire 75% of Staff&amp;#8239;». ''Toronto Star'', 8 juillet 2011. [https://www.thestar.com/news/gta/2011/07/08/toronto_online_book_archive_forced_to_fire_75_of_staff.html https://www.thestar.com/news/gta/2011/07/08/toronto_online_book_archive_forced_to_fire_75_of_staff.html].

*Charron, Jeremie. 2019. «&amp;#8239;Province Digitizing Centuries-old Trading Post Records to Mark Manitoba 150&amp;#8239;». ''CTV News'', 28 février 2019. [https://winnipeg.ctvnews.ca/province-digitizing-centuries-old-trading-post-records-to-mark-manitoba-150-1.4317365 https://winnipeg.ctvnews.ca/province-digitizing-centuries-old-trading-post-records-to-mark-manitoba-150-1.4317365].

*Geist, Michael. 2016. «&amp;#8239;Why Canada’s E-Library is Barren&amp;#8239;». ''The Tyee'', 26 juillet 2021. [https://thetyee.ca/Mediacheck/2016/07/26/Canadas-E-Library-Is-Barren/ https://thetyee.ca/Mediacheck/2016/07/26/Canadas-E-Library-Is-Barren/].

*Ghoussoub, Michelle. 2012. «&amp;#8239;After Decades in Boxes, Vancouver’s LGBTQ Archive Now has a Home&amp;#8239;». ''CBC News''. 3 novembre 2021. [https://www.cbc.ca/news/canada/british-columbia/after-decades-in-boxes-vancouver-s-lgbtq-archive-now-has-a-home-1.5345714 https://www.cbc.ca/news/canada/british-columbia/after-decades-in-boxes-vancouver-s-lgbtq-archive-now-has-a-home-1.5345714.]

*Mayer, Allana. 2016. «&amp;#8239;The National Heritage Defeatist Strategy&amp;#8239;». 23 août 2016. [https://allanamayer.tumblr.com/post/149368526957/the-national-heritage-defeatist-strategy https://allanamayer.tumblr.com/post/149368526957/the-national-heritage-defeatist-strategy].

*Panetta, Alexander. 2021. «&amp;#8239;A World of Art at our Fingertips: How COVID-19 Accelerated the Digitization of Culture&amp;#8239;». ''CBC News''. 8 mai 2021. [https://www.cbc.ca/news/entertainment/digitization-culture-pandemic-1.6015861 https://www.cbc.ca/news/entertainment/digitization-culture-pandemic-1.6015861].

*RCDR (Réseau candien de documentation pour la recherche). 2021. «&amp;#8239;2021 CRKN Virtual Conference – 15 October 2021 – National Heritage Digitization Strategy (NHDS) Update&amp;#8239;». Vidéo, 29:53. 15 octobre 2021. [https://vimeo.com/648768588 https://vimeo.com/648768588].

*SNPD (Stratégie de numérisation du patrimoine documentaire). n.d.-a. ''Plan d’activités 2018–2019''. [https://scnpd.files.wordpress.com/2018/09/snpd-plan-dactivitc3a9s-2018-19.pdf https://scnpd.files.wordpress.com/2018/09/snpd-plan-dactivitc3a9s-2018-19.pdf].

*SNPD (Stratégie de numérisation du patrimoine documentaire). n.d.-b. «&amp;#8239;Numérisation de journaux dans le cadre de la SNPD&amp;#8239;». [https://snpd.ca/plan-daction/numerisation-de-certains-journaux-dans-le-cadre-du-projet-pilote-de-la-snpd/ https://snpd.ca/plan-daction/numerisation-de-certains-journaux-dans-le-cadre-du-projet-pilote-de-la-snpd/].

*SNPD (Stratégie de numérisation du patrimoine documentaire). n.d.-c. «&amp;#8239;Processus de planification stratégique de la SNPD&amp;#8239;». [https://snpd.ca/processus-de-planification-strategique-de-la-snpd/ https://snpd.ca/processus-de-planification-strategique-de-la-snpd/].

*SNPD (Stratégie de numérisation du patrimoine documentaire). 2018a. «&amp;#8239;Demande de financement dans le cadre de la SNPD pour numériser vos collections&amp;#8239;». 17 april 2018. [https://snpd.ca/2018/04/17/demande-de-financement-dans-le-cadre-de-la-snpd-pour-numeriser-vos-collections/ https://snpd.ca/2018/04/17/demande-de-financement-dans-le-cadre-de-la-snpd-pour-numeriser-vos-collections/].

*SNPD (Stratégie de numérisation du patrimoine documentaire). 2018b. «&amp;#8239;Mise à jour d’automne de la Stratégie de numérisation du patrimoine documentaire&amp;#8239;». 21 septembre 2018. [https://snpd.ca/2018/09/21/mise-a-jour-dautomne-de-la-strategie-de-numerisation-du-patrimoine-documentaire/ https://snpd.ca/2018/09/21/mise-a-jour-dautomne-de-la-strategie-de-numerisation-du-patrimoine-documentaire/].

*SNPD (Stratégie de numérisation du patrimoine documentaire). 2018c. «&amp;#8239;Stratégie de numérisation du patrimoine documentaire : 21 demandes de financement approuvées dans l’ensemble du Canada&amp;#8239;». 16 octobre 2018. [https://snpd.ca/2018/10/16/strategie-de-numerisation-du-patrimoine-documentaire-21-demandes-de-financement-approuvees-dans-lensemble-du-canada/ https://snpd.ca/2018/10/16/strategie-de-numerisation-du-patrimoine-documentaire-21-demandes-de-financement-approuvees-dans-lensemble-du-canada/].

*SNPD (Stratégie de numérisation du patrimoine documentaire). 2020. «&amp;#8239;Transfert du secrétariat de la SNPD au RCDR&amp;#8239;». 4 novembre 2020. [https://snpd.ca/2020/11/04/transfert-du-secretariat-de-la-snpd-au-rcdr/ https://snpd.ca/2020/11/04/transfert-du-secretariat-de-la-snpd-au-rcdr/].

*SNPD (Stratégie de numérisation du patrimoine documentaire). 2021b. «&amp;#8239;Prochaines étapes de la SNPD : mise à jour sur la gouvernance et la planification stratégique&amp;#8239;». 7 juin 2021. [https://snpd.ca/2021/06/07/prochaines-etapes-de-la-snpd-mise-a-jour-sur-la-gouvernance-et-la-planification-strategique/ https://snpd.ca/2021/06/07/prochaines-etapes-de-la-snpd-mise-a-jour-sur-la-gouvernance-et-la-planification-strategique/].

*Thorkelson, Erika. 2019. «&amp;#8239;Les archives a l’ère de la numérisation et de la décolonisation&amp;#8239;». ''Affaires universitaires.'' 18 septembre 2019. [https://www.affairesuniversitaires.ca/articles-de-fond/article/les-archives-a-lere-de-la-numerisation-et-de-la-decolonisation/?_ga=2.2862896.1629680361.1644268837-1326693258.1641858361 https://www.affairesuniversitaires.ca/articles-de-fond/article/les-archives-a-lere-de-la-numerisation-et-de-la-decolonisation/?_ga=2.2862896.1629680361.1644268837-1326693258.1641858361].

*Yarr, Kevin. 2018. «&amp;#8239;From Confederation to the Great War: P.E.I. Digital Newspaper Collection Expanding&amp;#8239;». 23 octobre 2018. [https://www.cbc.ca/news/canada/prince-edward-island/pei-newspaper-archive-1.4874414 https://www.cbc.ca/news/canada/prince-edward-island/pei-newspaper-archive-1.4874414].

[[Catégorie:Extension : Observatoire des politiques sur les savoirs ouverts, 2021-2024 (livre)]]</text>
      <sha1>41tudw47r3bjms15b1gxxx1w9s55uqn</sha1>
    </revision>
  </page>
  <page>
    <title>Extension : Observatoire des politiques sur les savoirs ouverts, 2021-2024/La Collaboration entre l’ABRC et OpenAIRE</title>
    <ns>0</ns>
    <id>82357</id>
    <revision>
      <id>744017</id>
      <parentid>742409</parentid>
      <timestamp>2025-06-02T22:33:21Z</timestamp>
      <contributor>
        <username>LodestarChariot2</username>
        <id>120009</id>
      </contributor>
      <minor />
      <comment>/* Ouvrages citées */</comment>
      <origin>744017</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="16777" sha1="dq9tirrro1gukisv1rzwqq2mah8ppeu" xml:space="preserve">''Cette observation a été écrit par Caroline Winter (avec remerciements à Kathleen Shearer et Martha Whitehead pour ses commentaires et contribution), pour le Electronic Textual Cultures Laboratory et le partenariat Implementing New Knowledge Environments.''

En janvier 2018, [https://www.carl-abrc.ca/fr/ l'Association des bibliothèques de recherche du Canada (ABRC)] a entamé une [https://www.carl-abrc.ca/fr/faire-avancer-la-recherche/depots-institutionnels/groupe-de-travail-depots-ouverts/collaboration-avec-openaire/ collaboration] avec [https://www.openaire.eu/ OpenAIRE], une organisation européenne d'infrastructure de science ouverte, dans le but d'améliorer la visibilité de la recherche canadienne. L'un des résultats de cette collaboration est [https://canada.explore.openaire.eu/ Canada Explore], un portail de recherche dans les dépôts institutionnels canadiens.

Cette collaboration et le portail qui en résulte contribuent aux efforts de l'ABRC pour rendre les résultats de recherche disparates du Canada disponibles via une interface unique, dans le cadre d'une infrastructure de communication savante distribuée et en réseau mondial. La collaboration augmentera la découvrabilité de la recherche canadienne, avec un accent initial sur les travaux financés par les trois organismes du Canada, comprenant [https://cihr-irsc.gc.ca/f/193.html les Instituts de recherche en santé du Canada (IRSC)], [https://www.nserc-crsng.gc.ca/index_fra.asp le Conseil de recherches en sciences naturelles et en génie du Canada (CRSNG)] et [https://www.sshrc-crsh.gc.ca/home-accueil-fra.aspx le Conseil de recherche en sciences humaines (CRSH)]. L'un de ses principaux objectifs est de saisir les relations avec les subventionnaires afin de permettre le suivi de la conformité à [https://www.ic.gc.ca/eic/site/063.nsf/fra/h_F6765465.html la Politique des trois organismes sur le libre accès aux publications] (ABRC s.d-b ; voir «&amp;#8239;[[Observations fondamentales : Observatoire des politiques sur les savoirs ouverts, 2017-2020/Politique des trois organismes sur le libre accès aux publications|Politique des trois organismes sur le libre accès aux publications]]&amp;#8239;» et «&amp;#8239;[[Observations fondamentales : Observatoire des politiques sur les savoirs ouverts, 2017-2020/Conformité à la politique de libre accès au Canada|Conformité à la politique de libre accès au Canada]]&amp;#8239;»). Cela permettra également d'avoir une vision plus claire du paysage du libre accès au Canada.

La collaboration entre ABRC et OpenAIRE, coordonnée par le [https://www.coar-repositories.org/ Confederation of Open Access Repositories (COAR)], a été lancée dans le cadre du projet [https://www.openaire.eu/advance/ Advance] d'OpenAIRE, un projet financé par la Commission européenne qui vise à promouvoir l'érudition ouverte dans un contexte mondial grâce à des collaborations avec des parties prenantes en Afrique, Canada, Japon, Amérique latine et des États-Unis (OpenAIRE 2018).

==OpenAIRE==
OpenAIRE (Open Access Infrastructure for Research in Europe) a été fondée en 2008 par la Commission européenne pour promouvoir et soutenir la mise en œuvre des directives du [https://erc.europa.eu/sites/default/files/document/file/ERC_Open_Access_Guidelines-revised_Dec_2021.pdf European Research Council’s Open Access Guidelines] de la recherche pour le libre accès et du [https://ec.europa.eu/commission/presscorner/detail/fr/MEMO_08_548 septième programme-cadre de recherche (FP7)] de la Commission européenne, qui exigeait que tous les résultats de la recherche financée doivent être librement accessibles soit par l'intermédiaire d'une revue, soit par l'intermédiaire d'un dépôt.

OpenAIRE, devenue une entité juridique, fournit un certain nombre de services, dont [http://catalogue.openaire.eu/service/openaire.usage_statistics le service de métriques OpenAIRE] et des tableaux de bord institutionnels, communautaires et subventionnaires. Il fournit également [https://www.openaire.eu/noad-activities?highlight=WyJub2FkIl0= des bureaux nationaux de libre accès], qui sont des services d'assistance aux politiques qui offrent une formation et un soutien aux chercheurs et aux institutions pour le partager de leurs travaux dans des dépôts. En outre, il offre une infrastructure de recherche numérique sous la forme de [https://zenodo.org/ Zenodo], un dépôt ouvert pour toutes les disciplines développé avec le [https://home.cern/fr CERN], ainsi que des normes de liaison des données, grâce à l'adoption d'identifiants persistants qui aident à lever l'ambiguïté des organisations de recherche (voir «&amp;#8239;[[Observations fondamentales : Observatoire des politiques sur les savoirs ouverts, 2017-2020/ORCID : Connecter la recherche et les chercheurs|ORCID : Connecter la recherche et des chercheurs]]&amp;#8239;» et «&amp;#8239;[[Observations fondamentales : Observatoire des politiques sur les savoirs ouverts, 2017-2020/Le Persistent Identifier (PID) Consortium de Royaume-Uni|Le «&amp;#8239Persistent Identifier (PID) Consortium&amp;#8239;» de Royaume-Uni]]&amp;#8239;»).

[https://graph.openaire.eu/ Le plate-forme OpenAIRE] agrège les métadonnées de milliers de fournisseurs de contenu (par exemple, Zenodo, arXiv, les revues en libre accès) ainsi que des registres d'entités (par exemple, ORCID, CrossRef) pour créer le base de données, au-dessus duquel les services d'OpenAIRE sont construits. Grâce à [https://explore.openaire.eu/ OpenAIRE Explore], les utilisateurs peuvent rechercher et trouver des publications, des projets de recherche, des données de recherche, des organismes de recherche, des dépôts et d'autres fournisseurs de contenu (OpenAIRE s.d.).

==Le portail Explore Canada==
[https://canada.explore.openaire.eu/ Canada Explore] est un portail personnalisé pour la recherche canadienne qui affiche un sous-ensemble du base de données d'OpenAIRE (OpenAIRE 2021). Il fournit une vue de tous les enregistrements dans le base de données avec une affiliation avec des auteurs, des institutions ou des subventionnaires au Canada. Le portail utilise les capacités d'exploration de données d'OpenAIRE pour capturer les relations avec les subventionnaires et d'autres points de données à partir du texte intégral des publications qui ne sont pas capturées dans les métadonnées. Par exemple, en octobre 2021, le portail affichait 55 595 résultats financés par l’IRSC, dont 37 671 ont été découverts grâce à l'exploration de texte (ABRC 2021, 24:05).

Afin de soutenir l'inclusion des collections de dépôts canadiens dans le base de données d’OpenAIRE, [https://www.carl-abrc.ca/fr/faire-avancer-la-recherche/depots-institutionnels/groupe-de-travail-depots-ouverts/ le Groupe de travail sur les dépôts ouverts] de l'ABRC travaille avec les institutions canadiennes pour s'assurer que leurs dépôts peuvent être récoltés par OpenAIRE. Cela nécessite que les dépôts soient conformes aux [https://guidelines.openaire.eu/en/latest/ directives OpenAIRE 4.0], qui dictent un certain format pour les métadonnées. Les dépôts de littérature qui ne sont pas en mesure de devenir conformes à OpenAIRE peuvent s'assurer que leurs métadonnées sont récoltées indirectement par l'intermédiaire du [https://canadaresearch.mcmaster.ca/handle/123456789/1?locale=fr Canada Research Aggregator], développé par les bibliothèques de l'Université McMaster. Les dépôts de données canadiens sont mis à la disposition d'OpenAIRE par l'intermédiaire du service de découverte du [https://www.frdr-dfdr.ca/repo/?locale=fr Dépôt fédéré de données de recherche (DFDR)] (CARL s.d.-a).

Pour soutenir une plus grande participation à OpenAIRE, le Groupe de travail sur les dépôts ouverts développe des documents pour aider les gestionnaires de dépôts, et l'ABRC a proposé une série de webinaires liés à la collaboration ABRC-OpenAIRE :
* [https://www.youtube.com/watch?v=i5pmEfn9G4U À la recherche d’une aiguille dans une botte de foin : Accroître la visibilité international de la recherche Canadienne grâce à la collaboration entre l’ABRC et OpenAIRE] (26 octobre 2021)
* [https://www.youtube.com/watch?v=8uG13dMzc7A La collaboration ABRC-OpenAIRE : Que faut-il faire dans nos établissements pour y participer?] (26 novembre 2021)
* [https://www.youtube.com/watch?v=H-MrsuYU8WE&amp;t=5s Webinaire pour les responables de dépôt : Mise a jour sur la collaboration entre l’ABRC et OpenAIRE] (2 décembre 2020)

==La collaboration CARL–OpenAIRE et la communauté INKE==
En plus de l'ABRC, la collaboration implique le CRSH, un partisan de l'INKE et membre des trois organismes. Matthew Lucas, directeur exécutif, Stratégie et rendement organisationnels au CRSH, note que la collaboration CARL-OpenAIRE est essentielle pour rendre la recherche canadienne plus ouverte et plus utilisable et pour améliorer la conformité à la politique des trois organismes sur le libre accès (CARL 2021). En plus de faciliter le suivi de la conformité à la politique, ces données peuvent également aider les trois organismes à déterminer quels obstacles à la conformité existent, comment ils peuvent être surmontés et comment mieux surveiller la conformité.

==La collaboration CARL-OpenAIRE et la communauté universitaire élargie==
En plus des avantages qu'elle apporte à la communauté canadienne, la collaboration CARL-OpenAIRE contribue également à la communauté plus large. Par exemple, dans le cadre du projet, le Groupe de travail sur les dépôts ouverts de l'ABRC a lancé le développement d'un plugin pour [https://duraspace.org/dspace/ DSpace] 5 et 6, des plates-formes de dépôt largement utilisées, pour permettre la conformité aux directives OpenAIRE. Cette extension a été dirigée et financée par la bibliothèque de l'Université Queen's avec un financement supplémentaire de l'Université de la Colombie-Britannique, de l'Université Laval, de l'Université de Montréal, de l'Université de la Saskatchewan, de l'Université de l'île de Vancouver et de l'Université York. Ce plugin est disponible pour tous les dépôts DSpace et permettra aux dépôts du monde entier de se conformer plus facilement aux directives OpenAIRE, qui sont également [https://www.coalition-s.org/plan-s-practical-advice/ recommandées pour les dépôts faisant partie du Plan S] (CARL 2019 ; CARL 2020 ; voir «&amp;#8239;[[Observations fondamentales : Observatoire des politiques sur les savoirs ouverts, 2017-2020/Plan S et cOAlition S|Plan S et cOAlition S]]&amp;#8239;»).

==La collaboration CARL-OpenAIRE et la science ouverte==
La collaboration entre l'ABRC et OpenAIRE met en évidence le rôle de l'infrastructure dans l'avancement de la science ouverte. Une infrastructure ouverte et dirigée par la communauté telle qu'OpenAIRE offre une plus grande transparence autour de la fourniture de services, ainsi qu'une couche importante de gouvernance communautaire. Vivian Lewis, présidente de l'ABRC, note que l'infrastructure ouverte et dirigée par la communauté est une partie importante de la vision décrite dans [https://www.carl-abrc.ca/wp-content/uploads/2018/03/CARL_ScholComm_Roadmap_FR.pdf ''la Feuille de route de l’ABRC sur la communication savante''] et [https://unesdoc.unesco.org/ark:/48223/pf0000379949.locale=fr ''la Recommendation de l'UNESCO sur une science ouverte''] (ABRC 2021 ; voir «&amp;#8239;[[Observations fondamentales : Observatoire des politiques sur les savoirs ouverts, 2017-2020/Feuille de route sur la communication savante de l'ABRC|Feuille de route sur la communication savante de l'ABRC]]&amp;#8239;» et «&amp;#8239;[[Observations fondamentales : Observatoire des politiques sur les savoirs ouverts, 2017-2020/La Recommandation de l’UNESCO sur la science ouverte|La Recommandation de l'UNESCO sur la science ouverte]]&amp;#8239;»).

Le développement et l'optimisation de cette infrastructure nécessitent l'adoption généralisée de normes de métadonnées, de vocabulaires et d'identificateurs persistants, et ceux-ci sont destinés au portail Canada Explore et à l'ouverture de la recherche plus largement.

Ce projet met en évidence la nature mondiale de la science ouverte. Comme indiqué dans un article [https://www.affairesuniversitaires.ca/actualites/actualites-article/des-organismes-subventionnaires-priorisent-la-gestion-des-donnees-de-recherche/?_ga=2.135693940.45428248.1645808203-1326693258.1641858361 d’''Affaires universitaires''] sur [https://science.gc.ca/eic/site/063.nsf/fra/h_97610.html ''la Politique des trois organismes sur la gestion des données de recherche''], par exemple, la collecte de [https://portagenetwork.ca/fr/nouvelles/metadonnees-du-dfdr-moissonnees-par-openaire/ métadonnées DFDR] dans le base de données d'OpenAIRE a rendu la recherche canadienne visible et accessible à la communauté internationale (Voinigescu 2021). Natalia Manola, PDG d'OpenAIRE, note que  la recherche est mondiale : la recherche qui trouve son origine en Europe ou en Canada n’y reste pas. Ce qu'il faut, c'est une infrastructure mondiale ouverte avec des nœuds décentralisés, avec des responsabilités, ressources et gouvernance partagée (CARL 2021, 19:50). À titre d'exemple, en améliorant la découvrabilité et l'interopérabilité des résultats de la recherche canadienne, le portail accroît sa visibilité dans le paysage mondial de la recherche.

==Ouvrages citées==
*ABRC (Association des bibliothèques de recherche du Canada). 2019. «&amp;#8239;Collaboration pour une plus grande visibilité et pour améliorer la découvrabilité de l’érudition ouverte – l’extension de DSpace 5 et 6 permettra bientôt de supporter les nouvelles lignes directrices liées à OpenAIRE&amp;#8239;». 2 décembre 2019. CARL. [https://www.carl-abrc.ca/fr/nouvelles/extension-dspace-5-6-conformite-openaire/ https://www.carl-abrc.ca/fr/nouvelles/extension-dspace-5-6-conformite-openaire/].

*ABRC (Association des bibliothèques de recherche du Canada). 2020. «&amp;#8239;Collaboration pour une plus grande visibilité et pour améliorer la découvrabilité de la science ouverte – l’extension de DSpace 5 et 6 est maintenant disponible pour supporter les nouvelles lignes directrices liées à ORCID et à OpenAIRE&amp;#8239;». 20 mai 2020. [https://www.carl-abrc.ca/fr/nouvelles/sortie-extension-dspace-openaire/ https://www.carl-abrc.ca/fr/nouvelles/sortie-extension-dspace-openaire/].

*ABRC (Association des bibliothèques de recherche du Canada). «&amp;#8239;CARL–OpenAIRE Collaboration Webinar (Oct. 26 2021)&amp;#8239;». YouTube, 1 novembre 2021. [https://www.youtube.com/watch?v=i5pmEfn9G4U https://www.youtube.com/watch?v=i5pmEfn9G4U].

*ABRC (Association des bibliothèques de recherche du Canada). s.d.-a. «&amp;#8239;Comment pouvez-vous participer ?&amp;#8239;» [https://www.carl-abrc.ca/fr/faire-avancer-la-recherche/depots-institutionnels/groupe-de-travail-depots-ouverts/collaboration-avec-openaire/comment-pouvez-vous-participer/ https://www.carl-abrc.ca/fr/faire-avancer-la-recherche/depots-institutionnels/groupe-de-travail-depots-ouverts/collaboration-avec-openaire/comment-pouvez-vous-participer/].

*ABRC (Association des bibliothèques de recherche du Canada). s.d.-b. «&amp;#8239;En quoi ce projet est-il important ?&amp;#8239;» [https://www.carl-abrc.ca/fr/faire-avancer-la-recherche/depots-institutionnels/groupe-de-travail-depots-ouverts/collaboration-avec-openaire/importance/ https://www.carl-abrc.ca/fr/faire-avancer-la-recherche/depots-institutionnels/groupe-de-travail-depots-ouverts/collaboration-avec-openaire/importance/].

*OpenAIRE. 2018. «&amp;#8239;OpenAIRE Advance&amp;#8239;». 20 avril 2018. [https://www.openaire.eu/openaire-advance-project https://www.openaire.eu/openaire-advance-project].

*OpenAIRE. 2021. «&amp;#8239;CANADA.EXPLORE: Discovering Canadian Research Outputs&amp;#8239;». 13 décembre 2021. [https://www.openaire.eu/identifying-canadian-research-outputs https://www.openaire.eu/identifying-canadian-research-outputs].

*OpenAIRE. s.d. «&amp;#8239;About&amp;#8239;». [https://graph.openaire.eu/about https://graph.openaire.eu/about].

*Voinigescu, Eva. 2021. «&amp;#8239;Des organismes subventionnaires priorisent la gestion des données de recherche&amp;#8239;». ''Affaires universitaires''. 15 juin 2021. [https://www.affairesuniversitaires.ca/actualites/actualites-article/des-organismes-subventionnaires-priorisent-la-gestion-des-donnees-de-recherche/?_ga=2.90745823.45428248.1645808203-1326693258.1641858361 https://www.affairesuniversitaires.ca/actualites/actualites-article/des-organismes-subventionnaires-priorisent-la-gestion-des-donnees-de-recherche.]

[[Catégorie:Extension : Observatoire des politiques sur les savoirs ouverts, 2021-2024 (livre)]]</text>
      <sha1>dq9tirrro1gukisv1rzwqq2mah8ppeu</sha1>
    </revision>
  </page>
  <page>
    <title>Extension : Observatoire des politiques sur les savoirs ouverts, 2021-2024/Le Rapport sur l’infrastructure ouverte du projet Future of Open Scholarship</title>
    <ns>0</ns>
    <id>82358</id>
    <revision>
      <id>744018</id>
      <parentid>742410</parentid>
      <timestamp>2025-06-02T22:34:58Z</timestamp>
      <contributor>
        <username>LodestarChariot2</username>
        <id>120009</id>
      </contributor>
      <minor />
      <comment>/* Ouvrages citées */</comment>
      <origin>744018</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="15984" sha1="7vvlu8q5q9y9if46yi8d831he1gkwnz" xml:space="preserve">''Cette observation a été écrit par Caroline Winter (avec remerciements à Janneke Adema et Virginia Barbour pour ses commentaires et contribution), pour le Electronic Textual Cultures Laboratory et le partenariat Implementing New Knowledge Environments.''

[https://investinopen.org/ Invest in Open Infrastructure (IOI)] est une organisation internationale qui recherche et défend une infrastructure de recherche ouverte et dirigée par la communauté et travaille à des modèles de financement coordonnés et durables. En août 2021, IOI a publié le rapport final du projet «&amp;#8239;[https://investinopen.org/research/future-of-open-scholarship/ Future of Open Scholarship (FOS)]&amp;#8239;». Ce projet de recherche vise à développer un modèle ouvert et durable pour l'infrastructure de recherche, que IOI définit sur son site Web comme l'ensemble de services, de normes, de protocoles et de logiciels dont l'écosystème universitaire a besoin pour remplir ses fonctions tout au long du cycle de vie de la recherche. IOI définit l'infrastructure ouverte comme les ensembles plus étroite de services, de normes, de protocoles et de logiciels qui permettre communautés de construire collectivement les infrastructures et les systèmes qui offrent des avantages collectifs sans restrictions, et pour un système d'infrastructure mondiale robuste (IOI sd, «&amp;#8239;About&amp;#8239;»).

Le projet FOS aborde les risques et les défis de longue date auxquels sont confrontées les infrastructures de recherche qui ont été exacerbés par la pandémie de COVID-19, y compris un besoin en augmentant de ressources ouvertes et en ligne, des budgets de bibliothèque surchargés et des pénuries de personnel (voir «&amp;#8239;[[Observations fondamentales : Observatoire des politiques sur les savoirs ouverts, 2017-2020/Science Ouverte et COVID-19|Science Ouverte et COVID-19]]&amp;#8239;»).

==Le rapport==
Le rapport final du FOS, [https://zenodo.org/record/5218968#.Yh_1FRPMKWA ''Designing a Preparedness Model for the Future of Open Scholarship''], s'appuie sur les cadres de modélisation de la préparation aux situations d'urgence et aux catastrophes utilisés pour se préparer aux crises de santé publique ou aux catastrophes environnementales. Ces cadres traitent des risques immédiats et urgents ainsi que de la durabilité à plus long terme. En demandant comment les infrastructures de recherche peuvent être développées et financées pour assurer la réactivité à la crise et la durabilité à l'avenir, le projet a adopté une approche communautaire de sa recherche en menant des entretiens, en organisant les appels de la communauté et en animant des ateliers avec des parties prenantes travaillant dans des bibliothèques universitaires, des bibliothèques et services d'archives, universités, organismes de recherche et d'innovation, édition et autres organismes de recherche. Les ateliers ont abordé les thèmes du rôle des principes et des valeurs dans le processus de prise de décision collective et les modèles et mécanismes de financement en matière d'infrastructures de recherche.

Le rapport indique que pour que la science ouverte prospère, nous devons assurer que les outils, les logiciels et les systèmes qui permettent la production et la diffusion des connaissances sont également entretenus et alignés sur les valeurs de la communauté, avec le soutien, la surveillance et des ressources adéquats.

Le rapport soutient qu'une infrastructure ouverte, détenue et exploitée par la communauté est nécessaire pour s'assurer que les valeurs et les besoins de la communauté universitaire sont prioritaires et pris en compte&amp;#8239;», puisque les infrastructures actuelles dominées par les produits commerciaux ne sont pas bien alignées sur les besoins et les valeurs de cette communauté. communauté (6). Il identifie certains défis auxquels sont confrontés les systèmes d'infrastructure ouverts, notamment «l'individualisme institutionnel», le temps nécessaire pour développer et mettre en œuvre des solutions open source par rapport aux solutions commerciales, la maintenance, l'alignement et la dotation en personnel. L'interopérabilité est devenue une préoccupation plus urgente étant donné le risque que certains systèmes d'infrastructure s'arrêtent en raison d'un manque de ressources, ce qui signifie que garantir que le contenu peut être migré est une priorité.

Le rapport identifie également la résilience - la capacité d'un système à se remettre d'une crise - comme un facteur clé de succès. S'appuyant sur l'efficacité de l'action collective pour faire progresser le mouvement du libre accès (Joseph 2013), le rapport appelle à une approche similaire pour faire progresser l'infrastructure ouverte, notant que les consortiums de bibliothèques jouent un rôle important, notamment dans l'élaboration d'un programme de changement partagé.

Le rapport recommande la création d'un «&amp;#8239;Open infrastructure technology oversight committee&amp;#8239;» comprenant des parties prenantes clés et souligne que les modèles de financement sont un élément clé pour une infrastructure de recherche ouverte durable. Enfin, le rapport présente cinq interventions recommandées, avec des mises à jour sur ce qui a été réalisé jusqu'à présent et des échéanciers futurs possibles. Ces recommandations sont, à court terme (&lt;1 an), de
* explorer des modèles permettant une plus grande interopérabilité entre les systèmes de partage d'informations
* créer un comité de surveillance des technologies d'infrastructure ouverte.

A moyen terme (1–2 ans+), pour
* identifier les opportunités de services collectifs et de modèles de soutien pour maximiser les avantages collectifs et améliorer la résilience.

Et à long terme, (3 ans+) pour
* piloter un fonds de réponse rapide pour soutenir la maintenance du projet, en s'appuyant sur le projet pilote précédent
* élaborer un cadre de modèle de financement pour évaluer la faisabilité d'un modèle de financement collectif, en coordonnant les efforts actuellement en cours (28–29).

En plus de son rapport final, le projet FOS comprend [https://docs.google.com/spreadsheets/d/1VkxmIOFCMYHFlrY4xm05PAsklA_SXbnaTyoHI20dQfg/edit#gid=311894591 un outil de modélisation financière interactif] et [https://zenodo.org/record/5153496#.Yh_r8RPMKWA un rapport] d'accompagnement qui modélise les coûts et les avantages de l'investissement collectif dans les infrastructures ouvertes.

==Le rapport FOS et le partenariat INKE==
Les membres de l'INKE sont impliqués dans plusieurs des initiatives d'infrastructure ouverte référencées dans le rapport FOS. [https://www.coalition-publi.ca/ Coalition Publica], un exemple de partenariat novateur cité dans le rapport, est une collaboration entre les partenaires INKE [https://www.erudit.org/fr/ Érudit] et [https://pkp.sfu.ca/ le Public Knowledge Project (PKP)] pour créer une infrastructure ouverte pour l'édition de revues au Canada. Cette infrastructure comprend [https://pkp.sfu.ca/ojs/ Open Journal Systems], une application de publication de revues open source développée par le PKP que le rapport cite comme un exemple d'infrastructure ouverte réussie. Les membres de l'INKE [https://www.canarie.ca/fr/rnre/ CANARIE], [https://www.carl-abrc.ca/fr/ l'Association des bibliothèques de recherche du Canada (ABRC)] et [https://portagenetwork.ca/fr/ Portage] ont apporté leur soutien à [https://dataverse.scholarsportal.info/fr/ Scholars Portal Dataverse] et à la plate-forme de dépôt de données ouvertes qui est également mentionnée comme un exemple clé d'infrastructure ouverte nécessitant un financement plus durable.

Les membres de l'INKE ont également été impliqués dans diverses initiatives visant à faire progresser l'infrastructure ouverte et à améliorer sa durabilité. En mars 2019, l'ABRC et [https://www.crkn-rcdr.ca/fr le Réseau canadien de documentation pour la recherche (RCDR)] se sont joints au SCOSS, une organisation qui facilite le financement collectif d'initiatives de la science ouverte ; deux initiatives précédemment financées sont [https://v2.sherpa.ac.uk/romeo/ Sherpa/RoMEO] et [https://doaj.org/ le Directory of Open Access Journals (DOAJ)] (CARL 2019). L'adhésion au SCOSS signifie que les membres de l'ABRC et du RCDR peuvent participer à un cadre de partage des coûts coordonné (SPARC Europe 2019, 1).

En juin 2021, l'ABRC et le RCDR ont co-présenté un webinaire avec SPARC intitulé [https://www.youtube.com/watch?v=GDWr6zVoA-g Perspectives des établissements par rapport aux investissements en infrastructures ouvertes], réunissant des bibliothécaires universitaires du Canada et des États-Unis pour discuter de stratégies d'investissement dans l'infrastructure ouverte.

L'ABRC a également collaboré avec [https://www.openaire.eu/ OpenAIRE], une organisation européenne de la science ouverte, pour développer [https://www.openaire.eu/identifying-canadian-research-outputs Canada Explore], un portail pour la recherche canadienne basé sur le OpenAIRE plate-forme (voir «&amp;#8239;[[Extension : Observatoire des politiques sur les savoirs ouverts, 2021-2024/La Collaboration entre l’ABRC et OpenAIRE|La Collaboration entre l'ABRC et OpenAIRE]]&amp;#8239;»).

==Le rapport FOS et la communauté universitaire élargie==
Comme le reconnaît le rapport FOS, de nombreux groupes et organisations au sein de la communauté universitaire travaillent déjà à la construction d'infrastructures ouvertes. En plus de ceux mentionnés dans le rapport, d'autres groupes développent et mettent en œuvre des infrastructures, telles que l'organisation d'identificateurs persistants [https://orcid.org/ ORCID], [https://www.copim.ac.uk/ COPIM (Community-led Open Publication Infrastructures for Monographs)] et [https://www.coar-repositories.org/ COAR (Confederation of Open Access Repositories)] (voir «&amp;#8239;[[Observations fondamentales : Observatoire des politiques sur les savoirs ouverts, 2017-2020/ORCID : Connecter la recherche et les chercheurs|ORCID : Connecter la recherche et les chercheurs]]&amp;#8239;» ; «&amp;#8239;[[Observations fondamentales : Observatoire des politiques sur les savoirs ouverts, 2017-2020/ORCID : Connecter la recherche et les chercheurs|Les monographies en libre accès]]&amp;#8239;»).

Faisant écho aux évaluations du rapport sur l'importance de la construction d'infrastructures ouvertes durables, [https://unesdoc.unesco.org/ark:/48223/pf0000379949_fre la Recommandation de l'UNESCO sur une science ouverte] reconnaît qu'en plus de ses avantages économiques, investir dans des infrastructures ouvertes permet la collaboration, améliore la réutilisation des données de recherche (et donc la réplicabilité et la reproductibilité des recherche), et promeut une plus grande égalité au sein de la communauté mondiale de la recherche (2021). La Recommandation de l'UNESCO indique également «&amp;#8239;Investir dans les infrastructures et les services de la science ouverte&amp;#8239;» comme l'un de ses objectifs clés (6) et appelle les infrastructures ouvertes l'un des «&amp;#8239;piliers essentiels&amp;#8239;» de la science ouverte (7).

==Le rapport FOS et la science ouverte==
L'infrastructure ouverte est un élément clé de la science ouverte et de l'écosystème de la communication savante. Comme le note le rapport FOS, l'effondrement des infrastructures pourrait entraîner un manque de diversité dans l'écosystème si les petites presses sont contraintes de fermer, les services et outils ouverts ne peuvent plus être pris en charge et les sociétés savantes ne peuvent plus générer de revenus grâce à des événements en personne. (Thaney 2020).

En plus du projet FOS, IOI développe un catalogue de services d'infrastructure ouverte qui décrit et évalue l'infrastructure ouverte, présentant des informations sur chacun sous une forme standardisée pour faciliter la sélection et la prise de décision.

De plus, la pandémie de COVID-19 est un contexte important pour le projet FOS, une crise en cours qui a rendu visibles à la fois les vulnérabilités de l'écosystème scientifique, y compris ses infrastructures, et son importance vitale, en particulier l'importance vitale du libre accès et la science ouverte (Barbour et Borchert 2020; Tavernier 2020). Dans un article pour le blog LSE, Kaitlin Thaney, directrice exécutive de l'IOI, note que les institutions ont réagi à la pandémie de l'une des deux manières suivantes : en continuer avec le nombre de fournisseurs de services afin d’assurer la continuité de la recherche à le coût de la flexibilité et de la capacité de changement, ou en voyant cela comme un moment pour s'adapter et renforcer la résilience en coordonnant dans le cadre d'une stratégie à long terme (2020). La collaboration et les efforts collectifs sont essentiels à la vision du rapport FOS d'un avenir durable pour la science ouverte.

==Ouvrages citées==
*ABRC (Association des bibliothèques de recherche du Canada). 2019. «&amp;#8239;L’ABRC et le RCDR se joignent à la SCOSS, la Global Sustainability Coalition for Open Science Services&amp;#8239;». 18 mars 2019. [https://www.carl-abrc.ca/fr/nouvelles/labrc-et-le-rcdr-se-joignent-au-scoss/ https://www.carl-abrc.ca/fr/nouvelles/labrc-et-le-rcdr-se-joignent-au-scoss/].

*ABRC (Association des bibliothèques de recherche du Canada). 2021. «&amp;#8239;Webinar: Institutional Perspectives on Investments in Open Infrastructure (June 17, 2021)&amp;#8239;». 23 juin 2021. [https://www.youtube.com/watch?v=GDWr6zVoA-g https://www.youtube.com/watch?v=GDWr6zVoA-g].

*Barbour, Virginia, et Martin Borchert. 2020. «&amp;#8239;Open Science: After the COVID-19 Pandemic There can be No Return to Closed Working&amp;#8239;». Australian Academy of Science. [https://www.science.org.au/curious/policy-features/open-science-after-covid-19-pandemic-there-can-be-no-return-closed-working https://www.science.org.au/curious/policy-features/open-science-after-covid-19-pandemic-there-can-be-no-return-closed-working].

*Goudarzi, Saman, Katrina Pugh, Vanessa Rhinesmith, Heather Staines, et Kaitlin Thaney. 2021. ''Designing a Preparedness Model for the Future of Open Scholarship. Invest in Open Infrastructure''. Juillet 2021. [http://doi.org/10.5281/zenodo.5218968 doi.org/10.5281/zenodo.5218968].

*IOI (Invest in Open Infrastructure). s.d. «&amp;#8239;About IOI&amp;#8239;». [https://investinopen.org/about/ https://investinopen.org/about/].

*Joseph, Heather. 2013. «&amp;#8239;The Open Access Movement Grows Up: Taking Stock of a Revolution&amp;#8239;». ''PLOS Biology'' 11, no. 10: e1001686. [https://doi.org/10.1371/journal.pbio.1001686 https://doi.org/10.1371/journal.pbio.1001686].

*SPARC Europe. 2019. ''A Global Sustainability Committee for Open Science Services: The Case''. [https://sparceurope.org/download/2859/ https://sparceurope.org/download/2859/].

*Tavernier, Willa. 2020. «&amp;#8239;COVID-19 Demonstrates the Value of Open Access&amp;#8239;». ''S&amp;RL News'', mai 2020, [https://crln.acrl.org/index.php/crlnews/article/viewFile/24414/32235 https://crln.acrl.org/index.php/crlnews/article/viewFile/24414/32235].

*Thaney, Kaitlin. 2020. «&amp;#8239;The Open Scholarship Ecosystem Faces a Collapse; It’s Also our Best Hope for a More Resilient Future&amp;#8239;». ''LSE Blog'', 19 juin 2020. [https://blogs.lse.ac.uk/impactofsocialsciences/2020/06/19/the-open-scholarship-ecosystem-faces-collapse-its-also-our-best-hope-for-a-more-resilient-future/ https://blogs.lse.ac.uk/impactofsocialsciences/2020/06/19/the-open-scholarship-ecosystem-faces-collapse-its-also-our-best-hope-for-a-more-resilient-future/].

*UNESCO. 2021. ''Recommendation de l’UNESCO sur une science ouverte''. [https://unesdoc.unesco.org/ark:/48223/pf0000379949_fre https://unesdoc.unesco.org/ark:/48223/pf0000379949_fre].

[[Catégorie:Extension : Observatoire des politiques sur les savoirs ouverts, 2021-2024 (livre)]]</text>
      <sha1>7vvlu8q5q9y9if46yi8d831he1gkwnz</sha1>
    </revision>
  </page>
  <page>
    <title>Extension : Observatoire des politiques sur les savoirs ouverts, 2021-2024/La Politique de libre accès du l’UKRI 2021</title>
    <ns>0</ns>
    <id>82359</id>
    <revision>
      <id>744019</id>
      <parentid>742504</parentid>
      <timestamp>2025-06-02T22:36:46Z</timestamp>
      <contributor>
        <username>LodestarChariot2</username>
        <id>120009</id>
      </contributor>
      <minor />
      <comment>/* Ouvrages citées */</comment>
      <origin>744019</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="25270" sha1="bphpndc373s3wgy0vqh39iwxf8cd0xd" xml:space="preserve">''Cette observation a été écrit par Caroline Winter (avec remerciements à Matthew Greenhall et Samuel Moore pour ses commentaires et contribution), pour le Electronic Textual Cultures Laboratory et le partenariat Implementing New Knowledge Environments.''

En août 2021, [https://www.ukri.org/ UK Research and Innovation (UKRI)] a publié [https://www.ukri.org/news/ukri-announces-new-open-access-policy/ une politique organisationnelle de libre accès] qui s'applique aux publications financées par l'un de [https://www.ukri.org/councils/ ses sept conseils de recherche, Research England et Innovate UK]. Cette nouvelle politique est le résultat d'un processus de consultation qui a débuté en 2018, avec une version de politique pour consultation publié en février 2020 (voir «&amp;#8239;[[Observations fondamentales : Observatoire des politiques sur les savoirs ouverts, 2017-2020/Examen et consultation de la politique de L’UKRI sur libre accès|Examen et consultation de la politique de l’UKRI sur libre accès]]&amp;#8239;»). Il s'appuie sur près de deux décennies d'élaboration de politiques de libre accès au Royaume-Uni, notamment le rapport Finch de 2012, la politique et les orientations du Research Excellence Framework (REF) 2021 sur libre accès et les politiques d'accès ouvert existants des conseils de recherche.

Dans le cadre de la nouvelle politique de libre accès, les articles de recherche soumis pour publication à compter du 1er avril 2022 doivent être publiés en libre accès immédiat via l'une des deux voies : dorée ou verte. Dans la voie 1 – libre accès dorée - l'article est publié dans une revue ou une plateforme libre accès (y compris des revues hybrides transformatifs) qui répond à un ensemble de normes techniques pour s'aligner sur [https://www.go-fair.org/fair-principles/ les principes FAIR (Findability, Accessibility, Interoperability, Reusability)]. Ces normes incluent l'utilisation d'identificateurs permanents, des normes de métadonnées, un programme de conservation à long terme et l'inclusion de la politique d'auto-archivage dans [https://v2.sherpa.ac.uk/romeo/ SHERPA/RoMEO] (UKRI 2021c ; voir «&amp;#8239;[[Observations fondamentales : Observatoire des politiques sur les savoirs ouverts, 2017-2020/Le Persistent Identifier (PID) Consortium de Royaume-Uni|Le «&amp;#8239;Persistent Identifier (PID) Consortium&amp;#8239;» de Royaume-Uni]]&amp;#8239;»).

Dans la voie 2 – libre accès verte - l'article est publié dans une revue payante et le manuscrit accepté de l'auteur ou la version de l’éditeur est déposé dans un dépôt institutionnel ou thématique. Une licence [https://creativecommons.org/about/cclicenses/ Creative Commons] doit également être appliquée, soit Attribution (CC BY) ou Attribution–No Derivatives (CC BY ND) 4.0 International. (UKRI 2021a). Le dépôt doit répondre à des normes techniques similaires à celles de la revue libre accès et doit être enregistré dans [https://v2.sherpa.ac.uk/opendoar/ le Directory of Open Access Repositories (OpenDOAR)]. Tous les articles biomédicaux doivent également être déposés dans [https://europepmc.org/ Europe PubMed Central] (politique UKRI 2021b).

Il s'agit de la première politique de libre accès de l’UKRI qui s'applique aux monographies ainsi qu'aux articles (voir  «&amp;#8239;[[Extension : Observatoire des politiques sur les savoirs ouverts, 2021-2024/Les monographies en libre accès|Les monographies en libre accès]]&amp;#8239;»). En vertu de la politique, les publications de forme longue - monographies, collections éditées et chapitres de livre - doivent être en libre accès dans les 12 mois suivant la publication, à compter du 1er janvier 2024, soit par publication sur une plate-forme en libre accès (similaire à la voie 1 ci-dessus ou en libre accès dorées) ou par dépôt du manuscrit accepté de l’auteur dans un dépot (similaire à la voie 2 ou à libre accès verte). Comme pour les articles, une licence CC doit être appliquée, soit CC BY (préféré), CC BY ND, ou Attribution–NonCommercial (CC BY NC) (UKRI 2021a). La politique reconnaît que certaines exceptions rares peuvent être faites lorsque la publication en libre accès n'est pas possible et encourage mais n'exige pas le respect des normes de métadonnées et l'utilisation des identificateurs permanents (UKRI 2021b).

La politique note que ses exigences en matière de licence ne s'appliquent à aucun matériel protégé par le droit d'auteur par une tierce partie, tel que des images ou des cartes, inclus dans des articles ou des publications de longue durée (Royaume-Uni 2021b). Et, bien que la politique ne s'applique pas aux prépublications, elle soutient leur utilisation et leur diffusion, en particulier dans les situations d'urgence (UKRI 2021b).

Pour soutenir la mise en œuvre de la nouvelle politique libre accès, l'UKRI a engagé jusqu'à 47,7 £ millions par an, dont 3,5 £ millions réservés aux monographies libre accès, mais les fonds de soutien ne peuvent être utilisés que pour publier des articles dans des revues hybrides qui ont un accord transformateur en place avec [https://www.jisc.ac.uk/content/open-access/our-role#requirements JISC] (UKRI 2021b ; URKI 2021c). Il s'efforcera de s'assurer que toutes les exigences libre accès futures du Research Excellence Framework (REF) sont conformes à celui-ci et fournira plus de détails sur la mise en œuvre et le financement, en particulier en ce qui concerne les publications de longue durée, plus tard en 2022 (UKRI 2021a ; UKRI 2021b). De plus amples détails sur la mise en œuvre seront disponibles sur le site [https://www.ukri.org/what-we-offer/supporting-healthy-research-and-innovation-culture/open-research/open-access-policies-review/ Shaping Our Open Access Policy] de l'UKRI dès qu'ils seront disponibles.

==Réactions de la communauté INKE==
[https://oaaustralasia.org/2021/08/12/new-ukri-open-access-policy/ Open Access Australasia], membre du partenariat INKE par le biais du [https://inke.ca/canadian-australian-partnership-for-open-scholarship/ Canadian–Australian Partnership for Open Scholarship (CAPOS)], a fait une déclaration en faveur de la nouvelle politique, notant qu'elle offre un exemple utile qui pourrait éclairer [https://oa2020.org/wp-content/uploads/POSTER_12_OpenAccessForAustralia_poster_DrCathyFoley.pdf la stratégie nationale australienne de libre accès], actuellement en cours de consultation.

==La nouvelle politique libre accès de l’UKRI dans la presse==
L'annonce de la politique a été couverte par la presse universitaire, notamment dans [https://physicsworld.com/a/researchers-and-publishers-respond-to-new-uk-open-access-policy/ ''Physics World''], [https://sciencebusiness.net/news/ukri-funded-research-be-published-open-access-journals ''Science Business''] et [https://universitybusiness.co.uk/research/ukri-publishes-new-open-access-policy-for-publicly-funded-research/ ''University Business'']. Comme le montre sa couverture médiatique, la politique de libre accès de l'UKRI bénéficie en principe d'un large soutien de la part de la communauté universitaire, mais les opinions divergent sur la manière dont elle devrait être mise en œuvre (Duncan 2021).

Dans un article au [https://www.timeshighereducation.com/blog/ukris-new-open-access-policy-will-hinder-open-science ''Times Higher Ed''], Carrie Webster (de Springer Nature) affirme que la nouvelle politique de libre accès de l'UKRI fait bien les choses, y compris ses engagements de financement et son exigence que le financement soit utilisé pour soutenir des accords transformatifs. Elle exprime cependant des inquiétudes quant au fait que la politique traite libre accès verte (voie 2) sur un pied d’égalité avec libre accès dorée (voie 1), car cela a le potentiel de saper les objectifs ultimes de la politique en enracinant plutôt qu'en s'éloignant d'un modèle basé sur l'abonnement (Webster 2021).

Un article au [https://www.nature.com/articles/d41586-021-02148-8 ''Nature''] de Richard Van Noorden est moins favorable à la politique, le décrivent  comme strict et le processus de l'UKRI pour déterminer quelles revues hybrides sont éligibles au soutien des frais de publication comme l’indécision (2021). Comme Webster, sa critique se concentre sur le soutien à libre accès vert, mais il fait part de l'inquiétude de la communauté de l'édition britannique que le soutien à libre accès vert féra souffrir des éditeurs en permettant aux auteurs de se conformer sans payer des frais de publication.

==Réaction de la communauté élargie==
L'UKRI a reçu une forte réponse de la communauté au sens large à son projet de politique pour consultation et a partagé [https://www.ukri.org/wp-content/uploads/2021/08/UKRI-060821-UKRIOpenAccessReviewConsultationAnalysis-FINAL.pdf une analyse des 350 réponses qu'elle a reçues].

[https://www.rluk.ac.uk/rluk-welcomes-publication-of-ukris-new-open-access-policy/ Research Libraries UK (RLUK)] a partagé une déclaration de soutien ferme à la nouvelle politique, tout comme [https://www.coalition-s.org/coalition-s-welcomes-the-plan-s-aligned-open-access-policy-from-ukri/ la cOAlition S] et [https://blog.frontiersin.org/2021/08/09/statement-in-support-of-ukris-new-open-access-policy/ Frontiers], ainsi que d'autres parties prenantes ont exprimé leur soutien à la politique avec des inquiétudes quant à sa mise en œuvre.

Bon nombre de ces préoccupations concernent l'élimination de tout embargo sur les articles déposés dans les dépôts. Par exemple, [https://www.publishers.org.uk/publications/the-practical-implications-of-ukris-proposed-open-access-policy-for-the-uks-research-sector/ le Publishers Association] déclare que mettre le libre accès verte sur un pied d'égalité avec dorée - plutôt que comme une option de secours lorsque le libre accès dorée n'est pas disponible - sapera à la fois l'industrie de l'édition et le mouvement libre accès (2021). Des préoccupations similaires ont été exprimées par [https://www.alpsp.org/news/ukri-policy-alpsp-response-aug21 le Copyright Committee de l'Association of Learned and Professional Society Publishers (ALPSP)], [https://www.stm-assoc.org/2021_08_09_STM_response_to_UKRI_Open_Access_Policy.pdf STM] (une organisation industrielle pour les éditeurs universitaires), [https://physicsworld.com/a/researchers-and-publishers-respond-to-new-uk-open-access-policy/ l'Institute of Physics (IOP) Publishing], [https://newsroom.taylorandfrancisgroup.com/taylor-francis-response-to-the-ukri-policy-announcement/ Taylor &amp; Francis] et [https://www.thebookseller.com/news/ukri-announces-new-open-access-policy-1274942 ''The Bookseller''] (un magazine spécialisé dans l'édition). [https://openaccess.ox.ac.uk/wp-content/uploads/sites/2/2021/08/Oxford-UKRI-OA-policy-response-09-08-21-1.pdf L'Université d'Oxford] a publié une déclaration en réponse à l'annonce de la politique exprimant sa préoccupation que les questions soulevées en réponse au projet n'aient pas été entièrement traitées. Il indique que le délai du 1er avril pour les articles est trop court, que les révisions de la politique n'ont pas pris en compte le nombre croissant d'accords transformateurs au Royaume-Uni et que les détails nécessaires sur le financement ne sont pas encore disponibles. En outre, il soutient que l'embargo de 12 mois sur les monographies mettra en péril l'avenir des presses savantes (Oxford 2021).

Jusqu'au 1er avril, date à laquelle la nouvelle politique devait prise effet, ''Nature'' et les autres revues publiées par Springer Nature n'étaient pas incluses dans [https://v2.sherpa.ac.uk/romeo/tjlists.html la liste des revues transformatifs approuvées par Jisc]. Cela a soulevé des inquiétudes quant au fait que le financement de l'UKRI ne pouvait pas être utilisé pour payer les frais de publication pour ces revues, empêchant ainsi les chercheurs et chercheuses de publier dans ces lieux prestigieux. Un accord temporaire de dernière minute entre Jisc et Springer Nature annoncé le 1er avril, en vigueur jusqu'à la fin de 2022, a temporairement résolu ces préoccupations, et Springer Nature devrait avoir un accord transformateur en place pour 2023 et au-delà. Cet accord reste cependant controversé en raison des frais de publication élevés facturés par ''Nature'' de 8290 £ ou 9500 € (Grove 2022).

D'autres intervenants ont exprimé des inquiétudes quant au traitement des monographies par la politique. [https://copim.ac.uk/about-us/ COPIM (Community-led Publication Infrastructures for Monographs)] a publié une réponse à l'appui de la politique, en particulier ses exigences pour les publications savantes de longue durée. Notant que d'autres organisations développent déjà les infrastructures nécessaires à la publication de monographies en libre accès, le COPIM s'oppose à l'exemption de l'éditeur approprié de la politique et aux possibilités d'embargos incluses dans le prochain REF (2021). [https://blog.royalhistsoc.org/2021/08/11/ukri-open-access-protocols-august-2021/ Le Royal Historical Society] du Royaume-Uni soutient généralement la politique et son traitement des publications de longue durée, mais exprime des préoccupations similaires au COPIM, que des détails importants sur le financement et la mise en œuvre restent indéfinis, et comment cette politique affectera la prochaine REF est encore inconnue (Finn et al. 2021 ; COPIM 2021).

Faisant écho aux préoccupations concernant les effets du soutien à libre accès hybride basé sur les frais de publication, la réponse du COPIM avertit que l'établissement d'un système similaire de financement des frais de publication des livres ne peut qu'enraciner davantage l'édition hybride et aggraver les inégalités existantes (COPIM 2021). [https://www.samuelmoore.org/2021/08/09/what-does-the-ukri-policy-mean-for-open-access-book-publishing/ Samuel Moore] exprime des préoccupations similaires, faisant valoir que la politique pourrait faire des frais de publication de monographie le principal modèle commercial pour les monographies libre accès plutôt que de soutenir des modèles d'édition plus innovants et dirigés par la communauté (Moore 2021). Dans le même ordre d'idées, [https://blogs.lse.ac.uk/impactofsocialsciences/2021/09/14/genuine-open-access-to-academic-books-requires-collective-solutions/#comments Lucy Barnes d'Open Book Publishers] soutient en réponse à la nouvelle politique que les modèles de financement collectifs sont le meilleur moyen de financer l'édition longue en libre accès sans compter sur les frais de publication de livres (2021).

==La nouvelle politique libre accès de l’UKRI et la science ouverte==
Les débats sur les effets potentiels de la politique sur l'industrie de l'édition et sur l'économie du Royaume-Uni dans son ensemble mettent en évidence le rôle de la science ouverte dans l'économie mondiale. La nouvelle politique de libre accès de l’UKRI fait partie de la stratégie globale [https://www.gov.uk/government/publications/build-back-better-our-plan-for-growth Build Back Better] du Royaume-Uni, une réponse à la pandémie de COVID-19 qui comprend des investissements importants dans la recherche et développement pour soutenir la croissance économique (Ficarra et Johnson 2021 ; voir «&amp;#8239;[[Observations fondamentales : Observatoire des politiques sur les savoirs ouverts, 2017-2020/Science Ouverte et COVID-19|Science ouverte et COVID-19]]&amp;#8239;») .

Cependant, [https://www.publishers.org.uk/wp-content/uploads/2021/02/FTI-Report-for-Publishers-Association-1.pdf un rapport sur les effets économiques potentiels de la nouvelle politique de libre accès] de FTI Consulting, commandé par le Publishers Association, conclut que la politique affectera négativement l'économie britannique (2021). Plus précisément, il constate que la suppression de la période d'embargo pour les articles publiés via le libre accès verte faire souffrir la capacité des éditeurs à récupérer leurs investissements dans les publications de recherche, avec des répercussions sur l'économie du Royaume-Uni dans son ensemble (9-10, 40). En réponse à ce rapport, [https://theplosblog.plos.org/2021/03/open-response-to-fti-consulting-report/ PLOS] fait valoir qu'en limitant son analyse aux effets économiques du libre accès sur l'industrie de l'édition - et sur les modèles d'édition traditionnels - le rapport ne tient pas compte des avantages généralisés du libre accès dans la science ouverte et au-delà (2021).

L'UKRI est un membre fondateur de la cOAlition S, et l'appel de la politique pour un libre accès immédiat et sans embargo s'aligne sur le Plan S et d'autres politiques de financement internationales (voir «&amp;#8239;[[Observations fondamentales : Observatoire des politiques sur les savoirs ouverts, 2017-2020/Plan S et cOAlition S|Plan S et cOAlition S]]&amp;#8239;» et «&amp;#8239;[[Extension : Observatoire des politiques sur les savoirs ouverts, 2021-2024/Mise à jour du Plan S : L’élargissement de l’adhésion de la cOAlition S|Mise à jour du Plan S: L’élargissement de l’adhésion de la cOAlition S]]&amp;#8239;») (O'Grady 2021 ; UKRI 2021a). L'exigence d'une licence Creative Commons met également la politique de l'UKRI en conformité avec la stratégie de conservation des droits du Plan S, qui a soulevé des inquiétudes quant aux impacts sur la science ouverte dans son ensemble, y compris la possibilité de rejets généralisés de manuscrits lorsque la politique de la revue exige le transfert du droit d'auteur et la l'effondrement des revues hybrides qui choisissent de ne passer pas à libre accès, mais Stephen Eglen soutient que bon nombre de ces préoccupations sont exagérées (voir «&amp;#8239;[[Extension : Observatoire des politiques sur les savoirs ouverts, 2021-2024/Mise à jour du Plan S : L’élargissement de l’adhésion de la cOAlition S|Mise à jour du Plan S: La Stratégie de conservation des droits]]&amp;#8239;» ; Eglen 2021).

La déclaration du Jisc en réponse à la politique souligne son importance au sein de l'écosystème des communications savantes et de la communauté au sens large, déclarant que la politique aidera la transition durable vers le libre accès complet et immédiat (2021). Étant donné que le Royaume-Uni est un leader mondial de l’édition en libre accès, la nouvelle politique de l’UKRI est une contribution significative à l'avancement de la science ouverte dans le monde entier.

==Ouvrages citées==
*Barnes, Lucy. «&amp;#8239;Genuine Open Access to Academic Books Requires Collective Solutions&amp;#8239;». ''LSE Blog''. 14 septembre 2021. [https://blogs.lse.ac.uk/impactofsocialsciences/2021/09/14/genuine-open-access-to-academic-books-requires-collective-solutions/#comments https://blogs.lse.ac.uk/impactofsocialsciences/2021/09/14/genuine-open-access-to-academic-books-requires-collective-solutions/#comments].

*COPIM (Community-led Publication Infrastructures for Monographs). 2021. «&amp;#8239;COPIM Response to new UKRI Open Access Policy&amp;#8239;». 11 août 2021. [https://copim.pubpub.org/pub/copim-response-to-new-ukri-open-access-policy/release/2 https://copim.pubpub.org/pub/copim-response-to-new-ukri-open-access-policy/release/2].

*Duncan, Bruce. «&amp;#8239;URKI Open Access Policy: A Revolution in Scholarly Communication?&amp;#8239;» ''Times Higher Ed''. 19 août 2021. [https://www.timeshighereducation.com/news/ukri-open-access-policy-revolution-scholarly-communication https://www.timeshighereducation.com/news/ukri-open-access-policy-revolution-scholarly-communication].

*Eglen Stephen J. 2021. «&amp;#8239;How will the Rights Retention Strategy affect Scholarly Publishing?&amp;#8239;» ''LSE Blog'', 10 septembre 2021. [https://blogs.lse.ac.uk/impactofsocialsciences/2021/09/10/how-will-the-rights-retention-strategy-affect-scholarly-publishing/ https://blogs.lse.ac.uk/impactofsocialsciences/2021/09/10/how-will-the-rights-retention-strategy-affect-scholarly-publishing/].

*Ficarra, Victoria, et Rob Johnson. 2021. «&amp;#8239;Guest Post – Five Things you Need to Know about UKRI’s New Open Access Policy&amp;#8239;». ''The Scholarly Kitchen''. 3 novembre 2021. [https://scholarlykitchen.sspnet.org/2021/11/03/guest-post-five-things-you-need-to-know-about-ukris-new-open-access-policy/ https://scholarlykitchen.sspnet.org/2021/11/03/guest-post-five-things-you-need-to-know-about-ukris-new-open-access-policy/].

*Finch, Janet et le Working Group on Expanding Access to Published Research Findings. 2012. ''Accessibility, Sustainability, Excellence: How to Expand Access to Research Publications''. Research Information Network. Grande Bretagne. [https://apo.org.au/node/29938 https://apo.org.au/node/29938].

*Finn, Margot, Richard Fisher, Emma Griffin et Peter Mandler. 2021. «&amp;#8239;UKRI Open Access Protocols: August 2021&amp;#8239;». ''Historical Transactions'', Royal Historical Society. [https://blog.royalhistsoc.org/2021/08/11/ukri-open-access-protocols-august-2021/ https://blog.royalhistsoc.org/2021/08/11/ukri-open-access-protocols-august-2021/].

*FTI Consulting. 2021. ''Economic Assessment of the Impact of the New Open Access Policy Developed by UK Research and Innovation''. [https://www.publishers.org.uk/wp-content/uploads/2021/02/FTI-Report-for-Publishers-Association-1.pdf https://www.publishers.org.uk/wp-content/uploads/2021/02/FTI-Report-for-Publishers-Association-1.pdf].

*Grove, Jack. 2022. «&amp;#8239;Late Reprieve Allows Scientists with UK Grants to Publish in Nature&amp;#8239;». ''Times Higher Education (THE)'', 14 avril 2022. [https://advance.lexis.com. https://advance.lexis.com.]

*Jisc. 2021. «&amp;#8239;New UKRI Policy is a ‘Significant Driver’ Towards Open Access Research&amp;#8239;». ''Jisc Blog''. 6 août 2021. [https://www.jisc.ac.uk/blog/new-ukri-policy-is-a-significant-driver-towards-open-access-research-06-aug-2021 https://www.jisc.ac.uk/blog/new-ukri-policy-is-a-significant-driver-towards-open-access-research-06-aug-2021].

*Moore, Samuel. 2021. «&amp;#8239;What Does the UKRI Policy Mean for Open Access Book Publishing?&amp;#8239;» 9 août 2021. [https://www.samuelmoore.org/2021/08/09/what-does-the-ukri-policy-mean-for-open-access-book-publishing/ https://www.samuelmoore.org/2021/08/09/what-does-the-ukri-policy-mean-for-open-access-book-publishing/].

*O’Grady, Cathleen. 2021. «&amp;#8239;Major U.K. Science Funder to Require Grantees to Make Papers Immediately Free to All&amp;#8239;». ''Science''. 6 août 2021. [https://www.science.org/content/article/major-uk-science-funder-require-grantees-make-papers-immediately-free-all https://www.science.org/content/article/major-uk-science-funder-require-grantees-make-papers-immediately-free-all].

*Oxford University. 2021. «&amp;#8239;Oxford UKRI OA Policy Response&amp;#8239;». 9 août 2021. [http://openaccess.ox.ac.uk/wp-content/uploads/sites/2/2021/08/Oxford-UKRI-OA-policy-response-09-08-21-1.pdf http://openaccess.ox.ac.uk/wp-content/uploads/sites/2/2021/08/Oxford-UKRI-OA-policy-response-09-08-21-1.pdf].

*PLOS. «&amp;#8239;Open Response to ‘Economic Impact of UKRI Open Access Policy’ Report&amp;#8239;». ''The Official PLOS Blog''. 17 mars 2021. [https://theplosblog.plos.org/2021/03/open-response-to-fti-consulting-report/ https://theplosblog.plos.org/2021/03/open-response-to-fti-consulting-report/].

*Publishers Association. 2021. ''The Practical Implications of UKRI’s Proposed Open Access Policy for the UK’s Research Sector''. 23 juin 2021. [https://www.publishers.org.uk/publications/the-practical-implications-of-ukris-proposed-open-access-policy-for-the-uks-research-sector/ https://www.publishers.org.uk/publications/the-practical-implications-of-ukris-proposed-open-access-policy-for-the-uks-research-sector/].

*UKRI. 2021a. «&amp;#8239;UKRI Announces New Open Access Policy&amp;#8239;». UK Research and Innovation [https://www.ukri.org/news/ukri-announces-new-open-access-policy/ https://www.ukri.org/news/ukri-announces-new-open-access-policy/].

*UKRI. 2021b. ''UKRI Open Access Policy''. UK Research and Innovation, [https://www.ukri.org/publications/ukri-open-access-policy/ https://www.ukri.org/publications/ukri-open-access-policy/].

*UKRI. 2021c. «&amp;#8239;UKRI Open Access Policy – Explanation of Policy Changes&amp;#8239;». 6 août 2021. [https://www.ukri.org/wp-content/uploads/2021/08/UKRI-180821-UKRIOpenAccessPolicyExplanationOfChanges-2.pdf https://www.ukri.org/wp-content/uploads/2021/08/UKRI-180821-UKRIOpenAccessPolicyExplanationOfChanges-2.pdf]

*Van Noorden, Richard. «&amp;#8239;Major UK Science Funder Unveils Strict Open-Access Policy&amp;#8239;». ''Nature''. 6 août 2021. [https://doi.org/10.1038/d41586-021-02148-8 https://doi.org/10.1038/d41586-021-02148-8].

*Webster, Carrie. 2021. «&amp;#8239;UKRI’s New Open Access Policy will Hinder Open Science&amp;#8239;». ''Times Higher Ed''. 3 septembre 2021. [https://www.timeshighereducation.com/blog/ukris-new-open-access-policy-will-hinder-open-science https://www.timeshighereducation.com/blog/ukris-new-open-access-policy-will-hinder-open-science].

[[Catégorie:Extension : Observatoire des politiques sur les savoirs ouverts, 2021-2024 (livre)]]</text>
      <sha1>bphpndc373s3wgy0vqh39iwxf8cd0xd</sha1>
    </revision>
  </page>
  <page>
    <title>Extension : Observatoire des politiques sur les savoirs ouverts, 2021-2024/Le mémo Nelson : Une politique d’accès public mis à jour aux États-Unis</title>
    <ns>0</ns>
    <id>82365</id>
    <revision>
      <id>744020</id>
      <parentid>742711</parentid>
      <timestamp>2025-06-02T22:49:08Z</timestamp>
      <contributor>
        <username>LodestarChariot2</username>
        <id>120009</id>
      </contributor>
      <minor />
      <comment>/* Ouvrages cités */</comment>
      <origin>744020</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="39487" sha1="1ae6kudh9ghmlm0es57dzsscetamqkn" xml:space="preserve">''Cette observation a été écrite par Caroline Winter (avec ses remerciements à Leslie Chan et Kate Shuttleworth pour leurs commentaires et contributions), pour le Electronic Textual Cultures Laboratory et le partenariat Implementing New Knowledge Environments.''

Le 25 août 2022, l'Office of Science and Technology Policy (OSTP) des États-Unis a publié un mémo intitulé [https://ospolicyobservatory.uvic.ca/wp-content/uploads/sites/7744/2025/05/08-2022-OSTP-Public-Access-Memo.pdf ''Ensuring free, immediate, and equitable access to federally funded research''] et un [https://ospolicyobservatory.uvic.ca/wp-content/uploads/sites/7744/2025/05/Nelson-Memo-media-release.pdf communiqué de presse] l’accompagnant. Ce mémo, appelé le mémo Nelson parce qu’il a été écrit par Alondra Nelson, en ce temps-là directrice par intérim de l’OSTP, présente les orientations politiques en matière d’accès public (libre accès) pour les agences fédérales américaines qui financent la recherche et le développement. Le rapport de l’OSTP [https://www.whitehouse.gov/wp-content/uploads/2022/08/08-2022-OSTP-Public-Access-Congressional-Report.pdf ''Economic Landscape of Federal Public Access Policy''], aussi publié en août 2022, examine les effets économiques potentiels du libre accès immédiat à la recherche financée par le gouvernement fédéral.

La politique mise à jour a suscité un débat animé au sein de la communauté de la communication savante et au-delà. Cette observation offre un bref résumé des points clés du mémo et un aperçu des premières réponses.

Le mémo Nelson s’appuie sur la politique fédérale américaine de libre accès publiée en 2013 par John Holdren, en ce temps-là directeur de l’OSTP, le [https://obamawhitehouse.archives.gov/sites/default/files/microsites/ostp/ostp_public_access_memo_2013.pdf ''Memorandum on Increasing Access to the Results of Federally Funded Research''], appelé le mémo Holdren. Ce mémo de 2013 demandait que les agences fédérales qui fournissaient plus de 100 millions de dollars par an en financement pour la recherche et le développement créent des plans pour rendre les publications et les données de recherche plus accessibles au public, avec un embargo autorisé de 12 mois.

Deux des changements importants apportés à cette politique mise à jour sont suivants :
* la politique s’applique à tous les organismes de financement fédéraux ;
* les publications doivent être en libre accès dès leur publication, sans embargo.
Le mémo Nelson spécifie que les organismes de financement fédéraux devraient
* Mettre à jour leurs politiques de libre accès pour rendre les publications et les données de la recherche financée accessibles au public dès leur publication ;
* Adopter des procédures transparentes garantissant l’intégrité scientifique de ces politiques ;
* Collaborer avec l’OSTP pour s’assurer que les résultats de la recherche financée, y compris les données, sont diffusés équitablement.

Les agences qui ont élaboré des politiques de libre accès conformément aux directives de 2013 doivent compléter leurs plans mis à jour dans les six mois suivant la publication du mémo Nelson, et d’autres ont un peu moins d’un an pour le faire. Toutes les politiques doivent être publiées au plus tard le 31 décembre 2024 et entrer en vigueur au plus tard le 31 décembre 2025.

Le mémo comprend les dispositions pour les publications examinées par les pairs et pour les données de recherche. Les publications financées par le gouvernement fédéral doivent être en libre accès dès leur publication par défaut, dans un dépôt désigné par des agences, bien que le mémo ne précise pas quelle version de la publication doit être disponible (c’est-à-dire le manuscrit accepté par l’auteur ou la version de l’éditeur). Cette disposition s’applique à tous les articles et peut inclure d’autres publications évaluées par les pairs tels que des actes de colloques, des éditoriaux et des chapitres de livre. Notamment, les plans des agences doivent envisager comment maximiser la diffusion équitable, non seulement par la publication en libre accès, mais aussi par la lisibilité automatique, l’accessibilité et les licences ouvertes.

Les plans d’accès public aux données de recherche doivent inclure des politiques pour la gestion et le partage des données, et les données de recherche associées aux publications doivent être librement et publiquement accessibles par défaut au moment de la publication, soumis aux conditions légales, éthiques, de confidentialité, et autres restrictions similaires. Les coûts associés à la gestion, la conservation et la publication des données peuvent être inclus dans les budgets de recherche.

Le mémo souligne l’importance de l’accès public et ouvert pour le soutien de l’intégrité scientifique et de la recherche et pour le renforcement de la confiance du public dans la recherche financée par le gouvernement fédéral. Il demande aux agences fédérales d’élaborer une politique pour collecter et partager les métadonnées sur les publications et les données de recherche, y compris des identifiants pérenne pour les résultats de la recherche, les chercheurs et les chercheuses, et les subventions fédérales, conformément aux directives afin de réaliser «&amp;#8239;[https://www.whitehouse.gov/wp-content/uploads/2022/01/010422-NSPM-33-Implementation-Guidance.pdf National Security Presidential Memorandum 33 (NSPM-33)]&amp;#8239;», publié par le National Science and Technology Council en janvier 2022. Cette mise à jour de la politique doit être achevée au plus tard le 31 décembre 2026 et entrer en vigueur au plus tard le 31 décembre 2027.

Le mémo aborde également la nécessité de coordonner les plans d’accès public entre les agences fédérales. Il décrit le rôle du National Science and Technology Council’s Subcommittee on Open Science, qui a été créé pour faciliter la coordination des plans et fournir des orientations supplémentaires sur la mise en œuvre des exigences du mémo.

==La politique dans la presse==
La mise à jour de la politique a été un sujet d’intérêt dans la presse universitaire. Un article de [https://www.science.org/content/article/white-house-requires-immediate-public-access-all-u-s--funded-research-papers-2025 ''Science''] note que, bien que la politique utilise le terme d’accès public, il s’agit essentiellement d’une politique du libre accès, le résultat de décennies de discussions sur la nécessité de rendre accessible au public la recherche financée par le secteur public (Brainard et Kaiser 2022). Un article pour [https://www.insidehighered.com/news/2022/09/12/wholl-pay-public-access-federally-funded-research ''Inside Higher Ed''] note également que cette mise à jour de la politique était en développement depuis près d’une décennie sous les administrations de Barack Obama et de Donald Trump, mais elle a en même temps rencontré l’opposition de la communauté des éditeurs, en particulier à l’élimination de l’embargo (D’Agostino et Lederman 2022).

Un article dans [https://www.chronicle.com/article/a-historic-moment-new-guidance-requires-federally-funded-research-to-be-open-access ''The Chronicle''] offre un aperçu des réponses à la mise à jour de la politique des avocats du libre accès, qui y sont généralement fortement favorables, et de l’industrie de l’édition, qui a exprimé des réserves sur la manière dont la politique sera mise en œuvre (Zahneis 2022). ''The Scholarly Kitchen'' a également publié plusieurs articles sur ce sujet dans les semaines qui ont suivi la publication du mémo, y compris les réponses de leur équipe ([https://scholarlykitchen.sspnet.org/2022/08/30/ask-the-chefs-ostp-policy-i/ partie 1] et [https://scholarlykitchen.sspnet.org/2022/08/31/ask-the-chefs-ostp-policy-ii/ partie 2]), un article [https://scholarlykitchen.sspnet.org/2022/09/13/guest-post-quantifying-the-impact-of-the-ostp-policy/ quantifiant l’impact de la politique], un [https://scholarlykitchen.sspnet.org/2022/10/03/the-new-ostp-memo-a-roundup-of-reactions-and-an-interview-preview/?informz=1&amp;nbd=e7acf065-7b8f-4940-9c2f-ebcb1b99d33d&amp;nbd_source=informz résumé de nombreuses réponses et réactions] au mémo, une [https://scholarlykitchen.sspnet.org/2022/10/11/new-light-on-the-new-ostp-memo-an-interview-with-dr-alondra-nelson/ entrevue avec Nelson], et quelques [https://scholarlykitchen.sspnet.org/2022/10/13/thoughts-and-observations-on-the-ostp-responses-to-our-interview-questions/ réflexions sur cette entrevue]. ''Library Journal'' ''InfoDocket'' a également publié un [https://www.infodocket.com/2022/08/25/white-house-office-of-science-and-technology-policy-ostp-issues-new-guidance-to-ensure-free-immediate-and-equitable-access-to-federally-funded-research/ résumé des réponses communautaire] à la fin du mois d’août.

La publication de la politique a également été couverte par le[https://www.goodnewsnetwork.org/white-house-bans-paywalls-on-taxpayer-funded-research/  ''Good News Network''], le[https://www.natlawreview.com/article/all-federal-research-agencies-to-update-public-access-policies  ''National Law Review''], le[https://www.nytimes.com/2022/08/25/us/white-house-federally-funded-research-access.html  ''New York Times''],[https://www.publishersweekly.com/pw/by-topic/international/Frankfurt-Book-Fair/article/90593-frankfurt-spotlight-u-s-to-require-open-access-by-2025.html  ''Publishers Weekly''], le[https://www.theregister.com/2022/08/25/science_research_release/  ''Register''] et[https://www.researchinformation.info/news/new-ostp-policy-federally-funded-research '' Research Information''], et le podcast[https://www.sciencefriday.com/segments/public-access-science-biden/  ''Science Friday''], entre autres.

==Réponses du partenariat INKE==
Un [https://www.lib.sfu.ca/help/publish/scholarly-publishing/radical-access/ostp-nelson-memo-open-access article de blog] de la Bibliothèque de l’Université Simon Fraser, un des partenaires d’INKE, place la politique mise à jour à côté de [https://www.lib.sfu.ca/help/publish/scholarly-publishing/open-access/open-access-policy la politique libre accès de l’université], qui exige le dépôt du texte finalisé de toutes les publications par l’auteur de l’université dans son entrepôt institutionnel, et d’autres politiques nationales et internationales du libre accès (Liuta 2022). Il s’agit notamment du Plan S et de [https://science.gc.ca/site/science/fr/financement-interorganismes-recherche/politiques-lignes-directrices/libre-acces/politique-trois-organismes-libre-acces-aux-publications?OpenDocument= la Politique des trois organismes sur le libre accès aux publications] du Canada de 2015, qui exige que des articles de revues financés par [https://cihr-irsc.gc.ca/f/193.html les Instituts de recherche en santé du Canada (IRSC)], [https://www.nserc-crsng.gc.ca/index_fra.asp le Conseil de recherches en sciences naturelles et en génie du Canada (CRSNG)] et [https://www.sshrc-crsh.gc.ca/home-accueil-fra.aspx le Conseil de recherches en sciences humaines (CRSH)] soient librement accessible dans les 12 mois suivant la publication (voir «&amp;#8239;[[Observations fondamentales : Observatoire des politiques sur les savoirs ouverts, 2017-2020/Politique des trois organismes sur le libre accès aux publications|Politique des trois organismes sur le libre accès aux publications]]&amp;#8239;»]).

Le [https://pkp.sfu.ca/2022/08/29/embargo-no-more/ Public Knowledge Project (PKP)], un des partenaires d’INKE, a exprimé son soutien à la mise à jour de la politique et à ses effets sur l’accès et la qualité de la recherche. En particulier, il salue l’accent mis par la politique sur la transparence et l’importance de la confiance du public (Racy 2022), notant qu’elle s’aligne sur le projet [https://docs.google.com/document/d/1AvIElSv6JYfdsOIiy15Cyvzdg3ENgOwCtkQIB39RCHY/edit Publication Facts Label] du PKP, actuellement en cours.

[https://oaaustralasia.org/2022/08/31/open-access-australasia-comment-on-us-white-house-ostp-public-access-guidance/ Open Access Australasia], un des partenaires d’INKE via le [https://inke.ca/canadian-australian-partnership-for-open-scholarship/ Canada–Australia Partnership for Open Scholarship (CAPOS)], a également exprimé son soutien à la mise à jour de la politique, déclarant que la politique est un facteur crucial dans le passage au libre accès et soulignant les changements provoqués par les politiques RCUK et cOAlition S ( 2022 ; voir «&amp;#8239;[[Observations fondamentales : Observatoire des politiques sur les savoirs ouverts, 2017-2020/Examen et consultation de la politique de L’UKRI sur libre accès|Examen et consultation de la politique de l’UKRI sur libre accès]]&amp;#8239;» et «&amp;#8239;[[Extension : Observatoire des politiques sur les savoirs ouverts, 2021-2024/La Politique de libre accès du l’UKRI 2021|La politique de libre accès du l’UKRI 2021]]&amp;#8239;»). Cette déclaration exprime également l’espoir que la politique conduira à une plus grande diversité de modèles et d’approches du libre accès qui reflètent mieux la diversité de la communauté de la recherche.

==Réponses de la communauté élargie==
La communauté élargie a exprimé un appui solide pour le mémo Nelson ainsi que plusieurs préoccupations, mais elle semble unie en pensant que la politique est un tournant pour le libre accès. [https://www.aip.org/fyi/2022/white-house-moves-make-federally-funded-research-free-upon-publication L'American Institute of Physics], par exemple, affirme qu’elle marque un changement tectonique dans le domaine de l’édition scientifique (2022), et [https://www.arl.org/news/arl-celebrates-biden-harris-administrations-historic-policy-to-make-federally-funded-research-immediately-available/ l’Association of Research Libraries] la décrit comme un moment historique pour les communications scientifiques (2022).

SPARC a exprimé son appui fort pour la politique dans son [https://sparcopen.org/news/2022/taxpayers-to-get-immediate-access-to-publicly-funded-research/ communiqué de presse] ainsi que dans une [https://sparcopen.org/our-work/2022-updated-ostp-policy-guidance/fact-sheet-white-house-ostp-memo-on-ensuring-free-immediate-and-equitable-access-to-federally-funded-research/ fiche d’information]. Les déclarations des [https://www.nih.gov/about-nih/who-we-are/nih-director/statements/statement-nih-plans-speed-access-federally-funded-research-results National Institutes of Health] et de la [https://www.nlm.nih.gov/news/Expediting_Access_To_Results_Of_Federally_Funded_Research.html National Library of Medicine] expriment leur empressement de mettre en œuvre la politique, mais certaines parties prenantes, en particulier, [https://www.aaas.org/news/aaas-statement-ostp-federally-funded-research-guidance l’'American Association for the Advancement of Science (AAAS)], [https://www.aip.org/fyi/2022/white-house-moves-make-federally-funded-research-free-upon-publication l’'American Institute of Physics] et [https://www.aau.edu/newsroom/press-releases/aau-statement-ostp-decision-make-federally-funded-research-publicly l'Association of American Universities], ont exprimé l’incertitude quant à la question du comment cela serait fait. .

Les parties prenantes ont également exprimé plusieurs préoccupations concernant la politique et ses effets potentiels. Certaines de ces préoccupations ont été liées au manque apparent de consultation des parties prenantes, ce qui a été souligné, entre autres,  par [https://publishers.org/news/statement-from-shelley-husband-senior-vice-president-government-affairs-association-of-american-publishers-on-decision-by-white-house-office-of-science-and-technology-policy-to-make-private-se/ l'Association of American Publishers] (Husband 2022 ; Michael, Vines et al. 2022). Bien qu’un bon nombre des éditeurs universitaires principaux n’aient pas publié de déclarations sur la politique, [https://newsroom.taylorandfrancisgroup.com/ostp-memorandum/ Taylor &amp; Francis] a exprimé son appui tout en reconnaissant les défis de la mise en œuvre.

Une autre préoccupation est le fait que le mémo présente des recommandations plutôt que des directives, et il n’est pas clair quelles seront les conséquences en cas de non-conformité (Anderson 2022 ; Anderson et Wulf 2022).

Les préoccupations principales sont liées à sa mise en œuvre, y compris plusieurs concernant le financement. Bien que certains éditeurs en libre accès, tels que [https://theplosblog.plos.org/2022/09/plos-cheers-the-ostp-memorandum/ PLOS] et [https://blog.frontiersin.org/2022/08/29/white-house-announces-new-policy-to-drop-paywalls-around-publicly-funded-research/ Frontiers], aient exprimé leur appui pour la politique mise à jour, d’autres membres du milieu de l’édition ont exprimé des préoccupations au sujet de l’impact de l’élimination de l’embargo sur leur viabilité financière.

Le mémo ne décrit pas de modèle d’entreprise particulier, permettant aux agences de décider des meilleurs modèles pour leurs communautés. Cependant, les modèles d’entreprise d’abonnement seront probablement intenables pour la plupart des éditeurs sans embargo. La rapidité de ce changement dépendra en partie des décisions politiques des agences, telles que la version d’une publication dont elles ont besoin pour être en libre accès lors de la publication et la restriction à laquelle une licence doit être appliquée (Clark et Esposito).

Le mémo ne promet pas de financement supplémentaire pour le soutien de la politique mise à jour, bien qu’il mentionne que les coûts associés peuvent être inclus dans les budgets de recherche. On ne sait pas quels seront les coûts de mise en œuvre de la politique, comment ils seront payés et par qui. Ceci est vrai pour les publications et pour les données de recherche, qui nécessiteront beaucoup d’infrastructures et un soutien financier important à long terme (voir Clark et Esposito ; Michael, Carpenter et al. 2022). La réponse du [https://datacurationnetwork.org/2022/09/06/dcn-is-ready-to-support-policies-resulting-from-ostp-public-access-memo%25EF%25BF%25BC/ Data Curation Network] à la mise à jour de la politique met en évidence le rôle clé que les dépôts institutionnels joueront dans la fourniture de l’infrastructure nécessaire à sa mise en œuvre. Une déclaration de [https://www.asbmb.org/advocacy/position-statements/asbmb-statement-on-ostp-memo l’American Society for Biochemistry and Molecular Biology] souligne que le financement de la recherche n’a pas suivi le rythme du coût croissant de la recherche et de la publication et appelle l’OSTP et les décideurs politiques à relever ce défi. Certains ont également remis en cause l’exhaustivité et la validité du rapport économique qui a éclairé cette politique (par exemple, D’Agostino 2022 ; Michael, Vines et al. 2022 ; White 2022).

Certaines parties prenantes s’inquiètent des effets potentiels de la politique sur l’équité dans le domaine de l’édition savante. Bien que la politique ne promette pas de financement supplémentaire et n’impose pas d’approche ou de modèle spécifique pour libre accès, elle stipule que les agences fédérales devraient permettre l’inclusion des coûts de publication raisonnables dans les budgets de recherches, en consultation avec l’Office of Mangaement and Budget. Les parties prenantes sont concernées donc que le libre accès sera financé principalement par les frais de publication des articles et que les coûts de gestion des données soient également répercutés sur les auteurs (Clark et Esposito 2022 ; Pooley 2022). Notant qu’une dépendance croissante aux frais de publication est probable, Jefferson Pooley souligne que libre accès soutenu financièrement de cette manière est déjà la norme aux États-Unis, surtout la publication dans les revues hybrides et les accords de lecture et de publication et d’autres accords transformatifs (voir «&amp;#8239;[[Extension : Observatoire des politiques sur les savoirs ouverts, 2021-2024/Les accords de libre accès|Les accords de libre accès]]&amp;#8239;»). Il demande des mesures pour atténuer les effets qui en résultent, comme le soutien à des modèles alternatifs et des plafonds sur les frais de publication. Une déclaration de [https://subscribetoopencommunity.org/ la communauté de pratique Subscribe to Open] soutient la politique et demande une multiplicité d’approches pour atteindre ses objectifs (2022).

Les bibliothèques de l’University of California décrivent la politique comme soutenant ses efforts afin de faire progresser le libre accès, suggérant que la politique pourrait inciter les éditeurs à abandonner le modèle d’abonnement payant et à développer des modèles d’entreprise entièrement différents conçus pour le libre accès (2022 ; voir «&amp;#8239;[[Observations fondamentales : Observatoire des politiques sur les savoirs ouverts, 2017-2020/La rupture entre Elsevier et l'University of California|La rupture entre Elsevier et l’University of California]]&amp;#8239;»). Il est également noté que toute augmentation des coûts pour les grands instituts de recherche en raison de l’élargissement de la lecture et de la publication ou de modèles similaires pourrait être compensée par les contributions des chercheurs et des chercheuses incluses dans les propositions de financement (2022). [https://scholarlykitchen.sspnet.org/2022/09/27/academia-zero-embargo/ Roger Schonfeld] note que certains éditeurs miseront sur la valeur qu’ils offrent en fournissant une version de record, citant en exemple [https://www.science.org/journal/science ''Science''], publié par l’AAAS, qui a annoncé [https://www.science.org/doi/10.1126/science.ade8028 une politique de libre accès verte] en réponse au mémo Nelson et en opposition à l’exclusion des tendances du libre accès basées sur les frais de publication.

Si le modèle «&amp;#8239;payer pour publier&amp;#8239;» devient plus établi, cependant, une conséquence serait de rendre la publication moins accessible aux chercheurs et chercheuses sans financement ou avec un financement insuffisant, y compris ceux et celles qui sont en début de leur carrière, qui viennent des plus petites institutions et qui font partie des disciplines avec moins de financement, y compris les sciences humaines. Une lettre ouverte à l’OSTP coordonnée par [https://neuromatch.io/ Neuromatch] avec plus de 1300 signatures souligne cette préoccupation, indiquant que la politique peut améliorer l’accès équitable mais rendre la participation à la recherche moins équitable, avec des conséquences graves pour le progrès de la recherche.

[https://www.arl.org/news/arl-celebrates-biden-harris-administrations-historic-policy-to-make-federally-funded-research-immediately-available/ L’Association of Research Libraries], cependant, fait l’éloge de la politique comme de celle qui fait progresser l’équité pour les personnes issues des milieux défavorisés et pour les chercheurs et chercheuses en début de leur carrière ainsi que comme de celle qui garantit que les résultats sont accessibles aux personnes handicapées (Aiwuyor 2022). Il souligne aussi l’accent mis par la politique sur l’harmonisation des politiques entre les agences afin de réduire la pression sur des bibliothèques de recherche. Un article du [https://www.libraryjournal.com/story/technology/white-house-make-public-access-to-research-immediate ''Library Journal''] souligne de la même manière l’objectif de la politique d’améliorer l’équité (Peet 2022).

==Le mémo Nelson et la science ouverte==
Le mémo Nelson contextualise ses mises à jour de politique dans le cadre de la transition généralisée vers libre accès pour la recherche sur le COVID-19 (voir «&amp;#8239;[[Observations fondamentales : Observatoire des politiques sur les savoirs ouverts, 2017-2020/Science Ouverte et COVID-19|Science ouverte et COVID-19]]&amp;#8239;»). Il note qu’à la suite de cette crise de santé publique, le gouvernement, l’industrie et les chercheurs et chercheuses ont travaillé ensemble volontairement pour adopter une politique d’accès public immédiat, ce qui a donné des conséquences formidables. Ces conséquences sont les suivantes : la recherche et les données ont circulé efficacement et des résultats accessibles ont accéléré la vitesse de la découverte et de la mise en pratique. Il indique également que le libre accès est aligné sur les valeurs américaines fondamentales d’égalité des chances et que rendre la science publique aidera les États-Unis à devenir un leader mondial de la science ouverte. Bien qu’une mise à jour de la politique de 2013 ait été rédigée en 2018, l’élan du mouvement libre accès à cause du COVID-19 a contribué au timing de la publication du mémo Nelson; l’émergence du virus monkeypox et l’intérêt personnel du président américain Biden pour l’accès publique peuvent également être des facteurs contributifs (Najokaitytė et Hudson 2022 ; Nelson 2022). L’accent mis par le mémo sur l’équité et la nécessité d’augmenter la confiance du public dans la science reflètent également les valeurs professionnelles de Nelson. Nelson est professeure de sociologie à l’Université de Columbia et présidente du [https://www.ssrc.org/staff/nelson-alondra/ Social Science Research Council], et ses recherches examinent les intersections entre les inégalités sociales et la science et la technologie.

Comme l’ont noté [https://sparcopen.org/news/2022/taxpayers-to-get-immediate-access-to-publicly-funded-research/ SPARC], [https://www.coalition-s.org/coalition-s-welcomes-the-updated-open-access-policy-guidance-from-the-white-house-office-of-science-technology-and-policy/ la cOAlition S] et [https://creativecommons.org/2022/08/26/a-big-win-for-open-access/ Creative Commons], la disposition de la politique qui élimine l’embargo s’aligne dans une certaine mesure sur les politiques internationales de libre accès telles que [https://www.coalition-s.org/ le Plan S] et la [https://unesdoc.unesco.org/ark:/48223/pf0000379949_fre Recommandation de l’UNESCO sur une science ouverte] (voir «&amp;#8239;[[Observations fondamentales : Observatoire des politiques sur les savoirs ouverts, 2017-2020/Plan S et cOAlition S|Plan S et cOAlition S]]&amp;#8239;», «&amp;#8239;[[Observations fondamentales : Observatoire des politiques sur les savoirs ouverts, 2017-2020/Mise à jour du Plan S : La Stratégie de conservation des droits|Mise à jour du Plan S : La stratégie de conservation des droits]]&amp;#8239;», «&amp;#8239;[[Extension : Observatoire des politiques sur les savoirs ouverts, 2021-2024/Mise à jour du Plan S : L’élargissement de l’adhésion de la cOAlition S|Mise à jour du Plan S : L’élargissement de l’adhésion de la cOAlition S]]&amp;#8239;» et «&amp;#8239;[[Observations fondamentales : Observatoire des politiques sur les savoirs ouverts, 2017-2020/La Recommandation de l’UNESCO sur la science ouverte|La recommandation de l’UNESCO sur la science ouverte]]&amp;#8239;»). Cependant, contrairement au Plan S, le mémo Nelson n’exclut pas les revues hybrides ni ne demande que le droit d’auteur reste aux auteurs (Clark et Esposito 2022). La déclaration de [https://creativecommons.org/2022/08/26/a-big-win-for-open-access/ Creative Commons] célèbre la politique mais appelle à un soutien supplémentaire pour les licences ouvertes et les infrastructures ouvertes dirigées par la communauté (Green 2022).

La politique mise à jour s’applique à toutes les recherches financées par le gouvernement fédéral, y compris les organismes de financement des sciences humaines et sociales qui ont été exclus de la politique de 2013, tels que [https://www.arts.gov/ le National Endowment for the Arts] et [https://www.neh.gov/ le National Endowment for the Humanities]. Le mémo Nelson, cependant, ne fait pas référence aux sciences humaines spécifiquement, contrairement au Plan S et à la Recommandation de l’UNESCO (cOAlition S, s.d. ; UNESCO 2020). Malgré cela, Karin Wulf note que la politique mise à jour renforcera la science ouverte en sciences humaines, ce qui, selon elle, est désespérément nécessaire à notre époque historique actuelle (Michael, Carpenter et al. 2022).

L’OSTP a estimé que le financement fédéral américain a soutenu 195 000 à 263 000 articles en 2020, ce qui représente environ 7 à 9 % des articles publiés dans le monde (Brainard et Kaiser 2022). La façon dont les agences mettront en œuvre la politique mise à jour déterminera dans une large mesure son effet sur les auteurs, les éditeurs et l’écosystème de l’édition dans son ensemble. Bien que le mémo Nelson présente une politique nationale de libre accès aux États-Unis, la taille pure de l’effort d’édition savante aux États-Unis signifie que les effets du mémo Nelson seront sûrement répandus, notamment en contribuant à l’élan du mouvement libre accès dans le monde entier.

==Ouvrages cités==
*Aiwuyor, Jessica. s.d. «&amp;#8239;ARL Celebrates Biden-Harris Administration’s Historic Policy to Make Federally Funded Research Immediately Available&amp;#8239;». Association of Research Libraries. Le 20 octobre 2022. [https://www.arl.org/news/arl-celebrates-biden-harris-administrations-historic-policy-to-make-federally-funded-research-immediately-available/ https://www.arl.org/news/arl-celebrates-biden-harris-administrations-historic-policy-to-make-federally-funded-research-immediately-available/].

*American Institute of Physics. 2022. «&amp;#8239;White House Moves to Make Federally Funded Research Free Upon Publication&amp;#8239;». American Institute of Physics. Le 30 août 2022. [https://www.aip.org/fyi/2022/white-house-moves-make-federally-funded-research-free-upon-publication https://www.aip.org/fyi/2022/white-house-moves-make-federally-funded-research-free-upon-publication].

*Anderson, Rick. 2022. «&amp;#8239;A New OSTP Memo: Some Initial Observations and Questions&amp;#8239;». ''The Scholarly Kitchen''. Le 29 août 2022. [https://scholarlykitchen.sspnet.org/2022/08/29/a-new-ostp-memo-some-initial-observations-and-questions/ https://scholarlykitchen.sspnet.org/2022/08/29/a-new-ostp-memo-some-initial-observations-and-questions/].

*Anderson, Rick, et Karin Wulf. 2022. «&amp;#8239;Thoughts and Observations on the OSTP Responses to Our Interview Questions&amp;#8239;». ''The Scholarly Kitchen''. Le 13 octobre 2022. [https://scholarlykitchen.sspnet.org/2022/10/13/thoughts-and-observations-on-the-ostp-responses-to-our-interview-questions/ https://scholarlykitchen.sspnet.org/2022/10/13/thoughts-and-observations-on-the-ostp-responses-to-our-interview-questions/].

*Brainard, Jeffrey, et Jocelyn Kaiser. «&amp;#8239;White House Requires Immediate Public Access to All U.S.-Funded Research Papers by 2025&amp;#8239;». ''Science'', le 26 août 2022. [https://www.science.org/content/article/white-house-requires-immediate-public-access-all-u-s--funded-research-papers-2025 https://www.science.org/content/article/white-house-requires-immediate-public-access-all-u-s--funded-research-papers-2025].

*Clark and Esposito. «&amp;#8239;Zero Embargo&amp;#8239;». ''The Brief'', le 29 août 2022. [https://www.ce-strategy.com/the-brief/zero-embargo/ https://www.ce-strategy.com/the-brief/zero-embargo/].

*cOAlition S. s.d. «&amp;#8239;Why Plan S&amp;#8239;». Consulté le 20 octobre 2022. [https://www.coalition-s.org/why-plan-s/ https://www.coalition-s.org/why-plan-s/].

*D’Agostino, Susan. 2022. «&amp;#8239;Who’ll Pay for Public Access to Federally Funded Research?&amp;#8239;» ''Inside Higher Ed''. Le 12 septembre 2022. [https://www.insidehighered.com/news/2022/09/12/wholl-pay-public-access-federally-funded-research https://www.insidehighered.com/news/2022/09/12/wholl-pay-public-access-federally-funded-research].

*D’Agostino, Susan, et Doug Lederman. «&amp;#8239;No Paywall for Taxpayer-Funded Research, U.S. Declares&amp;#8239;». ''Inside Higher Ed'', le 26 août 2022. [https://www.insidehighered.com/news/2022/08/26/us-mandates-immediate-public-access-taxpayer-funded-research https://www.insidehighered.com/news/2022/08/26/us-mandates-immediate-public-access-taxpayer-funded-research].

*Green, Cable. 2022. «&amp;#8239;A Big Win for Open Access: United States Mandates All Publicly Funded Research Be Freely Available with No Embargo&amp;#8239;». ''Creative Commons''. Le 26 août 2022. [https://creativecommons.org/2022/08/26/a-big-win-for-open-access/ https://creativecommons.org/2022/08/26/a-big-win-for-open-access/].

*Holdren, John P. 2013. «&amp;#8239;Increasing Access to the Results of Federally Funded Scientific Research&amp;#8239;». Office of Science and Technology Policy. [https://obamawhitehouse.archives.gov/sites/default/files/microsites/ostp/ostp_public_access_memo_2013.pdf https://obamawhitehouse.archives.gov/sites/default/files/microsites/ostp/ostp_public_access_memo_2013.pdf].

*Husband, Shelley. 2022. «&amp;#8239;Statement from Shelley Husband, Senior Vice President, Government Affairs, AAP, on Decision by The White House Office of Science and Technology Policy to Make Private Sector Publications Freely Available&amp;#8239;». ''Association of American Publishers''. Le 25 août 2022. [https://publishers.org/news/statement-from-shelley-husband-senior-vice-president-government-affairs-association-of-american-publishers-on-decision-by-white-house-office-of-science-and-technology-policy-to-make-private-se/ https://publishers.org/news/statement-from-shelley-husband-senior-vice-president-government-affairs-association-of-american-publishers-on-decision-by-white-house-office-of-science-and-technology-policy-to-make-private-se/].

*Liuta, Ioana. 2022. «&amp;#8239;Important Milestone in the Open Access Movement: Immediate Open Access by 2026, in the US&amp;#8239;». ''Radical Access''. Le 28 octobre 2022. [https://www.lib.sfu.ca/help/publish/scholarly-publishing/radical-access/ostp-nelson-memo-open-access https://www.lib.sfu.ca/help/publish/scholarly-publishing/radical-access/ostp-nelson-memo-open-access].

*Michael, Ann, et al. «&amp;#8239;Ask The Chefs: OSTP Policy Part I&amp;#8239;». ''The Scholarly Kitchen'', le 30 août 2022. [https://scholarlykitchen.sspnet.org/2022/08/30/ask-the-chefs-ostp-policy-i/ https://scholarlykitchen.sspnet.org/2022/08/30/ask-the-chefs-ostp-policy-i/].

*Michael, Ann, et al. 2022. «&amp;#8239;Ask The Chefs: OSTP Policy Part II&amp;#8239;». ''The Scholarly Kitchen''. Le 31 août 2022. [https://scholarlykitchen.sspnet.org/2022/08/31/ask-the-chefs-ostp-policy-ii/ https://scholarlykitchen.sspnet.org/2022/08/31/ask-the-chefs-ostp-policy-ii/].

*Naujokaitytė, Goda, et Richard L. Hudson. s.d. «&amp;#8239;Washington Gives a Big Boost to Drive for Open-Access Scientific Publishing&amp;#8239;». ''Science|Business''. Le 13 octobre 2022. [https://sciencebusiness.net/news/washington-gives-big-boost-drive-open-access-scientific-publishing https://sciencebusiness.net/news/washington-gives-big-boost-drive-open-access-scientific-publishing].

*Nelson, Alondra. 2022. «&amp;#8239;Ensuring Free, Immediate, and Equitable Access to Federally Funded Research&amp;#8239;». Office of Science and Technology Policy. [https://www.whitehouse.gov/wp-content/uploads/2022/08/08-2022-OSTP-Public-Access-Memo.pdf https://www.whitehouse.gov/wp-content/uploads/2022/08/08-2022-OSTP-Public-Access-Memo.pdf].

*Open Access Australasia. «&amp;#8239;Open Access Australasia Comment on US White House OSTP Public Access Guidance&amp;#8239;». Open Access Australasia, le 31 août 2022. [https://oaaustralasia.org/2022/08/31/open-access-australasia-comment-on-us-white-house-ostp-public-access-guidance https://oaaustralasia.org/2022/08/31/open-access-australasia-comment-on-us-white-house-ostp-public-access-guidance].

*«&amp;#8239;Open Letter to the WHOSTP and Subcommittee on Open Science&amp;#8239;». s.d. Consulté le 18 octobre 2022. [https://ostp-letter.github.io https://ostp-letter.github.io].

*Peet, Lisa. 2022. «&amp;#8239;White House: Make Public Access to Research Immediate&amp;#8239;». ''Library Journal'', le 26 septembre 2022. [https://www.libraryjournal.com/story/technology/white-house-make-public-access-to-research-immediate https://www.libraryjournal.com/story/technology/white-house-make-public-access-to-research-immediate].

*Pooley, Jefferson. «&amp;#8239;The APC Question Mark Hovering over the OSTP Announcement&amp;#8239;». ''LSE Blog'', le 2 septembre 2022. [https://blogs.lse.ac.uk/impactofsocialsciences/2022/09/02/the-apc-question-mark-hovering-over-the-ostp-announcement/ https://blogs.lse.ac.uk/impactofsocialsciences/2022/09/02/the-apc-question-mark-hovering-over-the-ostp-announcement/].

*Racy, Famira. «&amp;#8239;Embargo No More!&amp;#8239;» Public Knowledge Project, le 29 août 2022. [https://pkp.sfu.ca/2022/08/29/embargo-no-more/ https://pkp.sfu.ca/2022/08/29/embargo-no-more/].

*Schonfeld, Roger C. 2022. «&amp;#8239;How Will Academia Handle the Zero Embargo?&amp;#8239;» ''The Scholarly Kitchen''. Le 27 septembre 2022. [https://scholarlykitchen.sspnet.org/2022/09/27/academia-zero-embargo/ https://scholarlykitchen.sspnet.org/2022/09/27/academia-zero-embargo/].

*Subscribe to Open Community of Practice. «&amp;#8239;Subscribe-to-Open Community of Practice Statement on the OSTP ‘Nelson Memo’&amp;#8239;». SPARC, le 16 septembre 2022. [https://sparcopen.org/news/2022/subscribe-to-open-community-of-practice-statement-on-the-ostp-nelson-memo/ https://sparcopen.org/news/2022/subscribe-to-open-community-of-practice-statement-on-the-ostp-nelson-memo/].

*UNESCO. 2020. «&amp;#8239;Recommandation de l’UNESCO sur une science ouverte&amp;#8239;». [https://unesdoc.unesco.org/ark:/48223/pf0000379949_fre https://unesdoc.unesco.org/ark:/48223/pf0000379949_fre.]

*University of California, Office of Scholarly Communication. 2022. «&amp;#8239;‘Wind in Our Sails’: University of California Hails White House Guidance Accelerating Public Access to Federally Funded Research&amp;#8239;». ''University of California, Office of Scholarly Communication''. Le 26 août 2022. [https://osc.universityofcalifornia.edu/2022/08/wind-in-our-sails-university-of-california-hails-white-house-ostp-guidance/ https://osc.universityofcalifornia.edu/2022/08/wind-in-our-sails-university-of-california-hails-white-house-ostp-guidance/].

*White, Meg. «&amp;#8239;The Nelson Memo: More Questions than Answers&amp;#8239;». ''Charleston Hub'', le 6 septembre 2022.[https://www.charleston-hub.com/2022/09/the-nelson-memo-more-questions-than-answers/  https://www.charleston-hub.com/2022/09/the-nelson-memo-more-questions-than-answers/].

*Zahneis, Megan. «&amp;#8239;‘A Historic Moment’: New Guidance Requires Federally Funded Research to Be Open Access&amp;#8239;». ''The Chronicle of Higher Education'', le 25 août 2022. [https://www.chronicle.com/article/a-historic-moment-new-guidance-requires-federally-funded-research-to-be-open-access https://www.chronicle.com/article/a-historic-moment-new-guidance-requires-federally-funded-research-to-be-open-access].

[[Catégorie:Extension : Observatoire des politiques sur les savoirs ouverts, 2021-2024 (livre)]]</text>
      <sha1>1ae6kudh9ghmlm0es57dzsscetamqkn</sha1>
    </revision>
  </page>
  <page>
    <title>Extension : Observatoire des politiques sur les savoirs ouverts, 2021-2024/La Semaine internationale du libre accès 2022, le 24–30 octobre</title>
    <ns>0</ns>
    <id>82367</id>
    <revision>
      <id>744021</id>
      <parentid>742534</parentid>
      <timestamp>2025-06-02T22:54:51Z</timestamp>
      <contributor>
        <username>LodestarChariot2</username>
        <id>120009</id>
      </contributor>
      <minor />
      <comment>/* Ouvrage cité */</comment>
      <origin>744021</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="11291" sha1="m9mqjwzsf1lyzcdgcuhg83ocas1jbgg" xml:space="preserve">''Cette observation a été écrite par Caroline Winter (avec remerciements à Virginia Barbour pour ses commentaires et contributions), pour le Electronic Textual Cultures Laboratory et le partenariat Implementing New Knowledge Environments.''

La 15e [https://www.openaccessweek.org/ Semaine internationale du libre accès] s’est déroulée du 24 au 30 octobre. Le thème de cette année était « Ouvert à la justice climatique », reconnaissant que les effets généralisés du changement climatique sont vécus différemment par différents groupes de personnes. Une des façons dont cette injustice se manifeste est à travers les niveaux inéquitables d’accès aux connaissances et à l’information sur le changement climatique, alors le libre accès « peut créer des voies vers un partage plus équitable des connaissances et servir de moyen de lutte contre les inégalités qui conditionnent les impacts du changement climatique et notre réponse à ces derniers » (« Semaine » 2022).

La Semaine internationale du libre accès est une initiative de [https://sparcopen.org/ SPARC] et du [https://www.openaccessweek.org/about Comité consultatif de la Semaine du libre accès]. C’est l’occasion pour les communautés de recherche et du monde entier d’organiser des événements sous une bannière commune et d’attirer l’attention du public sur le libre accès. Cette année, des événements en personne, virtuels et hybrides, allant des ateliers et des conférences publiques à des projections de films et des cours de formation, ont eu lieu.

==Semaine internationale du libre accès dans la presse==
La Semaine internationale du libre accès n’a pas été largement couverte par la presse. Cependant, le site Web technologique [https://www.hpcwire.com/off-the-wire/cern-to-host-open-access-week-event-oct-24-28/ ''HPCwire''] a mentionné [https://indico.cern.ch/event/1179488/ les événements organisés par le Scientific Information Service du CERN], qui comprenaient une série de discussions en ligne qui a été enregistrée et peut être visionnée en ligne. [https://www.researchinformation.info/interview/us-every-week-open-access-week ''Research Information''] a également publié une entrevue avec le directeur de la publication d’Oxford University Press, Rhodri Jackson, qui s’est concentrée sur ses événements de la Semaine du libre accès et sur les initiatives du libre accès de l’éditeur. En outre, [https://asiapacificreport.nz/2022/10/26/fiji-academic-warns-over-media-climate-injustice-in-open-access-webinar/ ''Asia Pacific Report''] a mentionné un panel de médias sur l’injustice climatique qui faisait partie de l’agenda [https://oaaustralasia.org/events/open-access-week-2022/ d’Open Access Australasia pour la Semaine du libre accès].

==La Semaine internationale du libre accès et le Partenariat INKE==
Plusieurs membres du Partenariat INKE ont organisé des célébrations. La [https://www.lib.sfu.ca/help/publish/scholarly-publishing/open-access/open-access-week bibliothèque de l’Université Simon Fraser] a organisé une série d’ateliers, une exposition des affiches et des tableaux ainsi qu’une collection sur la justice climatique dans son dépôt institutionnel.

Le [https://pkp.sfu.ca/2022/10/20/celebrating-open-access-week-open-for-climate-justice/ Public Knowledge Project] a célébré avec une collection de recherche liée au climat, comprenant des revues ouvertes et des articles publiés avec son logiciel [https://pkp.sfu.ca/ojs/ Open Journal Systems].

[https://oaaustralasia.org/events/open-access-week-2022/ Open Access Australasia,] un partenaire de l’INKE via le [https://inke.ca/canadian-australian-partnership-for-open-scholarship/ Canadian–Australian Partnership for Open Scholarship (CAPOS),] a organisé un programme d’événements comprenant des tables rondes et un « hackathon » collaboratif dont le but était de développer un guide ouvert des ressources sur la justice climatique pour les enseignants. Les enregistrements de tous les webinaires sont disponibles pour visionnement.

Selon Virginia Barbour, directrice d’Open Access Australasia, un des objectifs principaux des événements de la semaine en Australie et en Nouvelle-Zélande était l’inclusion des chercheurs et chercheuses, des journalistes et des militants et militantes du climat de la région Pacifique, où, bien sûr, les effets du changement climatique se font sentir le plus intensément. Les membres de la communauté de recherche du Pacifique ont souligné toutes sortes des inégalités en ce qui concerne la recherche : non seulement le manque d’accès à la recherche, mais aussi les obstacles à la publication de la recherche en raison du coût et, enfin, le manque de la consultation et du partage de la recherche avec les communautés affectées. Les journalistes du Pacifique ont soulevé les risques d’un manque de diversité dans le journalisme, en particulier dans les langues locales.

==La Semaine internationale du libre accès et communauté universitaire élargie==
Voici un aperçu des événements qui ont eu lieu au Canada et dans le monde. Une liste plus complète est disponible sur [https://www.openaccessweek.org/events le site Web de la Semaine internationale du libre accès].

De nombreuses universités canadiennes ont organisé des événements pour célébrer la semaine. [https://library.concordia.ca/research/open-access/open-access-week.php La Bibliothèque de l’Université Concordia] a organisé un salon transdisciplinaire comprenant des conférences, des ateliers et des expositions numériques interactives. [https://libraryguides.mcgill.ca/c.php?g=518294&amp;p=3544275 La Bibliothèque de l’Université McGill] a également organisé des ateliers ainsi qu’une projection du film ''Paywall: The Business of Scholarship''  (voir « [[Observations fondamentales : Observatoire des politiques sur les savoirs ouverts, 2017-2020/Le Film Paywall : The Business of Scholarship|Le Film ''Paywall: The Business of Scholarship'']] »).] [https://uwaterloo.ca/open-scholarship/news/archive/2022-10 L’Université de Waterloo] a publié une série d’articles dans son ''Daily Bulletin'' sur la justice climatique. [https://utsc.library.utoronto.ca/join-us-open-access-week-2022 L’Université de Toronto Scarborough] a organisé un quiz sur le libre accès sur Twitter et a encouragé sa communauté de recherche à déposer les travaux dans le dépôt institutionnel en l’honneur de la Semaine du libre accès. De même, [https://library.uwinnipeg.ca/news/2022/10/open-access-week-20221.html l’Université de Winnipeg] a partagé un portail de recherche ouverte sur les changements climatiques accueillie dans son dépôt institutionnel.

En Afrique, [https://www.eifl.net/events/open-access-week-2022 Electronic Information for Libraries (EIFL)] a marqué la semaine en mettant en avant son [https://www.eifl.net/programmes/open-access-programme programme], qui plaide en faveur du libre accès et de la recherche ouverte aux niveaux national et international et renforce les capacités de publication de revues ouvertes et de dépôts en libre accès, entre autres activités.

La Semaine du libre accès a été largement célébrée en Europe. [https://scienceeurope.org/news/open-access-week-2022-science-europe/ Science Europe] a souligné la publication récente de son document de la nouvelle orientation [https://scienceeurope.org/our-resources/direction-paper-open-science/ ''Open Science as Part of a Well-Functioning Research System,''] soulignant également ses efforts pour faire progresser le libre accès diamant (voir « [[Extension : Observatoire des politiques sur les savoirs ouverts, 2021-2024/Un plan d’action pour faire avancer le libre accès diamant|Un plan d’action pour faire progresser le libre accès diamant]] »). L’organisation européenne d’infrastructure de science ouvertes [https://www.openaire.eu/oaweek2022 OpenAIRE] a organisé deux séries de webinaires, avec deux sessions axées sur l’élaboration des politiques: Research Communities &amp; Climate Action et Being Open to Drive Change and Open Data in the Forefront: Driving Policy Decisions for Climate Justice. Le [https://openaccess.dk/oaw2022 Danish Network for Open Access] a organisé une série de webinaires, et de nombreuses autres organisations de recherche européennes ont également célébré avec des événements au cours de la semaine.

Aux États-Unis, [https://acrl.ala.org/acrlinsider/celebrate-open-access-week-2022/ l’Association of College and Research Libraries] de l’American Library Association a célébré en mettant en avant ses livres, revues et bulletins d’information en libre accès ainsi que certains de ses ateliers, podcasts et webinaires ouverts. De nombreuses bibliothèques universitaires ont également organisé des événements pour marquer la semaine, rassemblés dans une liste de [https://www.arl.org/blog/arl-member-libraries-promote-open-access-week-2022/ l'Association of Research Libraries].

Plusieurs éditeurs ont également marqué la Semaine internationale du libre accès. Cambridge University Press a célébré en mettant en avant certaines de ses initiatives en libre accès, telles que son programme [https://www.research4life.org/ Research4Life] pour les institutions des pays à revenu faible et intermédiaire et son programme [https://www.cambridge.org/core/services/open-research/open-access/oa-book-pilot-flip-it-open Flip it Open], grâce auquel les monographies sont inversées pour être ouvertes une fois qu’elles atteignent un certain niveau de vente (voir « [[Extension : Observatoire des politiques sur les savoirs ouverts, 2021-2024/Une mise à jour sur les monographies en libre accès|Une mise à jour sur les monographies en libre accès]] »). MIT Press a mis en évidence certains de ses articles de revues et livres en libre accès liés à la justice climatique et à ses initiatives de publication en libre accès, y compris son modèle de publication Direct to Open pour les monographies et les collections éditées (voir « [[Extension : Observatoire des politiques sur les savoirs ouverts, 2021-2024/Les accords de libre accès|Les monographies en libre accès]] »). Le blogue Early Career Researchers Community du PLOS a présenté un [https://ecrcommunity.plos.org/2022/10/30/open-access-week-2022-open-for-climate-justice/ article sur la Semaine du libre accès], notant que les chercheurs et chercheuses émergents jouent un rôle important dans l’avancement du libre accès.

==La Semaine internationale du libre accès et la science ouverte==
Le libre accès est une composante importante de la science ouverte, et en attirant l’attention du public et en renforçant la communauté autour du libre accès, la Semaine internationale du libre accès contribue à faire progresser la science ouverte plus largement.

==Ouvrage cité==
*«&amp;#8239;Semaine de l'open access 2022: Ouvert pour la justice climatique&amp;#8239;». 2022. International Open Access Week. [https://www.openaccessweek.org/theme/fr https://www.openaccessweek.org/theme/fr].

[[Catégorie:Extension : Observatoire des politiques sur les savoirs ouverts, 2021-2024 (livre)]]</text>
      <sha1>m9mqjwzsf1lyzcdgcuhg83ocas1jbgg</sha1>
    </revision>
  </page>
  <page>
    <title>Extension : Observatoire des politiques sur les savoirs ouverts, 2021-2024/Les droits de propriété intellectuelle et la science ouverte en Europe</title>
    <ns>0</ns>
    <id>82370</id>
    <revision>
      <id>744022</id>
      <parentid>742615</parentid>
      <timestamp>2025-06-02T23:05:22Z</timestamp>
      <contributor>
        <username>LodestarChariot2</username>
        <id>120009</id>
      </contributor>
      <minor />
      <comment>/* Ouvrages cités */</comment>
      <origin>744022</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="22135" sha1="a8opipv8hxtut3lbi5qmpjw29z2mifr" xml:space="preserve">''Cette observation a été écrite par Caroline Winter, avec ses remerciements à Iryna Kuchma et John Willinsky pour leurs commentaires et contributions.''

L'intersection des droits de propriété intellectuelle (DPI) et de la science ouverte est depuis longtemps une question d'intérêt pour le milieu de la recherche et pour l'industrie. Les politiques et la législation en matière de propriété intellectuelle visent à établir un équilibre entre les droits moraux et économiques des créateurs et créatrices de leurs œuvres et les droits et intérêts du grand public. La nécessité de comprendre comment les DPI et la science ouverte interagissent est devenue plus pressante à mesure que le mouvement de la science ouverte a progressé. Cela est particulièrement vrai dans le contexte de la pandémie de COVID-19, qui a mis en évidence le pouvoir de la recherche ouverte et collaborative de résoudre des défis complexes et mondiaux (voir «&amp;#8239;[[Observations fondamentales : Observatoire des politiques sur les savoirs ouverts, 2017-2020/Science Ouverte et COVID-19|Science ouverte et COVID-19]]&amp;#8239;»).

En 2019, les membres de l'UNESCO ont demandé un instrument pour construire un consensus international autour de la science ouverte, et la [https://unesdoc.unesco.org/ark:/48223/pf0000379949_fre Recommandation de l'UNESCO sur une science ouverte] a été publiée en novembre 2021 (voir «&amp;#8239;[[Observations fondamentales : Observatoire des politiques sur les savoirs ouverts, 2017-2020/La Recommandation de l’UNESCO sur la science ouverte|La Recommandation de l'UNESCO sur la science ouverte]]&amp;#8239;»). La tension possible entre la science ouverte et les DPI a été l'une des questions clés identifiées lors des consultations de l'UNESCO.

En avril 2021, l'UNESCO a abordé cette question en organisant une réunion d'experts en ligne [https://www.unesco.org/en/articles/expert-meeting-open-science-and-intellectual-property-rights sur la science ouverte et les DPI], réunissant plus de 500 participants, y compris six experts et expertes invités. Comme il est indiqué dans le [https://en.unesco.org/sites/default/files/report_expert_meeting_ipr_os_23apr.pdf rapport de la Réunion d'experts], les messages clés suivants sont ressortis de la discussion :

# Étant donné qu'il existe des tensions possibles entre les DPI et la science ouverte, des politiques et des approches stratégiques équilibrées sont nécessaires.
# Plutôt que d'être un obstacle à la science ouverte, un cadre de propriété intellectuelle bien défini peut promouvoir l'ouverture et la collaboration : par exemple, les licences ouvertes peuvent aider à garantir que toutes les contributions à la recherche sont reconnues.
# Il est également nécessaire de comprendre les complexités et les diverses formes des DPI et leurs différentes implications pour la science ouverte, y compris la façon dont elles se croisent avec d'autres systèmes réglementaires (UNESCO 2021).

En Europe, les tensions possibles entre les DPI et la science ouverte ont été abordées dans plusieurs études et rapports publiés au cours des dernières années, parallèlement à des politiques appelant à une plus grande ouverture, telles que [https://www.coalition-s.org/ le Plan S] (lancé en 2018) (voir «&amp;#8239;[[Observations fondamentales : Observatoire des politiques sur les savoirs ouverts, 2017-2020/Plan S et cOAlition S|Plan S et coAlition S]]&amp;#8239;», «&amp;#8239;[[Extension : Observatoire des politiques sur les savoirs ouverts, 2021-2024/Mise à jour du Plan S : L’élargissement de l’adhésion de la cOAlition S|Mise à jour du Plan S : l’élargissement de l’adhésion de la cOAlition S]]&amp;#8239;» et «&amp;#8239;[[Extension : Observatoire des politiques sur les savoirs ouverts, 2021-2024/Les Fonds de recherche du Québec rejoignent la cOAlition S|Les Fonds de Recherche du Québec se rejoignent la cOAlition S]]&amp;#8239;»).

En 2017, le [https://commission.europa.eu/about-european-commission/departments-and-executive-agencies/joint-research-centre_en Centre commun de recherche (JRC) de la Commission européenne] et la [https://commission.europa.eu/about-european-commission/departments-and-executive-agencies/research-and-innovation_en Direction générale de la recherche et de l'innovation] ont organisé un atelier sur [https://op.europa.eu/en/publication-detail/-/publication/8294fcb4-8df7-11e7-b92d-01aa75ed71a1/language-en ''IPR, technology transfer &amp; open science'']. Les conclusions de l'atelier comprenaient que l'équilibre était nécessaire, que les DPI était un outil important pour assurer l'attribution en science ouverte, que les stratégies d'équilibre entre les deux devraient être éclairées par les meilleures pratiques existantes, et que le traitement de cette question était particulièrement urgent alors que l[https://eosc-portal.eu/ 'European Open Science Cloud] était en cours de développement (Crouzier 2017).

En 2020, European Association of Research and Technology Associations (EARTO) a publié le livre blanc [https://www.earto.eu/wp-content/uploads/EARTO-Paper-Towards-a-Balanced-Approach-Between-IPRs-and-Open-Science-Policy-Final.pdf ''Towards a Balanced Approach Between IPRs and Open Science Policy'']. Bien qu'il appelle également à l'équilibre, le document suggère des cadres politiques et des approches qui soutiennent la commercialisation et l'innovation ouverte, un modèle de recherche, de développement et d'innovation impliquant la collaboration entre les universités, les entreprises et d'autres parties prenantes.

En avril 2022, la European Federation of Academies of Sciences and Humanities (l’ALLEA) a publié la déclaration [https://allea.org/wp-content/uploads/2022/04/ALLEA-Statement-Aligning-IPR-with-Open-Science.pdf ''Aligning Intellectual Property Rights with Open Science'']. Cette déclaration met l'accent sur la commercialisation des innovations par le biais de brevets et souligne que la science ouverte peut être mise en œuvre dans le cadre des DPI. Par exemple, les brevets accordent aux créateurs et créatrices des droits exclusifs sur les innovations pendant un certain temps, mais lorsque les brevets expirent, ces innovations deviennent des connaissances ouvertes.

L'étude de 2022 de Christina Angelopoulos [https://op.europa.eu/en/publication-detail/-/publication/884062d5-1145-11ed-8fa0-01aa75ed71a1 ''Study on EU Copyright and Related Rights and Access to and Reuse of Scientific Publications, Including Open Access''] analyse le rôle du régime de droits d'auteur de l'UE dans l'accès et la réutilisation des publications savantes. Elle offre des recommandations législatives et non législatives pour faciliter l'accès et demande un examen attentif des effets – intentionnels et non intentionnels – de chacun.

Le rapport [https://op.europa.eu/en/publication-detail/-/publication/42d27e04-b715-11ec-b6f4-01aa75ed71a1/language-en ''Open Science and Intellectual Property Rights: How Can They Better Interact? State of the Art and Reflections''] a également été publié en avril 2022 par la Commission européenne. Ce rapport présente les résultats d'une méta-analyse de la littérature sur la science ouverte et la propriété intellectuelle de la dernière décennie, y compris la recherche publiée et la littérature grise (documents de politique, rapports et livres blancs). Il soutient que, bien qu'il existe une tension entre la science ouverte et la propriété intellectuelle, elles ne sont pas fondamentalement incompatibles. Elles doivent plutôt être équilibrées, c’est-à-dire aussi ouvertes que possible, aussi fermées que nécessaire (p. 2).

Le rapport de la Commission européenne présente quelques conclusions générales ainsi que des recommandations pour des décideurs et décideuses politiques, chercheurs et chercheuses et des praticiens et praticiennes qui font écho à celles des autres rapports décrits ici. Ces constatations et recommandations peuvent être résumées en plusieurs thèmes :
# Il doit y avoir un équilibre entre la protection de la propriété intellectuelle et le partage ouvert des connaissances, avec l'ouverture comme valeur par défaut. Idéalement, un cadre mondial des DPI devrait être mis au point pour la science ouverte qui soit adaptée à l'évolution des technologies et qui protège l'ouverture de la science fondamentale.
# D'autres recherches sur la relation entre les DPI et la science ouverte sont nécessaires, en particulier celles sur l'effet de la réglementation de la propriété intellectuelle sur l'innovation, aux niveaux national et européen. Une meilleure compréhension de la valeur des œuvres et de l'infrastructure du domaine public, y compris l'Internet, est également nécessaire.
# Bien que le financement gouvernemental et les réglementations en matière de propriété intellectuelle aient tendance à encourager les innovations qui peuvent aider à résoudre des défis mondiaux complexes (p. ex. la recherche sur la COVID-19), nous devons considérer de manière holistique la véritable valeur de la science ouverte et collaborative et les coûts réels de la protection des innovations potentiellement vitales en tant que propriété intellectuelle.
# Les choix des chercheurs et chercheuses quant à leur travail doivent être respectés. Ils ne devraient pas être pénalisés pour avoir fait la science ouverte, par exemple en raison de charges administratives ou financières supplémentaires. En même temps, leurs DPI et les modalités de réutilisation des données doivent être respectés.
# Les praticiens et praticiennes doivent être au courant des meilleures pratiques de la communauté des logiciels ouverts, y compris l'utilisation des licences à jour, la diversité des licences, la normalisation des licences et le processus de les rendre lisibles par l’homme et la machine, la création des communautés de pratique et la mentalité «&amp;#8239;release early, release often&amp;#8239;».

Au niveau politique, le rapport appelle à la création d'un Office for Free Intellectual Property Rights and Open Science, qui serait aligné sur [https://eur-lex.europa.eu/legal-content/FR/TXT/HTML/?uri=CELEX:52020DC0760&amp;qid=1689012632159 le Plan d’action en faveur de la propriété intellectuelle] de l'Union européenne et qui pourrait être financé par Horizon Europe. Il appelle également à une révision de la législation européenne en matière de propriété intellectuelle relative aux hyperliens, aux exceptions au droit d'auteur pour l'exploration de textes et de données et aux prélèvements sur le droit d'auteur.

Le rapport se termine par un appel à réviser et à adapter la réglementation en matière de propriété intellectuelle pour l'aligner sur les nouvelles technologies développées au cours des dernières décennies. Il soutient que l'ouverture de recherche et de la science bien que leurs processus devraient entraîner une transformation prometteuse de la science (p. 9). Un nouveau paradigme de propriété intellectuelle est nécessaire pour cette nouvelle ère numérique.

==DPI et la science ouvert dans la presse==
Bien que le rapport de la Commission européenne n'ait pas été largement couvert dans la presse, la propriété intellectuelle et la science ouverte sont des questions d'intérêt pour les communautés universitaires et celles plus larges en Europe et en Amérique du Nord.

Un article paru en 2020 dans [https://www.affairesuniversitaires.ca/articles-de-fond/article/le-neuro-de-montreal-porteur-de-changement-dans-les-sciences-universitaires/?_ga=2.127238605.1924387654.1689180763-1262500445.1689180763 ''University Affairs/Affaires universitaires''], par exemple, souligne la nécessité d'avoir des DPI moins restrictifs en biomédecine à travers l'exemple des chercheurs et chercheuses qui ont accéléré le développement d’un vaccin potentiel contre le SRAS en 2003, ce qui n'a été possible qu'en contournant les DPI (Voinigescu). Un document d'information récent d'Itzel Saldivar pour [https://www.timeshighereducation.com/campus/what-you-dont-know-about-ip-protections-should ''Times Higher Education''] décrit diverses formes de propriété intellectuelle – des brevets, droits d'auteur et marques de commerce – et soutient que les chercheurs et chercheuses devraient comprendre comment les DPI les affectent et affectent leur travail.

Un article de Claire Woodcock dans ''Vice'' explique comment la [https://www.vice.com/en/article/epzyde/librarians-are-finding-thousands-of-books-no-longer-protected-by-copyright-law New York Public Library a découvert ]des milliers d'œuvres créatives publiées avant 1964 qui sont maintenant dans le domaine public parce que leur droit d'auteur n'a pas été renouvelé, une découverte faite à l'aide de XML source ouverte. Dans le cadre de discussions animées sur les promesses et les pièges de l’intelligence artificielle générative, un article du [https://www.wsj.com/articles/ai-chatgpt-dall-e-microsoft-rutkowski-github-artificial-intelligence-11675466857 ''Wall Street Journal''] traite des recours collectifs lancés par les créateurs et créatrices des médias qui affirment que les données utilisées pour former Dall-E 2, Stable Diffusion et des systèmes d’intelligence artificielle génératifs similaires sont de la propriété intellectuelle volée.

==Les réponses du Partenariat INKE==
Plusieurs partenaires de l'INKE s'intéressent à des questions liées aux droits de propriété intellectuelle et à la science ouverte.

Au nom de ses membres, [https://www.carl-abrc.ca/fr/ l'Association des bibliothèques de recherche du Canada (ABRC)] entreprend des initiatives liées à la politique sur le droit d'auteur. Par exemple, elle a contribué à [https://www.carl-abrc.ca/fr/influencer-les-politiques/droit-dauteur/examen-2018/ l'examen législatif de 2018 de la Loi sur le droit d'auteur] et a soumis une [https://www.carl-abrc.ca/wp-content/uploads/2021/04/FCAB-ABRC_Reponse_conjointe_consultation_prolongation_droit_dauteur.pdf réponse conjointe avec la Fédération canadienne des associations de bibliothèques (FCAB) à l'accord Canada-United States-Mexico (CUSMA)] en 2021. En 2020, [https://www.carl-abrc.ca/wp-content/uploads/2020/10/200921-le-droit-dauteur-de-la-Couronne.pdf l'ABRC et le FCAB ont soumis une lettre conjointe ][https://www.carl-abrc.ca/wp-content/uploads/2020/10/200921-le-droit-dauteur-de-la-Couronne.pdf aux ministres fédéraux ][https://www.carl-abrc.ca/wp-content/uploads/2020/10/200921-le-droit-dauteur-de-la-Couronne.pdf au sujet du droit d'auteur de la Couronne], demandant des licences ouvertes pour l'information gouvernementale afin d'améliorer l'accès du public à l'information sur la COVID-19. Il a également publié une [https://www.carl-abrc.ca/wp-content/uploads/docs/CARL_Statement_on_Fair_Dealing_2016_FR-1.pdf déclaration sur l'utilisation équitable et le droit d'auteur] en 2016 et est intervenu dans l'[https://www.carl-abrc.ca/influencing-policy/copyright/ affaire York University v. Access Copyright].

À l'automne 2022, John Willinsky du [https://pkp.sfu.ca/ Public Knowledge Project (PKP)] a fait une [https://pkp.sfu.ca/2022/10/18/the-pkp-amend-copyright-tour/ tournée Amend Copyright] en Europe et en Amérique du Nord pour plaider en faveur de l'inclusion du droit d'auteur dans les intentions du mouvement de libre accès. Sa position sur les licences légales pour les publications de recherche, dans lesquelles les DPI sont placés au service du libre accès, est décrite dans son livre en libre accès [https://doi.org/10.7551/mitpress/14201.001.0001 ''Copyright's Broken Promise: How to Restore the Law's Ability to Promote the Progress of Science ''](Willinsky).

[https://www.crkn-rcdr.ca/fr/projet-sur-les-declarations-de-droits Le Projet sur les déclarations de droits] du [https://www.crkn-rcdr.ca/fr Réseau canadien de documentation pour la recherche (RCDR)] cherche une solution au problème des renseignements manquants et incomplets sur les droits dans [https://www.crkn-rcdr.ca/fr/collections-de-canadiana les collections Canadiana du RCDR]. Le projet est en train d'élaborer un cadre pour déterminer comment les matériaux du patrimoine numérique dans l'ensemble de la collection afin de protéger les droits des créateurs tout en rendant les collections aussi ouvertes et réutilisables que possible.

==Les réactions de l’ensemble de la communauté universitaire élargie==
Dans un article de blog pour [https://www.the-guild.eu/blog/connecting-the-dots-iprs-knowledge-transfer-innova.html ''The Guild''], Alessandra Baccigotti, l'une des experts et expertes invités à la réunion d'experts de l'UNESCO, discute de la réunion au côté de la première [https://eua.eu/partners-news/969-eu-knowledge-valorisation-week-2023.html Semaine européenne de valorisation des connaissances], organisée par la Commission européenne, qui s'est déroulée du 27 au 30 avril 2021. Elle note qu'il y a souvent un scepticisme au sein de la communauté de la science ouverte sur les DPI et la valorisation des connaissances ou la recherche et l'innovation, et tout comme l'UNESCO et d'autres organisations travaillent à l'établissement de connaissances et d'un consensus sur la science ouverte, la même chose doit être faite pour les DPI.

==DPI et la science ouverte==
Il a été largement reconnu au début de la pandémie de COVID-19 que l'ouverture et la collaboration étaient essentielles pour lutter contre la maladie, comme discuté [https://www.oecd.org/coronavirus/policy-responses/why-open-science-is-critical-to-combatting-covid-19-cd6ab2f9/ par l’OECD]. E. Richard Gold note dans un article paru dans [https://www.nature.com/articles/s41587-022-01485-x ''Nature''] que la réponse du milieu de la recherche à la pandémie a remis en question certaines hypothèses sur les DPI, y compris le fait que de solides réglementations en matière de DPI stimulent l'innovation. Au fur et à mesure que la pandémie a mis en évidence des questions plus larges telles que le droit à la santé et le droit à la connaissance, la nécessité d'examiner les DPI et la science ouverte d'une manière holistique est devenue plus claire.

Bien que ces problèmes aient été mis en avant par la pandémie, la réflexion sur les DPI et l'ouverture a changé parallèlement à la transition vers le libre accès. Willinsky note que dans le passé, les éditeurs avaient tendance à considérer le libre accès comme une menace pour leurs DPI, mais à mesure que le libre accès s'enracine, les éditeurs réfléchissent à la façon dont leurs DPI peuvent soutenir le libre accès à l'avenir.

En effet, cet aperçu des récents rapports de politique sur les DPI et la science ouverte en Europe montre que, dans ce contexte politique, les droits de propriété intellectuelle sont de plus en plus compris comme étant au service de la science ouverte plutôt qu'en opposition à celle-ci.

==Ouvrages cités==
*ALLEA (European Federation of Academies of Sciences and Humanities). 2022. «&amp;#8239;Aligning Intellectual Property Rights with Open Science: An ALLEA Statement&amp;#8239;». [https://allea.org/wp-content/uploads/2022/04/ALLEA-Statement-Aligning-IPR-with-Open-Science.pdf https://allea.org/wp-content/uploads/2022/04/ALLEA-Statement-Aligning-IPR-with-Open-Science.pdf].

*Angelopoulos, Christina. 2022. ''Study on EU Copyright and Related Rights and Access to and Reuse of Scientific Publications, Including Open Access: Exceptions and Limitations, Rights Retention Strategies and the Secondary Publication Right''. Office des publications de l’Union européenne. [https://data.europa.eu/doi/10.2777/891665 https://data.europa.eu/doi/10.2777/891665].

*Commission européenne, Direction générale pour Research and Innovation. 2022. ''Open Science and Intellectual Property Rights: How Can They Better Interact? State of the Art and Reflections: Executive Summary''. Office des publications de l’Union européenne. [https://data.europa.eu/doi/10.2777/347305 https://data.europa.eu/doi/10.2777/347305].

*EARTO (European Association of Research and Technology Organizations). 2020. «&amp;#8239;Towards a Balanced Approach between IPRs and Open Science Policy&amp;#8239;». [https://www.earto.eu/wp-content/uploads/EARTO-Paper-Towards-a-Balanced-Approach-Between-IPRs-and-Open-Science-Policy-Final.pdf https://www.earto.eu/wp-content/uploads/EARTO-Paper-Towards-a-Balanced-Approach-Between-IPRs-and-Open-Science-Policy-Final.pdf].

*UNESCO. 2021. «&amp;#8239;Towards a UNESCO Recommendation on Open Science: Online Expert Meeting on Open Science and Intellectual Property Rights&amp;#8239;». [https://en.unesco.org/sites/default/files/report_expert_meeting_ipr_os_23apr.pdf https://en.unesco.org/sites/default/files/report_expert_meeting_ipr_os_23apr.pdf].

*UNESCO. 2022. «&amp;#8239;Expert Meeting on Open Science and Intellectual Property Rights&amp;#8239;». [https://www.unesco.org/en/articles/expert-meeting-open-science-and-intellectual-property-rights https://www.unesco.org/en/articles/expert-meeting-open-science-and-intellectual-property-rights].

*Voinigescu, Eva. 2020. «&amp;#8239;Le Neuro de Montréal : porteur de changement dans les sciences universitaires ?&amp;#8239;» ''University Affairs/Affaires universitaires'', le 24 juin 2020. [https://www.affairesuniversitaires.ca/articles-de-fond/article/le-neuro-de-montreal-porteur-de-changement-dans-les-sciences-universitaires https://www.affairesuniversitaires.ca/articles-de-fond/article/le-neuro-de-montreal-porteur-de-changement-dans-les-sciences-universitaires].

*Willinsky, John. 2022. ''Copyright’s Broken Promise: How to Restore the Law’s Ability to Promote the Progress of Science''. MIT Press. [https://direct.mit.edu/books/book/5507/Copyright-s-Broken-PromiseHow-to-Restore-the-Law-s https://direct.mit.edu/books/book/5507/Copyright-s-Broken-PromiseHow-to-Restore-the-Law-s].

[[Catégorie:Extension : Observatoire des politiques sur les savoirs ouverts, 2021-2024 (livre)]]</text>
      <sha1>a8opipv8hxtut3lbi5qmpjw29z2mifr</sha1>
    </revision>
  </page>
  <page>
    <title>Extension : Observatoire des politiques sur les savoirs ouverts, 2021-2024/La sécurité de la recherche et la science ouverte au Canada</title>
    <ns>0</ns>
    <id>82372</id>
    <revision>
      <id>744023</id>
      <parentid>742625</parentid>
      <timestamp>2025-06-02T23:10:56Z</timestamp>
      <contributor>
        <username>LodestarChariot2</username>
        <id>120009</id>
      </contributor>
      <minor />
      <comment>/* Ouvrages cités */</comment>
      <origin>744023</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="34409" sha1="oytrvidhwbhjrqppvpxn1qaapq7ignq" xml:space="preserve">''Cette observation a été écrite par Caroline Winter (avec des remerciements à Aaron Mauro et John Simpson pour leurs commentaires et contributions), pour le Electronic Textual Cultures Laboratory et le partenariat Implementing New Knowledge Environments.''

La sécurité de la recherche, c'est-à-dire la capacité d’identifier les risques pour les processus et les produits de la recherche et de prendre des mesures pour les atténuer, est une préoccupation de longue date pour la communauté de la recherche et ses parties prenantes, y compris les individus et individues jusqu’aux gouvernements nationaux. Bien que l'ouverture et la collaboration soient essentielles pour faire avancer la recherche, une plus grande ouverture peut également entraîner de plus grands risques. Sécuriser les données et les connaissances numériques et d'autres extrants intangibles est particulièrement difficile. Cela a été mis en évidence pendant la pandémie de COVID-19, lorsque le pivot vers des environnements de travail virtuels et des niveaux sans précédent de collaboration mondiale et de partage de la recherche se sont accompagnés de menaces de sécurité accrues (voir «&amp;#8239;[[Observations fondamentales : Observatoire des politiques sur les savoirs ouverts, 2017-2020/Science Ouverte et COVID-19|Science ouverte et COVID-19]]&amp;#8239;»).

La sécurité de la recherche est une vaste question qui se rapporte à toutes les facettes de la recherche. Pour les chercheurs et chercheuses et les institutions individuelles, le vol de données et d'autres problèmes de sécurité peuvent entraver la recherche, menacer la propriété intellectuelle et affecter l'admissibilité au financement (voir «&amp;#8239;[[Extension : Observatoire des politiques sur les savoirs ouverts, 2021-2024/Les droits de propriété intellectuelle et la science ouverte en Europe|Les droits de propriété intellectuelle et la science ouverte en Europe]]&amp;#8239;»). La sécurité de la recherche est également une question de sécurité nationale puisque les données et les connaissances détournées peuvent être utilisées à des fins de renseignement national ou militaire néfastes. La sécurité est particulièrement préoccupante pour la recherche économiquement précieuse et à double usage – celle qui a des applications civiles et militaires potentielles – comme dans les domaines des infrastructures essentielles et de la recherche sur des sujets humains ainsi que de l'informatique quantique et de l'intelligence artificielle, qui sont tous deux des outils potentiels pour les cyberattaques ainsi que les domaines cibles actuels (Gouvernement du Canada 2023; OCDE 2022 ; Owens 2023a ; Science Canada 2021).

Le vol de données de recherche et/ou personnelles est une menace courante, car les données stockées sur les disques durs et les clés USB peuvent être volées ou égarées et les cyberattaques peuvent causer des violations de données et endommager les systèmes informatiques. Les attaques d'hameçonnage ont tendance à cibler des chercheurs et chercheuses individuels pour qui la sécurité n'est peut-être pas une priorité (OCDE 2022).

La sécurité de la recherche est également menacée par les «&amp;#8239;acteurs malfaisants&amp;#8239;», qui peuvent être des collaborateurs, des chercheurs invités, des étudiants ou d'autres personnes qui visent à détourner ou à altérer la recherche pour leur propre profit (p. ex., dans le cas de concurrents commerciaux) ou pour le bénéfice d'autres personnes (p. ex. des états hostiles, des groupes du crime organisé, des organisations terroristes). Ces acteurs malfaisants peuvent agir par choix ou être forcés ou contraints (Science Canada 2021).

Étant donné que la sécurité de la recherche est une question de plus en plus urgente, l'élaboration de politiques dans ce domaine est très active. Le document politique de l'Organisation de coopération et de développement économiques (OCDE) [https://doi.org/10.1787/39ee9438-fr ''Intégrité et sécurité dans l'écosystème mondial de la recherche''], publié en juin 2022, traite d'un certain nombre de politiques et d'initiatives de sécurité de la recherche de l'Australie, du Japon, des Pays-Bas, du Royaume-Uni et des États-Unis, élaborées par des gouvernements nationaux, des organismes de financement, des établissements de recherche publics, des associations universitaires, des universités, des projets de recherche internationaux, et des organisations politiques internationales (p. ex., le G7, la Commission européenne, le Global Research Council). Bon nombre de ces politiques traitent de l'établissement d'évaluations des risques dans les processus existants (p. ex. l'évaluation des demandes de financement), de la détermination et de la gestion des menaces et des conflits d'intérêts, ainsi que des lignes directrices sur la diligence raisonnable.

Le document politique de l'OCDE reconnaît que le sujet de la sécurité de la recherche peut être difficile à discuter, controversé et polarisant, mais souligne qu'il est essentiel de le considérer néanmoins. Il offre sept recommandations de haut niveau pour la communauté de la recherche :

# Souligner l'importance de la liberté de la recherche scientifique et de la collaboration internationale en tant qu'élément clé de l'écosystème mondial de la recherche
# Intégrer les considérations relatives à la sécurité de la recherche dans les cadres nationaux et institutionnels pour l'intégrité de la recherche
# Promouvoir une approche proportionnée et systématique de la gestion des risques dans la recherche
# Promouvoir l'ouverture et la transparence en matière de conflits d'intérêts ou d'engagement
# Mettre au point des directives claires, rationaliser les procédures et limiter la bureaucratie inutile
# Mobiliser l'ensemble des secteurs et des institutions pour élaborer des politiques plus intégrées et efficaces
# Améliorer le partage d’informations sur l'intégrité et la sécurité de la recherche à l’échelle internationale (10)

Le Canada a également élaboré des politiques sur la sécurité de la recherche. En décembre 2019, le U15 Regroupement des universités de recherche du Canada et Universités Canada ont publié [https://www.univcan.ca/wp-content/uploads/2020/08/attenuer-les-risques-economiques-et-geopolitiques-associes-aux-projets-de-recherche-sensibles-dec-2019.pdf ''Atténuer les risques économiques et géopolitiques associés aux projets de recherche sensibles : Guide à l'intention des chercheurs universitaires'']. Le guide traite de divers types de risques en plus de l'appropriation illicite de données. Par exemple, il souligne que, comme tous les chercheurs ne jouissent pas du même degré de liberté académique, la publication de certains résultats pourrait mettre en danger les partenaires internationaux et que les risques pour les droits humains doivent être évalués dans le cadre des plans de voyage des chercheurs (10).

Le gouvernement du Canada a également publié un groupe d'énoncés de politique connexes sur la sécurité de la recherche :

[https://www.canada.ca/fr/service-renseignement-securite/nouvelles/2020/05/declaration-du-cse-et-scrs-le-14-mai-2020.html '''Déclaration du CSE et SCRS, le 14 mai 2020 ''']: Cette déclaration du Centre de la sécurité des télécommunications (CST) et du Service canadien du renseignement de sécurité (SCRS) répond aux préoccupations accrues au sujet de la recherche et de la sécurité nationale liées à l'incertitude générée par la COVID-19. Il met en garde contre les menaces à la propriété intellectuelle ainsi qu'aux renseignements personnels, citant une [https://www.cyber.gc.ca/fr/alertes-avis/cybermenaces-pesant-sur-les-organismes-de-sante-canadiens alerte du Centre canadien pour la cybersécurité] et une [https://www.canada.ca/fr/affaires-mondiales/nouvelles/2020/04/declaration-sur-les-cybermenaces-visant-le-secteur-de-la-sante.html déclaration d'Affaires mondiales Canada] sur l'augmentation des cybermenaces pour le secteur de la santé.

[https://www.canada.ca/fr/innovation-sciences-developpement-economique/nouvelles/2020/09/enonce-de-politique-sur-la-securite-de-la-recherche-et-la-covid-19.html '''Énoncé de politique sur la sécurité de la recherche et la COVID-19, le 14 septembre 2020 ''']: Cet énoncé d'Innovation, Sciences et Développement économique Canada (ISDE) réaffirme l'engagement du gouvernement du Canada à l'égard de la science ouverte et rappelle à la communauté de la recherche de demeurer vigilant et d'examiner ses politiques et pratiques en matière de cybersécurité face aux menaces à la sécurité continues.

[https://www.canada.ca/fr/innovation-sciences-developpement-economique/nouvelles/2021/03/enonce-de-politique-sur-la-securite-de-la-recherche--printemps2021.html '''Énoncé de politique sur la sécurité de la recherche – Printemps 2021, le 24 mars 2021 ''']: Cet énoncé d'ISDE fait état d'une augmentation des niveaux de menace pour la recherche et la sécurité nationale et rappelle à la communauté de la recherche l'énoncé de politique de septembre 2020. Il note également qu'il a demandé au Groupe de travail mixte du gouvernement du Canada et des universités d'élaborer des lignes directrices sur les risques pour guider les chercheurs dans l'examen des questions de sécurité nationale liées à leurs recherches. Ces [https://science.gc.ca/site/science/fr/protegez-votre-recherche/lignes-directrices-outils-pour-mise-oeuvre-securite-recherche/lignes-directrices-securite-nationale-pour-partenariats-recherche Lignes directrices sur la sécurité nationale pour les partenariats de recherche] ont été publiées en juillet 2021. 

[https://www.canada.ca/fr/innovation-sciences-developpement-economique/nouvelles/2023/02/declaration-des-ministres-champagne-duclos-et-mendicino-sur-la-protection-de-la-recherche-canadienne.html '''Déclaration des ministres Champagne, Duclos et Mendicino sur la protection de la recherche canadienne, le 14 février 2023 ''']: Cette déclaration d'ISDE des Ministères de l'Innovation, des Sciences et de l'Industrie ; Santé ; et la Sécurité publique note encore une fois un niveau accru de menaces et annonce un changement dans la politique de financement pour les trois organismes : «&amp;#8239;Une demande de subvention de recherche dans un domaine sensible sera refusée si l'un des chercheurs travaillant sur le projet est affilié à une université, un institut de recherche ou un laboratoire rattaché à une organisation militaire ou à un organisme de défense nationale ou de sécurité d’un acteur étatique étranger qui représente un risque pour notre sécurité nationale&amp;#8239;» (ISDE 2023).

De plus, le [https://www.budget.canada.ca/2022/report-rapport/chap2-fr.html budget fédéral de 2022 du Canada ]a instauré un financement de 125 millions de dollars pour le [https://www.rsf-fsr.gc.ca/apply-demande/research_security-securite-recherche-fra.aspx Fonds de soutien à la recherche ]pour aider les établissements postsecondaires à renforcer leur capacité en matière de sécurité de la recherche, ainsi que 34,6 millions de dollars sur cinq ans et un financement permanent de 8,4 millions de dollars pour établir un centre de la sécurité de la recherche pour conseiller les établissements de recherche.

Bien que la sécurité de la recherche soit une question complexe, les chercheurs peuvent prendre des mesures pour se protéger et protéger leur travail. Le portail [https://science.gc.ca/site/science/fr/protegez-votre-recherche Protégez votre recherche] du gouvernement du Canada comprend de l'information sur la sécurité de la recherche ainsi que des outils et des lignes directrices à l'intention des chercheurs et des établissements. Les outils [https://science.gc.ca/site/science/fr/protegez-votre-recherche/lignes-directrices-outils-pour-mise-oeuvre-securite-recherche/evaluez-votre-profil-risque Évaluez votre profil de risque] et [https://science.gc.ca/site/science/fr/protegez-votre-recherche/lignes-directrices-outils-pour-mise-oeuvre-securite-recherche/attenuez-risques-lies-securite-recherche Atténuez les risques liés à la sécurité de la recherche] fournissent des conseils pratiques précis pour aider les chercheurs à évaluer et à gérer les risques propres à leurs projets. Les ressources partagées par l'entremise de ce portail sont celles du [https://science.gc.ca/site/science/fr/protegez-votre-recherche/renseignements-generaux-securite-recherche/propos-gouvernement-canada-groupe-travail-universites Groupe de travail sur les universités], qui travaille à la science ouverte, collaborative et sécurisée au Canada.

==La sécurité de la recherche dans la presse==
L'une des questions abordées dans la presse universitaire et populaire était un programme pilote élaboré en réponse à l'énoncé de politique de mars 2021 dans lequel les demandes de financement pour les [https://www.nserc-crsng.gc.ca/innovate-innover/alliance-alliance/index_fra.asp Subventions Alliance du CRSNG] ont été examinées par le SCRS et le CST. Des articles dans [https://www.affairesuniversitaires.ca/actualites/actualites-article/le-manque-de-clarte-lors-des-evaluations-de-risque-pour-la-securite-nationale-est-denonce/ ''Affaires universitaires''], [https://www.cbc.ca/news/politics/ottawa-reserach-champagne-security-1.6099163 ''CBC News''], le ''Globe and Mail ''([https://www.theglobeandmail.com/politics/article-ottawa-imposes-national-security-risk-assessments-for-university/ annonçant le projet pilote en 2021] et ses [https://www.theglobeandmail.com/canada/article-nserc-research-grants-sensitive/ résultats en 2023]) et [https://sciencebusiness.net/news/Cybersecurity/canadian-security-services-block-more-30-grant-proposals ''ScienceBusiness''] rapportent que, sur les quelque 1000 demandes de financement reçues par le CRSNG, 48 ont été signalées pcomme ayant besoin d’être examinéesur examen et 32 d'entre elles se sont vu refuser le financement pour des raisons de sécurité. 

À la suite de ce programme pilote, des examens de sécurité sont prévus pour toutes les demandes de financement des trois organismes. Cependant, certains chercheurs ont critiqué le programme pour son manque de transparence et de clarté (Owens 2023b). L'examen préalable ne peut pas mettre fin aux projets potentiellement risqués, puisque les projets qui se voient refuser du financement du CRSNG peuvent obtenir un financement équivalent auprès de leurs partenaires internationaux, et les projets qui ne cherchent pas à obtenir le financement fédéral ne seront pas examinés (Fife et Chase 2021). En mai 2023, le [https://www.thestar.com/news/canada/canada-set-to-name-foreign-labs-universities-that-pose-risk-to-national-security/article_4344a58d-f9f0-5e93-8604-82529aaff253.html ''Toronto Star''] a rapporté que l'ISDE était en train d'élaborer une politique énumérant des domaines de recherche et des établissements de préoccupation spécifiques pour relever certains de ces défis.

Une autre question abordée dans la presse est la menace spécifique à la sécurité de la recherche de la part de l'État chinois. Écrivant au sujet du programme pilote de dépistage, Brian Owens note que «&amp;#8239;[b]ien qu’on n’y nomme aucune organisation ni aucun pays explicitement&amp;#8239;» dans la Déclaration sur la protection de la recherche canadienne de février 2023, «&amp;#8239;il est généralement admis que les laboratoires et les entreprises chinoises présentent un risque particulier en raison de leurs liens étroits et souvent nébuleux avec les forces armées ainsi que des allégations d’usage abusif des droits de propriété intellectuelle&amp;#8239;» (Owens 2023b). La Chine a été largement discutée comme une menace pour la sécurité de la recherche dans la presse internationale, y compris des articles dans [https://globalnews.ca/news/9488207/canada-china-research-crackdown/ ''Global News''], [https://www.science.org/content/article/canada-moves-ban-funding-risky-foreign-collaborations ''Science''] et [https://www.timeshighereducation.com/news/canadian-scientists-questioned-agents-over-china-links ''Times Higher Education''].

Bien que la plupart des politiques (y compris la politique s’inclus le d’OCDE) aient adopté une approche agnostique par pays, des préoccupations ont été soulevées – comme dans des articles pour l'[https://www.theatlantic.com/ideas/archive/2021/12/china-initiative-intellectual-property-theft/621058/ ''Atlantic'']'', ''la [https://www.chronicle.com/newsletter/latitudes/2023-04-12 ''Chronicle of Higher Education''], [https://policyoptions.irpp.org/magazines/july-2023/canadian-research-china-collaboration/ ''Policy Options''] et [https://www.youtube.com/watch?v=IxobEDHW-Zs ''ScienceBusiness''], et [https://www.affairesuniversitaires.ca/articles-de-fond/article/la-securite-nationale-et-la-recherche-font-ils-bon-menage/ ''Affaires universitaires'']'' – ''au sujet de l'accent implicite mis sur les menaces de la Chine. [https://www.caut.ca/bulletin/2023/05/executive-directors-corner-academic-freedom-and-national-security David Robinson] décrit ces risques dans un article pour le bulletin de l'Association canadienne des professeurs d'université (ACPPU) : 

&lt;blockquote&gt;
La recherche universitaire peut présenter des risques légitimes pour la sécurité nationale, mais nous devons, en tant que communauté, nous garder de tout excès. Nous devons veiller à ce que les universitaires ne soient pas ciblés en raison de leur origine ethnique et à ce que les règles ne soient pas si larges qu’elles restreignent la recherche et l'érudition légitimes. La loi sur l'influence étrangère ne doit pas non plus être utilisée à mauvais escient pour cibler les universitaires qui critiquent la politique militaire ou étrangère du Canada. (Robinson 2023)
&lt;/blockquote&gt;

Comme le fait remarquer Robinson, l'accent mis sur les menaces de la Chine a conduit à un climat de peur de collaborer avec des chercheurs et chercheuses chinois qui entrave la recherche et les relations de collaboration et met les chercheurs et chercheuses individuels en danger.

==Réponses de la communauté INKE==
Les recherches d'Aaron Mauro, membre du partenariat INKE, se concentrent actuellement sur la cybersécurité de la recherche. Son livre de 2022 [https://www.bloomsbury.com/us/hacking-in-the-humanities-9781350231009/ ''Hacking in the Humanities : Cybersecurity, Speculative Fiction, and Navigating a Digital Future'' (2022) ]'' ''traite d'une approche de recherche qui prioritise la sécurité. Son [https://www.fu-berlin.de/en/sites/dhc/programme/termine/_Termin-Archiv_EN/DHCLs/2022-06-07_DHCL-Mauro.html discours du même nom] au Dahlem Humanities Center en 2022 soutient que les projets d’humanités numériques doivent adopter les meilleures pratiques de sécurité dans la façon dont nous planifions, menons et communiquons la recherche et que les humanistes numériques sont bien placés pour poser les questions critiques nécessaires. 

Mauro a donné une conférence au Digital Humanities Summer Institute (DHSI) 2021intitulée [https://web.archive.org/web/20210227025734/https:/dhsi.org/dhsi-2021-online-edition-institute-lectures/ «&amp;#8239;Human Exploits : Cybersecurity and the Humanities&amp;#8239;»,] et enseigne un cours DHSI sur [https://dhsi.org/on-campus-courses2024/ la cybersécurité pour les humanistes].

Parmi d'autres écrits liés à la cybersécurité, Mauro a écrit plusieurs articles pour ''The Conversation. ''Dans [https://theconversation.com/working-from-home-during-the-coronavirus-pandemic-creates-new-cybersecurity-threats-134954 «&amp;#8239;Working from Home during the Coronovirus Pandemic Creates New Cybersecurity Threats&amp;#8239;»,] il décrit comment les menaces telles que l’hameçonnage et le ransomware sont devenues de plus en plus courantes pendant la pandémie et le besoin d'une infrastructure plus sécurisée et de meilleures habitudes de sécurité par les utilisateurs. Dans [https://theconversation.com/ukrainian-cultural-artifacts-are-at-risk-during-the-russian-invasion-but-digitizing-them-may-offer-some-protection-185673 «&amp;#8239;Ukrainian Cultural Artifacts are at Risk during the Russian Invasion, but Digitizing Them my Offer Some Protection&amp;#8239;»,] il décrit comment les cyberattaques et la rhétorique russes menacent le patrimoine culturel ukrainien ainsi que sa sécurité nationale. Bien que la numérisation puisse créer des sauvegardes de documents du patrimoine culturel, note-t-il, elle dépend des infrastructures qui sont également menacées (pour plus sur la numérisation des documents du patrimoine culturel, voir «&amp;#8239;[[Extension : Observatoire des politiques sur les savoirs ouverts, 2021-2024/La Stratégie canadienne de numérisation du patrimoine documentaire|La Stratégie canadienne de numérisation du patrimoine documentaire]]&amp;#8239;»).

==La sécurité de la recherche et la communauté universitaire élargie==
De nombreuses initiatives dans l'ensemble de la communauté universitaire canadien portent sur des questions de sécurité de la recherche. À l'échelle nationale, par exemple, l'Alliance de recherche numérique du Canada (l'Alliance) a lancé en décembre 2022 [https://alliancecan.ca/fr/nouveautes/nouvelles/les-politiques-et-normes-de-cybersecurite-sont-maintenant-disponibles un ensemble de normes et de politiques de cybersécurité] liées à l'infrastructure nationale, abordant [https://alliancecan.ca/fr/document/741 la classification des données], la [https://alliancecan.ca/fr/document/739 gestion des données], [https://alliancecan.ca/fr/document/737 la gestion des vulnérabilités] et [https://alliancecan.ca/fr/document/733 la gestion des risques liés à la cybersécurité]. L'Alliance souligne également [https://alliancecan.ca/fr/nouveautes/nouvelles/mois-de-la-sensibilisation-la-cybersecurite le Mois de la sensibilisation à la cybersécurité 2023] avec une série d'ateliers en ligne tenus tout au long du mois d'octobre, chacun portant sur une question liée à la sécurité de la recherche numérique.

Toujours à l'échelle nationale, le [https://canssoc.ca/fr/ Canadian Shared Security Operations Centre (CanSSOC)], une collaboration entre [https://www.canarie.ca/fr/ CANARIE] et [https://www.canarie.ca/nren/ le Réseau national de la recherche et de l'éducation (RNRE), ]coordonne les services de cybersécurité locaux, régionaux et nationaux partout au Canada.

Les institutions et les organisations prennent également des mesures. Par exemple, en septembre 2021, le U15 a publié une [https://u15.ca/fr/publications/statements-releases/declaration-du-u15-sur-la-protection-des-valeurs-canadiennes-et-de-la-recherche-canadienne/ Déclaration du U15 sur la protection des valeurs canadiennes et de la recherche canadienne] qui souligne la nécessité que les politiques de sécurité soient claires, transparentes et prises en compte, reconnaissant que 

&lt;blockquote&gt;
la liberté académique et l'autonomie institutionnelle font partie des principes fondamentaux qui font que nos institutions sont à l'abri de toute ingérence politique, peuvent parler en toute franchise aux autorités et sont en mesure de répondre aux besoins sociaux, culturels et économiques des Canadiens. (Regroupement 2021)
&lt;/blockquote&gt;

En février 2023, l'Université de Waterloo a organisé une [https://uwaterloo.ca/research/research-security-conference conférence sur la sécurité de la recherche] afin de sensibiliser les gens à des questions clés et d'encourager la discussion, y compris sur le potentiel de discrimination raciale en raison des mesures de sécurité. Il a également abordé l'évolution du rôle des bureaux des services de recherche, car de nombreux établissements ont maintenant des divisions, des bureaux et / ou du financement dédié à la sécurité de la recherche. 

Et, bien qu'il n’est pas spécifiquement une politique de sécurité de la recherche, [https://fnigc.ca/fr/les-principes-de-pcap-des-premieres-nations/ Les principes de PCAP® des Premières Nations] du Centre de gouvernance de l'information des Premières Nations traitent de la propriété, du contrôle, de l'accès et de la possession, qui ont tous trait à l'intégrité et à la sécurité des données.

==Sécurité de la recherche et la science ouverte==
Un défi clé pour la science ouverte et sécurisée est que l'ouverture, la collaboration et le partage qui sont à la base des mouvements ouverts sont précisément ce que les acteurs malfaisants exploitent pour saper la sécurité de la recherche. Similairement, les infrastructures numériques et les technologies de communication en ligne qui rendent possible la science ouverte sont également particulièrement vulnérables aux attaques.

Un défi de sécurité connexe qui est aussi particulièrement pertinent pour la science ouverte est que plus les informations sont partagées ouvertement, plus le risque qu'elles soient utilisées à des fins néfastes est grand, comme [https://www.wired.co.uk/article/making-science-more-open-is-good-for-research-but-bad-for-security Grace Browne] s’explique dans un article pour ''Wired''. La recherche sur la COVID-19 pourrait être utilisée pour développer des bioarmes, par exemple, et le code d'intelligence générale artificielle génératif pourrait être utilisé pour diffuser de la désinformation. L'essor des serveurs de préimpression ouverts, en particulier pour la recherche à double usage, est particulièrement préoccupante parce que cette recherche n'est pas encore évaluée par les pairs et peut contenir des erreurs ou poser des risques potentiels pour la sécurité qui n'ont pas été identifiés. Notant que l'ouverture amplifie le risque déjà existant que la recherche soit utilisée de manière non intentionnelle et nuisible, Browne soutient qu'il est temps que la science ouverte réponde à ses risques, avant que le pire ne se réalise (Browne 2022).

En plus des efforts canadiens décrits ci-dessus, des efforts sont en cours dans le monde entier pour développer une culture de recherche axée sur la sécurité, souvent liée à des questions qui recoupent la science ouverte. Par exemple, les [https://www.nature.com/articles/s41597-020-0486-7 TRUST Principles for Digital Repositories] (transparence, responsabilité, accent mis sur l'utilisateur, durabilité, technologie), qui reconnaissent que les infrastructures numériques que les chercheurs utilisent pour déposer et sourcer des données doivent être sécurisées et fiables (voir «&amp;#8239;[[Observations fondamentales : Observatoire des politiques sur les savoirs ouverts, 2017-2020/Les principes TRUST pour les dépôts numériques|Les principes TRUST pour les dépôts numériques]]&amp;#8239;»). Dans leur [https://www.carl-abrc.ca/fr/nouvelles/principes-trust-pour-les-depots-numeriques/ approbation conjointe des principes], l'Association des bibliothèques de recherche du Canada (ABRC) et Portage (2020) ont noté que la technologie comprend «&amp;#8239;la capacité d’identifier immédiatement des menaces de sécurité et d'y répondre de manière efficace&amp;#8239;».

Educause a un [https://www.educause.edu/cybersecurity-and-privacy-guide guide de sécurité et de confidentialité] contenant des informations et des ressources pour soutenir l'élaboration de politiques et les programmes d'éducation pour la communauté de l'enseignement supérieur. En janvier 2022, la Commission européenne a publié [https://op.europa.eu/en/publication-detail/-/publication/3faf52e8-79a2-11ec-9136-01aa75ed71a1 ''Tackling R&amp;I Foreign Interference''], un document de travail contenant des lignes directrices spécifiques pour les organismes de recherche afin d'atténuer les risques de sécurité tout en faisant progresser la science ouverte. 

Ce ne sont là que quelques exemples d'initiatives en cours dans le monde pour s'attaquer à la question complexe de la sécurité de la recherche. Ils reflètent le consensus parmi les intervenants en matière de sécurité de la recherche selon lequel l'ouverture doit être équilibrée avec la sécurité tout en respectant les libertés académiques : une reconnaissance des avantages de travailler ouvertement et en collaboration au-delà des frontières nationales et des risques légitimes pour la sécurité encourus. 

==Ouvrages cités==
*ABRC (Association des bibliothèques de recherche du Canada). 2020. «&amp;#8239;L'ABRC et Portage adhérent aux principes TRUST pour les dépôts numériques&amp;#8239;». Le 31 juillet 2020. [https://www.carl-abrc.ca/news/trust-principles-for-digital-repositories/ https://www.carl-abrc.ca/news/trust-principles-for-digital-repositories/].

*Browne, Grace. 2022. «&amp;#8239;Making Science More Open is Good for Research––But Bad for Security&amp;#8239;». ''Wired'', le 22 avril 2022. [https://www.wired.com/story/making-science-more-open-good-research-bad-security/ https://www.wired.com/story/making-science-more-open-good-research-bad-security/].

*Fife, Robert, et Steven Chase. 2021. «&amp;#8239;Ottawa Imposes National-Security Risk Assessments for University Researchers Seeking Federal Funds&amp;#8239;». ''The Globe and Mail'', le 12 juillet 2021. [https://www.theglobeandmail.com/politics/article-ottawa-imposes-national-security-risk-assessments-for-university/ https://www.theglobeandmail.com/politics/article-ottawa-imposes-national-security-risk-assessments-for-university/].

*Gouvernement du Canada. 2021. «&amp;#8239;Qui constitue une menace?&amp;#8239;» Le 11 juillet 2021. [https://science.gc.ca/site/science/fr/protegez-votre-recherche/renseignements-generaux-securite-recherche/qui-constitue-menace https://science.gc.ca/site/science/fr/protegez-votre-recherche/renseignements-generaux-securite-recherche/qui-constitue-menace].

*Gouvernement du Canada. 2023. «&amp;#8239;Pourquoi devriez-vous protéger votre recherche?&amp;#8239;» Le 31 mars 2023. [https://science.gc.ca/site/science/fr/protegez-votre-recherche/renseignements-generaux-securite-recherche/pourquoi-devriez-vous-proteger-votre-recherche https://science.gc.ca/site/science/fr/protegez-votre-recherche/renseignements-generaux-securite-recherche/pourquoi-devriez-vous-proteger-votre-recherche].

*ISDE (Innovation, Sciences et Développement Économique Canada). 2023. «&amp;#8239;Déclaration des ministres Champagne, Duclos et Mendicino sur la protection de la recherche canadienne&amp;#8239;». Gouvernement du Canada. February 14, 2023. [https://www.canada.ca/fr/innovation-sciences-developpement-economique/nouvelles/2023/02/declaration-des-ministres-champagne-duclos-et-mendicino-sur-la-protection-de-la-recherche-canadienne.html https://www.canada.ca/fr/innovation-sciences-developpement-economique/nouvelles/2023/02/declaration-des-ministres-champagne-duclos-et-mendicino-sur-la-protection-de-la-recherche-canadienne.html].

*Mauro, Aaron. 2022. «&amp;#8239;Hacking in the Humanities : Cybersecurity, Speculative Fiction, and Navigating a Digital Future&amp;#8239;». Dahlem Humanities Center (DHC). Le 7 juin 2022. [https://www.fu-berlin.de/en/sites/dhc/videothek/Videothek/908-DHCL-Mauro/index.html https://www.fu-berlin.de/en/sites/dhc/videothek/Videothek/908-DHCL-Mauro/index.html].

*OCDE (Organisation de coopération et de développement économiques). 2022. «&amp;#8239;Intégrité et sécurité dans l'écosystème mondial de la recherche&amp;#8239;». OECD Science, Technology and Industry Policy Papers, no. 130. [https://doi.org/10.1787/39ee9438-fr https://doi.org/10.1787/39ee9438-fr].

*Owens, Brian. 2023a. «&amp;#8239;La sécurité nationale et la recherche font-ils bon ménage ?&amp;#8239;». ''Affaires universitaires'', le 14 juin 2023. [https://www.affairesuniversitaires.ca/articles-de-fond/article/la-securite-nationale-et-la-recherche-font-ils-bon-menage/ https://www.affairesuniversitaires.ca/articles-de-fond/article/la-securite-nationale-et-la-recherche-font-ils-bon-menage/].

*Owens, Brian. 2023b. «&amp;#8239;Le manque de clarté lors des évaluations de risque pour la sécurité nationale est dénoncé&amp;#8239;». ''Affaires universitaires'', le 23 mars 2023. [https://www.affairesuniversitaires.ca/actualites/actualites-article/le-manque-de-clarte-lors-des-evaluations-de-risque-pour-la-securite-nationale-est-denonce/ https://www.affairesuniversitaires.ca/actualites/actualites-article/le-manque-de-clarte-lors-des-evaluations-de-risque-pour-la-securite-nationale-est-denonce/].

*Robinson, David. 2023. «&amp;#8239;Liberté académique et sécurité nationale&amp;#8239;». ''Bulletin de l'ACPPU'', le juin 2023. [https://www.caut.ca/fr/bulletin/2023/05/le-coin-du-directeur-general-liberte-academique-et-securite-nationale https://www.caut.ca/fr/bulletin/2023/05/le-coin-du-directeur-general-liberte-academique-et-securite-nationale].

*Regroupement des universités de recherche canadiennes U15. 2021. «&amp;#8239;Déclaration du U15 sur la protection des valeurs canadiennes et de la recherche canadienne&amp;#8239;». Groupe U15 des universités de recherche canadiennes. Le 28 septembre 2021. [https://u15.ca/fr/publications/statements-releases/declaration-du-u15-sur-la-protection-des-valeurs-canadiennes-et-de-la-recherche-canadienne/ https://u15.ca/fr/publications/statements-releases/declaration-du-u15-sur-la-protection-des-valeurs-canadiennes-et-de-la-recherche-canadienne/].

*Regroupement des universités de recherche canadiennes et universités du Canada U15. 2019. «&amp;#8239;Atténuer les risques économiques et géopolitiques associés aux projets de recherche sensibles : guide à l’intention des chercheurs universitaires&amp;#8239;». [https://www.univcan.ca/wp-content/uploads/2020/08/attenuer-les-risques-economiques-et-geopolitiques-associes-aux-projets-de-recherche-sensibles-dec-2019.pdf https://www.univcan.ca/wp-content/uploads/2020/08/attenuer-les-risques-economiques-et-geopolitiques-associes-aux-projets-de-recherche-sensibles-dec-2019.pdf].

*Science Canada. 2021. «&amp;#8239;CSIS Research Security Briefing&amp;#8239;». Le 9 juillet 2021. [https://www.youtube.com/watch?v=LSu5ObwzM8c https://www.youtube.com/watch?v=LSu5ObwzM8c].

[[Catégorie:Extension : Observatoire des politiques sur les savoirs ouverts, 2021-2024 (livre)]]</text>
      <sha1>oytrvidhwbhjrqppvpxn1qaapq7ignq</sha1>
    </revision>
  </page>
  <page>
    <title>Extension : Observatoire des politiques sur les savoirs ouverts, 2021-2024/La communauté avant la commercialisation</title>
    <ns>0</ns>
    <id>82375</id>
    <revision>
      <id>744024</id>
      <parentid>742756</parentid>
      <timestamp>2025-06-02T23:19:12Z</timestamp>
      <contributor>
        <username>LodestarChariot2</username>
        <id>120009</id>
      </contributor>
      <minor />
      <comment>/* Références */</comment>
      <origin>744024</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="34714" sha1="795vbthmh51uf1cr3v2a8ngwi6eg4jr" xml:space="preserve">''Ce rapport «&amp;#8239;Insights and Signals&amp;#8239;» a été rédigé par Brittany Amell (avec nos remerciements à Claire Duncan et Jessica Dallaire-Clark pour leurs commentaires et contributions), pour le Electronic Textual Cultures Laboratory et le partenariat Implementing New Knowledge Environments.''

Ce rapport sur les perspectives et les signaux se concentre sur le thème de la Semaine internationale du libre accès de cette année, qui se déroule du 21 octobre au 27 octobre. Organisée chaque année depuis 2008, la semaine du libre accès est une célébration mondiale et une promotion de l'accès gratuit, immédiat et en ligne à la recherche et à l'érudition. Des individus, des groupes et des organisations se connectent à travers les disciplines, les fuseaux horaires, les continents et les secteurs pour faire progresser la compréhension et le plaidoyer en faveur de l'érudition ouverte.

[https://www.openaccessweek.org/theme/fr Le comité consultatif de la Semaine du libre accès,] en partenariat avec [https://sparcopen.org SPARC], a décidé de reprendre le thème de 2023, ''la communauté avant la commercialisation''. C'est la première fois qu'un thème est réutilisé depuis le début de la Semaine du libre accès, une décision que le comité consultatif de la Semaine du libre accès 2024 décrit comme une étape sans précédent mais nécessaire, étant donné l'importance de ce sujet et le besoin urgent de transformer la conversation collective en «&amp;#8239;action collective&amp;#8239;» ([https://www.openaccessweek.org/theme/fr Semaine internationale du libre accès 2024).]

Ce rapport aborde le thème de la Semaine de l'accès à l'information 2024, ainsi que quelques événements notables prévus pendant la Semaine de l'accès à l'information. Ce rapport comprend également un tour d'horizon exhaustif de certains développements en matière d'accès à l'information dans le monde. Les développements mentionnés sont les suivants :

* Annonces de la [https://www.gatesfoundation.org/about/policies-and-resources/open-access-policy Fondation Bill et Melinda Gates], du [https://blog.mdpi.com/2024/02/27/open-access-in-japan/ Japon], du [https://science.gc.ca/site/science/fr/financement-interorganismes-recherche/politiques-lignes-directrices/libre-acces/rapport-nous-avons-entendu-activites-mobilisation-revision-politique-trois-organismes-libre-acces Canada] (en français), de la [https://www.swissuniversities.ch/en/topics/open-science/open-access/national-strategy Suisse] et du [https://www.ukri.org/news/ukri-updates-guidance-for-open-access-policy/ Royaume-Uni] concernant la révision de leurs politiques ou stratégies respectives en matière de libre accès.
* [https://barcelona-declaration.org/downloads/barcelonadeclaration_fran%25c3%25a7ais.pdf Déclaration de Barcelone sur l'information de recherche ouverte (en français)]
* Engagements financiers importants pour le développement d'infrastructures de recherche en libre accès de la part du [https://www.nature.com/articles/d41586-024-01493-8 Japon] et du [https://frq.gouv.qc.ca/dix-millions-de-dollars-accordes-a-la-creation-du-reseau-quebecois-de-recherche-et-de-mutualisation-pour-les-revues-scientifiques/ Québec] (en français)
* Le [https://blog.doaj.org/2024/06/14/press-release-pubscholar-joins-the-movement-to-support-the-directory-of-open-access-journals/ partenariat récemment annoncé] (en anglais) entre PubScholar (une plateforme académique publique créée par l'Académie chinoise des sciences) et l'annuaire des revues en libre accès (Directory of Open Access Journals)
* [https://apropos.erudit.org/partenariat/ 10 ans de soutien à la publication équitable en libre accès au] Canada par le biais du ''Partenariat pour le libre accès'', une initiative menée par les partenaires INKE [https://www.crkn-rcdr.ca/fr/propos-du-rcdr Réseau canadien de documentation pour la recherche ] et Érudit[https://apropos.erudit.org/?lang=en . ]
* Deux rapports publiés en anglais par [https://investinopen.org/blog/announcing-the-2024-survey-of-recent-open-science-policy-developments/ Invest in Open Infrastructure], l'un sur l[https://zenodo.org/records/11499591?ref=investinopen.org 'évolution de la politique en matière de science ouverte] en Afrique, en Europe, en Amérique latine et aux États-Unis, et l'autre sur l'[https://zenodo.org/records/10934089 état de l'infrastructure ouverte en 2024.]
* Un autre rapport en anglais, publié par le Centre for Global Development (CGD), sur les [https://www.cgdev.org/blog/g20-open-access-policies-opportunity-harmonisation positions politiques des membres du G20 en matière de libre accès.]

==La communauté avant la commercialisation==
Le thème de la Semaine du libre accès 2024 réitère son appel à placer «&amp;#8239;la communauté avant la commercialisation&amp;#8239;».  À fait opportun, alors que l'on apprend que les éditeurs d'ouvrages savants à but lucratif ont vu leurs bénéfices augmenter pour 2023 - prenez, par exemple, la société mère d'Elsevier, RELX, qui a annoncé une augmentation de 10 % de ses bénéfices pour 2023 (ce qui équivaut approximativement à 3 189 967 950,00 dollars canadiens). Elsevier représente 33,7 % des revenus de RELX et 40,5 % de ses bénéfices, écrit Craig Nicholson dans [https://www.researchprofessionalnews.com/rr-news-europe-infrastructure-2024-2-elsevier-parent-reports-10-hike-in-profits-for-2023/ cet article pour Research Professional News]).

Ce thème est également lié aux préoccupations actuelles dans le monde concernant comme «&amp;#8239;la ruée vers l’intégration de l’intelligence artificielle dans les systèmes universitaires commerciaux sans consulter la communauté&amp;#8239;» ([https://www.openaccessweek.org/theme/fr Semaine internationale du libre accès 2024]).

Le thème «&amp;#8239;la communauté avant la commercialisation&amp;#8239;» est sous-tendu par des questions sur les conséquences de la prise de contrôle croissante des conditions de production et de diffusion des connaissances par des organisations à but lucratif, ainsi que par d'autres questions qui incluent les implications que les modèles commerciaux pourraient avoir pour exacerber les inégalités ou saper la liberté académique ([https://www.openaccessweek.org/theme/fr Semaine internationale du libre accès 2024]).

Ce thème et les questions qu'il soulève sont également en phase avec les quatre recommandations de haut niveau publiées par le comité de pilotage de Budapest sur le libre accès à l'occasion du [https://www.budapestopenaccessinitiative.org/boai20/boai20-french-translation/ 20e anniversaire de l'initiative de Budapest sur le libre accès]. À titre de référence, ces recommandations sont les suivantes e

* Accueillir la recherche ouverte sur l'infrastructure ouverte
* Réformer les pratiques et les politiques d'évaluation de la recherche (et éliminer les mesures dissuasives de l'EA)
* Donner la priorité à des canaux d'édition et de distribution inclusifs et cesser d'exclure les auteurs pour des raisons économiques.
* Éviter de concentrer la nouvelle littérature OA dans des revues commerciales (à but lucratif) et favoriser les modèles OA qui profitent à toutes les régions du monde.

([https://www.budapestopenaccessinitiative.org/boai20/boai20-french-translation/ Groupe de pilotage BOAI20 2022])

Plusieurs [https://www.openaccessweek.org/events événements] (en anglais) sont prévus dans le monde entier. En voici quelques exemples :

* 20 octobre 2024 : Danny Kingsley (Deakin) sur la communauté et la commercialisation (la version anglaise est [https://www.openaccessweek.org/events/2024/keynote-address-community-over-commercialisation ici)].
* 21 octobre 2024 : Table ronde sur le libre accès aux diamants (la version anglaise est [https://www.openaccessweek.org/events/2024/panel-discussion-diamond-open-access-sustainable-concept-or-utopian ici])
* 21 octobre 2024 : Table ronde sur la communauté et la commercialisation (la version anglaise est [https://www.openaccessweek.org/events/2024/panel-discussion-community-over-commercialisation ici])
* 24 octobre 2024 : Conférence, donnée par David Gaertner (Institute for Critical Indigenous Studies, UBC), intitulée «&amp;#8239;'Stop Generating' : Generative AI in the Contexts of Indigenous Studies,&amp;#8239;»  organisée par The University of British Columbia Vancouver and Okanagan Libraries (la version anglaise est [https://www.openaccessweek.org/events/2024/stop-generating-generative-ai-in-the-contexts-of-indigenous-studies ici]).
* 23 octobre 2024 : Conférence donnée par le Dr. Monica Granados, intitulée «&amp;#8239;Handing you the keys to open access,&amp;#8239;» organisée par les bibliothèques de l'Université métropolitaine de Toronto ([https://www.openaccessweek.org/events/2024/open-access-week-2024-handing-you-the-keys-to-open-access  la version anglaise est ici]).

Une liste complète des [https://www.openaccessweek.org/events événements est disponible sur le site de la Semaine du libre accès.]

==Un tour d'horizon non exhaustif des mises à jour de l'Open Access pour 2024==
Bien que 2023 ait été déclarée [https://www.nature.com/articles/d41586-023-00019-y Année du libre accès par la NASA] (ainsi que par une coalition de plus de 85 universités américaines et 10 agences fédérales), 2024 a été une année chargée pour le libre accès. Cette section propose un tour d'horizon exhaustif des mises à jour, développements et autres nouvelles liées au libre accès dans le monde et au Canada, organisé par mois.

'''Le mois de janvier '''débute avec la publication d'un article dans Scientometrics par Huang, Neylon et Montgomery (la version anglaise est [https://doi.org/10.1007/s11192-023-04894-0 ici]) qui montre que les publications en libre accès, en particulier celles qui sont mises à disposition en dehors de l'éditeur (par exemple, via un dépôt institutionnel), sont citées par un plus grand nombre de personnes à travers le monde.

En '''février''', le Japon a annoncé des changements dans sa politique de libre accès. À partir d'avril 2025, les chercheurs bénéficiant d'un financement public seront tenus de mettre leurs travaux en libre accès via des dépôts institutionnels ([https://blog.mdpi.com/2024/02/27/open-access-in-japan/ McKenna 2024]).

En '''mars, '''[https://www.gatesfoundation.org/about/policies-and-resources/open-access-policy la Fondation Bill et Melinda Gates a annoncé l']adoption d'une politique de libre accès comprenant un engagement à fournir une assistance pour le développement d'une infrastructure ouverte, l'obligation pour les bénéficiaires de subventions de publier des préimprimés et l'arrêt du soutien aux frais de traitement des articles.

En '''mars '''également, [https://ec.europa.eu/commission/presscorner/detail/en/ip_24_1701 la République de Corée (Corée du Sud) a rejoint Horizon Europe], le principal programme de financement de l'UE, ce qui signifie que les chercheurs sud-coréens qui reçoivent des fonds du programme seront tenus de publier leurs recherches en OA (McKenna 2023). La Corée du Sud n'a pas encore de politique nationale officielle en matière d'OA ([https://www.cgdev.org/blog/g20-open-access-policies-opportunity-harmonisation Demeshko et Drake, 2024]).

'''En avril, '''la [https://barcelona-declaration.org/downloads/barcelonadeclaration_fran%25C3%25A7ais.pdf Déclaration de Barcelone sur l'information de recherche ouverte] a été publiée à l'issue d'un vaste processus de collaboration auquel ont participé plus de 25 experts. La Déclaration énonce quatre engagements :

* Faire de la transparence la règle par défaut pour les informations que nous utilisons et produisons dans le domaine de la recherche
* Travailler avec des services et des systèmes qui soutiennent et permettent l'accès à l'information sur la recherche ouverte
* Soutenir la durabilité des infrastructures d'information sur la recherche ouverte
* Soutenir l'action collective pour accélérer la transition vers l'ouverture des informations sur la recherche

Plus de 40 organisations ajoutent leur nom à la [https://barcelona-declaration.org/signatories/ liste des signataires] avant la fin du mois d'avril ([https://sparcopen.org/news/2024/barcelona-declaration-pushes-for-open-default-to-research-information/ SPARC 2024]). La liste continue de s'allonger, mais en dehors d'[https://apropos.erudit.org/barcelona-declaration/?lang=en Érudit] et de [https://pkp.sfu.ca/2024/06/04/pkp-barcelona-declaration/ PKP], il y a une absence notable d'universités canadiennes et d'autres organismes de recherche.

En '''mai''', la Suisse [https://www.swissuniversities.ch/en/topics/open-science/open-access/national-strategy a publié sa stratégie nationale révisée en matière de libre accès]. Les mises à jour de la Stratégie comprennent le maintien des engagements visant à garantir que la publication dans le libre accès diamant est accessible aux auteurs. Ailleurs, le Royaume-Uni a annoncé des mises à jour de sa politique de libre accès, qui comprend désormais l'obligation de publier des monographies, des chapitres de livres et des collections éditées en plus des articles de recherche évalués par les pairs ([https://www.ukri.org/publications/ukri-open-access-policy/ UK Research and Innovation 2021 ; ][https://www.ukri.org/news/ukri-updates-guidance-for-open-access-policy/ UK Research and Innovation 2023]). Au Canada, le Fonds de recherche du Québec a annoncé la création du [https://frq.gouv.qc.ca/dix-millions-de-dollars-accordes-a-la-creation-du-reseau-quebecois-de-recherche-et-de-mutualisation-pour-les-revues-scientifiques/ Réseau québécois de recherche et de mutualisation pour les revues scientifiques], ainsi qu'un engagement financier important (10 millions de dollars canadiens sur cinq ans). L'un des principaux objectifs du Réseau sera «&amp;#8239;soutenir la publication scientifique de langue française dans le système universitaire québécois&amp;#8239;» en offrant, entre autres, «&amp;#8239;un appui soutenu pour aider les revues scientifiques québécoises&amp;#8239;» à établir un modèle d'édition en libre accès (Bilodeau 2024).

En '''juin, '''le Japon a annoncé le déblocage d'un financement de 63 millions USD destiné au développement des infrastructures nécessaires pour soutenir sa stratégie de libre accès ([https://www.nature.com/articles/d41586-024-01493-8 Chawla 2024] ; [https://open-access.network/en/services/news/article/green-open-access-for-japan Open Access Network 2024]). Un partenariat entre PubScholar (une plateforme académique publique créée par l'Académie chinoise des sciences) et le Directory of Open Access Journals a également été annoncé en juin (lire la [https://blog.doaj.org/2024/06/14/press-release-pubscholar-joins-the-movement-to-support-the-directory-of-open-access-journals/ version anglaise ici]). Par ailleurs, Invest in Open Infrastructure a publié une [https://zenodo.org/records/11499591?ref=investinopen.org étude sur l'évolution des politiques en matière de science ouverte ]en Afrique, en Europe, en Amérique latine et aux États-Unis. Cette étude s'appuie sur un rapport publié plus tôt dans l'année sur [https://zenodo.org/records/10934089 l'état de l'infrastructure ouverte en 2024]. Les deux rapports offrent une vue d'ensemble des politiques ou stratégies de science ouverte récemment mises en œuvre ou à venir sur le continent africain (Sellanga et al. 2024, 5).

En '''juillet''', l'UNESCO a [https://www.unesco.org/fr/articles/annonce-de-lalliance-mondiale-pour-lacces-ouvert-diamant annoncé et présenté l'Alliance Mondiale pour l’accès ouvert Diamant] (un enregistrement de l'annonce est disponible [https://www.youtube.com/watch?v=ZmNblPxt_nU ici]).

En '''août''', les trois agences nationales de financement de la recherche au Canada ont [https://science.gc.ca/site/science/fr/financement-interorganismes-recherche/politiques-lignes-directrices/libre-acces/rapport-nous-avons-entendu-activites-mobilisation-revision-politique-trois-organismes-libre-acces publié un rapport résumant les résultats de leur enquête sur l'examen des politiques de libre accès]. Au total, 1 431 personnes ont répondu à l'enquête. Parmi les principales conclusions, on note un soutien notable des participants aux modèles d'accès libre peu ou pas coûteux (tels que l'accès libre diamant ou vert). Les obstacles à la publication en libre accès comprennent les frais de traitement des articles, ainsi que l'infrastructure limitée et les incitations pour les revues scientifiques à publier des manuscrits en libre accès.

En '''septembre, '''l'UNESCO, la [https://www.nrf.ac.za/second-open-access-essay-competition-2024-africa-region-community-over-commercialisation-for-diamond-open-access/ NRF], SPARC, [https://www.redalyc.org/ Redalyc] et [https://amelica.org/index.php/en/home/ AmeliCA ][https://www.nrf.ac.za/second-open-access-essay-competition-2024-africa-region-community-over-commercialisation-for-diamond-open-access/ ont annoncé] un appel à candidatures pour ''la deuxième édition du concours d'essais en libre accès''. La première édition du concours, qui s'est tenue en Amérique latine en 2020, a reçu 68 manuscrits d'étudiants de premier et deuxième cycles situés dans 13 pays différents. Le thème du concours de cette année est «&amp;#8239;''La communauté plutôt que la commercialisation pour le libre accès au diamant''&amp;#8239;». Les lauréats bénéficieront d'un soutien pour assister au [https://doasummit.uct.ac.za/fr/ deuxième sommet Mondial sur l’accès ouvert Diamant, qui se tiendra au Cap]. Les essais gagnants seront publiés en 2025.

En '''octobre''', [https://www.crkn-rcdr.ca/fr/propos-du-rcdr le Réseau canadien de documentation pour la recherche ](RCDR) et [https://apropos.erudit.org/ Érudit], partenaires de l'INKE, célèbrent [https://apropos.erudit.org/partenariat/ dix ans de soutien à l'édition équitable en libre accès] par l'intermédiaire du Partenariat pour le libre accès (POA). S'inscrivant dans le mouvement diamantaire du libre accès, le Partenariat soutient plus de 240 revues savantes non commerciales au Canada grâce aux contributions financières fournies conjointement par un nombre impressionnant de bibliothèques universitaires au Canada (54 pour être exact) et dans le monde (39 en France et en Belgique). Chaque année, on estime que le POA permet la publication de plus de 2000 articles en accès libre immédiat ([https://apropos.erudit.org/partenariat/ Érudit], n.d.). Claire Duncan, responsable de la stratégie et de l'engagement au RCDR, nous a fait part du commentaire suivant : «&amp;#8239;Les dix années de ce partenariat sont une véritable expression des possibilités novatrices qu'offre la priorité donnée au libre accès dirigé par la communauté. Grâce au POA, nous favorisons l'accès à des contenus de recherche essentiels et nous nous faisons les champions de la bibliodiversité et de la durabilité dans l'écosystème de la recherche au Canada. Cette initiative communautaire engage les bibliothèques, les revues et les fournisseurs d'infrastructure dans une collaboration visant à mettre en place un système canadien de publication en libre accès équitable, non commercial et robuste. Notre partenariat soutient les revues appartenant à la communauté par un financement durable et les aide en fin de compte à évoluer vers un modèle d'accès libre diamantaire où le contenu est disponible en libre accès et où les auteurs peuvent publier en libre accès sans aucun frais.&amp;#8239;»

'''Le mois d'octobre '''a également vu la [https://www.cgdev.org/publication/how-science-diplomacy-can-reshape-global-research-publishing-theory-change publication d'un rapport du Centre for Global Development (CGD]) sur les positions des membres du G20 en matière de politique de libre accès. L'analyse menée par le CGD montre que la plupart des membres ont mis en place une certaine forme de politique ou de stratégie en matière de libre accès (voir [https://www.cgdev.org/blog/g20-open-access-policies-opportunity-harmonisation le résumé des principales conclusions en anglais ici]). Plusieurs pays, dont la France, l'Inde, le Mexique et la Turquie, exigent la publication immédiate en libre accès, et d'autres membres (comme le Canada, l'UE et le Japon) sont en train de réviser leurs politiques de libre accès en faveur du libre accès immédiat. Selon le CGD, l'Afrique du Sud, la Russie, la Corée du Sud, l'Indonésie, le Brésil et l'Union africaine figurent parmi les membres du G20 qui n'ont pas mis en place de politiques nationales officielles en matière de libre accès ([https://www.cgdev.org/blog/g20-open-access-policies-opportunity-harmonisation Demeshko et Drake 2024]).

Enfin, le '''mois d'octobre '''a également été marqué par la publication du [https://www.stm-assoc.org/oa-dashboard-2024/ tableau de bord STM OA Dashboard pour 2024] (en anglais). Selon ce tableau de bord, trois fois plus des articles de revues, des comptes rendus et des documents de conférence ont été publiés en libre accès en 2024 qu'en 2013 (11 %). Malheureusement, comme le note STM dans sa méthodologie, une limitation importante de cette dernière est qu'elle ne prend en compte que les formes d'accès aux publications de type bronze, or, vert et par abonnement uniquement. Les publications en libre accès de type platine ou diamant sont incluses dans la catégorie d'accès or.

En '''décembre, '''le deuxième [https://doasummit.uct.ac.za/fr/ sommet mondial sur le libre accès aux diamants] sera organisé par l'université du Cap. Les conclusions du premier sommet mondial sur le libre accès au diamant, qui [https://globaldiamantoa.org/fr/home-2-4-6/ s'est tenu à Toluca, au Mexique], [https://globaldiamantoa.org/wp-content/uploads/2023/11/202310-Sommet-Mondial-AOD-Conclusions.pdf sont disponibles ici]. Plusieurs partenaires de l'INKE ont participé au premier sommet mondial, notamment Érudit et PKP (lire leur [https://www.coalition-publi.ca/news-nouvelles/summit-diamond-oa-toluca réflexion commune sur l'expérience ici]). Érudit et PKP, tous deux partenaires du projet d'infrastructure canadien [https://www.coalition-publi.ca/le-projet Coalition Publica], ont été reconnus l'année dernière lors du Sommet mondial comme jouant un rôle important dans l'alimentation et le maintien des conversations sur le libre accès et la science ouverte.

À l'horizon '''2025''', les 194 États membres de l'UNESCO devront [https://www.unesco.org/en/open-science/2025reports soumettre des] rapports nationaux sur la [https://www.unesco.org/en/open-science/implementation mise en œuvre de la Recommandation de l'UNESCO de 2021 sur la science ouverte] avant la fin du mois de février 2025. Les rapports seront utilisés pour déterminer l'état d'avancement des efforts de mise en œuvre, ainsi que les tendances régionales et mondiales en matière de science ouverte. En outre, les politiques et stratégies d'information liées à la science ouverte et à l'accès ouvert seront rassemblées à l'aide des rapports et incorporées dans l'[https://www.unesco.org/en/go-spin?hub=686 Observatoire mondial des instruments de politique STI de l'UNESCO]. Nous prévoyons également la publication d'une politique révisée de libre accès par les trois agences nationales de financement de la recherche au Canada.

==Questions et considérations clés==
Si l'année 2024 a été marquée par de nombreuses réussites dans le domaine de l'accès libre, de nombreux défis subsistent. Par exemple, bien qu'une étude portant sur 420 millions de citations ait montré que les publications en libre accès étaient citées par un plus grand nombre de personnes dans le monde, des disparités Nord-Sud notables continuent de prévaloir ([https://blogs.lse.ac.uk/impactofsocialsciences/2024/01/30/open-access-works-420-million-citations-show-oa-outputs-are-cited-by-more-researchers-from-more-places/ Huang, Neylon et Montgomery, 2024]). Dans un [https://blogs.lse.ac.uk/impactofsocialsciences/2024/01/30/open-access-works-420-million-citations-show-oa-outputs-are-cited-by-more-researchers-from-more-places/ article explicatif rédigé pour le blog Impact of Social Sciences], Huang, Neylon et Montgomery (2024) soulignent que les chercheurs situés dans le nord de l'Europe qui ont publié en libre accès ont connu les plus fortes augmentations du nombre de citations, ainsi que la plus forte augmentation du nombre de fois où leurs travaux ont été cités par des chercheurs d'Afrique subsaharienne - mais la même chose n'était pas vraie dans le sens inverse.

Comme le note [https://www.nature.com/articles/d41586-024-01748-4 Else (2024)], l'accès à une infrastructure ouverte joue un rôle clé dans la capacité des chercheurs situés dans les pays à faible revenu à rendre leurs travaux librement accessibles. Souvent, l'objectif de cette infrastructure est de rendre à la communauté le contrôle de la publication et de la diffusion, explique Kathleen Fitzpatrick dans une allocution intitulée «&amp;#8239;[https://hsscommons.ca/fr/publications/7413/1 Open Infrastructures for the Future of Knowledge Production]&amp;#8239;» ([https://hsscommons.ca/en/publications/7413/1 Infrastructures ouvertes pour l'avenir de la production de connaissances]) prononcée devant les participants à la réunion «&amp;#8239;Implementing New Knowledge Environments&amp;#8239;» (Mise en œuvre de nouveaux environnements de connaissances) qui s'est tenue à Montréal [https://inke.ca/creative-approaches-to-open-social-scholarship-canada/ en juin dernier] et qui portait sur les approches créatives de l'érudition sociale ouverte au Canada. Cependant, ces infrastructures dépendent souvent d'autres infrastructures détenues et contrôlées par des entreprises (comme Amazon Web Services), ce qui remet en question la durabilité à long terme de ces infrastructures et systèmes (Fitzpatrick 2024). En effet, ces questions plus profondes concernant l'écosystème plus large de l'édition savante, y compris la façon dont l'impact de la recherche est mesuré et défini, continueront sans doute à être au premier plan de la lutte pour le libre accès à l'horizon 2025 et au-delà. Ou, si elles ne le sont pas, elles devraient l'être, car, comme le souligne Susan Murray (African Journals OnLine), «&amp;#8239;[https://doi.org/10.1038/d41586-024-01748-4 sans changer certains des aspects les plus enracinés des systèmes de recherche locaux, les avantages du libre accès pour les chercheurs des pays à faible revenu pourraient ne pas se concrétiser pleinement]&amp;#8239;» (Else, 2024).

==Références==
*Bilodeau, Maxime. 2024. «&amp;#8239;Libre accès : une mine de diamants sous ses pieds.«&amp;#8239;» ''Affaires universitaires ''(blog). 21 août 2024. [https://www.affairesuniversitaires.ca/actualites/actualites-article/libre-acces-une-mine-de-diamants-sous-ses-pieds/ https://www.affairesuniversitaires.ca/actualites/actualites-article/libre-acces-une-mine-de-diamants-sous-ses-pieds/]

*Groupe de pilotage BOAI20. 2022. «&amp;#8239;L’initiative de Budapest pour l’accès ouvert : recommandations du 20e anniversaire&amp;#8239;». ''Initiative de Budapest pour l’accès ouvert''. 15 mars 2022. [https://www.budapestopenaccessinitiative.org/boai20/boai20-french-translation/ https://www.budapestopenaccessinitiative.org/boai20/boai20-french-translation/]

*Chawla, Dalmeet Singh. 2024. «&amp;#8239;Japan's Push to Make All Research Open Access Is Taking Shape&amp;#8239;» (La volonté du Japon de rendre toute la recherche libre d'accès prend forme). ''Nature'', mai. [https://doi.org/10.1038/d41586-024-01493-8 https://doi.org/10.1038/d41586-024-01493-8].

*Demeshko, Anastassia, et Tom Drake. s.d. «&amp;#8239;G20 Open Access Policies : An Opportunity for Harmonisation&amp;#8239;». ''Center for Global Development ''(blog). Consulté le 8 octobre 2024. [https://www.cgdev.org/blog/g20-open-access-policies-opportunity-harmonisation https://www.cgdev.org/blog/g20-open-access-policies-opportunity-harmonisation].

*DOAJ. 2024. «&amp;#8239;Communiqué de presse : PubScholar rejoint le mouvement de soutien au répertoire des revues en libre accès&amp;#8239;». ''Blog du DOAJ''. 14 juin 2024. [https://blog.doaj.org/2024/06/14/press-release-pubscholar-joins-the-movement-to-support-the-directory-of-open-access-journals/ https://blog.doaj.org/2024/06/14/press-release-pubscholar-joins-the-movement-to-support-the-directory-of-open-access-journals/].

*Else, Holly. 2024. «&amp;#8239;Open Access Is Working - but Researchers in Lower-Income Countries Enjoy Fewer Benefits&amp;#8239;» (Le libre accès fonctionne, mais les chercheurs des pays à faible revenu bénéficient de moins d'avantages). ''Nature'', juin. [https://doi.org/10.1038/d41586-024-01748-4 https://doi.org/10.1038/d41586-024-01748-4].

*Érudit. n.d. «&amp;#8239;Le POA : soutenir un libre accès équitable&amp;#8239;». ''Érudit''. Consulté le 8 octobre 2024. [https://apropos.erudit.org/partenariat/ https://apropos.erudit.org/partenariat/].

*Fitzpatrick, Kathleen. 2024. «&amp;#8239;Open Infrastructures for the Future of Knowledge Production&amp;#8239;» (Infrastructures ouvertes pour l'avenir de la production de connaissances). Keynote présentée à ''Creative Approaches to Open Social Scholarship : Canada (réunion du partenariat Implementing New Knowledge Environments (INKE))''. Montréal, Canada. [https://hsscommons.ca/fr/publications/7413/1/ https://hsscommons.ca/fr/publications/7413/1/].

*Gordon, Ashley. 2024. «&amp;#8239;La déclaration de Barcelone prône l'accès libre à l'information sur la recherche&amp;#8239;». ''SPARC''. 16 avril 2024. [https://sparcopen.org/news/2024/barcelona-declaration-pushes-for-open-default-to-research-information/ https://sparcopen.org/news/2024/barcelona-declaration-pushes-for-open-default-to-research-information/].

*Huang, Chun-Kai, Cameron Neylon et Lucy Montgomery. 2024. «&amp;#8239;Open Access Works - 420 Million Citations Show OA Outputs Are Cited by More Researchers from More Places&amp;#8239;» (L'accès libre fonctionne - 420 millions de citations montrent que les résultats de l'accès libre sont cités par plus de chercheurs dans plus d'endroits). ''Impact of Social Sciences ''(blog). 30 janvier 2024. [https://blogs.lse.ac.uk/impactofsocialsciences/2024/01/30/open-access-works-420-million-citations-show-oa-outputs-are-cited-by-more-researchers-from-more-places/ https://blogs.lse.ac.uk/impactofsocialsciences/2024/01/30/open-access-works-420-million-citations-show-oa-outputs-are-cited-by-more-researchers-from-more-places/]

*Huang, Chun-Kai, Cameron Neylon, Lucy Montgomery, Richard Hosking, James P. Diprose, Rebecca N. Handcock et Katie Wilson. 2024. «&amp;#8239;Les résultats de la recherche en libre accès font l'objet de citations plus diversifiées&amp;#8239;». ''Scientometrics ''129 (2) : 825–45. [https://doi.org/10.1007/s11192-023-04894-0 https://doi.org/10.1007/s11192-023-04894-0].

*Semaine internationale du libre accès. 2024. «&amp;#8239;Semaine internationale du libre accès 2024 : Community over Commercialization[https://www.openaccessweek.org/theme/en&amp;#8239;». ]https://www.openaccessweek.org/theme/en.

*McKenna, Jack. 2024. «&amp;#8239;Open Access in Japan&amp;#8239;». ''MDPI Blog ''(blog). 27 février 2024. [https://mdpiblog.wordpress.sciforum.net/2024/02/27/open-access-in-japan/ https://mdpiblog.wordpress.sciforum.net/2024/02/27/open-access-in-japan/].

*Nicholson, Craig. 2024. «&amp;#8239;Elsevier Parent annonce une hausse de 10 % de ses bénéfices pour 2023&amp;#8239;». ''Research Professional News''. 15 février 2024. [https://www.researchprofessionalnews.com/rr-news-europe-infrastructure-2024-2-elsevier-parent-reports-10-hike-in-profits-for-2023/ https://www.researchprofessionalnews.com/rr-news-europe-infrastructure-2024-2-elsevier-parent-reports-10-hike-in-profits-for-2023/].

*«&amp;#8239;Tableau de bord de l'OA 2024&amp;#8239;». 2024. Tableau de bord OA. ''STM ''(blog). 2024. [https://www.stm-assoc.org/oa-dashboard-2024/ https://www.stm-assoc.org/oa-dashboard-2024/].

*Open Access Network (Réseau d'accès ouvert). 2024. «&amp;#8239;Green Open Access for Japan&amp;#8239;» («&amp;#8239;L'accès ouvert et vert pour le Japon&amp;#8239;»). ''Open Access Network News''. 5 juin 2024. [https://open-access.network/en/services/news/article/green-open-access-for-japan https://open-access.network/en/services/news/article/green-open-access-for-japan].

*Sellanga, Jerry, Gail Steinhart, Emmy Tsang et Nicky Wako. 2024. «&amp;#8239;2024 Survey of Recent Open Science Policy Developments&amp;#8239;» («&amp;#8239;Enquête 2024 sur les développements récents de la politique de la science ouverte&amp;#8239;»). ''Invest in Open Infrastructure.'' [https://doi.org/10.5281/zenodo.11499591 https://doi.org/10.5281/zenodo.11499591].

*Steinhart, Gail, Lauren Collister, Chun-Kai (Karl) Huang, Sarah Lippincott, Cameron Neylon, David Riordan, Jerry Sellanga, Katherine Skinner, Kaitlin Thaney et Emmy Tsang. 2024. «&amp;#8239;2024 State of Open Infrastructure: Trends in Characteristics, Funding, Governance, Adoption, and Policy&amp;#8239;» («&amp;#8239;État de l'infrastructure ouverte en 2024 : endances en matière de caractéristiques, de financement, de gouvernance, d'adoption et de politique&amp;#8239;»). ''Invest in Open Infrastructure''. [https://doi.org/10.5281/zenodo.10934089 https://doi.org/10.5281/zenodo.10934089].

*Recherche et innovation au Royaume-Uni. 2021. «&amp;#8239;UKRI Open Access Policy&amp;#8239;»  («&amp;#8239;Politique de libre accès de l'UKRI&amp;#8239;»). ''UK Research and Innovation''. 6 août 2021. [https://www.ukri.org/publications/ukri-open-access-policy/ https://www.ukri.org/publications/ukri-open-access-policy/].

*Recherche et innovation au Royaume-Uni. 2023. «&amp;#8239;UKRI Updates Guidance for Open Access Policy&amp;#8239;» («&amp;#8239;L'UKRI met à jour ses orientations en matière de politique de accès ouvert&amp;#8239;»). ''UK Research and Innovation''. 24 mai 2023. [https://www.ukri.org/news/ukri-updates-guidance-for-open-access-policy/ https://www.ukri.org/news/ukri-updates-guidance-for-open-access-policy/]

*UNESCO. 2024. «&amp;#8239;Annonce de l’Alliance Mondiale pour l’accès ouvert Diamant&amp;#8239;». ''Événement de l'UNESCO''. 10 juillet 2024. [https://www.unesco.org/fr/articles/annonce-de-lalliance-mondiale-pour-lacces-ouvert-diamant https://www.unesco.org/fr/articles/annonce-de-lalliance-mondiale-pour-lacces-ouvert-diamant]

[[Catégorie:Extension : Observatoire des politiques sur les savoirs ouverts, 2021-2024 (livre)]]</text>
      <sha1>795vbthmh51uf1cr3v2a8ngwi6eg4jr</sha1>
    </revision>
  </page>
  <page>
    <title>Extension : Observatoire des politiques sur les savoirs ouverts, 2021-2024/Réponses à l’intelligence artificielle</title>
    <ns>0</ns>
    <id>82376</id>
    <revision>
      <id>744025</id>
      <parentid>742851</parentid>
      <timestamp>2025-06-02T23:21:44Z</timestamp>
      <contributor>
        <username>LodestarChariot2</username>
        <id>120009</id>
      </contributor>
      <minor />
      <comment>/* Références */</comment>
      <origin>744025</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="37039" sha1="82160whfmle38fshg3j66ot9abx36h4" xml:space="preserve">''Ce rapport «&amp;#8239;Insights and Signals&amp;#8239;» a été rédigé par Brittany Amell (avec nos remerciements à John Willinsky, John Maxwell et William Bowen pour leurs commentaires et contributions), pour le Electronic Textual Cultures Laboratory et le partenariat Implementing New Knowledge Environments.''

Les rapports'' «&amp;#8239;Policy Insights and Signals&amp;#8239;» ''scrutent l'horizon afin d'identifier et d'analyser les tendances émergentes et les signaux précurseurs susceptibles d'influer sur les orientations politiques futures en matière de libre accès et d'érudition ouverte et sociale. Ils ont tendance à mettre en évidence les changements dans la technologie, l'opinion et les sentiments du public, et/ou les changements réglementaires à l'intérieur et à l'extérieur du Canada. Tout comme les observations politiques de l'OSPO, les rapports sur les perspectives et les signaux visent à aider les partenaires à élaborer des stratégies proactives, réactives et tournées vers l'avenir.

Ce rapport'' Insights and Signals'' est le premier d'une série qui se concentre sur l'évolution des discussions centrées sur l'intelligence artificielle (IA), en particulier l'IA générative (genAI) et les grands modèles de langage (LLM), et sur les implications qu'elles peuvent avoir pour l'accès libre et la recherche sociale ouverte. 

D'autres rapports «&amp;#8239;Insights and Signals&amp;#8239;» consacrés à l'intelligence artificielle vous intéressent ? Vous les trouverez [[Extension : Observatoire des politiques sur les savoirs ouverts, 2021-2024/L’IA générative et l’édition savante|ici]] et [[Extension : Observatoire des politiques sur les savoirs ouverts, 2021-2024/Les agences fédérales de financement de la recherche annoncent un projet de lignes directrices sur l’utilisation de l’intelligence artificielle générative|ici]].

Les points abordés dans ce rapport sont les suivants

* Une brève introduction à l'intelligence artificielle générative, avec des commentaires de John Maxwell
* [https://www.consilium.europa.eu/fr/press/press-releases/2024/05/21/artificial-intelligence-ai-act-council-gives-final-green-light-to-the-first-worldwide-rules-on-ai/ La première loi mondiale sur l'intelligence artificielle] adoptée en mai 2024 par le Conseil de l'Union européenne.
* L'inclusion de l'intelligence artificielle dans la [https://www.parl.ca/legisinfo/fr/projet-de-loi/44-1/c-27 loi de mise en œuvre de la Charte numérique du Canada] (2022), ainsi que les critiques de [https://news.westernu.ca/2024/04/proposed-ai-legislation/ Joanna Redden] (2024), professeure associée à la faculté d'études sur l'information et les médias de l'université Western, de critique la législation proposée par le Canada en matière d'intelligence artificielle dans sa forme actuelle.
* Plusieurs réactions à l'IA au Canada de la part de revues, d'établissements postsecondaires, de sociétés savantes et d'organismes subventionnaires, ainsi que certaines préoccupations fondamentales soulevées par ces groupes.
* Une [https://www.pm.gc.ca/fr/nouvelles/communiques/2024/04/07/pour-avantage-canadien-matiere-dintelligence-artificielle annonce] du premier ministre Justin Trudeau (2024) concernant son intention de consacrer 2,4 milliards de dollars pour assurer un avantage canadien en matière d'intelligence artificielle
* Réponses des partenaires de l'INKE John Willinsky (fondateur du Public Knowledge Project) et John Maxwell (professeur associé d'édition à l'Université Simon Fraser)
* Certains silences discursifs proposés à prendre en considération, tels que les perspectives sur l[https://montrealethics.ai/in-consideration-of-indigenous-data-sovereignty-data-mining-as-a-colonial-practice/ 'extraction des données comme pratique,] et la [https://ubctoday.ubc.ca/news/june-06-2024/indigenous-data-stewardship-stands-against-extractivist-ai souveraineté des données autochtones ]

Ce rapport se termine par quelques questions et considérations clés.

'''Remarque : Nous vous présentons nos excuses en avance, car la plupart des sources mentionnées dans ce rapport sont disponibles en anglais uniquement.'''

==Présentation succincte de l'intelligence artificielle générative==
Les débats largement répandus sur l'avenir de l'intelligence artificielle et la nécessité de cadres éthiques et de politiques réglementaires pour atténuer les dommages potentiels, relancés en 2022 par la première version du système d'intelligence artificielle générative (IA) [https://chat.openai.com/auth/login ChatGPT] d'OpenAI, continuent de retenir l'attention des chercheurs et des médias. Les outils d'intelligence artificielle générative tels que ChatGPT et [https://www.bing.com/ Bing] de Microsoft (tous deux alimentés par GPT-4 d'OpenAI) et [https://gemini.google.com/ Gemini de Google] (Bard, précédemment) peuvent être utilisés pour générer de la poésie, des essais, du code, des traductions et des réponses à des examens, ainsi que des images et des vidéos.

Cependant, si ces outils ont un potentiel énorme, ils créent également des défis et, dans certains cas, des préjudices (par exemple, [https://datajusticelab.org/data-harm-record/ «&amp;#8239;Data Harm Record&amp;#8239;» par Redden et al. 2020] ; voir également, de manière générale, [https://mitpress.mit.edu/9780262548328/more-than-a-glitch/ Broussard 2024], Noble 2018 et O'Neil 2016). Selon Josh Nicholson, cofondateur et PDG de Scite.ai, le modèle de langage large Galactica de Meta pour la science a été «&amp;#8239;retiré en moins d'une semaine parce qu'il était si problématique. Vous pouviez lui donner des instructions et obtenir un article complet en retour, mais il pouvait être raciste ou complètement erroné&amp;#8239;» ([https://www.wiley.com/en-us/network/research-libraries/libraries-archives-databases/open-access/making-ai-an-opportunity-for-open-access cité dans Wiley 2024], 1).

L'intelligence artificielle générative, ou genAI comme nous l'appelons ici, est utilisée pour décrire des outils tels que ceux mentionnés ci-dessus, mais elle décrit en réalité un changement fondamental dans la conception des instructions qui peuvent être suivies pour accomplir une tâche, également connues sous le nom d'algorithmes (Danaher et al. 2017). Ce changement a entraîné l'abandon des algorithmes «&amp;#8239;descendants&amp;#8239;» (où les ensembles de règles pour les algorithmes étaient définis de manière exhaustive par les programmeurs) au profit d'algorithmes d'apprentissage automatique «&amp;#8239;ascendants&amp;#8239;» (où un algorithme est essentiellement formé pour développer son propre ensemble de règles). Les algorithmes d'apprentissage automatique consistent à donner à la machine des données, un objectif, un retour d'information pour lui indiquer qu'elle est sur la bonne voie, puis à lui laisser du temps pour trouver la meilleure façon de suivre les instructions et d'atteindre l'objectif (Fry 2018, p. 11). En d'autres termes, la genAI s'appuie sur l'utilisation de diverses techniques statistiques pour produire les résultats qui émerveillent nombre d'entre nous (Gorwa et al. 2020 ; [https://blogs.lse.ac.uk/politicsandpolicy/why-artificial-intelligence-is-a-misnomer/ Whiteley 2023]).

En effet, le poème que vous avez demandé à ChatGPT de générer est le résultat de calculs probabilistes qui sélectionnent les mots en fonction de leur probabilité de s'adapter (statistiquement) au contexte. Cela semble moins romantique, mais c'est peut-être important - John Maxwell (professeur associé d'édition à l'université Simon Fraser), partenaire d'INKE, le pense en tout cas.

Répondant à cet article par courriel, John Maxwell a écrit : «&amp;#8239;Je suis de plus en plus préoccupé par le fait qu'en réagissant (à la fois individuellement et collectivement, de manière causale et formelle) à l'essor de l'apprentissage en profondeur, du texte génératif et des technologies de l'image - en suivant l'exemple de l'industrie qui les ‹ IA › - nous jouons le jeu d'un groupe de promoteurs d'investissements très habiles et, en même temps, nous sabotons nos propres sensibilités critiques à l'égard des diverses innovations rassemblées sous ce parapluie&amp;#8239;». (Vous pouvez lire l'intégralité de la réponse de John Maxwell en défilant jusqu'à la section «&amp;#8239;Réponses du partenariat INKE&amp;#8239;» ci-dessous).

Maxwell n'est pas le seul à tirer la sonnette d'alarme. Dans un [https://blogs.lse.ac.uk/politicsandpolicy/why-artificial-intelligence-is-a-misnomer/ article] publié sur le blog de la l'École d'économie et de sciences politiques de Londres, Paul Whiteley affirme que «&amp;#8239;l’intelligence artificielle&amp;#8239;» est une appellation erronée, inventée par l'informaticien John McCarthy en 1950 (et anthropomorphisée par le reste d'entre nous depuis lors).

Même ChatGPT est d'accord. Lorsque nous avons demandé à ChatGPT s'il pensait que les utilisateurs avaient tendance à l'anthropomorphiser, il a généré le «&amp;#8239;résultat statistique&amp;#8239;» suivant :

&lt;blockquote&gt;
Oui, les gens m'anthropomorphisent souvent ! C'est tout à fait naturel ; le langage humain et l'interaction impliquent souvent des hypothèses sur des expériences, une compréhension ou des intentions partagées. Étant donné que mes réponses relèvent de la conversation et imitent les schémas du langage humain, les utilisateurs peuvent parfois m'attribuer des pensées, des sentiments ou des intentions, même si je n'ai pas d'expérience, de conscience ou de compréhension personnelle. La familiarité de la conversation peut faire oublier que les réponses proviennent de modèles plutôt que d'un sentiment intérieur. C'est fascinant parce que cela met en évidence à quel point les gens sont prêts à chercher une connexion, même avec une technologie qui est fondamentalement différente de l'esprit humain.
&lt;/blockquote&gt;

John Maxwell (professeur associé d'édition à l'université Simon Fraser et partenaire de l'INKE) nous met toutefois en garde contre cette anthropomorphisation, car elle rend difficile l'élaboration des réponses politiques significatives :

&lt;blockquote&gt;
Alors que, par exemple, «&amp;#8239;LLM&amp;#8239;» définit une technologie spécifique avec des caractéristiques spécifiques pour lesquelles nous pourrions développer une réponse politique cohérente, le terme «&amp;#8239;IA&amp;#8239;» est un fourre-tout de science-fiction qui comporte un ensemble de connotations utopiques, dystopiques et eschatologiques bien médiatisées (et monétisées). Il est peu probable que nous puissions apporter une réponse significative à un objet aussi mal défini. J'espère que, lorsque nous commencerons à élaborer des lignes directrices et des politiques, nous pourrons commencer à différencier ces technologies et à les désigner par leurs noms et fonctions spécifiques, au lieu de répéter le battage médiatique selon lequel ces boîtes noires massives, mystérieuses et appartenant à des entreprises, résoudront simultanément les problèmes de l'humanité tout en constituant une menace existentielle.
&lt;/blockquote&gt;

==L'UE annonce l'approbation de la première loi mondiale sur l'intelligence artificielle==
Sur le plan politique, le Conseil de l'UE [https://www.consilium.europa.eu/fr/press/press-releases/2024/05/21/artificial-intelligence-ai-act-council-gives-final-green-light-to-the-first-worldwide-rules-on-ai/ a officiellement approuvé] en mai dernier la [https://www.consilium.europa.eu/fr/press/press-releases/2024/05/21/artificial-intelligence-ai-act-council-gives-final-green-light-to-the-first-worldwide-rules-on-ai/ première loi mondiale sur l'intelligence artificielle.] La législation suivra une «&amp;#8239;approche fondée sur le risque, ce qui signifie que plus le risque de causer des dommages à la société est élevé, plus les règles sont strictes&amp;#8239;», explique le Conseil dans un [https://www.consilium.europa.eu/en/press/press-releases/2024/05/21/artificial-intelligence-ai-act-council-gives-final-green-light-to-the-first-worldwide-rules-on-ai/ communiqué de presse].

«&amp;#8239;Avec la législation sur l'IA, l'Europe souligne l'importance de la confiance, de la transparence et de l'obligation de rendre des comptes pour ce qui est des nouvelles technologies, tout en veillant dans le même temps à ce que cette technologie en évolution rapide puisse prospérer et stimuler l'innovation européenne&amp;#8239;», déclare Mathieu Michel, Secrétaire d'État fédéral belge à la Digitalisation, chargé de la Simplification administrative, de la Protection de la vie privée et de la Régie des bâtiments ([https://www.consilium.europa.eu/fr/press/press-releases/2024/05/21/artificial-intelligence-ai-act-council-gives-final-green-light-to-the-first-worldwide-rules-on-ai/ Conseil, 2024]).

Quatre organes directeurs, dont «&amp;#8239;un groupe scientifique d'experts indépendants&amp;#8239;», seront chargés de veiller à l'application de la loi sur l'IA. Trois autres organes comprennent un bureau de l'IA au sein de la Commission européenne, un forum consultatif pour les parties prenantes et un conseil de l'IA composé de représentants des États membres ([https://www.consilium.europa.eu/fr/press/press-releases/2024/05/21/artificial-intelligence-ai-act-council-gives-final-green-light-to-the-first-worldwide-rules-on-ai/ Conseil, 2024]).

==Vers une réglementation de l'intelligence artificielle au Canada?==
''' '''Au Canada, l'inclusion de l'intelligence artificielle dans le projet de la loi C-27 (Loi de 2022 sur la mise en œuvre de la Charte du numérique) fait toujours l'objet d'un examen en comité à la Chambre des communes depuis sa deuxième lecture il y a plus d'un an, en avril 2023.

[https://news.westernu.ca/2024/04/proposed-ai-legislation/ Selon Joanna Redden] (2024), professeure à la faculté d'études sur l'information et les médias de l'Université Western, qui critique la législation canadienne sur l'IA proposée dans sa forme actuelle, de nombreux Canadiens ont déjà peu confiance dans l'utilisation croissante de l'IA, même si [https://medium.com/politics-ai/an-overview-of-national-ai-strategies-2a70ec6edfd le Canada a été le premier pays à introduire une stratégie nationale en matière d'IA]. Faisant écho aux préoccupations de personnes telles qu'[https://papers.ssrn.com/sol3/papers.cfm?abstract_id=4658004 Andrew Clement] (professeur émérite, Université de Toronto), ainsi que [https://www.amo-oma.ca/en/ai-policy-report/ McKelvey et ses collègues (2024]), Redden suggère que cette méfiance est due, en partie, à un manque de consultation publique significative, «&amp;#8239;en dépit des préoccupations profondes du public&amp;#8239;». Redden note que la législation proposée est non seulement «&amp;#8239;déjà en décalage avec les besoins des Canadiens&amp;#8239;», mais qu'elle est également «&amp;#8239;en deçà des approches réglementaires adoptées par d'autres nations&amp;#8239;», telles que celle récemment approuvée par [https://www.consilium.europa.eu/fr/press/press-releases/2024/05/21/artificial-intelligence-ai-act-council-gives-final-green-light-to-the-first-worldwide-rules-on-ai/ l'Union européenne] ou le [https://www.whitehouse.gov/briefing-room/presidential-actions/2023/10/30/executive-order-on-the-safe-secure-and-trustworthy-development-and-use-of-artificial-intelligence/ décret publié par la Maison Blanche] en 2023.

Certains des besoins identifiés par Redden incluent la garantie que les utilisations de l’IA par les entreprises et les gouvernements sont transparentes et qu’il existe des mécanismes efficaces pour maintenir la surveillance et la responsabilité. En outre, Redden soutient qu’il est essentiel de consacrer des fonds pour garantir le maintien des «&amp;#8239;registres d’IA&amp;#8239;» publics. En outre, Joanna Redden estime qu'il est essentiel de consacrer des fonds à la tenue de «registres d'IA&amp;#8239;» publics (note : les registres d'IA, [https://tagcanada.shinyapps.io/register/ tels que celui mis au point par Redden et ses collègues], permettent de savoir où et comment l'IA et d'autres systèmes automatisés sont utilisés).

Si elle est adoptée, la [https://www.parl.ca/legisinfo/fr/projet-de-loi/44-1/c-27 Loi de 2022 sur la mise en œuvre de la Charte du numérique] (également connue sous le nom de «&amp;#8239;loi édictant la loi sur la protection de la vie privée du consommateur, la loi sur le Tribunal de la protection des renseignements personnels et des données et la loi sur l'intelligence artificielle et les données, et apportant des modifications corrélatives et connexes à d'autres lois&amp;#8239;») serait la première loi axée sur la réglementation de l'IA au Canada.

Actuellement, les gestionnaires et les développeurs d'IA générative au Canada sont invités à s'engager volontairement à [https://ised-isde.canada.ca/site/ised/en/voluntary-code-conduct-responsible-development-and-management-advanced-generative-ai-systems respecter ]un [https://ised-isde.canada.ca/site/isde/fr/code-conduite-volontaire-visant-developpement-gestion-responsables-systemes-dia-generative-avances Code de conduite volontaire visant un développement et une gestion responsables des systèmes d'IA générative avancés]. Ce code de conduite volontaire met l'accent sur six résultats : la responsabilité, la sécurité, la justice et l'équité, la transparence, la surveillance humaine et le suivi, ainsi que la validité et la robustesse.

==Réponses des revues, des établissements d'enseignement postsecondaire, des sociétés savantes et des organismes subventionnaires à l'IA au Canada==
Dans le but de freiner l'utilisation abusive de l'IA générative, '''plusieurs revues '''(voir [https://www.cmaj.ca/content/195/34/E1168 ici], [https://www.caaa.ca/fr/ ici] et [https://www.jogc.com/article/S1701-2163(23)00167-6/fulltext ici]), '''établissements d'enseignement postsecondaire '''(voir [https://uwaterloo.ca/information-systems-technology/about/policies-standards-and-guidelines/guidance-artificial-intelligence-use ici] et [https://www.senecapolytechnic.ca/about/policies/generative-ai-policy.html ici] pour des exemples, ainsi qu'[https://cdlra-acrfl.ca/wp-content/uploads/2024/05/2023-AI-Special-Topics-Report.pdf ici] pour un commentaire plus général et [https://higheredstrategy.com/ai-observatory-home/ ici] pour l'observatoire de HESA sur l'IA dans le secteur postsecondaire au Canada), '''associations savantes '''(voir [https://publicationethics.org/guidance/cope-position/authorship-and-ai-tools ici] et [https://www.carl-abrc.ca/wp-content/uploads/2023/12/Generative-Artificial-Intelligence-A-Brief-Primer-FR.pdf ici]) et '''organismes subventionnaires '''(en savoir plus [https://science.gc.ca/site/science/fr/financement-interorganismes-recherche/politiques-lignes-directrices/lutilisation-lintelligence-artificielle-generative-dans-lelaboration-levaluation-propositions ici] et [https://ospolicyobservatory.uvic.ca/trois-organismes-ia/ ici]) sont en train d'élaborer et de publier des déclarations, des politiques et/ou des lignes directrices qui définissent les attentes concernant ce qui est considéré comme une utilisation équitable ou responsable de l'IA dans leurs contextes respectifs.

Les préoccupations relatives à la responsabilité, à la paternité, à la transparence, à la divulgation de l'utilisation, à la responsabilité, à l'exactitude, à la partialité, à la sécurité, à la confidentialité et à la vie privée, ainsi qu'aux droits d'auteur et à la propriété intellectuelle reviennent constamment dans ces déclarations, politiques et lignes directrices. Plusieurs revues ainsi que de grands éditeurs tels que SAGE, Elsevier et Wiley interdisent explicitement de citer un outil d'IA (tel que ChatGPT) comme auteur car, comme l'écrit Tulandi (2023) dans une revue médicale canadienne, «&amp;#8239;la qualité d'auteur implique des responsabilités et des tâches qui ne peuvent être attribuées et exécutées que par des êtres humains&amp;#8239;» (paragraphe 7).

Outre les préoccupations soulevées ci-dessus, l'ABRC, ou l'[https://www.carl-abrc.ca/wp-content/uploads/2023/12/Generative-Artificial-Intelligence-A-Brief-Primer-FR.pdf Association des bibliothèques de recherche du Canada (2023)], recommande que les réponses à l'IA générative tiennent également compte des impacts sociaux associés à l'utilisation de l'IA, notamment qui a accès aux outils d'IA générative et qui n'y a pas accès, que ce soit pour des raisons financières ou autres. [https://blog.core.ac.uk/2023/03/17/core-gpt-combining-open-access-research-and-ai-for-credible-trustworthy-question-answering/ Citant les travaux d'un groupe de chercheurs associés à l'Open University au Royaume-Uni], l'ABRC (2023) se demande également si la combinaison d'articles en libre accès et d'articles payants dans le développement d'ensembles de données utilisés pour former l'IA générative pourrait améliorer sa fiabilité et sa crédibilité, bien qu'elle note également le risque d'implications juridiques.

Alors que les débats relatifs à la loi de mise en œuvre de la Charte numérique se poursuivent, le Premier ministre Justin Trudeau (2024) a [https://www.pm.gc.ca/fr/nouvelles/communiques/2024/04/07/pour-avantage-canadien-matiere-dintelligence-artificielle annoncé son intention] de consacrer 2,4 milliards de dollars à la «&amp;#8239;sécurisation de l'avantage du Canada en matière d'IA&amp;#8239;», bien qu'il soit intéressant de noter que seulement 2 % de ce financement (50 millions de dollars) est destiné à l'exploration des impacts sociaux associés à l'utilisation accrue de l'IA.

==Questions et considérations clés==
Les idées et les signaux décrits ci-dessus indiquent que les développements récents de l'IA générative, ainsi que son intégration continue dans divers contextes académiques (et plus largement dans la société), posent des défis importants aux personnes impliquées dans l'élaboration des réponses politiques.

En même temps, même s'il est important de prêter attention aux réponses existantes, les silences discursifs ou les absences (c'est-à-dire ce qui n'est '''pas '''dit, ou peut-être ce qui '''n'est pas '''amplifié et repris dans les rapports sur ce sujet) sont tout aussi importants et méritent d'être pris en considération.

Parmi les absences notables proposées, citons la question de savoir si l'utilisation du contenu en ligne par les LLM est considérée comme une utilisation équitable (ainsi que d'autres considérations relatives au droit d'auteur). D'autres absences importantes concernent l'impact social et écologique des grands modèles de langage (LLM) et les matériaux, la main-d'œuvre et la puissance de calcul nécessaires pour les maintenir – en parallèle avec les conversations sur la durabilité dans les humanités numériques (comme [https://doi.org/10.1093/llc/fqab025 celle] de Johanna Drucker 2021 ou [https://www.thebritishacademy.ac.uk/publishing/journal-british-academy/10/facing-the-challenge-of-digital-sustainability-as-humanities-researchers/ celle] de Joanna Tucker 2022). D'autres incluent les implications des LLM pour les souverainetés des données Autochtone ([https://www.unesco.org/fr/articles/un-nouveau-rapport-et-des-lignes-directrices-pour-maintenir-la-souverainete-des-donnees-autochtones l'UNESCO publie un nouveau rapport et des lignes directrices pour maintenir la souveraineté des données autochtones qui s’inscrivent dans les développements de l'intelligence artificielle]), ainsi que les implications que les souverainetés (des données) autochtone peuvent avoir pour la réflexion sur «&amp;#8239;l’IA éthique&amp;#8239;» (Gaertner 2024 ; Roberts and Montoya 2024).

Par exemple, en réfléchissant à l'intersection entre les nouvelles formes d'[https://www.arts.ubc.ca/news/indigenous-data-stewardship-stands-against-extractivist-ai/ IA et la souveraineté et la gestion des données autochtones], le professeur associé David Gaertner (Institute for Critical Indigenous Studies, UBC) établit d'autres liens entre l'IA formée sur de grands modèles linguistiques et les impacts du colonialisme de peuplement :

&lt;blockquote&gt;
Les technologies de l'IA, formées sur de grands modèles linguistiques, reflètent la privation des droits et la violence imposées par le colonialisme de peuplement tout en les redistribuant à l'échelle. Les algorithmes institutionnalisent une dynamique de pouvoir dans laquelle les récits linguistiques et culturels dominants sont davantage ancrés et amplifiés dans l'infrastructure sociale, tandis que l'expression personnelle devient de plus en plus obsolète et marginale. L'émergence des rapports détaillant la manière dont l'internet se cannibalise actuellement et génère de nouveaux contenus d'IA à partir de matériaux d'IA existants, également connue sous le nom de «&amp;#8239;[https://en.wikipedia.org/wiki/Dead_Internet_theory théorie de l'Internet Mort]&amp;#8239;», amplifie encore ces préoccupations.
&lt;/blockquote&gt;

Cependant, nombreux sont ceux qui soulignent que les questions relatives au développement et à l'utilisation éthiques de l'IA sont souvent adressées aux entreprises privées et aux organisations qui utilisent leurs modèles. Qu'en est-il des membres de la communauté, des universitaires et des parties prenantes ? L'IA restera-t-elle uniquement entre les mains des entreprises privées et des sociétés à but lucratif ?

Pas nécessairement. Certains commencent à explorer des approches de l'apprentissage automatique fondées sur les biens communs, comme [https://openfuture.eu/our-work/ai-and-the-commons/ Open Future, une] organisation à but non lucratif basée en Europe qui souhaite étudier les risques et les avantages potentiels associés aux nouveaux cadres de partage des modèles d'IA sous licence libre. Le commentaire suivant, que John Willinsky (fondateur du Public Knowledge Project et partenaire de l'INKE) a partagé avec nous, va dans le même sens :

&lt;blockquote&gt;
Bien qu'il y ait des raisons de s'inquiéter des récentes avancées de l'IA, les universitaires ont également la responsabilité d'explorer les contributions et les avancées potentielles de l'IA pour la recherche et l'érudition. Depuis un certain temps, le [https://pkp.sfu.ca/ Public Knowledge Project] se tourne vers l'IA pour résoudre les problèmes urgents liés à l'équité et à la qualité des ressources dans les communications savantes, avec un succès limité. Il mène actuellement des recherches sur la capacité des grands modèles de langage à relever le défi de longue date que représente le développement d'un moyen durable pour les revues accès libre diamant de publier dans les formats standard HTML et PDF, ainsi que d'exporter des fichiers en JATS XML. (Le commentaire de John Willinsky peut être lu dans son intégralité ci-dessous).
&lt;/blockquote&gt;

Il est intéressant de noter que plusieurs modèles d'IA ont [https://www.forbes.com/sites/bernardmarr/2024/05/07/the-best-open-source-generative-ai-models-available-today/ déjà été publiés] sous la [https://www.apache.org/licenses/LICENSE-2.0 licence Apache 2.0] (une licence de logiciel permissive qui autorise l'utilisation du logiciel à toutes fins, y compris la distribution, la modification et la distribution de versions modifiées sans redevances, selon [https://en.wikipedia.org/wiki/Apache_License Wikipédia]), et d'autres pourraient être publiés avant la fin de l'année (des [https://www.theverge.com/2024/10/24/24278999/openai-plans-orion-ai-model-release-december rumeurs ]indiquent qu'OpenAI publiera son dernier modèle, «&amp;#8239;Orion&amp;#8239;», en décembre 2024).

==Réponses du partenariat INKE==
''Réponse de John Willinsky (Fondateur, Public Knowledge Project) :''
&lt;blockquote&gt;
Bien qu'il y ait des raisons de s'inquiéter des récentes avancées de l'IA, les universitaires ont également la responsabilité d'explorer les contributions et les avancées potentielles de l'IA pour la recherche et l'érudition. Depuis un certain temps, le [https://pkp.sfu.ca/ Public Knowledge Project] se tourne vers l'IA pour résoudre les problèmes urgents liés à l'équité et à la qualité des ressources dans les communications savantes, avec un succès limité. Il mène actuellement des recherches sur la capacité des grands modèles de langage à relever le défi de longue date que représente le développement d'un moyen durable pour les revues Diamond OA de publier dans les formats standard HTML et PDF, ainsi que d'exporter des fichiers en JATS XML. L'objectif principal de ce travail est d'établir si les LLM peuvent être suffisamment adaptés pour automatiser de manière fiable le balisage HTML et JATS XML des manuscrits des auteurs (étant donné que ce balisage nécessite actuellement des compétences techniques ou des paiements qui dépassent la capacité de la plupart des revues Diamond OA). Ce travail a atteint le stade initial de la preuve de concept, et les travaux se poursuivent sur sa valeur comparative (par rapport à d'autres outils) et sur les moyens d'intégrer et de maintenir un tel service de balisage dans le flux de travail éditorial.
&lt;/blockquote&gt;

''Réponse de John Maxwell (professeur associé d'édition à l'université Simon Fraser) :''
&lt;blockquote&gt;
Je crains de plus en plus qu'en réagissant (à la fois individuellement et collectivement, de manière causale et formelle) à l'essor des technologies d'apprentissage en profondeur, de texte génératif et d'image - en suivant l'exemple de l'industrie qui les appelle «&amp;#8239;IA&amp;#8239;» - nous fassions le jeu d'un groupe de promoteurs d'investissements très habiles et que nous minions en même temps notre propre sensibilité critique à l'égard des diverses innovations rassemblées sous cette égide. Le terme «&amp;#8239;IA&amp;#8239;» sert depuis plusieurs décennies déjà de marque d'aspiration pour une grande variété de technologies informatiques. Aujourd'hui, c'est le nom de marque d'un investissement massif de capitaux finançant une collection d'approches disparates d'apprentissage profond : LLM, modèles de diffusion, systèmes de reconnaissance faciale et autres outils. Il s'agit de technologies spécifiques qui existent et qui ont un impact sur les études et le travail. Mais alors que, par exemple, «&amp;#8239;LLM&amp;#8239;» définit une technologie spécifique avec des caractéristiques spécifiques pour lesquelles nous pourrions développer une réponse politique cohérente, le terme «&amp;#8239;IA&amp;#8239;» est un fourre-tout de science-fiction qui porte avec lui un ensemble de connotations utopiques, dystopiques et eschatologiques bien médiatisées (et monétisées). Il est peu probable que nous puissions apporter une réponse significative à un objet aussi mal défini. J'espère que, lorsque nous commencerons à élaborer des lignes directrices et des politiques, nous pourrons commencer à différencier ces technologies et à les désigner par leurs noms et fonctions spécifiques, au lieu de répéter le battage médiatique selon lequel ces boîtes noires massives, mystérieuses et appartenant à des entreprises résoudront simultanément les problèmes de l'humanité tout en constituant une menace existentielle. Il semblerait que les investisseurs en capital-risque et les hommes du battage médiatique nous aient devancés sur la ligne de départ ; nous devons rapidement mettre en place un appareil critique (par exemple, des études scientifiques et technologiques) pour l'analyse et l'élaboration de politiques et de lignes directrices efficaces.
&lt;/blockquote&gt;

==Références==
*Association bibliothèques de recherche du Canada. 2023. «&amp;#8239;Intelligence artificielle générative : Une brève introduction pour les établissements de l’ABRC&amp;#8239;». [https://www.carl-abrc.ca/wp-content/uploads/2023/12/Generative-Artificial-Intelligence-A-Brief-Primer-FR.pdf https://www.carl-abrc.ca/wp-content/uploads/2023/12/Generative-Artificial-Intelligence-A-Brief-Primer-FR.pdf].

*Broussard, Meredith. 2024. ''More than a Glitch: Confronting Race, Gender, and Ability Bias in Tech''. First MIT Press paperback edition. Cambridge, Massachusetts and London, England: The MIT Press.

*«&amp;#8239;C-27 (44-1) : Loi édictant la Loi sur la protection de la vie privée des consommateurs, la Loi sur le Tribunal de la protection des renseignements personnels et des données et la Loi sur l'intelligence artificielle et les données et apportant des modifications corrélatives et connexes à d'autres lois&amp;#8239;». Parlement du Canada. Consulté le 30 octobre 2024. [https://www.parl.ca/legisinfo/fr/projet-de-loi/44-1/c-27 https://www.parl.ca/legisinfo/fr/projet-de-loi/44-1/c-27]

*Drucker, Johanna. 2021. «&amp;#8239;Sustainability and Complexity: Knowledge and Authority in the Digital Humanities&amp;#8239;». ''Digital Scholarship in the Humanities'' 36 (2): ii86–ii94. [https://doi.org/10.1093/llc/fqab025 https://doi.org/10.1093/llc/fqab025].

*Fitzpatrick, Kathleen. 2024. «&amp;#8239;Open Infrastructures for the Future of Knowledge Production&amp;#8239;». Keynote presented at ''Creative Approaches to Open Social Scholarship: Canada (An Implementing New Knowledge Environments (INKE) Partnership Gathering)''. Montreal, Canada.[https://doi.org/10.25547/6GG1-7B37  https://doi.org/10.25547/6GG1-7B37].

*Fry, Hannah. 2019. ''Hello World: Being Human in the Age of Algorithms''. New York: W.W. Norton &amp; Company.

*Gaertner, David. 2024. «&amp;#8239;Indigenous Data Stewardship Stands against Extractivist AI&amp;#8239;». ''UBC Faculty of Arts'' (blog). 18 juin 2024. [https://www.arts.ubc.ca/news/indigenous-data-stewardship-stands-against-extractivist-ai/ https://www.arts.ubc.ca/news/indigenous-data-stewardship-stands-against-extractivist-ai/]

*Gorwa, Robert, Reuben Binns, and Christian Katzenbach. 2020. «&amp;#8239;Algorithmic Content Moderation: Technical and Political Challenges in the Automation of Platform Governance&amp;#8239;». ''Big Data &amp; Society'' 7 (1): 2053951719897945. [https://doi.org/10.1177/2053951719897945 https://doi.org/10.1177/2053951719897945].

*McKelvey, Fenwick, Sophie Toupin, and Maurice Jones. 2024. «&amp;#8239;Introduction&amp;#8239;». In ''Northern Lights and Silicon Dreams: AI Governance in Canada (2011-2022)'', edited by Fenwick McKelvey, Johnathan Roberge, and Sophie Toupin, 7–30. Montreal, Canada: Shaping AI. [https://www.amo-oma.ca/wp-content/uploads/2024/04/ORA-CA-Policy.pdf https://www.amo-oma.ca/wp-content/uploads/2024/04/ORA-CA-Policy.pdf].

*Noble, Safiya Umoja. 2018. ''Algorithms of Oppression: How Search Engines Reinforce Racism''. New York: New York University Press.

*O’Neil, Cathy. 2017. ''Weapons of Math Destruction: How Big Data Increases Inequality and Threatens Democracy''. New York: Crown.

*Pride, David. 2023. «&amp;#8239;CORE-GPT: Combining Open Access Research and AI for Credible, Trustworthy Question Answering&amp;#8239;». ''CORE'' (blog). 17 mars 2023. [https://blog.core.ac.uk/2023/03/17/core-gpt-combining-open-access-research-and-ai-for-credible-trustworthy-question-answering/ https://blog.core.ac.uk/2023/03/17/core-gpt-combining-open-access-research-and-ai-for-credible-trustworthy-question-answering/].

*Redden, Joanna, Jessica Brand, and Vanesa Terzieva. 2020. «&amp;#8239;Data Harm Record&amp;#8239;». Data Justice Lab. 2020. [https://datajusticelab.org/data-harm-record/ https://datajusticelab.org/data-harm-record/].

*Redden, Joanna. 2024. «&amp;#8239;Canada’s AI Legislation Misses the Mark&amp;#8239;». ''Western News'' (blog). 12 avril 2024. [https://news.westernu.ca/2024/04/proposed-ai-legislation/ https://news.westernu.ca/2024/04/proposed-ai-legislation/].

*Roberts, Jennafer Shae, and Laura N. Montoya. 2023. «&amp;#8239;In Consideration of Indigenous Data Sovereignty: Data Mining as a Colonial Practice&amp;#8239;». In ''Proceedings of the Future Technologies Conference (FTC) 2023, Volume 2'', edited by Kohei Arai, 180–96. Cham: Springer Nature Switzerland. [https://doi.org/10.1007/978-3-031-47451-4_13 https://doi.org/10.1007/978-3-031-47451-4_13].

*Roberts, Jennafer Shae. 2024. «&amp;#8239;In Consideration of Indigenous Data Sovereignty: Data Mining as a Colonial Practice&amp;#8239;». ''Montreal AI Ethics Institute'' (blog). 23 janvier 2024. [https://montrealethics.ai/in-consideration-of-indigenous-data-sovereignty-data-mining-as-a-colonial-practice/ https://montrealethics.ai/in-consideration-of-indigenous-data-sovereignty-data-mining-as-a-colonial-practice/].

*Tucker, Joanna. 2022. «&amp;#8239;Facing the Challenge of Digital Sustainability as Humanities Researchers&amp;#8239;». ''Journal of the British Academy'', 10: 93–120. [https://doi.org/10.5871/jba/010.093 https://doi.org/10.5871/jba/010.093].

[[Catégorie:Extension : Observatoire des politiques sur les savoirs ouverts, 2021-2024 (livre)]]</text>
      <sha1>82160whfmle38fshg3j66ot9abx36h4</sha1>
    </revision>
  </page>
  <page>
    <title>Extension : Observatoire des politiques sur les savoirs ouverts, 2021-2024/L’IA générative et l’édition savante</title>
    <ns>0</ns>
    <id>82377</id>
    <revision>
      <id>744026</id>
      <parentid>742852</parentid>
      <timestamp>2025-06-02T23:27:25Z</timestamp>
      <contributor>
        <username>LodestarChariot2</username>
        <id>120009</id>
      </contributor>
      <minor />
      <comment>/* Références */</comment>
      <origin>744026</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="22648" sha1="mxhex7mfrejqcti82j03uzv68a90tfz" xml:space="preserve">''Ce rapport « Insights and Signals » a été rédigé par Brittany Amell (avec nos remerciements à John Willinsky, John Maxwell et William Bowen pour leurs commentaires et contributions), pour le Electronic Textual Cultures Laboratory et le partenariat Implementing New Knowledge Environments.''

==Résumé==
Les rapports'' «&amp;#8239;Policy Insights and Signals&amp;#8239;» ''scrutent l’horizon afin d’identifier et d’analyser les tendances émergentes et les signaux précurseurs susceptibles d’influer sur les orientations politiques futures en matière de libre accès et d’érudition ouverte et sociale. Ils ont tendance à mettre en évidence les changements dans la technologie, l’opinion et les sentiments du public, et/ou les changements réglementaires à l’intérieur et à l’extérieur du Canada. Tout comme les observations politiques de l’OSPO, les rapports sur les perspectives et les signaux visent à aider les partenaires à élaborer des stratégies proactives, réactives et tournées vers l’avenir.

Ce rapport sur les perspectives et les signaux poursuit l'examen par l'OSPO de l'évolution du dialogue sur les implications de l'IA générative pour les bourses d'études ouvertes et l'édition en libre accès. «&amp;#8239;L'IA générative fait référence à une classe d'algorithmes qui guident la création de divers types de contenu ([https://sites.broadviewpress.com/ai/talking/ Dobrin, 2023]). Parfois évoquée dans le même temps que [https://chatgpt.com/ ChatGPT], [https://openai.com/index/dall-e-2/ DALL-E 2] ou [https://gemini.google.com/ Gemini], nous commençons déjà à voir l'impact de l'IA générative sur l'édition savante, malgré son introduction relativement récente.

Compte tenu de l'intérêt croissant pour les implications de l'IA générative pour le libre accès et la communication savante en général, ce rapport s'articule autour des discussions récentes sur les risques et les opportunités potentiels pour le secteur. Vous êtes intéressé par d’autres rapports «&amp;#8239;Insights and Signals&amp;#8239;» consacrés à l’IA ? Vous les trouverez [[Extension : Observatoire des politiques sur les savoirs ouverts, 2021-2024/Les agences fédérales de financement de la recherche annoncent un projet de lignes directrices sur l’utilisation de l’intelligence artificielle générative|ici]] ou [[Extension : Observatoire des politiques sur les savoirs ouverts, 2021-2024/Réponses à l’intelligence artificielle|ici]].

Les points abordés dans ce rapport sont les suivants :

* [https://sr.ithaka.org/blog/generative-ai-and-scholarly-publishing/ Une annonce récente] d'Ithaka S+R concernant un nouveau projet de recherche axé sur l'IA générative et l'édition savante.
* [https://scholarlykitchen.sspnet.org/2024/06/06/guest-post-doajs-role-in-supporting-trust-in-scholarly-journals-current-challenges-and-future-solutions/ Un article invité de] Shen et Ball (DOAJ) sur le Scholarly Kitchen concernant l'augmentation du nombre d'articles rétractés et la crise de confiance envers les revues en libre accès dans un contexte d'innovations en matière d'IA générative.
* Une [https://www.coalition-s.org/towards-responsible-publishing/ proposition de] la cOAlition S concernant l'édition responsable
* Les applications potentielles des principes FAIR à l'élaboration de politiques en réponse à l'IA générative, ainsi que le chevauchement entre ces principes et ceux mentionnés dans un [https://research-and-innovation.ec.europa.eu/document/2b6cf7e5-36ac-41cb-aab5-0d32050143dc_en récent guide sur l'utilisation responsable de l'IA] dans la recherche publié par la direction générale de la recherche et de l'innovation de la Commission européenne.
* Le [https://doi.org/10.1590/SciELOPreprints.6799 Publication Facts Label] (PFL - également : [https://pkp.sfu.ca/2024/05/06/pkp-publication-facts-label/ ici]), ainsi qu'une [https://pkp.sfu.ca/2024/09/06/announcing-publication-facts-label-for-ojs/ annonce récente du Public Knowledge Project] concernant l'essai du PFL pour les revues fonctionnant avec OJS (v 3.3 ou plus).

'''''Remarque : Nous vous présentons nos excuses en avance, car la plupart des sources mentionnées dans ce rapport sont disponibles en anglais uniquement.'''''

==Le groupe de recherche sur l'édition savante annonce un nouveau projet explorant les implications de l'IA générative==
Le groupe de recherche [https://sr.ithaka.org/about/ Ithaka S+R] a récemment annoncé son [https://sr.ithaka.org/blog/generative-ai-and-scholarly-publishing/ intention d'entreprendre un nouveau projet de recherche axé sur l'IA générative et l'édition savante :] «&amp;#8239;L'évolution rapide des besoins et des attentes des utilisateurs, le potentiel de l'IA générative pour atténuer les défis systémiques tenaces dans le secteur de l'édition savante, et la prise de conscience des risques que l'IA générative fait peser sur les connaissances des experts exigent que nous trouvions le temps de réfléchir en profondeur à ce que l'IA générative ''signifie ''pour l'édition savante commesecteur et à sa valeur en tant que composante de l'infrastructure partagée qui soutient la recherche et les communications savantes et scientifiques&amp;#8239;» (Ruediger et Bergstrom, 2024). Ce projet examinera les opportunités, les risques et les implications stratégiques que l'IA générative pourrait avoir pour l'édition savante. Il s'appuie sur l'étude d'Ithaka S+R de 2023, «&amp;#8239;[https://sr.ithaka.org/publications/the-second-digital-transformation-of-scholarly-publishing/ The Second Digital Transformation of Scholarly Publishing]&amp;#8239;», qui examinait les besoins partagés en matière d'infrastructures de communication savante à la lumière des transformations numériques (Bergstrom, Rieger et Schonfeld, 2024).

Comme l'écrivent Shen et Ball (2024) [https://scholarlykitchen.sspnet.org/2024/06/06/guest-post-doajs-role-in-supporting-trust-in-scholarly-journals-current-challenges-and-future-solutions/ dans leur article invité pour The Scholarly Kitchen,] bien que les menaces à la confiance et à la crédibilité aient toujours été au centre des préoccupations d'organisations telles que le Directory of Open Access Journals (DOAJ), ces menaces sont devenues encore plus urgentes. Constatant une augmentation du nombre d'articles rétractés, qui a atteint le chiffre record de 10 000 en 2023, Shen et Ball (2024) expliquent qu'il est devenu nécessaire de prendre des mesures supplémentaires pour préserver la confiance et la crédibilité à l'ère de l'IA générative.

Pour le DOAJ, l'une de ces mesures a consisté à former une équipe chargée d'enquêter sur les «&amp;#8239;cas présumés de pratiques douteuses&amp;#8239;». Ces pratiques douteuses sont signalées soit par des membres de la communauté du DOAJ au sens large, soit par ceux qui participent au processus d'évaluation de la demande d'inclusion d'une revue dans le DOAJ. Une fois le signalement effectué, les membres de l'équipe examinent de près les articles publiés par la revue, ainsi que la composition et la compétence de son comité de rédaction, ses pratiques d'évaluation par les pairs et d'autres facteurs.

«&amp;#8239;Comme les pratiques prédatrices continuent d'évoluer, nos enquêtes deviennent de plus en plus complexes&amp;#8239;», écrivent Shen et Ball (2024). «&amp;#8239;Nous consultons parfois des experts externes en la matière pour obtenir leurs conseils. Rien qu'en 2023, nous avons mené un total de 409 enquêtes sur des revues et des éditeurs, dont beaucoup ont abouti à des exclusions du DOAJ d'au moins un an&amp;#8239;».

Aider les éditeurs et le public à évaluer la crédibilité d'une publication est une chose à laquelle les membres du Public Knowledge Project (PKP) ont beaucoup réfléchi. Le Publication Facts Label, conceptualisé à l'origine par John Willinsky (fondateur du Public Knowledge Project et présenté plus en détail [https://pkp.sfu.ca/2024/05/06/pkp-publication-facts-label/ ici] et [https://doi.org/10.1590/SciELOPreprints.6799 ici]), en est un exemple. Basé sur le Nutrition Facts Label - ce tableau bien connu que l'on trouve sur les emballages alimentaires au Canada et aux États-Unis - le Publication Facts Label (ou PFL en abrégé) regroupe huit normes en un guide facile à consulter que les plateformes d'édition peuvent utiliser pour présenter l'intégrité d'une publication à un large public (Willinsky et Pimental). PKP [https://pkp.sfu.ca/2024/09/06/announcing-publication-facts-label-for-ojs/ a récemment annoncé] la mise à l'essai du Publication Facts Label pour les revues utilisant l'Open Journal Systems (v 3.3 ou plus). En installant un plug-in, comme expliqué [https://pkp.sfu.ca/2024/09/06/announcing-publication-facts-label-for-ojs/ ici], le PFL peut être affiché automatiquement sur la page d'accueil d'un article.

==La cOAlition S élabore une proposition de publication responsable==
Alors qu'Ithaka S+R se prépare à avancer dans son projet, la [https://www.coalition-s.org/about/ cOAlition S] (associée au [https://www.coalition-s.org/why-plan-s/ Plan S)] a terminé la phase de consultation de sa proposition intitulée «&amp;#8239;[https://www.coalition-s.org/towards-responsible-publishing/ Vers une édition responsable]&amp;#8239;».

«&amp;#8239;Poussés par le même ‹ devoir de diligence pour le bon fonctionnement du système scientifique › qui a inspiré le Plan S, les bailleurs de fonds qui forment la cOAlition S explorent maintenant une nouvelle vision de la communication savante ; une vision qui promet d'être plus efficace, plus abordable et plus équitable, pour finalement bénéficier à la société dans son ensemble&amp;#8239;», écrivent Bodo Stern (chef des initiatives stratégiques à l'Howard Hughes Medical Institute) et Johan Rooryck (directeur exécutif de la cOAlition S) dans un [https://www.coalition-s.org/blog/introducing-the-towards-responsible-publishing-proposal-from-coalition-s/ billet de blog annonçant la proposition.] La cOAlition S a révisé la proposition sur la base des commentaires reçus entre novembre 2023 et avril 2024, et a partagé la proposition révisée avec une réunion des bailleurs de fonds du cOAlition S en juin.

Les réactions à la proposition ont été rendues publiques par cOAlitionS [https://zenodo.org/records/11243942 ici.]

La proposition «&amp;#8239;Vers une publication responsable&amp;#8239;» met en avant un ensemble de principes qui peuvent être utilisés pour guider les décisions concernant la manière de soutenir «&amp;#8239;la diffusion de la recherche de manière responsable, équitable et durable&amp;#8239;» (Stern et al. 2023, 2) - une phrase qui évoque les priorités clés nommées dans l[https://eua.eu/downloads/publications/eua%20os%20agenda.pdf 'Agenda de la science ouverte 2025 de l'Association européenne des universités]. L'Open Science Agenda de l'Association, qui a été publié en février 2022 en prévision de la conférence et de l'assemblée générale qui se tiendront en 2025-2026, énonce plusieurs priorités et objectifs, dont celui de faire en sorte que toutes les universités européennes fassent partie d'un «&amp;#8239;écosystème d'édition savante juste&amp;#8239;» d'ici à 2025 ([https://www.scienceeurope.org/media/yg3ho4tp/doa-conf-vinciane-gaillard.pdf Gaillard, 2022]).

Vinciane Gaillard (directrice adjointe pour la recherche et l'innovation, Association européenne des universités) décrit un écosystème d'édition savante juste comme étant «&amp;#8239;transparent, diversifié, économiquement abordable et durable, techniquement interopérable et piloté par la communauté des chercheurs et ses institutions par le biais de politiques coordonnées&amp;#8239;» ([https://www.scienceeurope.org/media/yg3ho4tp/doa-conf-vinciane-gaillard.pdf diapositive 4)].

==Elsevier lance ScopusAI==
Au début de l'année 2024, [https://www.elsevier.com/about/press-releases/launch-of-scopus-ai-to-help-researchers-navigate-the-world-of-research Elsevier a annoncé le lancement de ScopusAI], un outil d'intelligence artificielle proposé aux institutions sur une base d'abonnement. Selon le site web d'Elsevier, [https://www.elsevier.com/products/scopus/scopus-ai ScopusAI] sert de «&amp;#8239;guide expert&amp;#8239;» que les chercheurs peuvent utiliser pour naviguer dans «&amp;#8239;la vaste étendue de la connaissance humaine dans Scopus&amp;#8239;». En plus de résumer la littérature disponible dans Scopus, l'outil est apparemment aussi capable de «&amp;#8239;repérer&amp;#8239;» ce qu'Elsevier appelle «&amp;#8239;l'espace blanc&amp;#8239;» dans la littérature afin que les chercheurs puissent ostensiblement mieux identifier les types de contributions qu'ils peuvent apporter. Il est inquiétant de constater que les résumés générés par l'outil renvoient à ce qu'Elsevier et l'outil ScopusAI considèrent comme des documents «&amp;#8239;fondamentaux&amp;#8239;» pour un sujet donné - il s'agit «&amp;#8239;d'articles à fort impact qui sont le plus souvent cités par les articles utilisés dans les résumés&amp;#8239;». Outre les décisions algorithmiques concernant les articles considérés comme fondamentaux, l'outil offre également la possibilité de «&amp;#8239;découvrir des experts&amp;#8239;» dans un domaine. Cependant, l'outil ne prend en compte que les articles et les profils qui figurent déjà dans Scopus qui est déjà connu comme une base de données qui surreprésente les universitaires et les chercheurs d'Europe, d'Océanie et d'Amérique du Nord par rapport aux universitaires et aux chercheurs d'autres régions du monde (Asubiaro et al. 2024).

==Questions et considérations clés==
[[Extension : Observatoire des politiques sur les savoirs ouverts, 2021-2024/Réponses à l’intelligence artificielle|Les idées et les signaux décrits ci-dessus et ailleurs indiquent que l'intégration de l'IA générative dans l'édition savante]] présente à la fois des opportunités et des défis, ainsi que des implications significatives pour la qualité, l'intégrité et l'accessibilité des résultats de l'édition savante. Plusieurs questions se posent pour l'élaboration des politiques, notamment

* Quelle est la place éventuelle de l'IA générative dans l'édition en libre accès ?
* Comment les éditeurs en libre accès peuvent-ils guider l'utilisation responsable, éthique et crédible de l'IA générative ?

Par exemple, John Willinsky (fondateur du Public Knowledge Project) nous a fait savoir que le PKP étudie activement la manière dont l'IA basée sur de grands modèles linguistiques pourrait contribuer à la durabilité de l'édition en libre accès :

L'objectif principal de ce travail est d'établir si les LLM peuvent être suffisamment adaptés pour automatiser de manière fiable le balisage HTML et JATS XML des manuscrits des auteurs (étant donné que ce balisage nécessite actuellement des compétences techniques ou des paiements qui dépassent la capacité de la plupart des revues Diamond OA). Ce travail a atteint le stade initial de la preuve de concept, et les travaux se poursuivent sur sa valeur comparative (par rapport à d'autres outils) et sur les moyens d'intégrer et de maintenir un tel service de balisage dans le flux de travail éditorial. (Lisez l'intégralité du commentaire de John Willinsky ci-dessous).

En plus de ces questions, les lecteurs pourraient également se demander quelles leçons et perspectives clés du mouvement de l'accès libre, du discours, de la recherche et de la littérature pourraient être appliquées au paysage en évolution de l'IA générative, le cas échéant. Par exemple, les principes FAIR pour la gestion et l'intendance des données ([https://www.nature.com/articles/sdata201618 Wilkinson et al. 2016]) - envisagés à l'origine comme un moyen de soutenir la réutilisation des données savantes en veillant à ce qu'elles soient trouvables, accessibles, interopérables et réutilisables - pourraient servir d'exemple. Les principes FAIR ont été réinterprétés pour s'appliquer aux logiciels, aux flux de travail, aux outils, aux algorithmes et, de plus en plus, aux modèles d'IA ([https://www.nature.com/articles/s41597-023-02298-6 Huerta et al. 2023]). Dans le même ordre d'idées, la Direction générale de la recherche et de l'innovation de la Commission européenne a récemment [https://research-and-innovation.ec.europa.eu/document/2b6cf7e5-36ac-41cb-aab5-0d32050143dc_en publié un ensemble de principes visant à orienter l'utilisation responsable de l'IA générative dans la recherche]. On peut dire que ces principes recoupent les principes FAIR, ce qui offre d'autres possibilités de réflexion. (Pour mémoire, les quatre principes clés sont la fiabilité, l'honnêteté, le respect et la responsabilité).

==Commentaires du partenariat INKE==
''Réponse de John Willinsky (fondateur, Public Knowledge Project) :''

&lt;blockquote&gt;
Bien qu'il y ait des raisons de s'inquiéter des récentes avancées de l'IA, les universitaires ont également la responsabilité d'explorer les contributions et les avancées potentielles de l'IA pour la recherche et l'érudition. Depuis un certain temps, le [https://pkp.sfu.ca/ Public Knowledge Project] se tourne vers l'IA pour résoudre les problèmes urgents liés à l'équité et à la qualité des ressources dans les communications savantes, avec un succès limité. Il mène actuellement des recherches sur la capacité des grands modèles de langage à relever le défi de longue date que représente le développement d'un moyen durable pour les revues Diamond OA de publier dans les formats standard HTML et PDF, ainsi que d'exporter des fichiers en JATS XML. L'objectif principal de ce travail est d'établir si les LLM peuvent être suffisamment adaptés pour automatiser de manière fiable le balisage HTML et JATS XML des manuscrits des auteurs (étant donné que ce balisage nécessite actuellement des compétences techniques ou des paiements qui dépassent la capacité de la plupart des revues Diamond OA). Ce travail a atteint le stade initial de la preuve de concept, et les travaux se poursuivent sur sa valeur comparative (par rapport à d'autres outils) et sur les moyens d'intégrer et de maintenir un tel service de balisage dans le flux de travail éditorial.
&lt;/blockquote&gt;

==Références==
*Ahari, Juni. 2024. «&amp;#8239;Generative AI and Scholarly Publishing&amp;#8239;». ''Ithaka S+R ''(blog). 23 avril 2024. [https://sr.ithaka.org/blog/generative-ai-and-scholarly-publishing/ https://sr.ithaka.org/blog/generative-ai-and-scholarly-publishing/].

*Asubiaro, Toluwase, Sodiq Onaolapo et David Mills. 2024. «&amp;#8239;Regional disparities in Web of Science and Scopus journal coverage&amp;#8239;». ''Scientometrics ''129 (3) : 1469–91. [https://doi.org/10.1007/s11192-024-04948-x https://doi.org/10.1007/s11192-024-04948-x].

*Bergstrom, Tracy, Oya Y. Rieger et Roger C. Schonfeld. 2024. «&amp;#8239;The Second Digital Transformation of Scholarly Publishing: Strategic Context and Shared Infrastructure&amp;#8239;». Ithaka S+R. [https://doi.org/10.18665/sr.320210 https://doi.org/10.18665/sr.320210].

*Chiarelli, Andrea, Ellie Cox, Rob Johnson, Ludo Waltman, Wolfgang Kaltenbrunner, André Brasil, Andrea Reyes Elizondo et Stephen Pinfield. 2024. «&amp;#8239;Towards Responsible Publishing&amp;#8239;» : Findings from a global stakeholder consultation. cOAlition S. Zenodo. [https://doi.org/10.5281/zenodo.11243942 https://doi.org/10.5281/zenodo.11243942].

*Directorate-General for Research and Innovation. 2024. «&amp;#8239;Living Guidelines on the Responsible Use of Generative AI in Research (Version 1)&amp;#8239;». Brussels: European Commission. [https://research-and-innovation.ec.europa.eu/document/download/2b6cf7e5-36ac-41cb-aab5-0d32050143dc_en?filename=ec_rtd_ai-guidelines.pdf https://research-and-innovation.ec.europa.eu/document/download/2b6cf7e5-36ac-41cb-aab5-0d32050143dc_en?filename=ec_rtd_ai-guidelines.pdf].

*Dobrin, Sidney I. 2023. «&amp;#8239;Talking about Generative AI: A Guide for Educators&amp;#8239;». Version 1. Broadview Press. [https://sites.broadviewpress.com/ai/talking/ https://sites.broadviewpress.com/ai/talking/].

*Gaillard, Vinciane. 2022. «&amp;#8239;Encouraging/Supporting Sustainability in the Diamond Action Plan Community&amp;#8239;». Presented at the 2022 Diamond Open Access Conference, September. [https://www.scienceeurope.org/media/yg3ho4tp/doa-conf-vinciane-gaillard.pdf https://www.scienceeurope.org/media/yg3ho4tp/doa-conf-vinciane-gaillard.pdf]

*Huerta, E. A., Ben Blaiszik, L. Catherine Brinson, Kristofer E. Bouchard, Daniel Diaz, Caterina Doglioni, Javier M. Duarte, et al. 2023. «&amp;#8239;FAIR for AI: An Interdisciplinary and International Community Building Perspective&amp;#8239;». ''Scientific Data'' 10 (1): 487. [https://doi.org/10.1038/s41597-023-02298-6 https://doi.org/10.1038/s41597-023-02298-6].

*Shen, Cenyu, and Joanna Ball. 2024. «&amp;#8239;DOAJ’s Role in Supporting Trust in Scholarly Journals: Current Challenges and Future Solutions&amp;#8239;». ''The Scholarly Kitchen'' (blog). June 6, 2024. [https://scholarlykitchen.sspnet.org/2024/06/06/guest-post-doajs-role-in-supporting-trust-in-scholarly-journals-current-challenges-and-future-solutions/ https://scholarlykitchen.sspnet.org/2024/06/06/guest-post-doajs-role-in-supporting-trust-in-scholarly-journals-current-challenges-and-future-solutions/].

*Stern, Bodo, et Johan Rooryck. 2023. «&amp;#8239;Introducing the ‘Towards Responsible Publishing’ Proposal from cOAlition S | Plan S&amp;#8239;». sOApbox : A Plan S Blog (blog). 31 octobre 2023. [https://www.coalition-s.org/blog/introducing-the-towards-responsible-publishing-proposal-from-coalition-s/ https://www.coalition-s.org/blog/introducing-the-towards-responsible-publishing-proposal-from-coalition-s/].

*Stern, Bodo, Zoé Ancion, Andreas Björke, Ashley Farley, Marte Qvenild, Katharina Rieck, Jeroen Sondervan, et al. 2023. «&amp;#8239;Towards Responsible Publishing : Seeking Input from the Research Community to a Draft Proposal from cOAlition S&amp;#8239;», octobre. [https://doi.org/10.5281/ZENODO.8398480 https://doi.org/10.5281/ZENODO.8398480].

*Wilkinson, Mark D., Michel Dumontier, IJsbrand Jan Aalbersberg, Gabrielle Appleton, Myles Axton, Arie Baak, Niklas Blomberg, et al. 2016. «&amp;#8239;The FAIR Guiding Principles for Scientific Data Management and Stewardship&amp;#8239;». ''Scientific Data'' 3 (1): 160018. [https://doi.org/10.1038/sdata.2016.18 https://doi.org/10.1038/sdata.2016.18].

[[Catégorie:Extension : Observatoire des politiques sur les savoirs ouverts, 2021-2024 (livre)]]</text>
      <sha1>mxhex7mfrejqcti82j03uzv68a90tfz</sha1>
    </revision>
  </page>
  <page>
    <title>Fonctionnement d'un ordinateur/Les architectures à accumulateur</title>
    <ns>0</ns>
    <id>82386</id>
    <revision>
      <id>744132</id>
      <parentid>743532</parentid>
      <timestamp>2025-06-05T00:29:02Z</timestamp>
      <contributor>
        <username>Mewtow</username>
        <id>31375</id>
      </contributor>
      <minor />
      <comment>/* Les registres des anciennes architectures à accumulateur */</comment>
      <origin>744132</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="36319" sha1="klq0txs8rhwgaj87u5zrf9cgnh71g23" xml:space="preserve">Les architectures que nous avons vu précédemment dans ce cours disposent de registres pour les données, en plus du pointeur de pile, d'un ''program counter'', et de quelques autres. Elles sont appelées des '''architectures à registres''', terme qui trahit bien le fait qu'elles ont des registres généraux ou spécialisés pour stocker temporairement des données. Et si on leur a donné un nom, c'est parce qu'il existe des architectures qui ne sont pas dans cette catégorie. Il en existe plusieurs types, mais ce chapitre va se concentrer sur les '''architectures à accumulateur'''.

[[File:Isaccumulator.png|vignette|Architecture à accumulateur.]]

Les architectures à accumulateur sont centrées autour d'un registre architectural appelé l''''accumulateur'''. Il est utilisé pour toutes les opérations arithmétiques dyadiques, où il sert à la fois de source et de destination. Toutes les instructions dyadiques sont de type ''load-op'' : une opérande est lue depuis l'accumulateur, le second opérande est lu depuis la mémoire RAM, le résultat de l'instruction est automatiquement mémorisé dans l'accumulateur. Les instructions monadiques peuvent utiliser un opérande dans l'accumulateur, ou dans la mémoire RAM, les deux sont théoriquement possibles.

La conséquence est que le nombre d'accès mémoire est drastiquement diminué : de 3 par instructions sur une architecture mémoire-mémoire, on passe à seulement un avec un accumulateur. Les opérations dyadiques ont besoin d'un seul accès mémoire pour lire la seconde opérande, les opérations monadique en font aussi un seul pour lire leur unique opérande.

{|class=&quot;wikitable&quot;
|-
! Classe d'architecture
! Nombre d'accès mémoire par opération dyadique
|-
|-
! Architecture à accumulateur
| Un accès mémoire par instruction, pour lire la seconde opérande
|-
! Architecture à registres
| Zéro si les opérandes sont dans les registres, un pour les opérations ''load-op'', LOAD et STORE.
|}

==Le jeu d'instruction des architectures à accumulateur sans registres d'indice==

L'accumulateur est adressé grâce au mode d'adressage implicite, de même que le résultat de l'opération. Par contre, les autres opérandes sont localisés avec d'autres modes d'adressage, et lues en mémoire RAM. Le résultat ainsi qu'un des opérandes sont adressés de façon implicite car dans l'accumulateur, seule la seconde opérande étant adressée directement. Grâce à l'accumulateur, une instruction ne fait qu'un seul accès mémoire maximum, ce qui rend le processeur très facile à implémenter.

===Les registres des anciennes architectures à accumulateur===

[[File:IBM 701console.jpg|vignette|IBM 701, console extérieure.]]

Les architectures à accumulateurs sont apparues dès les débuts de l'informatique, un peu après les architectures mémoire-mémoire. Les deux ont existé conjointement pendant un temps. A l'époque, les ordinateurs étaient gigantesques, ils prenaient une pièce de bâtiment entière dans le pire des cas, une armoire entière dans le meilleur. Les ordinateurs de l'époque étaient surtout utilisés pour du calcul scientifique ou des tâches d’ingénierie demandant beaucoup de calcul, rarement pour de la compatibilité.

Les nombres flottants n'étaient pas encore apparus. A la place, les ordinateurs de l'époque géraient des nombres entiers de grande taille, de 30 bits ou plus. En conséquence, l'accumulateur faisait facilement 30 à 60 bits. Par exemple, les ordinateurs de la Série scientifique IBM 700/7000 géraient des entiers de 36 bits, l’accumulateur faisait 38 bits : 36 bits plus deux bits pour les débordements. Au passage, de tels processeurs utilisaient l'adressage par mot, et non par byte.

[[File:BabyArchitecture.png|vignette|Architecture de la Manchester Baby.]]

Pour donner un exemple, le ''Manchester Baby'', le tout premier ordinateur à programme enregistré en mémoire, était une architecture à accumulateur. Niveau interface, l'ordinateur avait une console avec 32 boutons, des interrupteurs et un écran de sortie sur lequel afficher les résultats. A l'intérieur, il y avait un processeur et une RAM de 32 adresses de 32 bits, fabriquée avec des tubes Williams (abordés dans une annexe à la fin du cours). Le programme devait tenir dans la RAM, avec une instruction par adresse maximum, ce qui limitait les programmes à 32 instructions maximum. Une instruction prenait donc 32 bits, 3 indiquaient quelle opération utiliser, 12 servait à indiquer où se trouvent les opérandes en RAM, les 16 restants sont inutilisés. Le processeur avait un registre accumulateur de 32 bits, un ''program counter'' et un registre d'instruction. Il gérait 8 instructions en tout, mais ne gérait pas l'addition. Il gérait la soustraction, des instructions de branchement et d'accès mémoire, rien d'autre. Il pouvait cependant émuler l'addition à partir d'une soustraction et inversant l'opérande soustraite.

Historiquement, les premières architectures à accumulateur ne contenaient aucun autre registre que l'accumulateur. Ce n'est que dans les années 60 que de nombreuses architectures à accumulateur ont ajouté un second '''registre pour les multiplication/divisions'''. Un exemple est celui de l'IBM 701, qui incorporait un registre accumulateur de 38 bits et un registre multiplieur de 36 bits. Le registre mémorise le multiplieur lors d'une opération de multiplication. Il mémorise donc un opérande, pas le résultat. Il peut aussi décaler le multiplieur vers la droite/gauche, ce qui est utile pour exécuter la multiplication. C'est ce qui est fait sur l'IBM 7094.

Une autre possibilité est que ce registre mémorise une partie du résultat de l'opération. Pour rappel, le résultat d'une multiplication/division est codé sur deux fois de bits que ses opérandes. Par exemple, multipliez deux opérandes de 30 bits, vous obtiendrez un résultat de 60 bits. Les 30 bits de poids faible du résultat vont dans l'accumulateur, les 30 bits de poids fort vont dans ce second registre.

Les architectures à accumulateur parfois un '''registre pour le pointeur de pile''', utilisé pour gérer les fonctions/procédures. Les architectures à accumulateurs supportaient une pile d'adresse de retour, souvent une pile d'appel. Mais pour cela, il fallait mémoriser le pointeur de pile dans le processeur, ce qui demandait un registre dédié.

===L'adressage indirect avec l'accumulateur===

Les instructions LOAD et STORE existent bel et bien sur les architectures à accumulateur, mais n'ont pas les mêmes modes d'adressages. L'instruction LOAD copie une donnée de la RAM vers l'accumulateur, l'instruction STORE copie l'accumulateur dans une adresse. Les deux instructions n'ont pas besoin d'adresser l'accumulateur, qui est adressé de manière implicite, juste de préciser l'adresse à lire/écrire.

Les architectures à accumulateur supportaient souvent le mode d'adressage indirect mémoire. Un exemple est celui des ordinateurs Data General Nova, qui sont des architectures à accumulateur et qui supportaient ce mode d'adressage. Les deux instructions LOAD et STORE existaient en deux versions, distinguées par un bit d'indirection. Si ce bit est à 0 dans l'opcode, alors l'instruction utilise le mode d'adressage absolu normal : l'adresse intégrée dans l'instruction est celle de la donnée. Mais s'il est à 1, alors l'adresse intégrée dans l'instruction est celle du pointeur.

Cependant, la présence de l'accumulateur permettait d'utiliser l'adressage indirect à registre, pour gérer les pointeurs. Pour rappel, avec le mode d'adressage indirect à registre, l'adresse à lire/écrire est dans un registre. Ici, l'adresse à lire/écrire est prise dans l'accumulateur, seul registre disponible pour. L'adressage indirect est plus simple à implémenter pour l'instruction LOAD, car elle prend un seul opérande : l'adresse à lire. L'adresse à lire est placée dans l'accumulateur, la donnée lue est elle aussi chargée dans l'accumulateur. Pour l'instruction STORE, il faut fournir deux opérandes, l'adresse et la donnée à écrire, ce qui peut poser problème. Mais au pire, il est toujours possible d'utiliser l'adressage absolu ou indirect mémoire : l'adresse est dans l'instruction, la donnée à écrire dans l'accumulateur.

===L'encodage des instructions===

Sur une architecture à accumulateur l'encodage d'une instruction dyadique est assez simple, vu que l'accumulateur est adressé implicitement. La seconde opérande est localisée soit par une adresse mémoire (adressage absolu), soit est une constante (adressage immédiat). L'adresse mémoire est généralement assez longue, plus que l'opcode.

{|class=&quot;wikitable&quot;
|+ Encodage d'une instruction dyadique
|-
! rowspan=&quot;2&quot; | Opcode 
| Adresse mémoire (adressage absolu)
|-
| Constante (adressage immédiat)
|}

L'encodage d'une instruction monadique est similaire. Si l'opérande est lue depuis la mémoire RAM, alors l'instruction est encodée comme une instruction dyadique. Il en est de même pour les instructions qui copient une constante dans l'accumulateur. Par contre, si l'opérande est dans l'accumulateur, alors il y a juste besoin d'encoder l'opcode. La majorité des instructions a besoin de préciser une adresse, rares sont celles qui s'en passent. Au vu de cet encodage, les architectures à accumulateur sont qualifiées d''''architectures à une adresse''' par abus de langage.

Il est intéressant de contraster leur encodage avec les architectures à registres. Les architectures à registre doivent encoder deux opérandes en plus de l'opcode, avec éventuellement où enregistrer le résultat sur les architectures 3-adresses. Par contre, les opérandes sont généralement des noms de registre, ce qui prend moins de place qu'une adresse mémoire. A la rigueur, les instructions avec une constante immédiate prennent un peu plus de place, car elles doivent encoder un nom de registre en plus de la constante et de l'opcode. Les instructions ''load-op'' des processeurs CISC sont un peu dans le même cas, sauf qu'il faut remplacer la constante par une adresse, qui a généralement la même taille. Les instructions sont donc en moyenne plus courte sur les processeurs à registre, du fait de la présence de registres.

==La micro-architecture des architectures à accumulateur sans registres d'indice==

L'organisation interne d'une architecture à accumulateur est très différente de celle des processeurs à registre. Elle est plus ou moins la même pour tous ces processeurs, le point important étant que le chemin de données se résume à une ALU, un registre accumulateur et le bus de données. L'ALU est reliée au registre accumulateur, ainsi qu'au bus de données pour lire la seconde opérande, comme illustré ci-dessous.

[[File:Accumulator.png|centre|vignette|upright=2|Accumulateur.]]

===L'unité de calcul et l'accumulateur===

Pour simplifier l'implémentation, le résultat est mémorisé dans un registre en sortie de l'unité de calcul. La raison est qu'on ne veut pas altérer l'accumulateur tant que le résultat final n'est pas totalement calculé. Rappelons que l'ALU ne fournit pas un résultat d'un seul bloc, mais que certains bits arrivent avant les autres, typiquement les bits de poids faible. Si le résultat était écrit dans l'accumulateur directement, il écraserait des bits de l’opérande en cours d'utilisation, ce qui fausserait le résultat.

[[File:Accumulateur avec registre de sortie.png|centre|vignette|upright=2|Accumulateur avec registre de sortie]]

Une autre solution utilisait un registre entre l'accumulateur et l'unité de calcul, appelé l’'''''accumulator latch'''''. Il remplace le registre en sortie de l'ALU, dans le sens où il permet d'écrire dans l'accumulateur sans effacer l'opérande, pendant que l’opération est en cours dans l'ALU. L'accumulateur est copié dans l’''accumulator latch'', avant que l'ALU démarre ses calculs. L'opérande est donc maintenue même si on commence à écrire le résultat dans l'accumulateur.

Sur le 8085 d'Intel, l’''accumulator latch'' peut être initialisé avec une constante prédéfinie, ce qui permet d'implémenter certaines instructions très facilement. Par exemple, il peut être initialisé à 0, ce qui permet d'implémenter les instructions MOV et INC (incrémentation). Un MOV est équivalent à faire un OU entre le registre lu et 0. Une instruction INC initialise l'entrée de retenue de l'unité de calcul à 1, puis ajoute 0. La décrémentation est implémentée de la même manière, sauf que l’''accumulator latch'' est initialisé à -2 pour compenser l'entrée de retenue à 1. De plus, pour supporter les conversion de décimal à BCD, l’''accumulator latch'' peut être initialisé avec les constantes 0x00, 0x06, 0x60, or 0x66. L'''accumulator latch'' est relié à divers fils de commande provenant de l'unité de contrôle, qui décide quelle valeur d'initialisation utiliser en fonction de l'instruction décodée.

[[File:Accumulator latch.png|centre|vignette|upright=2|Accumulator latch]]

[[File:Chemin de données à un seul bus.png|vignette|Chemin de données à un seul bus]]

De même, la seconde opérande, celle lue sur le bus de données, est mémorisée dans un registre en amont de l'ALU. C'était notamment très utile si le processeur utilisait une ALU plus courte que les opérandes, avec par exemple une ALU 4 bits pour un CPU 8 bits. Les anciens processeurs à accumulateur de type ''mainframe'' utilisaient des opérandes de grande taille, du genre 36 ou 48 bits, ce qui avait des conséquences sur l'unité de calcul utilisée, ainsi que sur la communication avec la mémoire. Il arrivait que de tels processeurs utilisaient des ALU sérielles, ou du moins octet-sérielles, plutôt qu'une véritable ALU 36 bits. Nous verrons aussi que c'est très utile sur les processeurs à accumulateur avec un bus interne unique, dans la suite du chapitre.

===La micro-architecture des architectures à accumulateur avec instructions LOAD/STORE===

Nous venons de voir comment est implémenté l'unité de calcul et l'accumulateur, et comment le tout est relié au bus de données. Mais cela ne permet que d'avoir un processeur à accumulateur rudimentaire, qui ne gére que des instructions arithmétiques et logiques. Il faut aussi gérer le cas des opérations LOAD/STORE et des modes d'adressages associés, mais c'est le séquenceur qui s'en occupe. Avec l'adressage absolu, les instructions LOAD et STORE ne font que connecter l'accumulateur au bus de données. L'instruction STORE nécessite de connecter l'accumulateur au bus de données, de manière à ce que le transfert des données se fasse de l'accumulateur vers le bus de données. L'instruction LOAD s'implémente de la même manière, sauf que le sens de transfert est inversé.

Cependant, il existe une optimisation qui permet d'implémenter l'instruction LOAD sans ajouter de circuits. Pour cela, il suffit que l'unité de calcul gére les opérations ''pass through'', à savoir des opérations qui se contentent de recopier un opérande sur la sortie. Ici, l'idée est de recopier l'opérande provenant du bus de données.

[[File:Architecture à accumulateur, microarchitecture.png|centre|vignette|upright=2|Architecture à accumulateur, microarchitecture]]

Pour gérer nativement l'adressage indirect à registre, il suffit de connecter l'accumulateur au bus d'adresse. Le plus simple est d'ajouter un multiplexeur, comme illustré ci-dessous. La donnée lue est copiée dans l'accumulateur, ce qui fait qu'il vaut mieux utiliser un registre d’interfaçage, l'accumulateur n'étant pas utilisable à la fois pour le bus d'adresse et de données.

[[File:Adressage indirect sur une architecture à accumulateur.png|centre|vignette|upright=2|Adressage indirect sur une architecture à accumulateur]]

Pour finir, voyons comment le pointeur de pile et le ''program counter'' sont implémentés. Les architectures à accumulateur ont souvent des adresses de taille différente des données, ce qui fait qu'il vaut mieux utiliser un circuit incrémenteur dédié pour incrémenter le ''program counter'', plutôt que de l'incrémenter via l'unité de calcul. Les architectures à accumulateur ont parfois un pointeur de pile, qui gère une pile d'adresse de retour, pas une vraie pile d'appel. Aussi, le pointeur de pile est censé être incrémenté et décrémenté, pas plus. Pas d'addition ou de soustraction pour gérer des cadres de pile. Là encore, c'est la solution de l'incrémenteur séparé qui est retenue. Pour économiser des transistors, il n'y a qu'un seul incrémenteur partagé pour les deux.

==Les architectures à accumulateur à registres d'indice==

Les architectures à accumulateur décrites dans la section précédente sont capables de faire de l'adressage indirect, mais n'incluent pas les modes d'adressage base + indice et absolus indicés, qui prennent une adresse et y ajoute un indice. Il s'agit des toutes premières architectures à accumulateur, comme les premiers ordinateurs IBM ou le fameux PDP-8. Mais par la suite, les processeurs à accumulateurs ont inclus un support des modes d'adressages indicés, grâce à des '''registres d'indice'''.

===Les registres d'indice===

Les registres d'indice stockent des indices de tableaux. Ils permettaient de supporter deux modes d'adressage :
* Le '''mode d'adressage absolu indicé''' où une adresse fixe est additionnée à un indice variable. L'adresse fixe est intégrée dans l'instruction (adressage absolu), l'indice est dans un registre d'indice.
* Le '''mode d'adressage base + indice''', où l'adresse est dans l'accumulateur et l'indice dans le registre d'indice.

Les processeurs à accumulateur supportaient souvent des variantes des modes d'adressage précédents, où le registre d'indice était automatiquement incrémenté ou décrémenté à chaque utilisation.

Au départ, ces processeurs n'utilisaient qu'un seul registre d'indice qui se comportait comme un second accumulateur spécialisé dans les calculs d'adresses mémoire. Le processeur supportait de nouvelles instructions qui utilisaient ce registre d'indice de façon implicite. Mais avec le temps, les processeurs finirent par incorporer plusieurs de ces registres. Les instructions de lecture ou d'écriture devaient alors préciser quel registre d'indice utiliser, en précisant un nom de registre d'indice, un numéro de registre d'indice.

Il faut préciser que les registres d'indice ont une taille bien plus petite que l'accumulateur. Ils mémorisent des indices codés sur 16 bits ou moins, alors que l'accumulateur faisait typiquement 36 à 48 bits, parfois plus. La taille classique sur les anciens ''mainframes'' était de 15 bits, parfois moins. Il n'était pas rare de tomber sur des registres d'indice de 8 ou 9 bits. Leur petite taille rendait leur implémentation matérielle peu couteuse. Et c'est ce qui explique qu'ils étaient préférés à l'usage d'un second accumulateur.

Un exemple est le cas du processeur Motorola 6809, un processeur à accumulateur qui contient deux registres d'indices nommés X et Y. L'accumulateur est noté D et fait 16 bits, il peut être parfois géré comme deux accumulateurs séparés A et B de 8 bits chacun. Il contenait aussi deux pointeurs de pile, l'un pour les programmes, l'autre pour le système d'exploitation, ainsi qu'un ''program counter''. Le registre de page était utilisé pour l'adressage absolu, comme vu dans le chapitre sur les modes d'adressage.

[[File:6809 Internal Registers.svg|centre|vignette|upright=2|6809 Internal Registers]]

Les processeurs IBM avaient autrefois plusieurs registres d'indice. Par exemple, l'IBM 704 avait trois registres d'indice de 15 bits. Leur contenu était soustrait de l'adresse absolue. Une instruction pouvait utiliser plusieurs registres d'indice pour adresser son opérande. Toute instruction utilisait trois bits pour sélectionner les registres d'indice utilisés. Fait assez original, lorsque plusieurs registres d'indice sont sélectionnés, le processeur n'additionne pas les trois registres à l'adresse de base. À la place, il fait un OU bit à bit entre les registres d'indice sélectionnés, et additionne le résultat à l'adresse.

Les processeurs IBM à accumulateur ont fait ça sur toute la gamme IBM 700/7000, pour des raisons de compatibilité. Les processeurs suivants avaient 7 registres d'indices, mais conservaient les trois bits pour adresser les registres d'indices. Ils pouvaient fonctionner dans deux modes. Le premier mode est plus intuitif : les trois bits précisent un registre d'indice parmi les 7, qui est additionné avec l'adresse absolue. La valeur zéro indique qu'aucun registre d'indice n'est utilisé, ce qui explique qu'il y a 7 registres d'indice et non 8. Un second mode, compatible avec l'IBM 704, fait un OU logique entre les registres d'indice sélectionnés. Seuls les trois premiers registres d'indices peuvent être sélectionnés dans ce mode. Il y a deux instructions pour changer de mode : une pour passer en mode compatible, l'autre pour le quitter pour l'autre mode.

Quelques rares processeurs à registres généraux ont utilisés des registres d'indice, en plus des registres généraux. Ce qui fait l'association que nous avons faite entre registres d'indice et architectures à accumulateur est imparfait, bien que solide sur le principe. Un exemple d'architecture de ce type sont les architectures de la série UNIVAC 1100/2200. Ils disposaient de 128 registres, qui étaient mappés en mémoire à partir de l'adresse mémoire 0, la majorité étant inaccessibles par le programmeur. Ils regroupaient 12 registres accumulateurs, 11 registres d'indice et 4 registres hybrides qui pouvaient servir soit de registre d'indice, soit de registres accumulateurs.

===La micro-architecture des architectures à accumulateur avec registres d'indice===

La présence de registres d'indice modifie grandement l'implémentation du processeur. En effet, il faut rajouter un banc de registre pour les registres d'indice. Le banc de registre est monoport, car on a besoin de lire ou d'écrire un indice à la fois. Et il faut aussi potentiellement rajouter de quoi faire les calculs d'adresse. Deux solutions sont possibles : une ALU dédiée aux calculs d'adresse, une seule ALU pour toutes les opérations.

Dans le premier cas, il y a une ALU séparée associée aux registres d'indice. L'ALU et les registres d'indice sont placés en sortie du séquenceur, en-dehors du chemin de données, la sortie de l'ALU est directement connectée au bus d'adresse. L'unité de calcul d'adresse peut être utilisée pour incrémenter le ''program counter''. Un défaut de cette approche est qu'elle ne gère pas l'adresse indirect à registre.

[[File:Chemin de données sans support des pointeurs, avec adressage absolu indicé.png|centre|vignette|upright=2|Chemin de données sans support des pointeurs, avec adressage absolu indicé]]

Une autre option utilise un bus interne, qui interconnecte tout le chemin de données. Dans sa version la plus simple, il est relié à l'accumulateur, l'unité de calcul, le banc de registre d'indice et le bus de données. Avec cette solution, l'ALU est utilisé à la fois pour calculer les adresses et pour les instructions de calcul. En reliant le bus interne au bus d'adresse à travers un multiplexeur, on gère naturellement les adressages indirects.

[[File:Architecture à accumulateur avec registres associés.png|centre|vignette|upright=2.5|Architecture à accumulateur avec registres associés]]

Il faut noter que sur les architectures Von Neumann, le séquenceur est relié à ce bus interne. En effet, charger une instruction demande de passer par le bus mémoire, donc par l’intermédiaire de ce bus internet. Le ''program counter'' est envoyé sur ce bus pour lire l'instruction, puis l'instruction lue est recopiée dans le registre d'instruction. Le chargement d'une instruction est donc géré comme une lecture des plus classiques. De plus, cela permet d'incrémenter le ''program counter'' au niveau de l'unité de calcul entière. Le ''program counter'' est envoyé sur le bus interne, incrémenté par l'ALU, puis le résultat est recopié dans le ''program counter'' via le bus interne.

[[File:Architecture à accumulateur avec bus unique de type Von Neumann.png|centre|vignette|upright=2|Architecture à accumulateur avec bus unique de type Von Neumann]]

==Les processeurs bi-accumulateurs : le Motorola 6800==

Le Motorola 6800 était un processeur 8 bits qui gérait des adresses de 16 bits. Il contenait deux accumulateurs nommés A et B, de 8 bits chacun. Il disposait aussi d'un registre d'indice, d'un pointeur de pile et d'un ''program counter'', tous les trois de 16 bits. Le registre d'état regroupait 6 bits, qu'on ne détaillera pas ici.

[[File:MC6800 Processor Diagram.png|centre|vignette|upright=2|Interface et registres du MC6800.]]

La présence des deux accumulateurs impactait surtout les instructions dyadiques. Les instructions monadiques avaient juste à préciser où se trouvait l'opérande : soit en RAM, soit dans le premier accumulateur, soit dans le second. Pour les opérations dyadiques, la gestion était totalement différente. En théorie, le premier opérande est dans un accumulateur, soit A, soit B. La seconde opérande vient soit de l'autre accumulateur, soit de la mémoire RAM. Et selon les instructions, tout variait.

Pour l'addition, il y avait trois instructions. Les deux premières additionnaient un opérande provenant de la mémoire avec un accumulateur. L'instruction ADDA sélectionnait le premier accumulateur, l'instruction ADDB sélectionnait le second accumulateur. Mais une troisième instruction, l’instruction ABA, permettait d'additionner le contenu des deux accumulateurs.

Pour les autres opérations, il n'était pas possible d'utiliser les deux accumulateurs en même temps. La seule possibilité était de faire une opération entre un accumulateur et un opérande venant de la mémoire. Toutes les instructions étaient en double, avec une copie par accumulateur. Par exemple, l'instruction ANDA faisait un ET entre l’accumulateur A et l'opérande mémoire, l'instruction ANDB faisait pareil avec l'accumulateur B.

==Les architectures hybrides registres-accumulateur==

Il a existé quelques architectures qui étaient des hybrides entre architectures à accumulateur et architecture à registre. Elles ont servi de transition entre les deux, durant les années 80-90. Elles avaient un accumulateur unique couplé à un banc de registres généraux. Par exemple, les premiers processeurs Intel 8 bits étaient des processeurs hybrides-accumulateur. Lles CPU Intel 8 bits disposaient de 7 registres de 8 bits nommés A, B, C, D, E, F, H, L, SP. Ils correspondent respectivement à :
* l'accumulateur A ;
* six registres nommés B, C, D, E, H et L ;
* le registre d'état F ;
* le pointeur de pile SP.

Sur ces processeurs, les instructions dyadiques devaient mettre leur premier opérande dans l'accumulateur, la seconde provenait soit des registres, soit de la RAM, soit d'une constante immédiate. Les opérations monadiques pouvaient lire leur opérande depuis l'accumulateur, les autres registres ou la RAM, tout était permis. Les registres d'indices disparaissaient sur ces architectures, en théorie. Les registres généraux pouvaient être utilisés comme registre d'indice ou pour stocker des opérandes, ils étaient assez versatiles pour servir de registres d'indices.

La présence de registres a de nombreux avantages, comparé aux architectures à accumulateur pures. Les instructions arithmétiques sont plus rapide, lire un registre étant plus rapide qu'un accès RAM. Les performances sont donc augmentées. De plus, les instructions arithmétiques utilisant ces registres sont plus courtes : pas besoin d'encoder une adresse mémoire, un nom de registre suffit. Vu que les processeurs de l’époque avaient des instructions de taille variable, cela améliorait la densité de code.

La microarchitecture de ces processeurs est très similaire à celle d'un processeur avec des registres d'indices. La seule différence est que le banc de registre contient des registres généraux et non des registres d'indices. Le banc de registre est systématiquement monoport, car il n'avait aucune raison d'être multiport. Pour les instructions dyadiques, seules à lire deux opérandes, il ne servait que pour la seconde opérande, la première était lue depuis l'accumulateur.

Les processeurs hybrides registre-accumulateur se classent en deux types principaux : ceux qui ont un seul bus interne, et ceux qui en ont deux. Le premier cas est identique à celui vu précédemment pour les architectures à accumulateur avec registres d'indice, à la seule différence est que le banc de registre contient des registres généraux et non des registres d'indices. Afin de gérer l'adressage indirect à registre, le bus interne est connecté aux deux registres d’interfaçage mémoire.

[[File:Architecture à accumulateur avec bus unique de type Von Neumann.png|centre|vignette|upright=2|Architecture à accumulateur avec bus unique de type Von Neumann]]

Notons que cela permet aussi d'implémenter facilement les branchements indirects, car le bus interne permet d'échanger des adresses entre ''program counter'' et banc de registre. De même, il est possible d'utiliser l'ALU pour gérer les branchements indirects., en plus de l'utiliser pour incrémenter le ''program counter''.

[[File:Single bus organization.jpg|centre|vignette|upright=2|Single bus organization]]

Une autre solution utilisait deux bus internes : un connecté au bus de données, un autre relié au bus d'adresse. Le bus de commande mémoire était lui commandé par le séquenceur, l'unité de contrôle. L'intermédiaire entre ces deux bus était le banc de registre, ainsi que les autres registres. Le banc de registre était connecté aux deux bus interne, avec un port de lecture relié au bus d'adresse, un port de lecture-écriture relié au bus de données. Le port de lecture était utilisé pour l'adressage indirect, l'autre l'était pour le reste.

[[File:Proz1-e.png|centre|vignette|upright=2|Intérieur d'un processeur.]]

L'organisation à deux bus simplifiait la gestion du ''program counter'' et le chargement des instructions. Le ''program counter'' était soit séparé du banc de registre, soit placé dans le banc de registre. Les deux solutions étaient utilisés, tout dépend du processeur. Il faut noter que si le ''program counter'' est intégré au banc de registres, alors la microarchitecture du processeur est bien plus simple. L'envoi du ''program counter'' sur le bus d'adresse utilise le port de lecture relié au bus d'adresse, qui sert aussi pour l'adressage indirect. L'économie de circuits, sans compter la simplicité d'implémentation que cela implique, explique sans doute que la technique a été utilisée sur quelques processeurs anciens.

Le ''program counter'' était généralement incrémenté par l'ALU, ce qui explique qu'il soit connecté au bus interne pour les données. La connexion est aussi utile pour gérer les branchements indirects, qui copient un registre dans le ''program counter'', ainsi que les branchements relatifs (addition dans l'ALU), voire les branchements directs (l'adresse vers laquelle brancher est envoyée en entrée de l'ALU et propagée en sortie avec une opération ''pass through'').

[[File:Connexion du program counter sur les bus avec PC dans le banc de registres.png|centre|vignette|upright=2|Connexion du program counter sur les bus avec PC dans le banc de registres]]

===Les registres d'interruption avec un processeur hybride-accumulateur : l'exemple du Z80===

Un exemple de processeur registre-accumulateur à deux bus interne est le Z80, un processeur fortement inspiré des CPU Intel 8 bits. Il a un jeu d'instruction similaire, mais a diverses améliorations par rapport au design original. Notamment, le processeur a des registres séparés pour les interruptions.

Sur le Z80, les registres généraux sont dupliqués avec 6 registres pour les interruptions et 6 registres pour les programmes autres. Leur copie pour les interruptions sont nommées B', C', D', E', H', L'. Les 12 registres sont placés dans le banc de registre, ce qui implique que le fenêtrage de registres est utilisé pour gérer la séparation entre registre d'interruption et normaux. Il faut noter que l'accumulateur et le registre d'état sont aussi dupliqués, leurs copies étant nommées A' et F'. Mais leur duplication se fait autrement que par fenêtrage de registre.

En plus des registres précédents, le Z80 incorporait deux registres d'indice nommés X et Y, ainsi qu'un pointeur de pile SP et un ''program counter'' PC. Ils n'étaient pas dupliqués pour les interruptions. Les registres d'indice étaient reliés à une unité de calcul d'adresse. L'unité de calcul d'adresse prenait deux opérandes : un indice, et une adresse mémoire provenant soit du banc de registre, soit de l'accumulateur. En clair, l'unité de calcul d'adresse faisait le lien entre les deux bus internet : le bus de données interne en entrée, le bus d'adresse en sortie.

À l'intérieur du processeur, tous les registres étaient regroupés dans un banc de registre unique, sauf les accumulateurs, les registres d'état et le ''program counter''. Bien que ce ne soit pas indiqué sur le schéma ci-dessous, le ''program counter'' est séparé du banc de registre, alors que le pointeur de pile est dedans. Le compteur IR est lui associé au ''program counter'', il est sortit du banc de registre. Le Z80 utilise lui aussi un incrémenteur séparé de l'ALU, qui est utilisé pour mettre à jour le ''program counter'', le pointeur de pile et un compteur de rafraichissement mémoire nommé IR sur le Z80 (pour rappel, le rafraichissement mémoire demande de balayer la mémoire d'adresse en adresse et été fait par le CPU à l'époque). De plus, il est utilisé pour les instructions INC et DEC qui incrémentent une opérande de 16 bits obtenue en combinant deux registres de 8 bits. En clair, l'incrémenteur du ''program counter'' a été réutilisé de beaucoup de manières originales.

[[File:Z80 arch.svg|centre|vignette|upright=3|Microarchitecture du Z80.]]

Le Z80 incorporait des instructions pour échanger le contenu des deux ensembles de registres, accumulateur inclus. Elles permettaient d'utiliser les registres d'interruption pour les programmes et réciproquement. En clair, cela doublait le nombre de registres si les interruptions n'étaient pas utilisées.
* L'instruction EXX échangeait les deux fenêtres de registres généraux : les registres B, C, D, E, H et L devenaient les registres B', C', D', E', H' et L' et inversement.
* L'instruction EX échangeait l'accumulateur et le registre d'état : les registres A,F devenait A',F' et inversement.

Le fenêtrage de registre était modifié par l'instruction EXX, qui échangeait les deux fenêtres de registres. Pour l'implémenter, une bascule était ajouté au processeur, appelons-la la bascule INT. Elle était relié au bus d'adresse du banc de registre, dont elle mémorisait le bit de poids fort. L'instruction EXX inversait la valeur de la bascule INT. Il est aussi possible d'échanger le contenu des registres D,E et H,L avec une instruction dédiée, ce qui est là encore fait par deux bascules : une pour les registres D,E et une autre pour les registres H,L.

Pour l'accumulateur et le registre d'état, le choix entre registre normal et registre d'interruption se faisait là encore par une seconde bascule appelée la bascule A. La bascule est reliée à un multiplexeur et un démultiplexeur, qui permet de choisir quel accumulateur relier à l'unité de calcul. L'instruction EX inverse le contenu de la bascule A.

&lt;noinclude&gt;
{{NavChapitre | book=Fonctionnement d'un ordinateur
           | prev=L'unité de contrôle
           | prevText=L'unité de contrôle
           | next=Les processeurs 8 bits et moins
           | nextText=Les processeurs 8 bits et moins
}}
&lt;/noinclude&gt;</text>
      <sha1>klq0txs8rhwgaj87u5zrf9cgnh71g23</sha1>
    </revision>
    <revision>
      <id>744133</id>
      <parentid>744132</parentid>
      <timestamp>2025-06-05T00:30:23Z</timestamp>
      <contributor>
        <username>Mewtow</username>
        <id>31375</id>
      </contributor>
      <minor />
      <comment>/* Les registres des anciennes architectures à accumulateur */</comment>
      <origin>744133</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="36269" sha1="2odvhhyeh8t9l81rfo0n5r1jfacl500" xml:space="preserve">Les architectures que nous avons vu précédemment dans ce cours disposent de registres pour les données, en plus du pointeur de pile, d'un ''program counter'', et de quelques autres. Elles sont appelées des '''architectures à registres''', terme qui trahit bien le fait qu'elles ont des registres généraux ou spécialisés pour stocker temporairement des données. Et si on leur a donné un nom, c'est parce qu'il existe des architectures qui ne sont pas dans cette catégorie. Il en existe plusieurs types, mais ce chapitre va se concentrer sur les '''architectures à accumulateur'''.

[[File:Isaccumulator.png|vignette|Architecture à accumulateur.]]

Les architectures à accumulateur sont centrées autour d'un registre architectural appelé l''''accumulateur'''. Il est utilisé pour toutes les opérations arithmétiques dyadiques, où il sert à la fois de source et de destination. Toutes les instructions dyadiques sont de type ''load-op'' : une opérande est lue depuis l'accumulateur, le second opérande est lu depuis la mémoire RAM, le résultat de l'instruction est automatiquement mémorisé dans l'accumulateur. Les instructions monadiques peuvent utiliser un opérande dans l'accumulateur, ou dans la mémoire RAM, les deux sont théoriquement possibles.

La conséquence est que le nombre d'accès mémoire est drastiquement diminué : de 3 par instructions sur une architecture mémoire-mémoire, on passe à seulement un avec un accumulateur. Les opérations dyadiques ont besoin d'un seul accès mémoire pour lire la seconde opérande, les opérations monadique en font aussi un seul pour lire leur unique opérande.

{|class=&quot;wikitable&quot;
|-
! Classe d'architecture
! Nombre d'accès mémoire par opération dyadique
|-
|-
! Architecture à accumulateur
| Un accès mémoire par instruction, pour lire la seconde opérande
|-
! Architecture à registres
| Zéro si les opérandes sont dans les registres, un pour les opérations ''load-op'', LOAD et STORE.
|}

==Le jeu d'instruction des architectures à accumulateur sans registres d'indice==

L'accumulateur est adressé grâce au mode d'adressage implicite, de même que le résultat de l'opération. Par contre, les autres opérandes sont localisés avec d'autres modes d'adressage, et lues en mémoire RAM. Le résultat ainsi qu'un des opérandes sont adressés de façon implicite car dans l'accumulateur, seule la seconde opérande étant adressée directement. Grâce à l'accumulateur, une instruction ne fait qu'un seul accès mémoire maximum, ce qui rend le processeur très facile à implémenter.

===Les registres des anciennes architectures à accumulateur===

[[File:BabyArchitecture.png|vignette|Architecture de la Manchester Baby.]]

Les architectures à accumulateurs sont apparues dès les débuts de l'informatique. Le tout premier ordinateur à programme enregistré en mémoire, le ''Manchester Baby'', était une architecture à accumulateur. Niveau interface, l'ordinateur avait une console avec 32 boutons, des interrupteurs et un écran de sortie sur lequel afficher les résultats. A l'intérieur, il y avait un processeur et une RAM de 32 adresses de 32 bits, fabriquée avec des tubes Williams (abordés dans une annexe à la fin du cours).

Le programme devait tenir dans la RAM, avec une instruction par adresse maximum, ce qui limitait les programmes à 32 instructions maximum. Une instruction prenait donc 32 bits, 3 indiquaient quelle opération utiliser, 12 servait à indiquer où se trouvent les opérandes en RAM, les 16 restants sont inutilisés.

Le processeur avait un registre accumulateur de 32 bits, un ''program counter'' et un registre d'instruction. Il gérait 8 instructions en tout, mais ne gérait pas l'addition. Il gérait la soustraction, des instructions de branchement et d'accès mémoire, rien d'autre. Il pouvait cependant émuler l'addition à partir d'une soustraction et inversant l'opérande soustraite.

[[File:IBM 701console.jpg|vignette|IBM 701, console extérieure.]]

Les architectures à accumulateur étaient communes dans les années 50-60. A l'époque, les ordinateurs étaient gigantesques, ils prenaient une pièce de bâtiment entière dans le pire des cas, une armoire entière dans le meilleur. Les ordinateurs de l'époque étaient surtout utilisés pour du calcul scientifique ou des tâches d’ingénierie demandant beaucoup de calcul, rarement pour de la compatibilité.

Les nombres flottants n'étaient pas encore apparus. A la place, les ordinateurs de l'époque géraient des nombres entiers de grande taille, de 30 bits ou plus. En conséquence, l'accumulateur faisait facilement 30 à 60 bits. Par exemple, les ordinateurs de la Série scientifique IBM 700/7000 géraient des entiers de 36 bits, l’accumulateur faisait 38 bits : 36 bits plus deux bits pour les débordements. Au passage, de tels processeurs utilisaient l'adressage par mot, et non par byte.

Historiquement, les premières architectures à accumulateur ne contenaient aucun autre registre que l'accumulateur. Ce n'est que dans les années 60 que de nombreuses architectures à accumulateur ont ajouté un second '''registre pour les multiplication/divisions'''. Un exemple est celui de l'IBM 701, qui incorporait un registre accumulateur de 38 bits et un registre multiplieur de 36 bits. Le registre mémorise le multiplieur lors d'une opération de multiplication. Il mémorise donc un opérande, pas le résultat. Il peut aussi décaler le multiplieur vers la droite/gauche, ce qui est utile pour exécuter la multiplication. C'est ce qui est fait sur l'IBM 7094.

Une autre possibilité est que ce registre mémorise une partie du résultat de l'opération. Pour rappel, le résultat d'une multiplication/division est codé sur deux fois de bits que ses opérandes. Par exemple, multipliez deux opérandes de 30 bits, vous obtiendrez un résultat de 60 bits. Les 30 bits de poids faible du résultat vont dans l'accumulateur, les 30 bits de poids fort vont dans ce second registre.

Les architectures à accumulateur parfois un '''registre pour le pointeur de pile''', utilisé pour gérer les fonctions/procédures. Les architectures à accumulateurs supportaient une pile d'adresse de retour, souvent une pile d'appel. Mais pour cela, il fallait mémoriser le pointeur de pile dans le processeur, ce qui demandait un registre dédié.

===L'adressage indirect avec l'accumulateur===

Les instructions LOAD et STORE existent bel et bien sur les architectures à accumulateur, mais n'ont pas les mêmes modes d'adressages. L'instruction LOAD copie une donnée de la RAM vers l'accumulateur, l'instruction STORE copie l'accumulateur dans une adresse. Les deux instructions n'ont pas besoin d'adresser l'accumulateur, qui est adressé de manière implicite, juste de préciser l'adresse à lire/écrire.

Les architectures à accumulateur supportaient souvent le mode d'adressage indirect mémoire. Un exemple est celui des ordinateurs Data General Nova, qui sont des architectures à accumulateur et qui supportaient ce mode d'adressage. Les deux instructions LOAD et STORE existaient en deux versions, distinguées par un bit d'indirection. Si ce bit est à 0 dans l'opcode, alors l'instruction utilise le mode d'adressage absolu normal : l'adresse intégrée dans l'instruction est celle de la donnée. Mais s'il est à 1, alors l'adresse intégrée dans l'instruction est celle du pointeur.

Cependant, la présence de l'accumulateur permettait d'utiliser l'adressage indirect à registre, pour gérer les pointeurs. Pour rappel, avec le mode d'adressage indirect à registre, l'adresse à lire/écrire est dans un registre. Ici, l'adresse à lire/écrire est prise dans l'accumulateur, seul registre disponible pour. L'adressage indirect est plus simple à implémenter pour l'instruction LOAD, car elle prend un seul opérande : l'adresse à lire. L'adresse à lire est placée dans l'accumulateur, la donnée lue est elle aussi chargée dans l'accumulateur. Pour l'instruction STORE, il faut fournir deux opérandes, l'adresse et la donnée à écrire, ce qui peut poser problème. Mais au pire, il est toujours possible d'utiliser l'adressage absolu ou indirect mémoire : l'adresse est dans l'instruction, la donnée à écrire dans l'accumulateur.

===L'encodage des instructions===

Sur une architecture à accumulateur l'encodage d'une instruction dyadique est assez simple, vu que l'accumulateur est adressé implicitement. La seconde opérande est localisée soit par une adresse mémoire (adressage absolu), soit est une constante (adressage immédiat). L'adresse mémoire est généralement assez longue, plus que l'opcode.

{|class=&quot;wikitable&quot;
|+ Encodage d'une instruction dyadique
|-
! rowspan=&quot;2&quot; | Opcode 
| Adresse mémoire (adressage absolu)
|-
| Constante (adressage immédiat)
|}

L'encodage d'une instruction monadique est similaire. Si l'opérande est lue depuis la mémoire RAM, alors l'instruction est encodée comme une instruction dyadique. Il en est de même pour les instructions qui copient une constante dans l'accumulateur. Par contre, si l'opérande est dans l'accumulateur, alors il y a juste besoin d'encoder l'opcode. La majorité des instructions a besoin de préciser une adresse, rares sont celles qui s'en passent. Au vu de cet encodage, les architectures à accumulateur sont qualifiées d''''architectures à une adresse''' par abus de langage.

Il est intéressant de contraster leur encodage avec les architectures à registres. Les architectures à registre doivent encoder deux opérandes en plus de l'opcode, avec éventuellement où enregistrer le résultat sur les architectures 3-adresses. Par contre, les opérandes sont généralement des noms de registre, ce qui prend moins de place qu'une adresse mémoire. A la rigueur, les instructions avec une constante immédiate prennent un peu plus de place, car elles doivent encoder un nom de registre en plus de la constante et de l'opcode. Les instructions ''load-op'' des processeurs CISC sont un peu dans le même cas, sauf qu'il faut remplacer la constante par une adresse, qui a généralement la même taille. Les instructions sont donc en moyenne plus courte sur les processeurs à registre, du fait de la présence de registres.

==La micro-architecture des architectures à accumulateur sans registres d'indice==

L'organisation interne d'une architecture à accumulateur est très différente de celle des processeurs à registre. Elle est plus ou moins la même pour tous ces processeurs, le point important étant que le chemin de données se résume à une ALU, un registre accumulateur et le bus de données. L'ALU est reliée au registre accumulateur, ainsi qu'au bus de données pour lire la seconde opérande, comme illustré ci-dessous.

[[File:Accumulator.png|centre|vignette|upright=2|Accumulateur.]]

===L'unité de calcul et l'accumulateur===

Pour simplifier l'implémentation, le résultat est mémorisé dans un registre en sortie de l'unité de calcul. La raison est qu'on ne veut pas altérer l'accumulateur tant que le résultat final n'est pas totalement calculé. Rappelons que l'ALU ne fournit pas un résultat d'un seul bloc, mais que certains bits arrivent avant les autres, typiquement les bits de poids faible. Si le résultat était écrit dans l'accumulateur directement, il écraserait des bits de l’opérande en cours d'utilisation, ce qui fausserait le résultat.

[[File:Accumulateur avec registre de sortie.png|centre|vignette|upright=2|Accumulateur avec registre de sortie]]

Une autre solution utilisait un registre entre l'accumulateur et l'unité de calcul, appelé l’'''''accumulator latch'''''. Il remplace le registre en sortie de l'ALU, dans le sens où il permet d'écrire dans l'accumulateur sans effacer l'opérande, pendant que l’opération est en cours dans l'ALU. L'accumulateur est copié dans l’''accumulator latch'', avant que l'ALU démarre ses calculs. L'opérande est donc maintenue même si on commence à écrire le résultat dans l'accumulateur.

Sur le 8085 d'Intel, l’''accumulator latch'' peut être initialisé avec une constante prédéfinie, ce qui permet d'implémenter certaines instructions très facilement. Par exemple, il peut être initialisé à 0, ce qui permet d'implémenter les instructions MOV et INC (incrémentation). Un MOV est équivalent à faire un OU entre le registre lu et 0. Une instruction INC initialise l'entrée de retenue de l'unité de calcul à 1, puis ajoute 0. La décrémentation est implémentée de la même manière, sauf que l’''accumulator latch'' est initialisé à -2 pour compenser l'entrée de retenue à 1. De plus, pour supporter les conversion de décimal à BCD, l’''accumulator latch'' peut être initialisé avec les constantes 0x00, 0x06, 0x60, or 0x66. L'''accumulator latch'' est relié à divers fils de commande provenant de l'unité de contrôle, qui décide quelle valeur d'initialisation utiliser en fonction de l'instruction décodée.

[[File:Accumulator latch.png|centre|vignette|upright=2|Accumulator latch]]

[[File:Chemin de données à un seul bus.png|vignette|Chemin de données à un seul bus]]

De même, la seconde opérande, celle lue sur le bus de données, est mémorisée dans un registre en amont de l'ALU. C'était notamment très utile si le processeur utilisait une ALU plus courte que les opérandes, avec par exemple une ALU 4 bits pour un CPU 8 bits. Les anciens processeurs à accumulateur de type ''mainframe'' utilisaient des opérandes de grande taille, du genre 36 ou 48 bits, ce qui avait des conséquences sur l'unité de calcul utilisée, ainsi que sur la communication avec la mémoire. Il arrivait que de tels processeurs utilisaient des ALU sérielles, ou du moins octet-sérielles, plutôt qu'une véritable ALU 36 bits. Nous verrons aussi que c'est très utile sur les processeurs à accumulateur avec un bus interne unique, dans la suite du chapitre.

===La micro-architecture des architectures à accumulateur avec instructions LOAD/STORE===

Nous venons de voir comment est implémenté l'unité de calcul et l'accumulateur, et comment le tout est relié au bus de données. Mais cela ne permet que d'avoir un processeur à accumulateur rudimentaire, qui ne gére que des instructions arithmétiques et logiques. Il faut aussi gérer le cas des opérations LOAD/STORE et des modes d'adressages associés, mais c'est le séquenceur qui s'en occupe. Avec l'adressage absolu, les instructions LOAD et STORE ne font que connecter l'accumulateur au bus de données. L'instruction STORE nécessite de connecter l'accumulateur au bus de données, de manière à ce que le transfert des données se fasse de l'accumulateur vers le bus de données. L'instruction LOAD s'implémente de la même manière, sauf que le sens de transfert est inversé.

Cependant, il existe une optimisation qui permet d'implémenter l'instruction LOAD sans ajouter de circuits. Pour cela, il suffit que l'unité de calcul gére les opérations ''pass through'', à savoir des opérations qui se contentent de recopier un opérande sur la sortie. Ici, l'idée est de recopier l'opérande provenant du bus de données.

[[File:Architecture à accumulateur, microarchitecture.png|centre|vignette|upright=2|Architecture à accumulateur, microarchitecture]]

Pour gérer nativement l'adressage indirect à registre, il suffit de connecter l'accumulateur au bus d'adresse. Le plus simple est d'ajouter un multiplexeur, comme illustré ci-dessous. La donnée lue est copiée dans l'accumulateur, ce qui fait qu'il vaut mieux utiliser un registre d’interfaçage, l'accumulateur n'étant pas utilisable à la fois pour le bus d'adresse et de données.

[[File:Adressage indirect sur une architecture à accumulateur.png|centre|vignette|upright=2|Adressage indirect sur une architecture à accumulateur]]

Pour finir, voyons comment le pointeur de pile et le ''program counter'' sont implémentés. Les architectures à accumulateur ont souvent des adresses de taille différente des données, ce qui fait qu'il vaut mieux utiliser un circuit incrémenteur dédié pour incrémenter le ''program counter'', plutôt que de l'incrémenter via l'unité de calcul. Les architectures à accumulateur ont parfois un pointeur de pile, qui gère une pile d'adresse de retour, pas une vraie pile d'appel. Aussi, le pointeur de pile est censé être incrémenté et décrémenté, pas plus. Pas d'addition ou de soustraction pour gérer des cadres de pile. Là encore, c'est la solution de l'incrémenteur séparé qui est retenue. Pour économiser des transistors, il n'y a qu'un seul incrémenteur partagé pour les deux.

==Les architectures à accumulateur à registres d'indice==

Les architectures à accumulateur décrites dans la section précédente sont capables de faire de l'adressage indirect, mais n'incluent pas les modes d'adressage base + indice et absolus indicés, qui prennent une adresse et y ajoute un indice. Il s'agit des toutes premières architectures à accumulateur, comme les premiers ordinateurs IBM ou le fameux PDP-8. Mais par la suite, les processeurs à accumulateurs ont inclus un support des modes d'adressages indicés, grâce à des '''registres d'indice'''.

===Les registres d'indice===

Les registres d'indice stockent des indices de tableaux. Ils permettaient de supporter deux modes d'adressage :
* Le '''mode d'adressage absolu indicé''' où une adresse fixe est additionnée à un indice variable. L'adresse fixe est intégrée dans l'instruction (adressage absolu), l'indice est dans un registre d'indice.
* Le '''mode d'adressage base + indice''', où l'adresse est dans l'accumulateur et l'indice dans le registre d'indice.

Les processeurs à accumulateur supportaient souvent des variantes des modes d'adressage précédents, où le registre d'indice était automatiquement incrémenté ou décrémenté à chaque utilisation.

Au départ, ces processeurs n'utilisaient qu'un seul registre d'indice qui se comportait comme un second accumulateur spécialisé dans les calculs d'adresses mémoire. Le processeur supportait de nouvelles instructions qui utilisaient ce registre d'indice de façon implicite. Mais avec le temps, les processeurs finirent par incorporer plusieurs de ces registres. Les instructions de lecture ou d'écriture devaient alors préciser quel registre d'indice utiliser, en précisant un nom de registre d'indice, un numéro de registre d'indice.

Il faut préciser que les registres d'indice ont une taille bien plus petite que l'accumulateur. Ils mémorisent des indices codés sur 16 bits ou moins, alors que l'accumulateur faisait typiquement 36 à 48 bits, parfois plus. La taille classique sur les anciens ''mainframes'' était de 15 bits, parfois moins. Il n'était pas rare de tomber sur des registres d'indice de 8 ou 9 bits. Leur petite taille rendait leur implémentation matérielle peu couteuse. Et c'est ce qui explique qu'ils étaient préférés à l'usage d'un second accumulateur.

Un exemple est le cas du processeur Motorola 6809, un processeur à accumulateur qui contient deux registres d'indices nommés X et Y. L'accumulateur est noté D et fait 16 bits, il peut être parfois géré comme deux accumulateurs séparés A et B de 8 bits chacun. Il contenait aussi deux pointeurs de pile, l'un pour les programmes, l'autre pour le système d'exploitation, ainsi qu'un ''program counter''. Le registre de page était utilisé pour l'adressage absolu, comme vu dans le chapitre sur les modes d'adressage.

[[File:6809 Internal Registers.svg|centre|vignette|upright=2|6809 Internal Registers]]

Les processeurs IBM avaient autrefois plusieurs registres d'indice. Par exemple, l'IBM 704 avait trois registres d'indice de 15 bits. Leur contenu était soustrait de l'adresse absolue. Une instruction pouvait utiliser plusieurs registres d'indice pour adresser son opérande. Toute instruction utilisait trois bits pour sélectionner les registres d'indice utilisés. Fait assez original, lorsque plusieurs registres d'indice sont sélectionnés, le processeur n'additionne pas les trois registres à l'adresse de base. À la place, il fait un OU bit à bit entre les registres d'indice sélectionnés, et additionne le résultat à l'adresse.

Les processeurs IBM à accumulateur ont fait ça sur toute la gamme IBM 700/7000, pour des raisons de compatibilité. Les processeurs suivants avaient 7 registres d'indices, mais conservaient les trois bits pour adresser les registres d'indices. Ils pouvaient fonctionner dans deux modes. Le premier mode est plus intuitif : les trois bits précisent un registre d'indice parmi les 7, qui est additionné avec l'adresse absolue. La valeur zéro indique qu'aucun registre d'indice n'est utilisé, ce qui explique qu'il y a 7 registres d'indice et non 8. Un second mode, compatible avec l'IBM 704, fait un OU logique entre les registres d'indice sélectionnés. Seuls les trois premiers registres d'indices peuvent être sélectionnés dans ce mode. Il y a deux instructions pour changer de mode : une pour passer en mode compatible, l'autre pour le quitter pour l'autre mode.

Quelques rares processeurs à registres généraux ont utilisés des registres d'indice, en plus des registres généraux. Ce qui fait l'association que nous avons faite entre registres d'indice et architectures à accumulateur est imparfait, bien que solide sur le principe. Un exemple d'architecture de ce type sont les architectures de la série UNIVAC 1100/2200. Ils disposaient de 128 registres, qui étaient mappés en mémoire à partir de l'adresse mémoire 0, la majorité étant inaccessibles par le programmeur. Ils regroupaient 12 registres accumulateurs, 11 registres d'indice et 4 registres hybrides qui pouvaient servir soit de registre d'indice, soit de registres accumulateurs.

===La micro-architecture des architectures à accumulateur avec registres d'indice===

La présence de registres d'indice modifie grandement l'implémentation du processeur. En effet, il faut rajouter un banc de registre pour les registres d'indice. Le banc de registre est monoport, car on a besoin de lire ou d'écrire un indice à la fois. Et il faut aussi potentiellement rajouter de quoi faire les calculs d'adresse. Deux solutions sont possibles : une ALU dédiée aux calculs d'adresse, une seule ALU pour toutes les opérations.

Dans le premier cas, il y a une ALU séparée associée aux registres d'indice. L'ALU et les registres d'indice sont placés en sortie du séquenceur, en-dehors du chemin de données, la sortie de l'ALU est directement connectée au bus d'adresse. L'unité de calcul d'adresse peut être utilisée pour incrémenter le ''program counter''. Un défaut de cette approche est qu'elle ne gère pas l'adresse indirect à registre.

[[File:Chemin de données sans support des pointeurs, avec adressage absolu indicé.png|centre|vignette|upright=2|Chemin de données sans support des pointeurs, avec adressage absolu indicé]]

Une autre option utilise un bus interne, qui interconnecte tout le chemin de données. Dans sa version la plus simple, il est relié à l'accumulateur, l'unité de calcul, le banc de registre d'indice et le bus de données. Avec cette solution, l'ALU est utilisé à la fois pour calculer les adresses et pour les instructions de calcul. En reliant le bus interne au bus d'adresse à travers un multiplexeur, on gère naturellement les adressages indirects.

[[File:Architecture à accumulateur avec registres associés.png|centre|vignette|upright=2.5|Architecture à accumulateur avec registres associés]]

Il faut noter que sur les architectures Von Neumann, le séquenceur est relié à ce bus interne. En effet, charger une instruction demande de passer par le bus mémoire, donc par l’intermédiaire de ce bus internet. Le ''program counter'' est envoyé sur ce bus pour lire l'instruction, puis l'instruction lue est recopiée dans le registre d'instruction. Le chargement d'une instruction est donc géré comme une lecture des plus classiques. De plus, cela permet d'incrémenter le ''program counter'' au niveau de l'unité de calcul entière. Le ''program counter'' est envoyé sur le bus interne, incrémenté par l'ALU, puis le résultat est recopié dans le ''program counter'' via le bus interne.

[[File:Architecture à accumulateur avec bus unique de type Von Neumann.png|centre|vignette|upright=2|Architecture à accumulateur avec bus unique de type Von Neumann]]

==Les processeurs bi-accumulateurs : le Motorola 6800==

Le Motorola 6800 était un processeur 8 bits qui gérait des adresses de 16 bits. Il contenait deux accumulateurs nommés A et B, de 8 bits chacun. Il disposait aussi d'un registre d'indice, d'un pointeur de pile et d'un ''program counter'', tous les trois de 16 bits. Le registre d'état regroupait 6 bits, qu'on ne détaillera pas ici.

[[File:MC6800 Processor Diagram.png|centre|vignette|upright=2|Interface et registres du MC6800.]]

La présence des deux accumulateurs impactait surtout les instructions dyadiques. Les instructions monadiques avaient juste à préciser où se trouvait l'opérande : soit en RAM, soit dans le premier accumulateur, soit dans le second. Pour les opérations dyadiques, la gestion était totalement différente. En théorie, le premier opérande est dans un accumulateur, soit A, soit B. La seconde opérande vient soit de l'autre accumulateur, soit de la mémoire RAM. Et selon les instructions, tout variait.

Pour l'addition, il y avait trois instructions. Les deux premières additionnaient un opérande provenant de la mémoire avec un accumulateur. L'instruction ADDA sélectionnait le premier accumulateur, l'instruction ADDB sélectionnait le second accumulateur. Mais une troisième instruction, l’instruction ABA, permettait d'additionner le contenu des deux accumulateurs.

Pour les autres opérations, il n'était pas possible d'utiliser les deux accumulateurs en même temps. La seule possibilité était de faire une opération entre un accumulateur et un opérande venant de la mémoire. Toutes les instructions étaient en double, avec une copie par accumulateur. Par exemple, l'instruction ANDA faisait un ET entre l’accumulateur A et l'opérande mémoire, l'instruction ANDB faisait pareil avec l'accumulateur B.

==Les architectures hybrides registres-accumulateur==

Il a existé quelques architectures qui étaient des hybrides entre architectures à accumulateur et architecture à registre. Elles ont servi de transition entre les deux, durant les années 80-90. Elles avaient un accumulateur unique couplé à un banc de registres généraux. Par exemple, les premiers processeurs Intel 8 bits étaient des processeurs hybrides-accumulateur. Lles CPU Intel 8 bits disposaient de 7 registres de 8 bits nommés A, B, C, D, E, F, H, L, SP. Ils correspondent respectivement à :
* l'accumulateur A ;
* six registres nommés B, C, D, E, H et L ;
* le registre d'état F ;
* le pointeur de pile SP.

Sur ces processeurs, les instructions dyadiques devaient mettre leur premier opérande dans l'accumulateur, la seconde provenait soit des registres, soit de la RAM, soit d'une constante immédiate. Les opérations monadiques pouvaient lire leur opérande depuis l'accumulateur, les autres registres ou la RAM, tout était permis. Les registres d'indices disparaissaient sur ces architectures, en théorie. Les registres généraux pouvaient être utilisés comme registre d'indice ou pour stocker des opérandes, ils étaient assez versatiles pour servir de registres d'indices.

La présence de registres a de nombreux avantages, comparé aux architectures à accumulateur pures. Les instructions arithmétiques sont plus rapide, lire un registre étant plus rapide qu'un accès RAM. Les performances sont donc augmentées. De plus, les instructions arithmétiques utilisant ces registres sont plus courtes : pas besoin d'encoder une adresse mémoire, un nom de registre suffit. Vu que les processeurs de l’époque avaient des instructions de taille variable, cela améliorait la densité de code.

La microarchitecture de ces processeurs est très similaire à celle d'un processeur avec des registres d'indices. La seule différence est que le banc de registre contient des registres généraux et non des registres d'indices. Le banc de registre est systématiquement monoport, car il n'avait aucune raison d'être multiport. Pour les instructions dyadiques, seules à lire deux opérandes, il ne servait que pour la seconde opérande, la première était lue depuis l'accumulateur.

Les processeurs hybrides registre-accumulateur se classent en deux types principaux : ceux qui ont un seul bus interne, et ceux qui en ont deux. Le premier cas est identique à celui vu précédemment pour les architectures à accumulateur avec registres d'indice, à la seule différence est que le banc de registre contient des registres généraux et non des registres d'indices. Afin de gérer l'adressage indirect à registre, le bus interne est connecté aux deux registres d’interfaçage mémoire.

[[File:Architecture à accumulateur avec bus unique de type Von Neumann.png|centre|vignette|upright=2|Architecture à accumulateur avec bus unique de type Von Neumann]]

Notons que cela permet aussi d'implémenter facilement les branchements indirects, car le bus interne permet d'échanger des adresses entre ''program counter'' et banc de registre. De même, il est possible d'utiliser l'ALU pour gérer les branchements indirects., en plus de l'utiliser pour incrémenter le ''program counter''.

[[File:Single bus organization.jpg|centre|vignette|upright=2|Single bus organization]]

Une autre solution utilisait deux bus internes : un connecté au bus de données, un autre relié au bus d'adresse. Le bus de commande mémoire était lui commandé par le séquenceur, l'unité de contrôle. L'intermédiaire entre ces deux bus était le banc de registre, ainsi que les autres registres. Le banc de registre était connecté aux deux bus interne, avec un port de lecture relié au bus d'adresse, un port de lecture-écriture relié au bus de données. Le port de lecture était utilisé pour l'adressage indirect, l'autre l'était pour le reste.

[[File:Proz1-e.png|centre|vignette|upright=2|Intérieur d'un processeur.]]

L'organisation à deux bus simplifiait la gestion du ''program counter'' et le chargement des instructions. Le ''program counter'' était soit séparé du banc de registre, soit placé dans le banc de registre. Les deux solutions étaient utilisés, tout dépend du processeur. Il faut noter que si le ''program counter'' est intégré au banc de registres, alors la microarchitecture du processeur est bien plus simple. L'envoi du ''program counter'' sur le bus d'adresse utilise le port de lecture relié au bus d'adresse, qui sert aussi pour l'adressage indirect. L'économie de circuits, sans compter la simplicité d'implémentation que cela implique, explique sans doute que la technique a été utilisée sur quelques processeurs anciens.

Le ''program counter'' était généralement incrémenté par l'ALU, ce qui explique qu'il soit connecté au bus interne pour les données. La connexion est aussi utile pour gérer les branchements indirects, qui copient un registre dans le ''program counter'', ainsi que les branchements relatifs (addition dans l'ALU), voire les branchements directs (l'adresse vers laquelle brancher est envoyée en entrée de l'ALU et propagée en sortie avec une opération ''pass through'').

[[File:Connexion du program counter sur les bus avec PC dans le banc de registres.png|centre|vignette|upright=2|Connexion du program counter sur les bus avec PC dans le banc de registres]]

===Les registres d'interruption avec un processeur hybride-accumulateur : l'exemple du Z80===

Un exemple de processeur registre-accumulateur à deux bus interne est le Z80, un processeur fortement inspiré des CPU Intel 8 bits. Il a un jeu d'instruction similaire, mais a diverses améliorations par rapport au design original. Notamment, le processeur a des registres séparés pour les interruptions.

Sur le Z80, les registres généraux sont dupliqués avec 6 registres pour les interruptions et 6 registres pour les programmes autres. Leur copie pour les interruptions sont nommées B', C', D', E', H', L'. Les 12 registres sont placés dans le banc de registre, ce qui implique que le fenêtrage de registres est utilisé pour gérer la séparation entre registre d'interruption et normaux. Il faut noter que l'accumulateur et le registre d'état sont aussi dupliqués, leurs copies étant nommées A' et F'. Mais leur duplication se fait autrement que par fenêtrage de registre.

En plus des registres précédents, le Z80 incorporait deux registres d'indice nommés X et Y, ainsi qu'un pointeur de pile SP et un ''program counter'' PC. Ils n'étaient pas dupliqués pour les interruptions. Les registres d'indice étaient reliés à une unité de calcul d'adresse. L'unité de calcul d'adresse prenait deux opérandes : un indice, et une adresse mémoire provenant soit du banc de registre, soit de l'accumulateur. En clair, l'unité de calcul d'adresse faisait le lien entre les deux bus internet : le bus de données interne en entrée, le bus d'adresse en sortie.

À l'intérieur du processeur, tous les registres étaient regroupés dans un banc de registre unique, sauf les accumulateurs, les registres d'état et le ''program counter''. Bien que ce ne soit pas indiqué sur le schéma ci-dessous, le ''program counter'' est séparé du banc de registre, alors que le pointeur de pile est dedans. Le compteur IR est lui associé au ''program counter'', il est sortit du banc de registre. Le Z80 utilise lui aussi un incrémenteur séparé de l'ALU, qui est utilisé pour mettre à jour le ''program counter'', le pointeur de pile et un compteur de rafraichissement mémoire nommé IR sur le Z80 (pour rappel, le rafraichissement mémoire demande de balayer la mémoire d'adresse en adresse et été fait par le CPU à l'époque). De plus, il est utilisé pour les instructions INC et DEC qui incrémentent une opérande de 16 bits obtenue en combinant deux registres de 8 bits. En clair, l'incrémenteur du ''program counter'' a été réutilisé de beaucoup de manières originales.

[[File:Z80 arch.svg|centre|vignette|upright=3|Microarchitecture du Z80.]]

Le Z80 incorporait des instructions pour échanger le contenu des deux ensembles de registres, accumulateur inclus. Elles permettaient d'utiliser les registres d'interruption pour les programmes et réciproquement. En clair, cela doublait le nombre de registres si les interruptions n'étaient pas utilisées.
* L'instruction EXX échangeait les deux fenêtres de registres généraux : les registres B, C, D, E, H et L devenaient les registres B', C', D', E', H' et L' et inversement.
* L'instruction EX échangeait l'accumulateur et le registre d'état : les registres A,F devenait A',F' et inversement.

Le fenêtrage de registre était modifié par l'instruction EXX, qui échangeait les deux fenêtres de registres. Pour l'implémenter, une bascule était ajouté au processeur, appelons-la la bascule INT. Elle était relié au bus d'adresse du banc de registre, dont elle mémorisait le bit de poids fort. L'instruction EXX inversait la valeur de la bascule INT. Il est aussi possible d'échanger le contenu des registres D,E et H,L avec une instruction dédiée, ce qui est là encore fait par deux bascules : une pour les registres D,E et une autre pour les registres H,L.

Pour l'accumulateur et le registre d'état, le choix entre registre normal et registre d'interruption se faisait là encore par une seconde bascule appelée la bascule A. La bascule est reliée à un multiplexeur et un démultiplexeur, qui permet de choisir quel accumulateur relier à l'unité de calcul. L'instruction EX inverse le contenu de la bascule A.

&lt;noinclude&gt;
{{NavChapitre | book=Fonctionnement d'un ordinateur
           | prev=L'unité de contrôle
           | prevText=L'unité de contrôle
           | next=Les processeurs 8 bits et moins
           | nextText=Les processeurs 8 bits et moins
}}
&lt;/noinclude&gt;</text>
      <sha1>2odvhhyeh8t9l81rfo0n5r1jfacl500</sha1>
    </revision>
    <revision>
      <id>744134</id>
      <parentid>744133</parentid>
      <timestamp>2025-06-05T00:30:48Z</timestamp>
      <contributor>
        <username>Mewtow</username>
        <id>31375</id>
      </contributor>
      <minor />
      <comment>/* Les registres des anciennes architectures à accumulateur */</comment>
      <origin>744134</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="36345" sha1="3bbm88yatht8pg1r442bxm8xdmfngq3" xml:space="preserve">Les architectures que nous avons vu précédemment dans ce cours disposent de registres pour les données, en plus du pointeur de pile, d'un ''program counter'', et de quelques autres. Elles sont appelées des '''architectures à registres''', terme qui trahit bien le fait qu'elles ont des registres généraux ou spécialisés pour stocker temporairement des données. Et si on leur a donné un nom, c'est parce qu'il existe des architectures qui ne sont pas dans cette catégorie. Il en existe plusieurs types, mais ce chapitre va se concentrer sur les '''architectures à accumulateur'''.

[[File:Isaccumulator.png|vignette|Architecture à accumulateur.]]

Les architectures à accumulateur sont centrées autour d'un registre architectural appelé l''''accumulateur'''. Il est utilisé pour toutes les opérations arithmétiques dyadiques, où il sert à la fois de source et de destination. Toutes les instructions dyadiques sont de type ''load-op'' : une opérande est lue depuis l'accumulateur, le second opérande est lu depuis la mémoire RAM, le résultat de l'instruction est automatiquement mémorisé dans l'accumulateur. Les instructions monadiques peuvent utiliser un opérande dans l'accumulateur, ou dans la mémoire RAM, les deux sont théoriquement possibles.

La conséquence est que le nombre d'accès mémoire est drastiquement diminué : de 3 par instructions sur une architecture mémoire-mémoire, on passe à seulement un avec un accumulateur. Les opérations dyadiques ont besoin d'un seul accès mémoire pour lire la seconde opérande, les opérations monadique en font aussi un seul pour lire leur unique opérande.

{|class=&quot;wikitable&quot;
|-
! Classe d'architecture
! Nombre d'accès mémoire par opération dyadique
|-
|-
! Architecture à accumulateur
| Un accès mémoire par instruction, pour lire la seconde opérande
|-
! Architecture à registres
| Zéro si les opérandes sont dans les registres, un pour les opérations ''load-op'', LOAD et STORE.
|}

==Le jeu d'instruction des architectures à accumulateur sans registres d'indice==

L'accumulateur est adressé grâce au mode d'adressage implicite, de même que le résultat de l'opération. Par contre, les autres opérandes sont localisés avec d'autres modes d'adressage, et lues en mémoire RAM. Le résultat ainsi qu'un des opérandes sont adressés de façon implicite car dans l'accumulateur, seule la seconde opérande étant adressée directement. Grâce à l'accumulateur, une instruction ne fait qu'un seul accès mémoire maximum, ce qui rend le processeur très facile à implémenter.

===La toute première architecture à accumulateur : le Manchester Baby===

[[File:BabyArchitecture.png|vignette|Architecture de la Manchester Baby.]]

Les architectures à accumulateurs sont apparues dès les débuts de l'informatique. Le tout premier ordinateur à programme enregistré en mémoire, le ''Manchester Baby'', était une architecture à accumulateur. Niveau interface, l'ordinateur avait une console avec 32 boutons, des interrupteurs et un écran de sortie sur lequel afficher les résultats. A l'intérieur, il y avait un processeur et une RAM de 32 adresses de 32 bits, fabriquée avec des tubes Williams (abordés dans une annexe à la fin du cours).

Le programme devait tenir dans la RAM, avec une instruction par adresse maximum, ce qui limitait les programmes à 32 instructions maximum. Une instruction prenait donc 32 bits, 3 indiquaient quelle opération utiliser, 12 servait à indiquer où se trouvent les opérandes en RAM, les 16 restants sont inutilisés.

Le processeur avait un registre accumulateur de 32 bits, un ''program counter'' et un registre d'instruction. Il gérait 8 instructions en tout, mais ne gérait pas l'addition. Il gérait la soustraction, des instructions de branchement et d'accès mémoire, rien d'autre. Il pouvait cependant émuler l'addition à partir d'une soustraction et inversant l'opérande soustraite.

===Les registres des anciennes architectures à accumulateur===

[[File:IBM 701console.jpg|vignette|IBM 701, console extérieure.]]

Les architectures à accumulateur étaient communes dans les années 50-60. A l'époque, les ordinateurs étaient gigantesques, ils prenaient une pièce de bâtiment entière dans le pire des cas, une armoire entière dans le meilleur. Les ordinateurs de l'époque étaient surtout utilisés pour du calcul scientifique ou des tâches d’ingénierie demandant beaucoup de calcul, rarement pour de la compatibilité.

Les nombres flottants n'étaient pas encore apparus. A la place, les ordinateurs de l'époque géraient des nombres entiers de grande taille, de 30 bits ou plus. En conséquence, l'accumulateur faisait facilement 30 à 60 bits. Par exemple, les ordinateurs de la Série scientifique IBM 700/7000 géraient des entiers de 36 bits, l’accumulateur faisait 38 bits : 36 bits plus deux bits pour les débordements. Au passage, de tels processeurs utilisaient l'adressage par mot, et non par byte.

Historiquement, les premières architectures à accumulateur ne contenaient aucun autre registre que l'accumulateur. Ce n'est que dans les années 60 que de nombreuses architectures à accumulateur ont ajouté un second '''registre pour les multiplication/divisions'''. Un exemple est celui de l'IBM 701, qui incorporait un registre accumulateur de 38 bits et un registre multiplieur de 36 bits. Le registre mémorise le multiplieur lors d'une opération de multiplication. Il mémorise donc un opérande, pas le résultat. Il peut aussi décaler le multiplieur vers la droite/gauche, ce qui est utile pour exécuter la multiplication. C'est ce qui est fait sur l'IBM 7094.

Une autre possibilité est que ce registre mémorise une partie du résultat de l'opération. Pour rappel, le résultat d'une multiplication/division est codé sur deux fois de bits que ses opérandes. Par exemple, multipliez deux opérandes de 30 bits, vous obtiendrez un résultat de 60 bits. Les 30 bits de poids faible du résultat vont dans l'accumulateur, les 30 bits de poids fort vont dans ce second registre.

Les architectures à accumulateur parfois un '''registre pour le pointeur de pile''', utilisé pour gérer les fonctions/procédures. Les architectures à accumulateurs supportaient une pile d'adresse de retour, souvent une pile d'appel. Mais pour cela, il fallait mémoriser le pointeur de pile dans le processeur, ce qui demandait un registre dédié.

===L'adressage indirect avec l'accumulateur===

Les instructions LOAD et STORE existent bel et bien sur les architectures à accumulateur, mais n'ont pas les mêmes modes d'adressages. L'instruction LOAD copie une donnée de la RAM vers l'accumulateur, l'instruction STORE copie l'accumulateur dans une adresse. Les deux instructions n'ont pas besoin d'adresser l'accumulateur, qui est adressé de manière implicite, juste de préciser l'adresse à lire/écrire.

Les architectures à accumulateur supportaient souvent le mode d'adressage indirect mémoire. Un exemple est celui des ordinateurs Data General Nova, qui sont des architectures à accumulateur et qui supportaient ce mode d'adressage. Les deux instructions LOAD et STORE existaient en deux versions, distinguées par un bit d'indirection. Si ce bit est à 0 dans l'opcode, alors l'instruction utilise le mode d'adressage absolu normal : l'adresse intégrée dans l'instruction est celle de la donnée. Mais s'il est à 1, alors l'adresse intégrée dans l'instruction est celle du pointeur.

Cependant, la présence de l'accumulateur permettait d'utiliser l'adressage indirect à registre, pour gérer les pointeurs. Pour rappel, avec le mode d'adressage indirect à registre, l'adresse à lire/écrire est dans un registre. Ici, l'adresse à lire/écrire est prise dans l'accumulateur, seul registre disponible pour. L'adressage indirect est plus simple à implémenter pour l'instruction LOAD, car elle prend un seul opérande : l'adresse à lire. L'adresse à lire est placée dans l'accumulateur, la donnée lue est elle aussi chargée dans l'accumulateur. Pour l'instruction STORE, il faut fournir deux opérandes, l'adresse et la donnée à écrire, ce qui peut poser problème. Mais au pire, il est toujours possible d'utiliser l'adressage absolu ou indirect mémoire : l'adresse est dans l'instruction, la donnée à écrire dans l'accumulateur.

===L'encodage des instructions===

Sur une architecture à accumulateur l'encodage d'une instruction dyadique est assez simple, vu que l'accumulateur est adressé implicitement. La seconde opérande est localisée soit par une adresse mémoire (adressage absolu), soit est une constante (adressage immédiat). L'adresse mémoire est généralement assez longue, plus que l'opcode.

{|class=&quot;wikitable&quot;
|+ Encodage d'une instruction dyadique
|-
! rowspan=&quot;2&quot; | Opcode 
| Adresse mémoire (adressage absolu)
|-
| Constante (adressage immédiat)
|}

L'encodage d'une instruction monadique est similaire. Si l'opérande est lue depuis la mémoire RAM, alors l'instruction est encodée comme une instruction dyadique. Il en est de même pour les instructions qui copient une constante dans l'accumulateur. Par contre, si l'opérande est dans l'accumulateur, alors il y a juste besoin d'encoder l'opcode. La majorité des instructions a besoin de préciser une adresse, rares sont celles qui s'en passent. Au vu de cet encodage, les architectures à accumulateur sont qualifiées d''''architectures à une adresse''' par abus de langage.

Il est intéressant de contraster leur encodage avec les architectures à registres. Les architectures à registre doivent encoder deux opérandes en plus de l'opcode, avec éventuellement où enregistrer le résultat sur les architectures 3-adresses. Par contre, les opérandes sont généralement des noms de registre, ce qui prend moins de place qu'une adresse mémoire. A la rigueur, les instructions avec une constante immédiate prennent un peu plus de place, car elles doivent encoder un nom de registre en plus de la constante et de l'opcode. Les instructions ''load-op'' des processeurs CISC sont un peu dans le même cas, sauf qu'il faut remplacer la constante par une adresse, qui a généralement la même taille. Les instructions sont donc en moyenne plus courte sur les processeurs à registre, du fait de la présence de registres.

==La micro-architecture des architectures à accumulateur sans registres d'indice==

L'organisation interne d'une architecture à accumulateur est très différente de celle des processeurs à registre. Elle est plus ou moins la même pour tous ces processeurs, le point important étant que le chemin de données se résume à une ALU, un registre accumulateur et le bus de données. L'ALU est reliée au registre accumulateur, ainsi qu'au bus de données pour lire la seconde opérande, comme illustré ci-dessous.

[[File:Accumulator.png|centre|vignette|upright=2|Accumulateur.]]

===L'unité de calcul et l'accumulateur===

Pour simplifier l'implémentation, le résultat est mémorisé dans un registre en sortie de l'unité de calcul. La raison est qu'on ne veut pas altérer l'accumulateur tant que le résultat final n'est pas totalement calculé. Rappelons que l'ALU ne fournit pas un résultat d'un seul bloc, mais que certains bits arrivent avant les autres, typiquement les bits de poids faible. Si le résultat était écrit dans l'accumulateur directement, il écraserait des bits de l’opérande en cours d'utilisation, ce qui fausserait le résultat.

[[File:Accumulateur avec registre de sortie.png|centre|vignette|upright=2|Accumulateur avec registre de sortie]]

Une autre solution utilisait un registre entre l'accumulateur et l'unité de calcul, appelé l’'''''accumulator latch'''''. Il remplace le registre en sortie de l'ALU, dans le sens où il permet d'écrire dans l'accumulateur sans effacer l'opérande, pendant que l’opération est en cours dans l'ALU. L'accumulateur est copié dans l’''accumulator latch'', avant que l'ALU démarre ses calculs. L'opérande est donc maintenue même si on commence à écrire le résultat dans l'accumulateur.

Sur le 8085 d'Intel, l’''accumulator latch'' peut être initialisé avec une constante prédéfinie, ce qui permet d'implémenter certaines instructions très facilement. Par exemple, il peut être initialisé à 0, ce qui permet d'implémenter les instructions MOV et INC (incrémentation). Un MOV est équivalent à faire un OU entre le registre lu et 0. Une instruction INC initialise l'entrée de retenue de l'unité de calcul à 1, puis ajoute 0. La décrémentation est implémentée de la même manière, sauf que l’''accumulator latch'' est initialisé à -2 pour compenser l'entrée de retenue à 1. De plus, pour supporter les conversion de décimal à BCD, l’''accumulator latch'' peut être initialisé avec les constantes 0x00, 0x06, 0x60, or 0x66. L'''accumulator latch'' est relié à divers fils de commande provenant de l'unité de contrôle, qui décide quelle valeur d'initialisation utiliser en fonction de l'instruction décodée.

[[File:Accumulator latch.png|centre|vignette|upright=2|Accumulator latch]]

[[File:Chemin de données à un seul bus.png|vignette|Chemin de données à un seul bus]]

De même, la seconde opérande, celle lue sur le bus de données, est mémorisée dans un registre en amont de l'ALU. C'était notamment très utile si le processeur utilisait une ALU plus courte que les opérandes, avec par exemple une ALU 4 bits pour un CPU 8 bits. Les anciens processeurs à accumulateur de type ''mainframe'' utilisaient des opérandes de grande taille, du genre 36 ou 48 bits, ce qui avait des conséquences sur l'unité de calcul utilisée, ainsi que sur la communication avec la mémoire. Il arrivait que de tels processeurs utilisaient des ALU sérielles, ou du moins octet-sérielles, plutôt qu'une véritable ALU 36 bits. Nous verrons aussi que c'est très utile sur les processeurs à accumulateur avec un bus interne unique, dans la suite du chapitre.

===La micro-architecture des architectures à accumulateur avec instructions LOAD/STORE===

Nous venons de voir comment est implémenté l'unité de calcul et l'accumulateur, et comment le tout est relié au bus de données. Mais cela ne permet que d'avoir un processeur à accumulateur rudimentaire, qui ne gére que des instructions arithmétiques et logiques. Il faut aussi gérer le cas des opérations LOAD/STORE et des modes d'adressages associés, mais c'est le séquenceur qui s'en occupe. Avec l'adressage absolu, les instructions LOAD et STORE ne font que connecter l'accumulateur au bus de données. L'instruction STORE nécessite de connecter l'accumulateur au bus de données, de manière à ce que le transfert des données se fasse de l'accumulateur vers le bus de données. L'instruction LOAD s'implémente de la même manière, sauf que le sens de transfert est inversé.

Cependant, il existe une optimisation qui permet d'implémenter l'instruction LOAD sans ajouter de circuits. Pour cela, il suffit que l'unité de calcul gére les opérations ''pass through'', à savoir des opérations qui se contentent de recopier un opérande sur la sortie. Ici, l'idée est de recopier l'opérande provenant du bus de données.

[[File:Architecture à accumulateur, microarchitecture.png|centre|vignette|upright=2|Architecture à accumulateur, microarchitecture]]

Pour gérer nativement l'adressage indirect à registre, il suffit de connecter l'accumulateur au bus d'adresse. Le plus simple est d'ajouter un multiplexeur, comme illustré ci-dessous. La donnée lue est copiée dans l'accumulateur, ce qui fait qu'il vaut mieux utiliser un registre d’interfaçage, l'accumulateur n'étant pas utilisable à la fois pour le bus d'adresse et de données.

[[File:Adressage indirect sur une architecture à accumulateur.png|centre|vignette|upright=2|Adressage indirect sur une architecture à accumulateur]]

Pour finir, voyons comment le pointeur de pile et le ''program counter'' sont implémentés. Les architectures à accumulateur ont souvent des adresses de taille différente des données, ce qui fait qu'il vaut mieux utiliser un circuit incrémenteur dédié pour incrémenter le ''program counter'', plutôt que de l'incrémenter via l'unité de calcul. Les architectures à accumulateur ont parfois un pointeur de pile, qui gère une pile d'adresse de retour, pas une vraie pile d'appel. Aussi, le pointeur de pile est censé être incrémenté et décrémenté, pas plus. Pas d'addition ou de soustraction pour gérer des cadres de pile. Là encore, c'est la solution de l'incrémenteur séparé qui est retenue. Pour économiser des transistors, il n'y a qu'un seul incrémenteur partagé pour les deux.

==Les architectures à accumulateur à registres d'indice==

Les architectures à accumulateur décrites dans la section précédente sont capables de faire de l'adressage indirect, mais n'incluent pas les modes d'adressage base + indice et absolus indicés, qui prennent une adresse et y ajoute un indice. Il s'agit des toutes premières architectures à accumulateur, comme les premiers ordinateurs IBM ou le fameux PDP-8. Mais par la suite, les processeurs à accumulateurs ont inclus un support des modes d'adressages indicés, grâce à des '''registres d'indice'''.

===Les registres d'indice===

Les registres d'indice stockent des indices de tableaux. Ils permettaient de supporter deux modes d'adressage :
* Le '''mode d'adressage absolu indicé''' où une adresse fixe est additionnée à un indice variable. L'adresse fixe est intégrée dans l'instruction (adressage absolu), l'indice est dans un registre d'indice.
* Le '''mode d'adressage base + indice''', où l'adresse est dans l'accumulateur et l'indice dans le registre d'indice.

Les processeurs à accumulateur supportaient souvent des variantes des modes d'adressage précédents, où le registre d'indice était automatiquement incrémenté ou décrémenté à chaque utilisation.

Au départ, ces processeurs n'utilisaient qu'un seul registre d'indice qui se comportait comme un second accumulateur spécialisé dans les calculs d'adresses mémoire. Le processeur supportait de nouvelles instructions qui utilisaient ce registre d'indice de façon implicite. Mais avec le temps, les processeurs finirent par incorporer plusieurs de ces registres. Les instructions de lecture ou d'écriture devaient alors préciser quel registre d'indice utiliser, en précisant un nom de registre d'indice, un numéro de registre d'indice.

Il faut préciser que les registres d'indice ont une taille bien plus petite que l'accumulateur. Ils mémorisent des indices codés sur 16 bits ou moins, alors que l'accumulateur faisait typiquement 36 à 48 bits, parfois plus. La taille classique sur les anciens ''mainframes'' était de 15 bits, parfois moins. Il n'était pas rare de tomber sur des registres d'indice de 8 ou 9 bits. Leur petite taille rendait leur implémentation matérielle peu couteuse. Et c'est ce qui explique qu'ils étaient préférés à l'usage d'un second accumulateur.

Un exemple est le cas du processeur Motorola 6809, un processeur à accumulateur qui contient deux registres d'indices nommés X et Y. L'accumulateur est noté D et fait 16 bits, il peut être parfois géré comme deux accumulateurs séparés A et B de 8 bits chacun. Il contenait aussi deux pointeurs de pile, l'un pour les programmes, l'autre pour le système d'exploitation, ainsi qu'un ''program counter''. Le registre de page était utilisé pour l'adressage absolu, comme vu dans le chapitre sur les modes d'adressage.

[[File:6809 Internal Registers.svg|centre|vignette|upright=2|6809 Internal Registers]]

Les processeurs IBM avaient autrefois plusieurs registres d'indice. Par exemple, l'IBM 704 avait trois registres d'indice de 15 bits. Leur contenu était soustrait de l'adresse absolue. Une instruction pouvait utiliser plusieurs registres d'indice pour adresser son opérande. Toute instruction utilisait trois bits pour sélectionner les registres d'indice utilisés. Fait assez original, lorsque plusieurs registres d'indice sont sélectionnés, le processeur n'additionne pas les trois registres à l'adresse de base. À la place, il fait un OU bit à bit entre les registres d'indice sélectionnés, et additionne le résultat à l'adresse.

Les processeurs IBM à accumulateur ont fait ça sur toute la gamme IBM 700/7000, pour des raisons de compatibilité. Les processeurs suivants avaient 7 registres d'indices, mais conservaient les trois bits pour adresser les registres d'indices. Ils pouvaient fonctionner dans deux modes. Le premier mode est plus intuitif : les trois bits précisent un registre d'indice parmi les 7, qui est additionné avec l'adresse absolue. La valeur zéro indique qu'aucun registre d'indice n'est utilisé, ce qui explique qu'il y a 7 registres d'indice et non 8. Un second mode, compatible avec l'IBM 704, fait un OU logique entre les registres d'indice sélectionnés. Seuls les trois premiers registres d'indices peuvent être sélectionnés dans ce mode. Il y a deux instructions pour changer de mode : une pour passer en mode compatible, l'autre pour le quitter pour l'autre mode.

Quelques rares processeurs à registres généraux ont utilisés des registres d'indice, en plus des registres généraux. Ce qui fait l'association que nous avons faite entre registres d'indice et architectures à accumulateur est imparfait, bien que solide sur le principe. Un exemple d'architecture de ce type sont les architectures de la série UNIVAC 1100/2200. Ils disposaient de 128 registres, qui étaient mappés en mémoire à partir de l'adresse mémoire 0, la majorité étant inaccessibles par le programmeur. Ils regroupaient 12 registres accumulateurs, 11 registres d'indice et 4 registres hybrides qui pouvaient servir soit de registre d'indice, soit de registres accumulateurs.

===La micro-architecture des architectures à accumulateur avec registres d'indice===

La présence de registres d'indice modifie grandement l'implémentation du processeur. En effet, il faut rajouter un banc de registre pour les registres d'indice. Le banc de registre est monoport, car on a besoin de lire ou d'écrire un indice à la fois. Et il faut aussi potentiellement rajouter de quoi faire les calculs d'adresse. Deux solutions sont possibles : une ALU dédiée aux calculs d'adresse, une seule ALU pour toutes les opérations.

Dans le premier cas, il y a une ALU séparée associée aux registres d'indice. L'ALU et les registres d'indice sont placés en sortie du séquenceur, en-dehors du chemin de données, la sortie de l'ALU est directement connectée au bus d'adresse. L'unité de calcul d'adresse peut être utilisée pour incrémenter le ''program counter''. Un défaut de cette approche est qu'elle ne gère pas l'adresse indirect à registre.

[[File:Chemin de données sans support des pointeurs, avec adressage absolu indicé.png|centre|vignette|upright=2|Chemin de données sans support des pointeurs, avec adressage absolu indicé]]

Une autre option utilise un bus interne, qui interconnecte tout le chemin de données. Dans sa version la plus simple, il est relié à l'accumulateur, l'unité de calcul, le banc de registre d'indice et le bus de données. Avec cette solution, l'ALU est utilisé à la fois pour calculer les adresses et pour les instructions de calcul. En reliant le bus interne au bus d'adresse à travers un multiplexeur, on gère naturellement les adressages indirects.

[[File:Architecture à accumulateur avec registres associés.png|centre|vignette|upright=2.5|Architecture à accumulateur avec registres associés]]

Il faut noter que sur les architectures Von Neumann, le séquenceur est relié à ce bus interne. En effet, charger une instruction demande de passer par le bus mémoire, donc par l’intermédiaire de ce bus internet. Le ''program counter'' est envoyé sur ce bus pour lire l'instruction, puis l'instruction lue est recopiée dans le registre d'instruction. Le chargement d'une instruction est donc géré comme une lecture des plus classiques. De plus, cela permet d'incrémenter le ''program counter'' au niveau de l'unité de calcul entière. Le ''program counter'' est envoyé sur le bus interne, incrémenté par l'ALU, puis le résultat est recopié dans le ''program counter'' via le bus interne.

[[File:Architecture à accumulateur avec bus unique de type Von Neumann.png|centre|vignette|upright=2|Architecture à accumulateur avec bus unique de type Von Neumann]]

==Les processeurs bi-accumulateurs : le Motorola 6800==

Le Motorola 6800 était un processeur 8 bits qui gérait des adresses de 16 bits. Il contenait deux accumulateurs nommés A et B, de 8 bits chacun. Il disposait aussi d'un registre d'indice, d'un pointeur de pile et d'un ''program counter'', tous les trois de 16 bits. Le registre d'état regroupait 6 bits, qu'on ne détaillera pas ici.

[[File:MC6800 Processor Diagram.png|centre|vignette|upright=2|Interface et registres du MC6800.]]

La présence des deux accumulateurs impactait surtout les instructions dyadiques. Les instructions monadiques avaient juste à préciser où se trouvait l'opérande : soit en RAM, soit dans le premier accumulateur, soit dans le second. Pour les opérations dyadiques, la gestion était totalement différente. En théorie, le premier opérande est dans un accumulateur, soit A, soit B. La seconde opérande vient soit de l'autre accumulateur, soit de la mémoire RAM. Et selon les instructions, tout variait.

Pour l'addition, il y avait trois instructions. Les deux premières additionnaient un opérande provenant de la mémoire avec un accumulateur. L'instruction ADDA sélectionnait le premier accumulateur, l'instruction ADDB sélectionnait le second accumulateur. Mais une troisième instruction, l’instruction ABA, permettait d'additionner le contenu des deux accumulateurs.

Pour les autres opérations, il n'était pas possible d'utiliser les deux accumulateurs en même temps. La seule possibilité était de faire une opération entre un accumulateur et un opérande venant de la mémoire. Toutes les instructions étaient en double, avec une copie par accumulateur. Par exemple, l'instruction ANDA faisait un ET entre l’accumulateur A et l'opérande mémoire, l'instruction ANDB faisait pareil avec l'accumulateur B.

==Les architectures hybrides registres-accumulateur==

Il a existé quelques architectures qui étaient des hybrides entre architectures à accumulateur et architecture à registre. Elles ont servi de transition entre les deux, durant les années 80-90. Elles avaient un accumulateur unique couplé à un banc de registres généraux. Par exemple, les premiers processeurs Intel 8 bits étaient des processeurs hybrides-accumulateur. Lles CPU Intel 8 bits disposaient de 7 registres de 8 bits nommés A, B, C, D, E, F, H, L, SP. Ils correspondent respectivement à :
* l'accumulateur A ;
* six registres nommés B, C, D, E, H et L ;
* le registre d'état F ;
* le pointeur de pile SP.

Sur ces processeurs, les instructions dyadiques devaient mettre leur premier opérande dans l'accumulateur, la seconde provenait soit des registres, soit de la RAM, soit d'une constante immédiate. Les opérations monadiques pouvaient lire leur opérande depuis l'accumulateur, les autres registres ou la RAM, tout était permis. Les registres d'indices disparaissaient sur ces architectures, en théorie. Les registres généraux pouvaient être utilisés comme registre d'indice ou pour stocker des opérandes, ils étaient assez versatiles pour servir de registres d'indices.

La présence de registres a de nombreux avantages, comparé aux architectures à accumulateur pures. Les instructions arithmétiques sont plus rapide, lire un registre étant plus rapide qu'un accès RAM. Les performances sont donc augmentées. De plus, les instructions arithmétiques utilisant ces registres sont plus courtes : pas besoin d'encoder une adresse mémoire, un nom de registre suffit. Vu que les processeurs de l’époque avaient des instructions de taille variable, cela améliorait la densité de code.

La microarchitecture de ces processeurs est très similaire à celle d'un processeur avec des registres d'indices. La seule différence est que le banc de registre contient des registres généraux et non des registres d'indices. Le banc de registre est systématiquement monoport, car il n'avait aucune raison d'être multiport. Pour les instructions dyadiques, seules à lire deux opérandes, il ne servait que pour la seconde opérande, la première était lue depuis l'accumulateur.

Les processeurs hybrides registre-accumulateur se classent en deux types principaux : ceux qui ont un seul bus interne, et ceux qui en ont deux. Le premier cas est identique à celui vu précédemment pour les architectures à accumulateur avec registres d'indice, à la seule différence est que le banc de registre contient des registres généraux et non des registres d'indices. Afin de gérer l'adressage indirect à registre, le bus interne est connecté aux deux registres d’interfaçage mémoire.

[[File:Architecture à accumulateur avec bus unique de type Von Neumann.png|centre|vignette|upright=2|Architecture à accumulateur avec bus unique de type Von Neumann]]

Notons que cela permet aussi d'implémenter facilement les branchements indirects, car le bus interne permet d'échanger des adresses entre ''program counter'' et banc de registre. De même, il est possible d'utiliser l'ALU pour gérer les branchements indirects., en plus de l'utiliser pour incrémenter le ''program counter''.

[[File:Single bus organization.jpg|centre|vignette|upright=2|Single bus organization]]

Une autre solution utilisait deux bus internes : un connecté au bus de données, un autre relié au bus d'adresse. Le bus de commande mémoire était lui commandé par le séquenceur, l'unité de contrôle. L'intermédiaire entre ces deux bus était le banc de registre, ainsi que les autres registres. Le banc de registre était connecté aux deux bus interne, avec un port de lecture relié au bus d'adresse, un port de lecture-écriture relié au bus de données. Le port de lecture était utilisé pour l'adressage indirect, l'autre l'était pour le reste.

[[File:Proz1-e.png|centre|vignette|upright=2|Intérieur d'un processeur.]]

L'organisation à deux bus simplifiait la gestion du ''program counter'' et le chargement des instructions. Le ''program counter'' était soit séparé du banc de registre, soit placé dans le banc de registre. Les deux solutions étaient utilisés, tout dépend du processeur. Il faut noter que si le ''program counter'' est intégré au banc de registres, alors la microarchitecture du processeur est bien plus simple. L'envoi du ''program counter'' sur le bus d'adresse utilise le port de lecture relié au bus d'adresse, qui sert aussi pour l'adressage indirect. L'économie de circuits, sans compter la simplicité d'implémentation que cela implique, explique sans doute que la technique a été utilisée sur quelques processeurs anciens.

Le ''program counter'' était généralement incrémenté par l'ALU, ce qui explique qu'il soit connecté au bus interne pour les données. La connexion est aussi utile pour gérer les branchements indirects, qui copient un registre dans le ''program counter'', ainsi que les branchements relatifs (addition dans l'ALU), voire les branchements directs (l'adresse vers laquelle brancher est envoyée en entrée de l'ALU et propagée en sortie avec une opération ''pass through'').

[[File:Connexion du program counter sur les bus avec PC dans le banc de registres.png|centre|vignette|upright=2|Connexion du program counter sur les bus avec PC dans le banc de registres]]

===Les registres d'interruption avec un processeur hybride-accumulateur : l'exemple du Z80===

Un exemple de processeur registre-accumulateur à deux bus interne est le Z80, un processeur fortement inspiré des CPU Intel 8 bits. Il a un jeu d'instruction similaire, mais a diverses améliorations par rapport au design original. Notamment, le processeur a des registres séparés pour les interruptions.

Sur le Z80, les registres généraux sont dupliqués avec 6 registres pour les interruptions et 6 registres pour les programmes autres. Leur copie pour les interruptions sont nommées B', C', D', E', H', L'. Les 12 registres sont placés dans le banc de registre, ce qui implique que le fenêtrage de registres est utilisé pour gérer la séparation entre registre d'interruption et normaux. Il faut noter que l'accumulateur et le registre d'état sont aussi dupliqués, leurs copies étant nommées A' et F'. Mais leur duplication se fait autrement que par fenêtrage de registre.

En plus des registres précédents, le Z80 incorporait deux registres d'indice nommés X et Y, ainsi qu'un pointeur de pile SP et un ''program counter'' PC. Ils n'étaient pas dupliqués pour les interruptions. Les registres d'indice étaient reliés à une unité de calcul d'adresse. L'unité de calcul d'adresse prenait deux opérandes : un indice, et une adresse mémoire provenant soit du banc de registre, soit de l'accumulateur. En clair, l'unité de calcul d'adresse faisait le lien entre les deux bus internet : le bus de données interne en entrée, le bus d'adresse en sortie.

À l'intérieur du processeur, tous les registres étaient regroupés dans un banc de registre unique, sauf les accumulateurs, les registres d'état et le ''program counter''. Bien que ce ne soit pas indiqué sur le schéma ci-dessous, le ''program counter'' est séparé du banc de registre, alors que le pointeur de pile est dedans. Le compteur IR est lui associé au ''program counter'', il est sortit du banc de registre. Le Z80 utilise lui aussi un incrémenteur séparé de l'ALU, qui est utilisé pour mettre à jour le ''program counter'', le pointeur de pile et un compteur de rafraichissement mémoire nommé IR sur le Z80 (pour rappel, le rafraichissement mémoire demande de balayer la mémoire d'adresse en adresse et été fait par le CPU à l'époque). De plus, il est utilisé pour les instructions INC et DEC qui incrémentent une opérande de 16 bits obtenue en combinant deux registres de 8 bits. En clair, l'incrémenteur du ''program counter'' a été réutilisé de beaucoup de manières originales.

[[File:Z80 arch.svg|centre|vignette|upright=3|Microarchitecture du Z80.]]

Le Z80 incorporait des instructions pour échanger le contenu des deux ensembles de registres, accumulateur inclus. Elles permettaient d'utiliser les registres d'interruption pour les programmes et réciproquement. En clair, cela doublait le nombre de registres si les interruptions n'étaient pas utilisées.
* L'instruction EXX échangeait les deux fenêtres de registres généraux : les registres B, C, D, E, H et L devenaient les registres B', C', D', E', H' et L' et inversement.
* L'instruction EX échangeait l'accumulateur et le registre d'état : les registres A,F devenait A',F' et inversement.

Le fenêtrage de registre était modifié par l'instruction EXX, qui échangeait les deux fenêtres de registres. Pour l'implémenter, une bascule était ajouté au processeur, appelons-la la bascule INT. Elle était relié au bus d'adresse du banc de registre, dont elle mémorisait le bit de poids fort. L'instruction EXX inversait la valeur de la bascule INT. Il est aussi possible d'échanger le contenu des registres D,E et H,L avec une instruction dédiée, ce qui est là encore fait par deux bascules : une pour les registres D,E et une autre pour les registres H,L.

Pour l'accumulateur et le registre d'état, le choix entre registre normal et registre d'interruption se faisait là encore par une seconde bascule appelée la bascule A. La bascule est reliée à un multiplexeur et un démultiplexeur, qui permet de choisir quel accumulateur relier à l'unité de calcul. L'instruction EX inverse le contenu de la bascule A.

&lt;noinclude&gt;
{{NavChapitre | book=Fonctionnement d'un ordinateur
           | prev=L'unité de contrôle
           | prevText=L'unité de contrôle
           | next=Les processeurs 8 bits et moins
           | nextText=Les processeurs 8 bits et moins
}}
&lt;/noinclude&gt;</text>
      <sha1>3bbm88yatht8pg1r442bxm8xdmfngq3</sha1>
    </revision>
    <revision>
      <id>744136</id>
      <parentid>744134</parentid>
      <timestamp>2025-06-05T00:33:47Z</timestamp>
      <contributor>
        <username>Mewtow</username>
        <id>31375</id>
      </contributor>
      <minor />
      <comment>/* La toute première architecture à accumulateur : le Manchester Baby */</comment>
      <origin>744136</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="37109" sha1="sxm2bb0icutnps8nsdu9lehlb63k9jj" xml:space="preserve">Les architectures que nous avons vu précédemment dans ce cours disposent de registres pour les données, en plus du pointeur de pile, d'un ''program counter'', et de quelques autres. Elles sont appelées des '''architectures à registres''', terme qui trahit bien le fait qu'elles ont des registres généraux ou spécialisés pour stocker temporairement des données. Et si on leur a donné un nom, c'est parce qu'il existe des architectures qui ne sont pas dans cette catégorie. Il en existe plusieurs types, mais ce chapitre va se concentrer sur les '''architectures à accumulateur'''.

[[File:Isaccumulator.png|vignette|Architecture à accumulateur.]]

Les architectures à accumulateur sont centrées autour d'un registre architectural appelé l''''accumulateur'''. Il est utilisé pour toutes les opérations arithmétiques dyadiques, où il sert à la fois de source et de destination. Toutes les instructions dyadiques sont de type ''load-op'' : une opérande est lue depuis l'accumulateur, le second opérande est lu depuis la mémoire RAM, le résultat de l'instruction est automatiquement mémorisé dans l'accumulateur. Les instructions monadiques peuvent utiliser un opérande dans l'accumulateur, ou dans la mémoire RAM, les deux sont théoriquement possibles.

La conséquence est que le nombre d'accès mémoire est drastiquement diminué : de 3 par instructions sur une architecture mémoire-mémoire, on passe à seulement un avec un accumulateur. Les opérations dyadiques ont besoin d'un seul accès mémoire pour lire la seconde opérande, les opérations monadique en font aussi un seul pour lire leur unique opérande.

{|class=&quot;wikitable&quot;
|-
! Classe d'architecture
! Nombre d'accès mémoire par opération dyadique
|-
|-
! Architecture à accumulateur
| Un accès mémoire par instruction, pour lire la seconde opérande
|-
! Architecture à registres
| Zéro si les opérandes sont dans les registres, un pour les opérations ''load-op'', LOAD et STORE.
|}

==Le jeu d'instruction des architectures à accumulateur sans registres d'indice==

L'accumulateur est adressé grâce au mode d'adressage implicite, de même que le résultat de l'opération. Par contre, les autres opérandes sont localisés avec d'autres modes d'adressage, et lues en mémoire RAM. Le résultat ainsi qu'un des opérandes sont adressés de façon implicite car dans l'accumulateur, seule la seconde opérande étant adressée directement. Grâce à l'accumulateur, une instruction ne fait qu'un seul accès mémoire maximum, ce qui rend le processeur très facile à implémenter.

===La toute première architecture à accumulateur : le Manchester Baby===

[[File:BabyArchitecture.png|vignette|Architecture de la Manchester Baby.]]

Les architectures à accumulateurs sont apparues dès les débuts de l'informatique. Le tout premier ordinateur à programme enregistré en mémoire, le ''Manchester Baby'', était une architecture à accumulateur. Niveau interface, l'ordinateur avait une console avec 32 boutons, des interrupteurs et un écran de sortie sur lequel afficher les résultats. A l'intérieur, il y avait un processeur et une RAM de 32 adresses de 32 bits, fabriquée avec des tubes Williams (abordés dans une annexe à la fin du cours).

Le programme devait tenir dans la RAM, avec une instruction par adresse maximum, ce qui limitait les programmes à 32 instructions maximum. Une instruction prenait donc 32 bits, 3 indiquaient quelle opération utiliser, 12 servait à indiquer où se trouvent les opérandes en RAM, les 16 restants sont inutilisés.

Le processeur avait un registre accumulateur de 32 bits, un ''program counter'' et un registre d'instruction. Il gérait 8 instructions en tout, mais ne gérait pas l'addition. Il gérait la soustraction, des instructions de branchement et d'accès mémoire, rien d'autre. Il pouvait cependant émuler l'addition à partir d'une soustraction et inversant l'opérande soustraite.

Le Manchester Mark 1 était une amélioration du Manchester Baby. Il utilisait 4500 tubes à vide. L'ordinateur gérait des nombres de 40 bits, mais les instructions étaient codées sur 20 bits. La RAM avait la même taille, à savoir 32 nombres, leur taille était simplement augmentée. Par contre, la RAM était complémentée par l’ancêtre du disque dur magnétique, à savoir un tambour magnétique, l’ancêtre du disque dur magnétique. Il contenait 40 pages, chacune ayant la même taille que la RAM. C'était là encore une architecture à accumulateur, sauf qu'elle intégrait aussi des registres d'indice. Et surtout : son processeur gérait l'addition et quelques opérations logiques (ET et OU), en plus de la soustraction et de la comparaison.

===Les registres des anciennes architectures à accumulateur===

[[File:IBM 701console.jpg|vignette|IBM 701, console extérieure.]]

Les architectures à accumulateur étaient communes dans les années 50-60. A l'époque, les ordinateurs étaient gigantesques, ils prenaient une pièce de bâtiment entière dans le pire des cas, une armoire entière dans le meilleur. Les ordinateurs de l'époque étaient surtout utilisés pour du calcul scientifique ou des tâches d’ingénierie demandant beaucoup de calcul, rarement pour de la compatibilité.

Les nombres flottants n'étaient pas encore apparus. A la place, les ordinateurs de l'époque géraient des nombres entiers de grande taille, de 30 bits ou plus. En conséquence, l'accumulateur faisait facilement 30 à 60 bits. Par exemple, les ordinateurs de la Série scientifique IBM 700/7000 géraient des entiers de 36 bits, l’accumulateur faisait 38 bits : 36 bits plus deux bits pour les débordements. Au passage, de tels processeurs utilisaient l'adressage par mot, et non par byte.

Historiquement, les premières architectures à accumulateur ne contenaient aucun autre registre que l'accumulateur. Ce n'est que dans les années 60 que de nombreuses architectures à accumulateur ont ajouté un second '''registre pour les multiplication/divisions'''. Un exemple est celui de l'IBM 701, qui incorporait un registre accumulateur de 38 bits et un registre multiplieur de 36 bits. Le registre mémorise le multiplieur lors d'une opération de multiplication. Il mémorise donc un opérande, pas le résultat. Il peut aussi décaler le multiplieur vers la droite/gauche, ce qui est utile pour exécuter la multiplication. C'est ce qui est fait sur l'IBM 7094.

Une autre possibilité est que ce registre mémorise une partie du résultat de l'opération. Pour rappel, le résultat d'une multiplication/division est codé sur deux fois de bits que ses opérandes. Par exemple, multipliez deux opérandes de 30 bits, vous obtiendrez un résultat de 60 bits. Les 30 bits de poids faible du résultat vont dans l'accumulateur, les 30 bits de poids fort vont dans ce second registre.

Les architectures à accumulateur parfois un '''registre pour le pointeur de pile''', utilisé pour gérer les fonctions/procédures. Les architectures à accumulateurs supportaient une pile d'adresse de retour, souvent une pile d'appel. Mais pour cela, il fallait mémoriser le pointeur de pile dans le processeur, ce qui demandait un registre dédié.

===L'adressage indirect avec l'accumulateur===

Les instructions LOAD et STORE existent bel et bien sur les architectures à accumulateur, mais n'ont pas les mêmes modes d'adressages. L'instruction LOAD copie une donnée de la RAM vers l'accumulateur, l'instruction STORE copie l'accumulateur dans une adresse. Les deux instructions n'ont pas besoin d'adresser l'accumulateur, qui est adressé de manière implicite, juste de préciser l'adresse à lire/écrire.

Les architectures à accumulateur supportaient souvent le mode d'adressage indirect mémoire. Un exemple est celui des ordinateurs Data General Nova, qui sont des architectures à accumulateur et qui supportaient ce mode d'adressage. Les deux instructions LOAD et STORE existaient en deux versions, distinguées par un bit d'indirection. Si ce bit est à 0 dans l'opcode, alors l'instruction utilise le mode d'adressage absolu normal : l'adresse intégrée dans l'instruction est celle de la donnée. Mais s'il est à 1, alors l'adresse intégrée dans l'instruction est celle du pointeur.

Cependant, la présence de l'accumulateur permettait d'utiliser l'adressage indirect à registre, pour gérer les pointeurs. Pour rappel, avec le mode d'adressage indirect à registre, l'adresse à lire/écrire est dans un registre. Ici, l'adresse à lire/écrire est prise dans l'accumulateur, seul registre disponible pour. L'adressage indirect est plus simple à implémenter pour l'instruction LOAD, car elle prend un seul opérande : l'adresse à lire. L'adresse à lire est placée dans l'accumulateur, la donnée lue est elle aussi chargée dans l'accumulateur. Pour l'instruction STORE, il faut fournir deux opérandes, l'adresse et la donnée à écrire, ce qui peut poser problème. Mais au pire, il est toujours possible d'utiliser l'adressage absolu ou indirect mémoire : l'adresse est dans l'instruction, la donnée à écrire dans l'accumulateur.

===L'encodage des instructions===

Sur une architecture à accumulateur l'encodage d'une instruction dyadique est assez simple, vu que l'accumulateur est adressé implicitement. La seconde opérande est localisée soit par une adresse mémoire (adressage absolu), soit est une constante (adressage immédiat). L'adresse mémoire est généralement assez longue, plus que l'opcode.

{|class=&quot;wikitable&quot;
|+ Encodage d'une instruction dyadique
|-
! rowspan=&quot;2&quot; | Opcode 
| Adresse mémoire (adressage absolu)
|-
| Constante (adressage immédiat)
|}

L'encodage d'une instruction monadique est similaire. Si l'opérande est lue depuis la mémoire RAM, alors l'instruction est encodée comme une instruction dyadique. Il en est de même pour les instructions qui copient une constante dans l'accumulateur. Par contre, si l'opérande est dans l'accumulateur, alors il y a juste besoin d'encoder l'opcode. La majorité des instructions a besoin de préciser une adresse, rares sont celles qui s'en passent. Au vu de cet encodage, les architectures à accumulateur sont qualifiées d''''architectures à une adresse''' par abus de langage.

Il est intéressant de contraster leur encodage avec les architectures à registres. Les architectures à registre doivent encoder deux opérandes en plus de l'opcode, avec éventuellement où enregistrer le résultat sur les architectures 3-adresses. Par contre, les opérandes sont généralement des noms de registre, ce qui prend moins de place qu'une adresse mémoire. A la rigueur, les instructions avec une constante immédiate prennent un peu plus de place, car elles doivent encoder un nom de registre en plus de la constante et de l'opcode. Les instructions ''load-op'' des processeurs CISC sont un peu dans le même cas, sauf qu'il faut remplacer la constante par une adresse, qui a généralement la même taille. Les instructions sont donc en moyenne plus courte sur les processeurs à registre, du fait de la présence de registres.

==La micro-architecture des architectures à accumulateur sans registres d'indice==

L'organisation interne d'une architecture à accumulateur est très différente de celle des processeurs à registre. Elle est plus ou moins la même pour tous ces processeurs, le point important étant que le chemin de données se résume à une ALU, un registre accumulateur et le bus de données. L'ALU est reliée au registre accumulateur, ainsi qu'au bus de données pour lire la seconde opérande, comme illustré ci-dessous.

[[File:Accumulator.png|centre|vignette|upright=2|Accumulateur.]]

===L'unité de calcul et l'accumulateur===

Pour simplifier l'implémentation, le résultat est mémorisé dans un registre en sortie de l'unité de calcul. La raison est qu'on ne veut pas altérer l'accumulateur tant que le résultat final n'est pas totalement calculé. Rappelons que l'ALU ne fournit pas un résultat d'un seul bloc, mais que certains bits arrivent avant les autres, typiquement les bits de poids faible. Si le résultat était écrit dans l'accumulateur directement, il écraserait des bits de l’opérande en cours d'utilisation, ce qui fausserait le résultat.

[[File:Accumulateur avec registre de sortie.png|centre|vignette|upright=2|Accumulateur avec registre de sortie]]

Une autre solution utilisait un registre entre l'accumulateur et l'unité de calcul, appelé l’'''''accumulator latch'''''. Il remplace le registre en sortie de l'ALU, dans le sens où il permet d'écrire dans l'accumulateur sans effacer l'opérande, pendant que l’opération est en cours dans l'ALU. L'accumulateur est copié dans l’''accumulator latch'', avant que l'ALU démarre ses calculs. L'opérande est donc maintenue même si on commence à écrire le résultat dans l'accumulateur.

Sur le 8085 d'Intel, l’''accumulator latch'' peut être initialisé avec une constante prédéfinie, ce qui permet d'implémenter certaines instructions très facilement. Par exemple, il peut être initialisé à 0, ce qui permet d'implémenter les instructions MOV et INC (incrémentation). Un MOV est équivalent à faire un OU entre le registre lu et 0. Une instruction INC initialise l'entrée de retenue de l'unité de calcul à 1, puis ajoute 0. La décrémentation est implémentée de la même manière, sauf que l’''accumulator latch'' est initialisé à -2 pour compenser l'entrée de retenue à 1. De plus, pour supporter les conversion de décimal à BCD, l’''accumulator latch'' peut être initialisé avec les constantes 0x00, 0x06, 0x60, or 0x66. L'''accumulator latch'' est relié à divers fils de commande provenant de l'unité de contrôle, qui décide quelle valeur d'initialisation utiliser en fonction de l'instruction décodée.

[[File:Accumulator latch.png|centre|vignette|upright=2|Accumulator latch]]

[[File:Chemin de données à un seul bus.png|vignette|Chemin de données à un seul bus]]

De même, la seconde opérande, celle lue sur le bus de données, est mémorisée dans un registre en amont de l'ALU. C'était notamment très utile si le processeur utilisait une ALU plus courte que les opérandes, avec par exemple une ALU 4 bits pour un CPU 8 bits. Les anciens processeurs à accumulateur de type ''mainframe'' utilisaient des opérandes de grande taille, du genre 36 ou 48 bits, ce qui avait des conséquences sur l'unité de calcul utilisée, ainsi que sur la communication avec la mémoire. Il arrivait que de tels processeurs utilisaient des ALU sérielles, ou du moins octet-sérielles, plutôt qu'une véritable ALU 36 bits. Nous verrons aussi que c'est très utile sur les processeurs à accumulateur avec un bus interne unique, dans la suite du chapitre.

===La micro-architecture des architectures à accumulateur avec instructions LOAD/STORE===

Nous venons de voir comment est implémenté l'unité de calcul et l'accumulateur, et comment le tout est relié au bus de données. Mais cela ne permet que d'avoir un processeur à accumulateur rudimentaire, qui ne gére que des instructions arithmétiques et logiques. Il faut aussi gérer le cas des opérations LOAD/STORE et des modes d'adressages associés, mais c'est le séquenceur qui s'en occupe. Avec l'adressage absolu, les instructions LOAD et STORE ne font que connecter l'accumulateur au bus de données. L'instruction STORE nécessite de connecter l'accumulateur au bus de données, de manière à ce que le transfert des données se fasse de l'accumulateur vers le bus de données. L'instruction LOAD s'implémente de la même manière, sauf que le sens de transfert est inversé.

Cependant, il existe une optimisation qui permet d'implémenter l'instruction LOAD sans ajouter de circuits. Pour cela, il suffit que l'unité de calcul gére les opérations ''pass through'', à savoir des opérations qui se contentent de recopier un opérande sur la sortie. Ici, l'idée est de recopier l'opérande provenant du bus de données.

[[File:Architecture à accumulateur, microarchitecture.png|centre|vignette|upright=2|Architecture à accumulateur, microarchitecture]]

Pour gérer nativement l'adressage indirect à registre, il suffit de connecter l'accumulateur au bus d'adresse. Le plus simple est d'ajouter un multiplexeur, comme illustré ci-dessous. La donnée lue est copiée dans l'accumulateur, ce qui fait qu'il vaut mieux utiliser un registre d’interfaçage, l'accumulateur n'étant pas utilisable à la fois pour le bus d'adresse et de données.

[[File:Adressage indirect sur une architecture à accumulateur.png|centre|vignette|upright=2|Adressage indirect sur une architecture à accumulateur]]

Pour finir, voyons comment le pointeur de pile et le ''program counter'' sont implémentés. Les architectures à accumulateur ont souvent des adresses de taille différente des données, ce qui fait qu'il vaut mieux utiliser un circuit incrémenteur dédié pour incrémenter le ''program counter'', plutôt que de l'incrémenter via l'unité de calcul. Les architectures à accumulateur ont parfois un pointeur de pile, qui gère une pile d'adresse de retour, pas une vraie pile d'appel. Aussi, le pointeur de pile est censé être incrémenté et décrémenté, pas plus. Pas d'addition ou de soustraction pour gérer des cadres de pile. Là encore, c'est la solution de l'incrémenteur séparé qui est retenue. Pour économiser des transistors, il n'y a qu'un seul incrémenteur partagé pour les deux.

==Les architectures à accumulateur à registres d'indice==

Les architectures à accumulateur décrites dans la section précédente sont capables de faire de l'adressage indirect, mais n'incluent pas les modes d'adressage base + indice et absolus indicés, qui prennent une adresse et y ajoute un indice. Il s'agit des toutes premières architectures à accumulateur, comme les premiers ordinateurs IBM ou le fameux PDP-8. Mais par la suite, les processeurs à accumulateurs ont inclus un support des modes d'adressages indicés, grâce à des '''registres d'indice'''.

===Les registres d'indice===

Les registres d'indice stockent des indices de tableaux. Ils permettaient de supporter deux modes d'adressage :
* Le '''mode d'adressage absolu indicé''' où une adresse fixe est additionnée à un indice variable. L'adresse fixe est intégrée dans l'instruction (adressage absolu), l'indice est dans un registre d'indice.
* Le '''mode d'adressage base + indice''', où l'adresse est dans l'accumulateur et l'indice dans le registre d'indice.

Les processeurs à accumulateur supportaient souvent des variantes des modes d'adressage précédents, où le registre d'indice était automatiquement incrémenté ou décrémenté à chaque utilisation.

Au départ, ces processeurs n'utilisaient qu'un seul registre d'indice qui se comportait comme un second accumulateur spécialisé dans les calculs d'adresses mémoire. Le processeur supportait de nouvelles instructions qui utilisaient ce registre d'indice de façon implicite. Mais avec le temps, les processeurs finirent par incorporer plusieurs de ces registres. Les instructions de lecture ou d'écriture devaient alors préciser quel registre d'indice utiliser, en précisant un nom de registre d'indice, un numéro de registre d'indice.

Il faut préciser que les registres d'indice ont une taille bien plus petite que l'accumulateur. Ils mémorisent des indices codés sur 16 bits ou moins, alors que l'accumulateur faisait typiquement 36 à 48 bits, parfois plus. La taille classique sur les anciens ''mainframes'' était de 15 bits, parfois moins. Il n'était pas rare de tomber sur des registres d'indice de 8 ou 9 bits. Leur petite taille rendait leur implémentation matérielle peu couteuse. Et c'est ce qui explique qu'ils étaient préférés à l'usage d'un second accumulateur.

Un exemple est le cas du processeur Motorola 6809, un processeur à accumulateur qui contient deux registres d'indices nommés X et Y. L'accumulateur est noté D et fait 16 bits, il peut être parfois géré comme deux accumulateurs séparés A et B de 8 bits chacun. Il contenait aussi deux pointeurs de pile, l'un pour les programmes, l'autre pour le système d'exploitation, ainsi qu'un ''program counter''. Le registre de page était utilisé pour l'adressage absolu, comme vu dans le chapitre sur les modes d'adressage.

[[File:6809 Internal Registers.svg|centre|vignette|upright=2|6809 Internal Registers]]

Les processeurs IBM avaient autrefois plusieurs registres d'indice. Par exemple, l'IBM 704 avait trois registres d'indice de 15 bits. Leur contenu était soustrait de l'adresse absolue. Une instruction pouvait utiliser plusieurs registres d'indice pour adresser son opérande. Toute instruction utilisait trois bits pour sélectionner les registres d'indice utilisés. Fait assez original, lorsque plusieurs registres d'indice sont sélectionnés, le processeur n'additionne pas les trois registres à l'adresse de base. À la place, il fait un OU bit à bit entre les registres d'indice sélectionnés, et additionne le résultat à l'adresse.

Les processeurs IBM à accumulateur ont fait ça sur toute la gamme IBM 700/7000, pour des raisons de compatibilité. Les processeurs suivants avaient 7 registres d'indices, mais conservaient les trois bits pour adresser les registres d'indices. Ils pouvaient fonctionner dans deux modes. Le premier mode est plus intuitif : les trois bits précisent un registre d'indice parmi les 7, qui est additionné avec l'adresse absolue. La valeur zéro indique qu'aucun registre d'indice n'est utilisé, ce qui explique qu'il y a 7 registres d'indice et non 8. Un second mode, compatible avec l'IBM 704, fait un OU logique entre les registres d'indice sélectionnés. Seuls les trois premiers registres d'indices peuvent être sélectionnés dans ce mode. Il y a deux instructions pour changer de mode : une pour passer en mode compatible, l'autre pour le quitter pour l'autre mode.

Quelques rares processeurs à registres généraux ont utilisés des registres d'indice, en plus des registres généraux. Ce qui fait l'association que nous avons faite entre registres d'indice et architectures à accumulateur est imparfait, bien que solide sur le principe. Un exemple d'architecture de ce type sont les architectures de la série UNIVAC 1100/2200. Ils disposaient de 128 registres, qui étaient mappés en mémoire à partir de l'adresse mémoire 0, la majorité étant inaccessibles par le programmeur. Ils regroupaient 12 registres accumulateurs, 11 registres d'indice et 4 registres hybrides qui pouvaient servir soit de registre d'indice, soit de registres accumulateurs.

===La micro-architecture des architectures à accumulateur avec registres d'indice===

La présence de registres d'indice modifie grandement l'implémentation du processeur. En effet, il faut rajouter un banc de registre pour les registres d'indice. Le banc de registre est monoport, car on a besoin de lire ou d'écrire un indice à la fois. Et il faut aussi potentiellement rajouter de quoi faire les calculs d'adresse. Deux solutions sont possibles : une ALU dédiée aux calculs d'adresse, une seule ALU pour toutes les opérations.

Dans le premier cas, il y a une ALU séparée associée aux registres d'indice. L'ALU et les registres d'indice sont placés en sortie du séquenceur, en-dehors du chemin de données, la sortie de l'ALU est directement connectée au bus d'adresse. L'unité de calcul d'adresse peut être utilisée pour incrémenter le ''program counter''. Un défaut de cette approche est qu'elle ne gère pas l'adresse indirect à registre.

[[File:Chemin de données sans support des pointeurs, avec adressage absolu indicé.png|centre|vignette|upright=2|Chemin de données sans support des pointeurs, avec adressage absolu indicé]]

Une autre option utilise un bus interne, qui interconnecte tout le chemin de données. Dans sa version la plus simple, il est relié à l'accumulateur, l'unité de calcul, le banc de registre d'indice et le bus de données. Avec cette solution, l'ALU est utilisé à la fois pour calculer les adresses et pour les instructions de calcul. En reliant le bus interne au bus d'adresse à travers un multiplexeur, on gère naturellement les adressages indirects.

[[File:Architecture à accumulateur avec registres associés.png|centre|vignette|upright=2.5|Architecture à accumulateur avec registres associés]]

Il faut noter que sur les architectures Von Neumann, le séquenceur est relié à ce bus interne. En effet, charger une instruction demande de passer par le bus mémoire, donc par l’intermédiaire de ce bus internet. Le ''program counter'' est envoyé sur ce bus pour lire l'instruction, puis l'instruction lue est recopiée dans le registre d'instruction. Le chargement d'une instruction est donc géré comme une lecture des plus classiques. De plus, cela permet d'incrémenter le ''program counter'' au niveau de l'unité de calcul entière. Le ''program counter'' est envoyé sur le bus interne, incrémenté par l'ALU, puis le résultat est recopié dans le ''program counter'' via le bus interne.

[[File:Architecture à accumulateur avec bus unique de type Von Neumann.png|centre|vignette|upright=2|Architecture à accumulateur avec bus unique de type Von Neumann]]

==Les processeurs bi-accumulateurs : le Motorola 6800==

Le Motorola 6800 était un processeur 8 bits qui gérait des adresses de 16 bits. Il contenait deux accumulateurs nommés A et B, de 8 bits chacun. Il disposait aussi d'un registre d'indice, d'un pointeur de pile et d'un ''program counter'', tous les trois de 16 bits. Le registre d'état regroupait 6 bits, qu'on ne détaillera pas ici.

[[File:MC6800 Processor Diagram.png|centre|vignette|upright=2|Interface et registres du MC6800.]]

La présence des deux accumulateurs impactait surtout les instructions dyadiques. Les instructions monadiques avaient juste à préciser où se trouvait l'opérande : soit en RAM, soit dans le premier accumulateur, soit dans le second. Pour les opérations dyadiques, la gestion était totalement différente. En théorie, le premier opérande est dans un accumulateur, soit A, soit B. La seconde opérande vient soit de l'autre accumulateur, soit de la mémoire RAM. Et selon les instructions, tout variait.

Pour l'addition, il y avait trois instructions. Les deux premières additionnaient un opérande provenant de la mémoire avec un accumulateur. L'instruction ADDA sélectionnait le premier accumulateur, l'instruction ADDB sélectionnait le second accumulateur. Mais une troisième instruction, l’instruction ABA, permettait d'additionner le contenu des deux accumulateurs.

Pour les autres opérations, il n'était pas possible d'utiliser les deux accumulateurs en même temps. La seule possibilité était de faire une opération entre un accumulateur et un opérande venant de la mémoire. Toutes les instructions étaient en double, avec une copie par accumulateur. Par exemple, l'instruction ANDA faisait un ET entre l’accumulateur A et l'opérande mémoire, l'instruction ANDB faisait pareil avec l'accumulateur B.

==Les architectures hybrides registres-accumulateur==

Il a existé quelques architectures qui étaient des hybrides entre architectures à accumulateur et architecture à registre. Elles ont servi de transition entre les deux, durant les années 80-90. Elles avaient un accumulateur unique couplé à un banc de registres généraux. Par exemple, les premiers processeurs Intel 8 bits étaient des processeurs hybrides-accumulateur. Lles CPU Intel 8 bits disposaient de 7 registres de 8 bits nommés A, B, C, D, E, F, H, L, SP. Ils correspondent respectivement à :
* l'accumulateur A ;
* six registres nommés B, C, D, E, H et L ;
* le registre d'état F ;
* le pointeur de pile SP.

Sur ces processeurs, les instructions dyadiques devaient mettre leur premier opérande dans l'accumulateur, la seconde provenait soit des registres, soit de la RAM, soit d'une constante immédiate. Les opérations monadiques pouvaient lire leur opérande depuis l'accumulateur, les autres registres ou la RAM, tout était permis. Les registres d'indices disparaissaient sur ces architectures, en théorie. Les registres généraux pouvaient être utilisés comme registre d'indice ou pour stocker des opérandes, ils étaient assez versatiles pour servir de registres d'indices.

La présence de registres a de nombreux avantages, comparé aux architectures à accumulateur pures. Les instructions arithmétiques sont plus rapide, lire un registre étant plus rapide qu'un accès RAM. Les performances sont donc augmentées. De plus, les instructions arithmétiques utilisant ces registres sont plus courtes : pas besoin d'encoder une adresse mémoire, un nom de registre suffit. Vu que les processeurs de l’époque avaient des instructions de taille variable, cela améliorait la densité de code.

La microarchitecture de ces processeurs est très similaire à celle d'un processeur avec des registres d'indices. La seule différence est que le banc de registre contient des registres généraux et non des registres d'indices. Le banc de registre est systématiquement monoport, car il n'avait aucune raison d'être multiport. Pour les instructions dyadiques, seules à lire deux opérandes, il ne servait que pour la seconde opérande, la première était lue depuis l'accumulateur.

Les processeurs hybrides registre-accumulateur se classent en deux types principaux : ceux qui ont un seul bus interne, et ceux qui en ont deux. Le premier cas est identique à celui vu précédemment pour les architectures à accumulateur avec registres d'indice, à la seule différence est que le banc de registre contient des registres généraux et non des registres d'indices. Afin de gérer l'adressage indirect à registre, le bus interne est connecté aux deux registres d’interfaçage mémoire.

[[File:Architecture à accumulateur avec bus unique de type Von Neumann.png|centre|vignette|upright=2|Architecture à accumulateur avec bus unique de type Von Neumann]]

Notons que cela permet aussi d'implémenter facilement les branchements indirects, car le bus interne permet d'échanger des adresses entre ''program counter'' et banc de registre. De même, il est possible d'utiliser l'ALU pour gérer les branchements indirects., en plus de l'utiliser pour incrémenter le ''program counter''.

[[File:Single bus organization.jpg|centre|vignette|upright=2|Single bus organization]]

Une autre solution utilisait deux bus internes : un connecté au bus de données, un autre relié au bus d'adresse. Le bus de commande mémoire était lui commandé par le séquenceur, l'unité de contrôle. L'intermédiaire entre ces deux bus était le banc de registre, ainsi que les autres registres. Le banc de registre était connecté aux deux bus interne, avec un port de lecture relié au bus d'adresse, un port de lecture-écriture relié au bus de données. Le port de lecture était utilisé pour l'adressage indirect, l'autre l'était pour le reste.

[[File:Proz1-e.png|centre|vignette|upright=2|Intérieur d'un processeur.]]

L'organisation à deux bus simplifiait la gestion du ''program counter'' et le chargement des instructions. Le ''program counter'' était soit séparé du banc de registre, soit placé dans le banc de registre. Les deux solutions étaient utilisés, tout dépend du processeur. Il faut noter que si le ''program counter'' est intégré au banc de registres, alors la microarchitecture du processeur est bien plus simple. L'envoi du ''program counter'' sur le bus d'adresse utilise le port de lecture relié au bus d'adresse, qui sert aussi pour l'adressage indirect. L'économie de circuits, sans compter la simplicité d'implémentation que cela implique, explique sans doute que la technique a été utilisée sur quelques processeurs anciens.

Le ''program counter'' était généralement incrémenté par l'ALU, ce qui explique qu'il soit connecté au bus interne pour les données. La connexion est aussi utile pour gérer les branchements indirects, qui copient un registre dans le ''program counter'', ainsi que les branchements relatifs (addition dans l'ALU), voire les branchements directs (l'adresse vers laquelle brancher est envoyée en entrée de l'ALU et propagée en sortie avec une opération ''pass through'').

[[File:Connexion du program counter sur les bus avec PC dans le banc de registres.png|centre|vignette|upright=2|Connexion du program counter sur les bus avec PC dans le banc de registres]]

===Les registres d'interruption avec un processeur hybride-accumulateur : l'exemple du Z80===

Un exemple de processeur registre-accumulateur à deux bus interne est le Z80, un processeur fortement inspiré des CPU Intel 8 bits. Il a un jeu d'instruction similaire, mais a diverses améliorations par rapport au design original. Notamment, le processeur a des registres séparés pour les interruptions.

Sur le Z80, les registres généraux sont dupliqués avec 6 registres pour les interruptions et 6 registres pour les programmes autres. Leur copie pour les interruptions sont nommées B', C', D', E', H', L'. Les 12 registres sont placés dans le banc de registre, ce qui implique que le fenêtrage de registres est utilisé pour gérer la séparation entre registre d'interruption et normaux. Il faut noter que l'accumulateur et le registre d'état sont aussi dupliqués, leurs copies étant nommées A' et F'. Mais leur duplication se fait autrement que par fenêtrage de registre.

En plus des registres précédents, le Z80 incorporait deux registres d'indice nommés X et Y, ainsi qu'un pointeur de pile SP et un ''program counter'' PC. Ils n'étaient pas dupliqués pour les interruptions. Les registres d'indice étaient reliés à une unité de calcul d'adresse. L'unité de calcul d'adresse prenait deux opérandes : un indice, et une adresse mémoire provenant soit du banc de registre, soit de l'accumulateur. En clair, l'unité de calcul d'adresse faisait le lien entre les deux bus internet : le bus de données interne en entrée, le bus d'adresse en sortie.

À l'intérieur du processeur, tous les registres étaient regroupés dans un banc de registre unique, sauf les accumulateurs, les registres d'état et le ''program counter''. Bien que ce ne soit pas indiqué sur le schéma ci-dessous, le ''program counter'' est séparé du banc de registre, alors que le pointeur de pile est dedans. Le compteur IR est lui associé au ''program counter'', il est sortit du banc de registre. Le Z80 utilise lui aussi un incrémenteur séparé de l'ALU, qui est utilisé pour mettre à jour le ''program counter'', le pointeur de pile et un compteur de rafraichissement mémoire nommé IR sur le Z80 (pour rappel, le rafraichissement mémoire demande de balayer la mémoire d'adresse en adresse et été fait par le CPU à l'époque). De plus, il est utilisé pour les instructions INC et DEC qui incrémentent une opérande de 16 bits obtenue en combinant deux registres de 8 bits. En clair, l'incrémenteur du ''program counter'' a été réutilisé de beaucoup de manières originales.

[[File:Z80 arch.svg|centre|vignette|upright=3|Microarchitecture du Z80.]]

Le Z80 incorporait des instructions pour échanger le contenu des deux ensembles de registres, accumulateur inclus. Elles permettaient d'utiliser les registres d'interruption pour les programmes et réciproquement. En clair, cela doublait le nombre de registres si les interruptions n'étaient pas utilisées.
* L'instruction EXX échangeait les deux fenêtres de registres généraux : les registres B, C, D, E, H et L devenaient les registres B', C', D', E', H' et L' et inversement.
* L'instruction EX échangeait l'accumulateur et le registre d'état : les registres A,F devenait A',F' et inversement.

Le fenêtrage de registre était modifié par l'instruction EXX, qui échangeait les deux fenêtres de registres. Pour l'implémenter, une bascule était ajouté au processeur, appelons-la la bascule INT. Elle était relié au bus d'adresse du banc de registre, dont elle mémorisait le bit de poids fort. L'instruction EXX inversait la valeur de la bascule INT. Il est aussi possible d'échanger le contenu des registres D,E et H,L avec une instruction dédiée, ce qui est là encore fait par deux bascules : une pour les registres D,E et une autre pour les registres H,L.

Pour l'accumulateur et le registre d'état, le choix entre registre normal et registre d'interruption se faisait là encore par une seconde bascule appelée la bascule A. La bascule est reliée à un multiplexeur et un démultiplexeur, qui permet de choisir quel accumulateur relier à l'unité de calcul. L'instruction EX inverse le contenu de la bascule A.

&lt;noinclude&gt;
{{NavChapitre | book=Fonctionnement d'un ordinateur
           | prev=L'unité de contrôle
           | prevText=L'unité de contrôle
           | next=Les processeurs 8 bits et moins
           | nextText=Les processeurs 8 bits et moins
}}
&lt;/noinclude&gt;</text>
      <sha1>sxm2bb0icutnps8nsdu9lehlb63k9jj</sha1>
    </revision>
    <revision>
      <id>744137</id>
      <parentid>744136</parentid>
      <timestamp>2025-06-05T00:34:09Z</timestamp>
      <contributor>
        <username>Mewtow</username>
        <id>31375</id>
      </contributor>
      <minor />
      <comment>/* Le jeu d'instruction des architectures à accumulateur sans registres d'indice */</comment>
      <origin>744137</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="37122" sha1="kqnefcjy1a2i92ec6iisa6ryw66pb6y" xml:space="preserve">Les architectures que nous avons vu précédemment dans ce cours disposent de registres pour les données, en plus du pointeur de pile, d'un ''program counter'', et de quelques autres. Elles sont appelées des '''architectures à registres''', terme qui trahit bien le fait qu'elles ont des registres généraux ou spécialisés pour stocker temporairement des données. Et si on leur a donné un nom, c'est parce qu'il existe des architectures qui ne sont pas dans cette catégorie. Il en existe plusieurs types, mais ce chapitre va se concentrer sur les '''architectures à accumulateur'''.

[[File:Isaccumulator.png|vignette|Architecture à accumulateur.]]

Les architectures à accumulateur sont centrées autour d'un registre architectural appelé l''''accumulateur'''. Il est utilisé pour toutes les opérations arithmétiques dyadiques, où il sert à la fois de source et de destination. Toutes les instructions dyadiques sont de type ''load-op'' : une opérande est lue depuis l'accumulateur, le second opérande est lu depuis la mémoire RAM, le résultat de l'instruction est automatiquement mémorisé dans l'accumulateur. Les instructions monadiques peuvent utiliser un opérande dans l'accumulateur, ou dans la mémoire RAM, les deux sont théoriquement possibles.

La conséquence est que le nombre d'accès mémoire est drastiquement diminué : de 3 par instructions sur une architecture mémoire-mémoire, on passe à seulement un avec un accumulateur. Les opérations dyadiques ont besoin d'un seul accès mémoire pour lire la seconde opérande, les opérations monadique en font aussi un seul pour lire leur unique opérande.

{|class=&quot;wikitable&quot;
|-
! Classe d'architecture
! Nombre d'accès mémoire par opération dyadique
|-
|-
! Architecture à accumulateur
| Un accès mémoire par instruction, pour lire la seconde opérande
|-
! Architecture à registres
| Zéro si les opérandes sont dans les registres, un pour les opérations ''load-op'', LOAD et STORE.
|}

==Le jeu d'instruction des architectures à accumulateur sans registres d'indice==

L'accumulateur est adressé grâce au mode d'adressage implicite, de même que le résultat de l'opération. Par contre, les autres opérandes sont localisés avec d'autres modes d'adressage, et lues en mémoire RAM. Le résultat ainsi qu'un des opérandes sont adressés de façon implicite car dans l'accumulateur, seule la seconde opérande étant adressée directement. Grâce à l'accumulateur, une instruction ne fait qu'un seul accès mémoire maximum, ce qui rend le processeur très facile à implémenter.

===Les registres des anciennes architectures à accumulateur===

[[File:IBM 701console.jpg|vignette|IBM 701, console extérieure.]]

Les architectures à accumulateur étaient communes dans les années 50-60. A l'époque, les ordinateurs étaient gigantesques, ils prenaient une pièce de bâtiment entière dans le pire des cas, une armoire entière dans le meilleur. Les ordinateurs de l'époque étaient surtout utilisés pour du calcul scientifique ou des tâches d’ingénierie demandant beaucoup de calcul, rarement pour de la compatibilité.

Les nombres flottants n'étaient pas encore apparus. A la place, les ordinateurs de l'époque géraient des nombres entiers de grande taille, de 30 bits ou plus. En conséquence, l'accumulateur faisait facilement 30 à 60 bits. Par exemple, les ordinateurs de la Série scientifique IBM 700/7000 géraient des entiers de 36 bits, l’accumulateur faisait 38 bits : 36 bits plus deux bits pour les débordements. Au passage, de tels processeurs utilisaient l'adressage par mot, et non par byte.

Historiquement, les premières architectures à accumulateur ne contenaient aucun autre registre que l'accumulateur. Ce n'est que dans les années 60 que de nombreuses architectures à accumulateur ont ajouté un second '''registre pour les multiplication/divisions'''. Un exemple est celui de l'IBM 701, qui incorporait un registre accumulateur de 38 bits et un registre multiplieur de 36 bits. Le registre mémorise le multiplieur lors d'une opération de multiplication. Il mémorise donc un opérande, pas le résultat. Il peut aussi décaler le multiplieur vers la droite/gauche, ce qui est utile pour exécuter la multiplication. C'est ce qui est fait sur l'IBM 7094.

Une autre possibilité est que ce registre mémorise une partie du résultat de l'opération. Pour rappel, le résultat d'une multiplication/division est codé sur deux fois de bits que ses opérandes. Par exemple, multipliez deux opérandes de 30 bits, vous obtiendrez un résultat de 60 bits. Les 30 bits de poids faible du résultat vont dans l'accumulateur, les 30 bits de poids fort vont dans ce second registre.

Les architectures à accumulateur parfois un '''registre pour le pointeur de pile''', utilisé pour gérer les fonctions/procédures. Les architectures à accumulateurs supportaient une pile d'adresse de retour, souvent une pile d'appel. Mais pour cela, il fallait mémoriser le pointeur de pile dans le processeur, ce qui demandait un registre dédié.

===L'adressage indirect avec l'accumulateur===

Les instructions LOAD et STORE existent bel et bien sur les architectures à accumulateur, mais n'ont pas les mêmes modes d'adressages. L'instruction LOAD copie une donnée de la RAM vers l'accumulateur, l'instruction STORE copie l'accumulateur dans une adresse. Les deux instructions n'ont pas besoin d'adresser l'accumulateur, qui est adressé de manière implicite, juste de préciser l'adresse à lire/écrire.

Les architectures à accumulateur supportaient souvent le mode d'adressage indirect mémoire. Un exemple est celui des ordinateurs Data General Nova, qui sont des architectures à accumulateur et qui supportaient ce mode d'adressage. Les deux instructions LOAD et STORE existaient en deux versions, distinguées par un bit d'indirection. Si ce bit est à 0 dans l'opcode, alors l'instruction utilise le mode d'adressage absolu normal : l'adresse intégrée dans l'instruction est celle de la donnée. Mais s'il est à 1, alors l'adresse intégrée dans l'instruction est celle du pointeur.

Cependant, la présence de l'accumulateur permettait d'utiliser l'adressage indirect à registre, pour gérer les pointeurs. Pour rappel, avec le mode d'adressage indirect à registre, l'adresse à lire/écrire est dans un registre. Ici, l'adresse à lire/écrire est prise dans l'accumulateur, seul registre disponible pour. L'adressage indirect est plus simple à implémenter pour l'instruction LOAD, car elle prend un seul opérande : l'adresse à lire. L'adresse à lire est placée dans l'accumulateur, la donnée lue est elle aussi chargée dans l'accumulateur. Pour l'instruction STORE, il faut fournir deux opérandes, l'adresse et la donnée à écrire, ce qui peut poser problème. Mais au pire, il est toujours possible d'utiliser l'adressage absolu ou indirect mémoire : l'adresse est dans l'instruction, la donnée à écrire dans l'accumulateur.

===L'encodage des instructions===

Sur une architecture à accumulateur l'encodage d'une instruction dyadique est assez simple, vu que l'accumulateur est adressé implicitement. La seconde opérande est localisée soit par une adresse mémoire (adressage absolu), soit est une constante (adressage immédiat). L'adresse mémoire est généralement assez longue, plus que l'opcode.

{|class=&quot;wikitable&quot;
|+ Encodage d'une instruction dyadique
|-
! rowspan=&quot;2&quot; | Opcode 
| Adresse mémoire (adressage absolu)
|-
| Constante (adressage immédiat)
|}

L'encodage d'une instruction monadique est similaire. Si l'opérande est lue depuis la mémoire RAM, alors l'instruction est encodée comme une instruction dyadique. Il en est de même pour les instructions qui copient une constante dans l'accumulateur. Par contre, si l'opérande est dans l'accumulateur, alors il y a juste besoin d'encoder l'opcode. La majorité des instructions a besoin de préciser une adresse, rares sont celles qui s'en passent. Au vu de cet encodage, les architectures à accumulateur sont qualifiées d''''architectures à une adresse''' par abus de langage.

Il est intéressant de contraster leur encodage avec les architectures à registres. Les architectures à registre doivent encoder deux opérandes en plus de l'opcode, avec éventuellement où enregistrer le résultat sur les architectures 3-adresses. Par contre, les opérandes sont généralement des noms de registre, ce qui prend moins de place qu'une adresse mémoire. A la rigueur, les instructions avec une constante immédiate prennent un peu plus de place, car elles doivent encoder un nom de registre en plus de la constante et de l'opcode. Les instructions ''load-op'' des processeurs CISC sont un peu dans le même cas, sauf qu'il faut remplacer la constante par une adresse, qui a généralement la même taille. Les instructions sont donc en moyenne plus courte sur les processeurs à registre, du fait de la présence de registres.

===Annexe : les toutes premières architectures à accumulateur : le Manchester Baby===

[[File:BabyArchitecture.png|vignette|Architecture de la Manchester Baby.]]

Les architectures à accumulateurs sont apparues dès les débuts de l'informatique. Le tout premier ordinateur à programme enregistré en mémoire, le ''Manchester Baby'', était une architecture à accumulateur. Niveau interface, l'ordinateur avait une console avec 32 boutons, des interrupteurs et un écran de sortie sur lequel afficher les résultats. A l'intérieur, il y avait un processeur et une RAM de 32 adresses de 32 bits, fabriquée avec des tubes Williams (abordés dans une annexe à la fin du cours).

Le programme devait tenir dans la RAM, avec une instruction par adresse maximum, ce qui limitait les programmes à 32 instructions maximum. Une instruction prenait donc 32 bits, 3 indiquaient quelle opération utiliser, 12 servait à indiquer où se trouvent les opérandes en RAM, les 16 restants sont inutilisés.

Le processeur avait un registre accumulateur de 32 bits, un ''program counter'' et un registre d'instruction. Il gérait 8 instructions en tout, mais ne gérait pas l'addition. Il gérait la soustraction, des instructions de branchement et d'accès mémoire, rien d'autre. Il pouvait cependant émuler l'addition à partir d'une soustraction et inversant l'opérande soustraite.

Le Manchester Mark 1 était une amélioration du Manchester Baby. Il utilisait 4500 tubes à vide. L'ordinateur gérait des nombres de 40 bits, mais les instructions étaient codées sur 20 bits. La RAM avait la même taille, à savoir 32 nombres, leur taille était simplement augmentée. Par contre, la RAM était complémentée par l’ancêtre du disque dur magnétique, à savoir un tambour magnétique, l’ancêtre du disque dur magnétique. Il contenait 40 pages, chacune ayant la même taille que la RAM. C'était là encore une architecture à accumulateur, sauf qu'elle intégrait aussi des registres d'indice. Et surtout : son processeur gérait l'addition et quelques opérations logiques (ET et OU), en plus de la soustraction et de la comparaison.

==La micro-architecture des architectures à accumulateur sans registres d'indice==

L'organisation interne d'une architecture à accumulateur est très différente de celle des processeurs à registre. Elle est plus ou moins la même pour tous ces processeurs, le point important étant que le chemin de données se résume à une ALU, un registre accumulateur et le bus de données. L'ALU est reliée au registre accumulateur, ainsi qu'au bus de données pour lire la seconde opérande, comme illustré ci-dessous.

[[File:Accumulator.png|centre|vignette|upright=2|Accumulateur.]]

===L'unité de calcul et l'accumulateur===

Pour simplifier l'implémentation, le résultat est mémorisé dans un registre en sortie de l'unité de calcul. La raison est qu'on ne veut pas altérer l'accumulateur tant que le résultat final n'est pas totalement calculé. Rappelons que l'ALU ne fournit pas un résultat d'un seul bloc, mais que certains bits arrivent avant les autres, typiquement les bits de poids faible. Si le résultat était écrit dans l'accumulateur directement, il écraserait des bits de l’opérande en cours d'utilisation, ce qui fausserait le résultat.

[[File:Accumulateur avec registre de sortie.png|centre|vignette|upright=2|Accumulateur avec registre de sortie]]

Une autre solution utilisait un registre entre l'accumulateur et l'unité de calcul, appelé l’'''''accumulator latch'''''. Il remplace le registre en sortie de l'ALU, dans le sens où il permet d'écrire dans l'accumulateur sans effacer l'opérande, pendant que l’opération est en cours dans l'ALU. L'accumulateur est copié dans l’''accumulator latch'', avant que l'ALU démarre ses calculs. L'opérande est donc maintenue même si on commence à écrire le résultat dans l'accumulateur.

Sur le 8085 d'Intel, l’''accumulator latch'' peut être initialisé avec une constante prédéfinie, ce qui permet d'implémenter certaines instructions très facilement. Par exemple, il peut être initialisé à 0, ce qui permet d'implémenter les instructions MOV et INC (incrémentation). Un MOV est équivalent à faire un OU entre le registre lu et 0. Une instruction INC initialise l'entrée de retenue de l'unité de calcul à 1, puis ajoute 0. La décrémentation est implémentée de la même manière, sauf que l’''accumulator latch'' est initialisé à -2 pour compenser l'entrée de retenue à 1. De plus, pour supporter les conversion de décimal à BCD, l’''accumulator latch'' peut être initialisé avec les constantes 0x00, 0x06, 0x60, or 0x66. L'''accumulator latch'' est relié à divers fils de commande provenant de l'unité de contrôle, qui décide quelle valeur d'initialisation utiliser en fonction de l'instruction décodée.

[[File:Accumulator latch.png|centre|vignette|upright=2|Accumulator latch]]

[[File:Chemin de données à un seul bus.png|vignette|Chemin de données à un seul bus]]

De même, la seconde opérande, celle lue sur le bus de données, est mémorisée dans un registre en amont de l'ALU. C'était notamment très utile si le processeur utilisait une ALU plus courte que les opérandes, avec par exemple une ALU 4 bits pour un CPU 8 bits. Les anciens processeurs à accumulateur de type ''mainframe'' utilisaient des opérandes de grande taille, du genre 36 ou 48 bits, ce qui avait des conséquences sur l'unité de calcul utilisée, ainsi que sur la communication avec la mémoire. Il arrivait que de tels processeurs utilisaient des ALU sérielles, ou du moins octet-sérielles, plutôt qu'une véritable ALU 36 bits. Nous verrons aussi que c'est très utile sur les processeurs à accumulateur avec un bus interne unique, dans la suite du chapitre.

===La micro-architecture des architectures à accumulateur avec instructions LOAD/STORE===

Nous venons de voir comment est implémenté l'unité de calcul et l'accumulateur, et comment le tout est relié au bus de données. Mais cela ne permet que d'avoir un processeur à accumulateur rudimentaire, qui ne gére que des instructions arithmétiques et logiques. Il faut aussi gérer le cas des opérations LOAD/STORE et des modes d'adressages associés, mais c'est le séquenceur qui s'en occupe. Avec l'adressage absolu, les instructions LOAD et STORE ne font que connecter l'accumulateur au bus de données. L'instruction STORE nécessite de connecter l'accumulateur au bus de données, de manière à ce que le transfert des données se fasse de l'accumulateur vers le bus de données. L'instruction LOAD s'implémente de la même manière, sauf que le sens de transfert est inversé.

Cependant, il existe une optimisation qui permet d'implémenter l'instruction LOAD sans ajouter de circuits. Pour cela, il suffit que l'unité de calcul gére les opérations ''pass through'', à savoir des opérations qui se contentent de recopier un opérande sur la sortie. Ici, l'idée est de recopier l'opérande provenant du bus de données.

[[File:Architecture à accumulateur, microarchitecture.png|centre|vignette|upright=2|Architecture à accumulateur, microarchitecture]]

Pour gérer nativement l'adressage indirect à registre, il suffit de connecter l'accumulateur au bus d'adresse. Le plus simple est d'ajouter un multiplexeur, comme illustré ci-dessous. La donnée lue est copiée dans l'accumulateur, ce qui fait qu'il vaut mieux utiliser un registre d’interfaçage, l'accumulateur n'étant pas utilisable à la fois pour le bus d'adresse et de données.

[[File:Adressage indirect sur une architecture à accumulateur.png|centre|vignette|upright=2|Adressage indirect sur une architecture à accumulateur]]

Pour finir, voyons comment le pointeur de pile et le ''program counter'' sont implémentés. Les architectures à accumulateur ont souvent des adresses de taille différente des données, ce qui fait qu'il vaut mieux utiliser un circuit incrémenteur dédié pour incrémenter le ''program counter'', plutôt que de l'incrémenter via l'unité de calcul. Les architectures à accumulateur ont parfois un pointeur de pile, qui gère une pile d'adresse de retour, pas une vraie pile d'appel. Aussi, le pointeur de pile est censé être incrémenté et décrémenté, pas plus. Pas d'addition ou de soustraction pour gérer des cadres de pile. Là encore, c'est la solution de l'incrémenteur séparé qui est retenue. Pour économiser des transistors, il n'y a qu'un seul incrémenteur partagé pour les deux.

==Les architectures à accumulateur à registres d'indice==

Les architectures à accumulateur décrites dans la section précédente sont capables de faire de l'adressage indirect, mais n'incluent pas les modes d'adressage base + indice et absolus indicés, qui prennent une adresse et y ajoute un indice. Il s'agit des toutes premières architectures à accumulateur, comme les premiers ordinateurs IBM ou le fameux PDP-8. Mais par la suite, les processeurs à accumulateurs ont inclus un support des modes d'adressages indicés, grâce à des '''registres d'indice'''.

===Les registres d'indice===

Les registres d'indice stockent des indices de tableaux. Ils permettaient de supporter deux modes d'adressage :
* Le '''mode d'adressage absolu indicé''' où une adresse fixe est additionnée à un indice variable. L'adresse fixe est intégrée dans l'instruction (adressage absolu), l'indice est dans un registre d'indice.
* Le '''mode d'adressage base + indice''', où l'adresse est dans l'accumulateur et l'indice dans le registre d'indice.

Les processeurs à accumulateur supportaient souvent des variantes des modes d'adressage précédents, où le registre d'indice était automatiquement incrémenté ou décrémenté à chaque utilisation.

Au départ, ces processeurs n'utilisaient qu'un seul registre d'indice qui se comportait comme un second accumulateur spécialisé dans les calculs d'adresses mémoire. Le processeur supportait de nouvelles instructions qui utilisaient ce registre d'indice de façon implicite. Mais avec le temps, les processeurs finirent par incorporer plusieurs de ces registres. Les instructions de lecture ou d'écriture devaient alors préciser quel registre d'indice utiliser, en précisant un nom de registre d'indice, un numéro de registre d'indice.

Il faut préciser que les registres d'indice ont une taille bien plus petite que l'accumulateur. Ils mémorisent des indices codés sur 16 bits ou moins, alors que l'accumulateur faisait typiquement 36 à 48 bits, parfois plus. La taille classique sur les anciens ''mainframes'' était de 15 bits, parfois moins. Il n'était pas rare de tomber sur des registres d'indice de 8 ou 9 bits. Leur petite taille rendait leur implémentation matérielle peu couteuse. Et c'est ce qui explique qu'ils étaient préférés à l'usage d'un second accumulateur.

Un exemple est le cas du processeur Motorola 6809, un processeur à accumulateur qui contient deux registres d'indices nommés X et Y. L'accumulateur est noté D et fait 16 bits, il peut être parfois géré comme deux accumulateurs séparés A et B de 8 bits chacun. Il contenait aussi deux pointeurs de pile, l'un pour les programmes, l'autre pour le système d'exploitation, ainsi qu'un ''program counter''. Le registre de page était utilisé pour l'adressage absolu, comme vu dans le chapitre sur les modes d'adressage.

[[File:6809 Internal Registers.svg|centre|vignette|upright=2|6809 Internal Registers]]

Les processeurs IBM avaient autrefois plusieurs registres d'indice. Par exemple, l'IBM 704 avait trois registres d'indice de 15 bits. Leur contenu était soustrait de l'adresse absolue. Une instruction pouvait utiliser plusieurs registres d'indice pour adresser son opérande. Toute instruction utilisait trois bits pour sélectionner les registres d'indice utilisés. Fait assez original, lorsque plusieurs registres d'indice sont sélectionnés, le processeur n'additionne pas les trois registres à l'adresse de base. À la place, il fait un OU bit à bit entre les registres d'indice sélectionnés, et additionne le résultat à l'adresse.

Les processeurs IBM à accumulateur ont fait ça sur toute la gamme IBM 700/7000, pour des raisons de compatibilité. Les processeurs suivants avaient 7 registres d'indices, mais conservaient les trois bits pour adresser les registres d'indices. Ils pouvaient fonctionner dans deux modes. Le premier mode est plus intuitif : les trois bits précisent un registre d'indice parmi les 7, qui est additionné avec l'adresse absolue. La valeur zéro indique qu'aucun registre d'indice n'est utilisé, ce qui explique qu'il y a 7 registres d'indice et non 8. Un second mode, compatible avec l'IBM 704, fait un OU logique entre les registres d'indice sélectionnés. Seuls les trois premiers registres d'indices peuvent être sélectionnés dans ce mode. Il y a deux instructions pour changer de mode : une pour passer en mode compatible, l'autre pour le quitter pour l'autre mode.

Quelques rares processeurs à registres généraux ont utilisés des registres d'indice, en plus des registres généraux. Ce qui fait l'association que nous avons faite entre registres d'indice et architectures à accumulateur est imparfait, bien que solide sur le principe. Un exemple d'architecture de ce type sont les architectures de la série UNIVAC 1100/2200. Ils disposaient de 128 registres, qui étaient mappés en mémoire à partir de l'adresse mémoire 0, la majorité étant inaccessibles par le programmeur. Ils regroupaient 12 registres accumulateurs, 11 registres d'indice et 4 registres hybrides qui pouvaient servir soit de registre d'indice, soit de registres accumulateurs.

===La micro-architecture des architectures à accumulateur avec registres d'indice===

La présence de registres d'indice modifie grandement l'implémentation du processeur. En effet, il faut rajouter un banc de registre pour les registres d'indice. Le banc de registre est monoport, car on a besoin de lire ou d'écrire un indice à la fois. Et il faut aussi potentiellement rajouter de quoi faire les calculs d'adresse. Deux solutions sont possibles : une ALU dédiée aux calculs d'adresse, une seule ALU pour toutes les opérations.

Dans le premier cas, il y a une ALU séparée associée aux registres d'indice. L'ALU et les registres d'indice sont placés en sortie du séquenceur, en-dehors du chemin de données, la sortie de l'ALU est directement connectée au bus d'adresse. L'unité de calcul d'adresse peut être utilisée pour incrémenter le ''program counter''. Un défaut de cette approche est qu'elle ne gère pas l'adresse indirect à registre.

[[File:Chemin de données sans support des pointeurs, avec adressage absolu indicé.png|centre|vignette|upright=2|Chemin de données sans support des pointeurs, avec adressage absolu indicé]]

Une autre option utilise un bus interne, qui interconnecte tout le chemin de données. Dans sa version la plus simple, il est relié à l'accumulateur, l'unité de calcul, le banc de registre d'indice et le bus de données. Avec cette solution, l'ALU est utilisé à la fois pour calculer les adresses et pour les instructions de calcul. En reliant le bus interne au bus d'adresse à travers un multiplexeur, on gère naturellement les adressages indirects.

[[File:Architecture à accumulateur avec registres associés.png|centre|vignette|upright=2.5|Architecture à accumulateur avec registres associés]]

Il faut noter que sur les architectures Von Neumann, le séquenceur est relié à ce bus interne. En effet, charger une instruction demande de passer par le bus mémoire, donc par l’intermédiaire de ce bus internet. Le ''program counter'' est envoyé sur ce bus pour lire l'instruction, puis l'instruction lue est recopiée dans le registre d'instruction. Le chargement d'une instruction est donc géré comme une lecture des plus classiques. De plus, cela permet d'incrémenter le ''program counter'' au niveau de l'unité de calcul entière. Le ''program counter'' est envoyé sur le bus interne, incrémenté par l'ALU, puis le résultat est recopié dans le ''program counter'' via le bus interne.

[[File:Architecture à accumulateur avec bus unique de type Von Neumann.png|centre|vignette|upright=2|Architecture à accumulateur avec bus unique de type Von Neumann]]

==Les processeurs bi-accumulateurs : le Motorola 6800==

Le Motorola 6800 était un processeur 8 bits qui gérait des adresses de 16 bits. Il contenait deux accumulateurs nommés A et B, de 8 bits chacun. Il disposait aussi d'un registre d'indice, d'un pointeur de pile et d'un ''program counter'', tous les trois de 16 bits. Le registre d'état regroupait 6 bits, qu'on ne détaillera pas ici.

[[File:MC6800 Processor Diagram.png|centre|vignette|upright=2|Interface et registres du MC6800.]]

La présence des deux accumulateurs impactait surtout les instructions dyadiques. Les instructions monadiques avaient juste à préciser où se trouvait l'opérande : soit en RAM, soit dans le premier accumulateur, soit dans le second. Pour les opérations dyadiques, la gestion était totalement différente. En théorie, le premier opérande est dans un accumulateur, soit A, soit B. La seconde opérande vient soit de l'autre accumulateur, soit de la mémoire RAM. Et selon les instructions, tout variait.

Pour l'addition, il y avait trois instructions. Les deux premières additionnaient un opérande provenant de la mémoire avec un accumulateur. L'instruction ADDA sélectionnait le premier accumulateur, l'instruction ADDB sélectionnait le second accumulateur. Mais une troisième instruction, l’instruction ABA, permettait d'additionner le contenu des deux accumulateurs.

Pour les autres opérations, il n'était pas possible d'utiliser les deux accumulateurs en même temps. La seule possibilité était de faire une opération entre un accumulateur et un opérande venant de la mémoire. Toutes les instructions étaient en double, avec une copie par accumulateur. Par exemple, l'instruction ANDA faisait un ET entre l’accumulateur A et l'opérande mémoire, l'instruction ANDB faisait pareil avec l'accumulateur B.

==Les architectures hybrides registres-accumulateur==

Il a existé quelques architectures qui étaient des hybrides entre architectures à accumulateur et architecture à registre. Elles ont servi de transition entre les deux, durant les années 80-90. Elles avaient un accumulateur unique couplé à un banc de registres généraux. Par exemple, les premiers processeurs Intel 8 bits étaient des processeurs hybrides-accumulateur. Lles CPU Intel 8 bits disposaient de 7 registres de 8 bits nommés A, B, C, D, E, F, H, L, SP. Ils correspondent respectivement à :
* l'accumulateur A ;
* six registres nommés B, C, D, E, H et L ;
* le registre d'état F ;
* le pointeur de pile SP.

Sur ces processeurs, les instructions dyadiques devaient mettre leur premier opérande dans l'accumulateur, la seconde provenait soit des registres, soit de la RAM, soit d'une constante immédiate. Les opérations monadiques pouvaient lire leur opérande depuis l'accumulateur, les autres registres ou la RAM, tout était permis. Les registres d'indices disparaissaient sur ces architectures, en théorie. Les registres généraux pouvaient être utilisés comme registre d'indice ou pour stocker des opérandes, ils étaient assez versatiles pour servir de registres d'indices.

La présence de registres a de nombreux avantages, comparé aux architectures à accumulateur pures. Les instructions arithmétiques sont plus rapide, lire un registre étant plus rapide qu'un accès RAM. Les performances sont donc augmentées. De plus, les instructions arithmétiques utilisant ces registres sont plus courtes : pas besoin d'encoder une adresse mémoire, un nom de registre suffit. Vu que les processeurs de l’époque avaient des instructions de taille variable, cela améliorait la densité de code.

La microarchitecture de ces processeurs est très similaire à celle d'un processeur avec des registres d'indices. La seule différence est que le banc de registre contient des registres généraux et non des registres d'indices. Le banc de registre est systématiquement monoport, car il n'avait aucune raison d'être multiport. Pour les instructions dyadiques, seules à lire deux opérandes, il ne servait que pour la seconde opérande, la première était lue depuis l'accumulateur.

Les processeurs hybrides registre-accumulateur se classent en deux types principaux : ceux qui ont un seul bus interne, et ceux qui en ont deux. Le premier cas est identique à celui vu précédemment pour les architectures à accumulateur avec registres d'indice, à la seule différence est que le banc de registre contient des registres généraux et non des registres d'indices. Afin de gérer l'adressage indirect à registre, le bus interne est connecté aux deux registres d’interfaçage mémoire.

[[File:Architecture à accumulateur avec bus unique de type Von Neumann.png|centre|vignette|upright=2|Architecture à accumulateur avec bus unique de type Von Neumann]]

Notons que cela permet aussi d'implémenter facilement les branchements indirects, car le bus interne permet d'échanger des adresses entre ''program counter'' et banc de registre. De même, il est possible d'utiliser l'ALU pour gérer les branchements indirects., en plus de l'utiliser pour incrémenter le ''program counter''.

[[File:Single bus organization.jpg|centre|vignette|upright=2|Single bus organization]]

Une autre solution utilisait deux bus internes : un connecté au bus de données, un autre relié au bus d'adresse. Le bus de commande mémoire était lui commandé par le séquenceur, l'unité de contrôle. L'intermédiaire entre ces deux bus était le banc de registre, ainsi que les autres registres. Le banc de registre était connecté aux deux bus interne, avec un port de lecture relié au bus d'adresse, un port de lecture-écriture relié au bus de données. Le port de lecture était utilisé pour l'adressage indirect, l'autre l'était pour le reste.

[[File:Proz1-e.png|centre|vignette|upright=2|Intérieur d'un processeur.]]

L'organisation à deux bus simplifiait la gestion du ''program counter'' et le chargement des instructions. Le ''program counter'' était soit séparé du banc de registre, soit placé dans le banc de registre. Les deux solutions étaient utilisés, tout dépend du processeur. Il faut noter que si le ''program counter'' est intégré au banc de registres, alors la microarchitecture du processeur est bien plus simple. L'envoi du ''program counter'' sur le bus d'adresse utilise le port de lecture relié au bus d'adresse, qui sert aussi pour l'adressage indirect. L'économie de circuits, sans compter la simplicité d'implémentation que cela implique, explique sans doute que la technique a été utilisée sur quelques processeurs anciens.

Le ''program counter'' était généralement incrémenté par l'ALU, ce qui explique qu'il soit connecté au bus interne pour les données. La connexion est aussi utile pour gérer les branchements indirects, qui copient un registre dans le ''program counter'', ainsi que les branchements relatifs (addition dans l'ALU), voire les branchements directs (l'adresse vers laquelle brancher est envoyée en entrée de l'ALU et propagée en sortie avec une opération ''pass through'').

[[File:Connexion du program counter sur les bus avec PC dans le banc de registres.png|centre|vignette|upright=2|Connexion du program counter sur les bus avec PC dans le banc de registres]]

===Les registres d'interruption avec un processeur hybride-accumulateur : l'exemple du Z80===

Un exemple de processeur registre-accumulateur à deux bus interne est le Z80, un processeur fortement inspiré des CPU Intel 8 bits. Il a un jeu d'instruction similaire, mais a diverses améliorations par rapport au design original. Notamment, le processeur a des registres séparés pour les interruptions.

Sur le Z80, les registres généraux sont dupliqués avec 6 registres pour les interruptions et 6 registres pour les programmes autres. Leur copie pour les interruptions sont nommées B', C', D', E', H', L'. Les 12 registres sont placés dans le banc de registre, ce qui implique que le fenêtrage de registres est utilisé pour gérer la séparation entre registre d'interruption et normaux. Il faut noter que l'accumulateur et le registre d'état sont aussi dupliqués, leurs copies étant nommées A' et F'. Mais leur duplication se fait autrement que par fenêtrage de registre.

En plus des registres précédents, le Z80 incorporait deux registres d'indice nommés X et Y, ainsi qu'un pointeur de pile SP et un ''program counter'' PC. Ils n'étaient pas dupliqués pour les interruptions. Les registres d'indice étaient reliés à une unité de calcul d'adresse. L'unité de calcul d'adresse prenait deux opérandes : un indice, et une adresse mémoire provenant soit du banc de registre, soit de l'accumulateur. En clair, l'unité de calcul d'adresse faisait le lien entre les deux bus internet : le bus de données interne en entrée, le bus d'adresse en sortie.

À l'intérieur du processeur, tous les registres étaient regroupés dans un banc de registre unique, sauf les accumulateurs, les registres d'état et le ''program counter''. Bien que ce ne soit pas indiqué sur le schéma ci-dessous, le ''program counter'' est séparé du banc de registre, alors que le pointeur de pile est dedans. Le compteur IR est lui associé au ''program counter'', il est sortit du banc de registre. Le Z80 utilise lui aussi un incrémenteur séparé de l'ALU, qui est utilisé pour mettre à jour le ''program counter'', le pointeur de pile et un compteur de rafraichissement mémoire nommé IR sur le Z80 (pour rappel, le rafraichissement mémoire demande de balayer la mémoire d'adresse en adresse et été fait par le CPU à l'époque). De plus, il est utilisé pour les instructions INC et DEC qui incrémentent une opérande de 16 bits obtenue en combinant deux registres de 8 bits. En clair, l'incrémenteur du ''program counter'' a été réutilisé de beaucoup de manières originales.

[[File:Z80 arch.svg|centre|vignette|upright=3|Microarchitecture du Z80.]]

Le Z80 incorporait des instructions pour échanger le contenu des deux ensembles de registres, accumulateur inclus. Elles permettaient d'utiliser les registres d'interruption pour les programmes et réciproquement. En clair, cela doublait le nombre de registres si les interruptions n'étaient pas utilisées.
* L'instruction EXX échangeait les deux fenêtres de registres généraux : les registres B, C, D, E, H et L devenaient les registres B', C', D', E', H' et L' et inversement.
* L'instruction EX échangeait l'accumulateur et le registre d'état : les registres A,F devenait A',F' et inversement.

Le fenêtrage de registre était modifié par l'instruction EXX, qui échangeait les deux fenêtres de registres. Pour l'implémenter, une bascule était ajouté au processeur, appelons-la la bascule INT. Elle était relié au bus d'adresse du banc de registre, dont elle mémorisait le bit de poids fort. L'instruction EXX inversait la valeur de la bascule INT. Il est aussi possible d'échanger le contenu des registres D,E et H,L avec une instruction dédiée, ce qui est là encore fait par deux bascules : une pour les registres D,E et une autre pour les registres H,L.

Pour l'accumulateur et le registre d'état, le choix entre registre normal et registre d'interruption se faisait là encore par une seconde bascule appelée la bascule A. La bascule est reliée à un multiplexeur et un démultiplexeur, qui permet de choisir quel accumulateur relier à l'unité de calcul. L'instruction EX inverse le contenu de la bascule A.

&lt;noinclude&gt;
{{NavChapitre | book=Fonctionnement d'un ordinateur
           | prev=L'unité de contrôle
           | prevText=L'unité de contrôle
           | next=Les processeurs 8 bits et moins
           | nextText=Les processeurs 8 bits et moins
}}
&lt;/noinclude&gt;</text>
      <sha1>kqnefcjy1a2i92ec6iisa6ryw66pb6y</sha1>
    </revision>
    <revision>
      <id>744139</id>
      <parentid>744137</parentid>
      <timestamp>2025-06-05T00:34:32Z</timestamp>
      <contributor>
        <username>Mewtow</username>
        <id>31375</id>
      </contributor>
      <minor />
      <comment>/* Annexe : les toutes premières architectures à accumulateur : le Manchester Baby */</comment>
      <origin>744139</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="37222" sha1="5b01xh2gbldnexgdfz9lwpr6gg9tbwn" xml:space="preserve">Les architectures que nous avons vu précédemment dans ce cours disposent de registres pour les données, en plus du pointeur de pile, d'un ''program counter'', et de quelques autres. Elles sont appelées des '''architectures à registres''', terme qui trahit bien le fait qu'elles ont des registres généraux ou spécialisés pour stocker temporairement des données. Et si on leur a donné un nom, c'est parce qu'il existe des architectures qui ne sont pas dans cette catégorie. Il en existe plusieurs types, mais ce chapitre va se concentrer sur les '''architectures à accumulateur'''.

[[File:Isaccumulator.png|vignette|Architecture à accumulateur.]]

Les architectures à accumulateur sont centrées autour d'un registre architectural appelé l''''accumulateur'''. Il est utilisé pour toutes les opérations arithmétiques dyadiques, où il sert à la fois de source et de destination. Toutes les instructions dyadiques sont de type ''load-op'' : une opérande est lue depuis l'accumulateur, le second opérande est lu depuis la mémoire RAM, le résultat de l'instruction est automatiquement mémorisé dans l'accumulateur. Les instructions monadiques peuvent utiliser un opérande dans l'accumulateur, ou dans la mémoire RAM, les deux sont théoriquement possibles.

La conséquence est que le nombre d'accès mémoire est drastiquement diminué : de 3 par instructions sur une architecture mémoire-mémoire, on passe à seulement un avec un accumulateur. Les opérations dyadiques ont besoin d'un seul accès mémoire pour lire la seconde opérande, les opérations monadique en font aussi un seul pour lire leur unique opérande.

{|class=&quot;wikitable&quot;
|-
! Classe d'architecture
! Nombre d'accès mémoire par opération dyadique
|-
|-
! Architecture à accumulateur
| Un accès mémoire par instruction, pour lire la seconde opérande
|-
! Architecture à registres
| Zéro si les opérandes sont dans les registres, un pour les opérations ''load-op'', LOAD et STORE.
|}

==Le jeu d'instruction des architectures à accumulateur sans registres d'indice==

L'accumulateur est adressé grâce au mode d'adressage implicite, de même que le résultat de l'opération. Par contre, les autres opérandes sont localisés avec d'autres modes d'adressage, et lues en mémoire RAM. Le résultat ainsi qu'un des opérandes sont adressés de façon implicite car dans l'accumulateur, seule la seconde opérande étant adressée directement. Grâce à l'accumulateur, une instruction ne fait qu'un seul accès mémoire maximum, ce qui rend le processeur très facile à implémenter.

===Les registres des anciennes architectures à accumulateur===

[[File:IBM 701console.jpg|vignette|IBM 701, console extérieure.]]

Les architectures à accumulateur étaient communes dans les années 50-60. A l'époque, les ordinateurs étaient gigantesques, ils prenaient une pièce de bâtiment entière dans le pire des cas, une armoire entière dans le meilleur. Les ordinateurs de l'époque étaient surtout utilisés pour du calcul scientifique ou des tâches d’ingénierie demandant beaucoup de calcul, rarement pour de la compatibilité.

Les nombres flottants n'étaient pas encore apparus. A la place, les ordinateurs de l'époque géraient des nombres entiers de grande taille, de 30 bits ou plus. En conséquence, l'accumulateur faisait facilement 30 à 60 bits. Par exemple, les ordinateurs de la Série scientifique IBM 700/7000 géraient des entiers de 36 bits, l’accumulateur faisait 38 bits : 36 bits plus deux bits pour les débordements. Au passage, de tels processeurs utilisaient l'adressage par mot, et non par byte.

Historiquement, les premières architectures à accumulateur ne contenaient aucun autre registre que l'accumulateur. Ce n'est que dans les années 60 que de nombreuses architectures à accumulateur ont ajouté un second '''registre pour les multiplication/divisions'''. Un exemple est celui de l'IBM 701, qui incorporait un registre accumulateur de 38 bits et un registre multiplieur de 36 bits. Le registre mémorise le multiplieur lors d'une opération de multiplication. Il mémorise donc un opérande, pas le résultat. Il peut aussi décaler le multiplieur vers la droite/gauche, ce qui est utile pour exécuter la multiplication. C'est ce qui est fait sur l'IBM 7094.

Une autre possibilité est que ce registre mémorise une partie du résultat de l'opération. Pour rappel, le résultat d'une multiplication/division est codé sur deux fois de bits que ses opérandes. Par exemple, multipliez deux opérandes de 30 bits, vous obtiendrez un résultat de 60 bits. Les 30 bits de poids faible du résultat vont dans l'accumulateur, les 30 bits de poids fort vont dans ce second registre.

Les architectures à accumulateur parfois un '''registre pour le pointeur de pile''', utilisé pour gérer les fonctions/procédures. Les architectures à accumulateurs supportaient une pile d'adresse de retour, souvent une pile d'appel. Mais pour cela, il fallait mémoriser le pointeur de pile dans le processeur, ce qui demandait un registre dédié.

===L'adressage indirect avec l'accumulateur===

Les instructions LOAD et STORE existent bel et bien sur les architectures à accumulateur, mais n'ont pas les mêmes modes d'adressages. L'instruction LOAD copie une donnée de la RAM vers l'accumulateur, l'instruction STORE copie l'accumulateur dans une adresse. Les deux instructions n'ont pas besoin d'adresser l'accumulateur, qui est adressé de manière implicite, juste de préciser l'adresse à lire/écrire.

Les architectures à accumulateur supportaient souvent le mode d'adressage indirect mémoire. Un exemple est celui des ordinateurs Data General Nova, qui sont des architectures à accumulateur et qui supportaient ce mode d'adressage. Les deux instructions LOAD et STORE existaient en deux versions, distinguées par un bit d'indirection. Si ce bit est à 0 dans l'opcode, alors l'instruction utilise le mode d'adressage absolu normal : l'adresse intégrée dans l'instruction est celle de la donnée. Mais s'il est à 1, alors l'adresse intégrée dans l'instruction est celle du pointeur.

Cependant, la présence de l'accumulateur permettait d'utiliser l'adressage indirect à registre, pour gérer les pointeurs. Pour rappel, avec le mode d'adressage indirect à registre, l'adresse à lire/écrire est dans un registre. Ici, l'adresse à lire/écrire est prise dans l'accumulateur, seul registre disponible pour. L'adressage indirect est plus simple à implémenter pour l'instruction LOAD, car elle prend un seul opérande : l'adresse à lire. L'adresse à lire est placée dans l'accumulateur, la donnée lue est elle aussi chargée dans l'accumulateur. Pour l'instruction STORE, il faut fournir deux opérandes, l'adresse et la donnée à écrire, ce qui peut poser problème. Mais au pire, il est toujours possible d'utiliser l'adressage absolu ou indirect mémoire : l'adresse est dans l'instruction, la donnée à écrire dans l'accumulateur.

===L'encodage des instructions===

Sur une architecture à accumulateur l'encodage d'une instruction dyadique est assez simple, vu que l'accumulateur est adressé implicitement. La seconde opérande est localisée soit par une adresse mémoire (adressage absolu), soit est une constante (adressage immédiat). L'adresse mémoire est généralement assez longue, plus que l'opcode.

{|class=&quot;wikitable&quot;
|+ Encodage d'une instruction dyadique
|-
! rowspan=&quot;2&quot; | Opcode 
| Adresse mémoire (adressage absolu)
|-
| Constante (adressage immédiat)
|}

L'encodage d'une instruction monadique est similaire. Si l'opérande est lue depuis la mémoire RAM, alors l'instruction est encodée comme une instruction dyadique. Il en est de même pour les instructions qui copient une constante dans l'accumulateur. Par contre, si l'opérande est dans l'accumulateur, alors il y a juste besoin d'encoder l'opcode. La majorité des instructions a besoin de préciser une adresse, rares sont celles qui s'en passent. Au vu de cet encodage, les architectures à accumulateur sont qualifiées d''''architectures à une adresse''' par abus de langage.

Il est intéressant de contraster leur encodage avec les architectures à registres. Les architectures à registre doivent encoder deux opérandes en plus de l'opcode, avec éventuellement où enregistrer le résultat sur les architectures 3-adresses. Par contre, les opérandes sont généralement des noms de registre, ce qui prend moins de place qu'une adresse mémoire. A la rigueur, les instructions avec une constante immédiate prennent un peu plus de place, car elles doivent encoder un nom de registre en plus de la constante et de l'opcode. Les instructions ''load-op'' des processeurs CISC sont un peu dans le même cas, sauf qu'il faut remplacer la constante par une adresse, qui a généralement la même taille. Les instructions sont donc en moyenne plus courte sur les processeurs à registre, du fait de la présence de registres.

===Annexe : les toutes premières architectures à accumulateur : le Manchester Baby===

[[File:BabyArchitecture.png|vignette|Architecture de la Manchester Baby.]]

Les architectures à accumulateurs sont apparues dès les débuts de l'informatique. Le tout premier ordinateur à programme enregistré en mémoire, le ''Manchester Baby'', était une architecture à accumulateur. Niveau interface, l'ordinateur avait une console avec 32 boutons, des interrupteurs et un écran de sortie sur lequel afficher les résultats. A l'intérieur, il y avait un processeur et une RAM de 32 adresses de 32 bits, fabriquée avec des tubes Williams (abordés dans une annexe à la fin du cours).

Le programme devait tenir dans la RAM, avec une instruction par adresse maximum, ce qui limitait les programmes à 32 instructions maximum. Une instruction prenait donc 32 bits, 3 indiquaient quelle opération utiliser, 12 servait à indiquer où se trouvent les opérandes en RAM, les 16 restants sont inutilisés.

Le processeur avait un registre accumulateur de 32 bits, un ''program counter'' et un registre d'instruction. Il gérait 8 instructions en tout, mais ne gérait pas l'addition. Il gérait la soustraction, des instructions de branchement et d'accès mémoire, rien d'autre. Il pouvait cependant émuler l'addition à partir d'une soustraction et inversant l'opérande soustraite.

Le Manchester Mark 1 était une amélioration du Manchester Baby. Il utilisait 4500 tubes à vide. L'ordinateur gérait des nombres de 40 bits, mais les instructions étaient codées sur 20 bits. La RAM avait la même taille, à savoir 32 nombres, leur taille était simplement augmentée. Par contre, la RAM était complémentée par l’ancêtre du disque dur magnétique, à savoir un tambour magnétique, l’ancêtre du disque dur magnétique. Il contenait 40 pages, chacune ayant la même taille que la RAM. C'était là encore une architecture à accumulateur, sauf qu'elle intégrait aussi des registres d'indice. Et surtout : son processeur gérait l'addition et quelques opérations logiques (ET et OU), en plus de la soustraction et de la comparaison.

[[File:MM1Schematic French.svg|centre|vignette|upright=2.5|Architecture de la Manchester Mark 1.]]

==La micro-architecture des architectures à accumulateur sans registres d'indice==

L'organisation interne d'une architecture à accumulateur est très différente de celle des processeurs à registre. Elle est plus ou moins la même pour tous ces processeurs, le point important étant que le chemin de données se résume à une ALU, un registre accumulateur et le bus de données. L'ALU est reliée au registre accumulateur, ainsi qu'au bus de données pour lire la seconde opérande, comme illustré ci-dessous.

[[File:Accumulator.png|centre|vignette|upright=2|Accumulateur.]]

===L'unité de calcul et l'accumulateur===

Pour simplifier l'implémentation, le résultat est mémorisé dans un registre en sortie de l'unité de calcul. La raison est qu'on ne veut pas altérer l'accumulateur tant que le résultat final n'est pas totalement calculé. Rappelons que l'ALU ne fournit pas un résultat d'un seul bloc, mais que certains bits arrivent avant les autres, typiquement les bits de poids faible. Si le résultat était écrit dans l'accumulateur directement, il écraserait des bits de l’opérande en cours d'utilisation, ce qui fausserait le résultat.

[[File:Accumulateur avec registre de sortie.png|centre|vignette|upright=2|Accumulateur avec registre de sortie]]

Une autre solution utilisait un registre entre l'accumulateur et l'unité de calcul, appelé l’'''''accumulator latch'''''. Il remplace le registre en sortie de l'ALU, dans le sens où il permet d'écrire dans l'accumulateur sans effacer l'opérande, pendant que l’opération est en cours dans l'ALU. L'accumulateur est copié dans l’''accumulator latch'', avant que l'ALU démarre ses calculs. L'opérande est donc maintenue même si on commence à écrire le résultat dans l'accumulateur.

Sur le 8085 d'Intel, l’''accumulator latch'' peut être initialisé avec une constante prédéfinie, ce qui permet d'implémenter certaines instructions très facilement. Par exemple, il peut être initialisé à 0, ce qui permet d'implémenter les instructions MOV et INC (incrémentation). Un MOV est équivalent à faire un OU entre le registre lu et 0. Une instruction INC initialise l'entrée de retenue de l'unité de calcul à 1, puis ajoute 0. La décrémentation est implémentée de la même manière, sauf que l’''accumulator latch'' est initialisé à -2 pour compenser l'entrée de retenue à 1. De plus, pour supporter les conversion de décimal à BCD, l’''accumulator latch'' peut être initialisé avec les constantes 0x00, 0x06, 0x60, or 0x66. L'''accumulator latch'' est relié à divers fils de commande provenant de l'unité de contrôle, qui décide quelle valeur d'initialisation utiliser en fonction de l'instruction décodée.

[[File:Accumulator latch.png|centre|vignette|upright=2|Accumulator latch]]

[[File:Chemin de données à un seul bus.png|vignette|Chemin de données à un seul bus]]

De même, la seconde opérande, celle lue sur le bus de données, est mémorisée dans un registre en amont de l'ALU. C'était notamment très utile si le processeur utilisait une ALU plus courte que les opérandes, avec par exemple une ALU 4 bits pour un CPU 8 bits. Les anciens processeurs à accumulateur de type ''mainframe'' utilisaient des opérandes de grande taille, du genre 36 ou 48 bits, ce qui avait des conséquences sur l'unité de calcul utilisée, ainsi que sur la communication avec la mémoire. Il arrivait que de tels processeurs utilisaient des ALU sérielles, ou du moins octet-sérielles, plutôt qu'une véritable ALU 36 bits. Nous verrons aussi que c'est très utile sur les processeurs à accumulateur avec un bus interne unique, dans la suite du chapitre.

===La micro-architecture des architectures à accumulateur avec instructions LOAD/STORE===

Nous venons de voir comment est implémenté l'unité de calcul et l'accumulateur, et comment le tout est relié au bus de données. Mais cela ne permet que d'avoir un processeur à accumulateur rudimentaire, qui ne gére que des instructions arithmétiques et logiques. Il faut aussi gérer le cas des opérations LOAD/STORE et des modes d'adressages associés, mais c'est le séquenceur qui s'en occupe. Avec l'adressage absolu, les instructions LOAD et STORE ne font que connecter l'accumulateur au bus de données. L'instruction STORE nécessite de connecter l'accumulateur au bus de données, de manière à ce que le transfert des données se fasse de l'accumulateur vers le bus de données. L'instruction LOAD s'implémente de la même manière, sauf que le sens de transfert est inversé.

Cependant, il existe une optimisation qui permet d'implémenter l'instruction LOAD sans ajouter de circuits. Pour cela, il suffit que l'unité de calcul gére les opérations ''pass through'', à savoir des opérations qui se contentent de recopier un opérande sur la sortie. Ici, l'idée est de recopier l'opérande provenant du bus de données.

[[File:Architecture à accumulateur, microarchitecture.png|centre|vignette|upright=2|Architecture à accumulateur, microarchitecture]]

Pour gérer nativement l'adressage indirect à registre, il suffit de connecter l'accumulateur au bus d'adresse. Le plus simple est d'ajouter un multiplexeur, comme illustré ci-dessous. La donnée lue est copiée dans l'accumulateur, ce qui fait qu'il vaut mieux utiliser un registre d’interfaçage, l'accumulateur n'étant pas utilisable à la fois pour le bus d'adresse et de données.

[[File:Adressage indirect sur une architecture à accumulateur.png|centre|vignette|upright=2|Adressage indirect sur une architecture à accumulateur]]

Pour finir, voyons comment le pointeur de pile et le ''program counter'' sont implémentés. Les architectures à accumulateur ont souvent des adresses de taille différente des données, ce qui fait qu'il vaut mieux utiliser un circuit incrémenteur dédié pour incrémenter le ''program counter'', plutôt que de l'incrémenter via l'unité de calcul. Les architectures à accumulateur ont parfois un pointeur de pile, qui gère une pile d'adresse de retour, pas une vraie pile d'appel. Aussi, le pointeur de pile est censé être incrémenté et décrémenté, pas plus. Pas d'addition ou de soustraction pour gérer des cadres de pile. Là encore, c'est la solution de l'incrémenteur séparé qui est retenue. Pour économiser des transistors, il n'y a qu'un seul incrémenteur partagé pour les deux.

==Les architectures à accumulateur à registres d'indice==

Les architectures à accumulateur décrites dans la section précédente sont capables de faire de l'adressage indirect, mais n'incluent pas les modes d'adressage base + indice et absolus indicés, qui prennent une adresse et y ajoute un indice. Il s'agit des toutes premières architectures à accumulateur, comme les premiers ordinateurs IBM ou le fameux PDP-8. Mais par la suite, les processeurs à accumulateurs ont inclus un support des modes d'adressages indicés, grâce à des '''registres d'indice'''.

===Les registres d'indice===

Les registres d'indice stockent des indices de tableaux. Ils permettaient de supporter deux modes d'adressage :
* Le '''mode d'adressage absolu indicé''' où une adresse fixe est additionnée à un indice variable. L'adresse fixe est intégrée dans l'instruction (adressage absolu), l'indice est dans un registre d'indice.
* Le '''mode d'adressage base + indice''', où l'adresse est dans l'accumulateur et l'indice dans le registre d'indice.

Les processeurs à accumulateur supportaient souvent des variantes des modes d'adressage précédents, où le registre d'indice était automatiquement incrémenté ou décrémenté à chaque utilisation.

Au départ, ces processeurs n'utilisaient qu'un seul registre d'indice qui se comportait comme un second accumulateur spécialisé dans les calculs d'adresses mémoire. Le processeur supportait de nouvelles instructions qui utilisaient ce registre d'indice de façon implicite. Mais avec le temps, les processeurs finirent par incorporer plusieurs de ces registres. Les instructions de lecture ou d'écriture devaient alors préciser quel registre d'indice utiliser, en précisant un nom de registre d'indice, un numéro de registre d'indice.

Il faut préciser que les registres d'indice ont une taille bien plus petite que l'accumulateur. Ils mémorisent des indices codés sur 16 bits ou moins, alors que l'accumulateur faisait typiquement 36 à 48 bits, parfois plus. La taille classique sur les anciens ''mainframes'' était de 15 bits, parfois moins. Il n'était pas rare de tomber sur des registres d'indice de 8 ou 9 bits. Leur petite taille rendait leur implémentation matérielle peu couteuse. Et c'est ce qui explique qu'ils étaient préférés à l'usage d'un second accumulateur.

Un exemple est le cas du processeur Motorola 6809, un processeur à accumulateur qui contient deux registres d'indices nommés X et Y. L'accumulateur est noté D et fait 16 bits, il peut être parfois géré comme deux accumulateurs séparés A et B de 8 bits chacun. Il contenait aussi deux pointeurs de pile, l'un pour les programmes, l'autre pour le système d'exploitation, ainsi qu'un ''program counter''. Le registre de page était utilisé pour l'adressage absolu, comme vu dans le chapitre sur les modes d'adressage.

[[File:6809 Internal Registers.svg|centre|vignette|upright=2|6809 Internal Registers]]

Les processeurs IBM avaient autrefois plusieurs registres d'indice. Par exemple, l'IBM 704 avait trois registres d'indice de 15 bits. Leur contenu était soustrait de l'adresse absolue. Une instruction pouvait utiliser plusieurs registres d'indice pour adresser son opérande. Toute instruction utilisait trois bits pour sélectionner les registres d'indice utilisés. Fait assez original, lorsque plusieurs registres d'indice sont sélectionnés, le processeur n'additionne pas les trois registres à l'adresse de base. À la place, il fait un OU bit à bit entre les registres d'indice sélectionnés, et additionne le résultat à l'adresse.

Les processeurs IBM à accumulateur ont fait ça sur toute la gamme IBM 700/7000, pour des raisons de compatibilité. Les processeurs suivants avaient 7 registres d'indices, mais conservaient les trois bits pour adresser les registres d'indices. Ils pouvaient fonctionner dans deux modes. Le premier mode est plus intuitif : les trois bits précisent un registre d'indice parmi les 7, qui est additionné avec l'adresse absolue. La valeur zéro indique qu'aucun registre d'indice n'est utilisé, ce qui explique qu'il y a 7 registres d'indice et non 8. Un second mode, compatible avec l'IBM 704, fait un OU logique entre les registres d'indice sélectionnés. Seuls les trois premiers registres d'indices peuvent être sélectionnés dans ce mode. Il y a deux instructions pour changer de mode : une pour passer en mode compatible, l'autre pour le quitter pour l'autre mode.

Quelques rares processeurs à registres généraux ont utilisés des registres d'indice, en plus des registres généraux. Ce qui fait l'association que nous avons faite entre registres d'indice et architectures à accumulateur est imparfait, bien que solide sur le principe. Un exemple d'architecture de ce type sont les architectures de la série UNIVAC 1100/2200. Ils disposaient de 128 registres, qui étaient mappés en mémoire à partir de l'adresse mémoire 0, la majorité étant inaccessibles par le programmeur. Ils regroupaient 12 registres accumulateurs, 11 registres d'indice et 4 registres hybrides qui pouvaient servir soit de registre d'indice, soit de registres accumulateurs.

===La micro-architecture des architectures à accumulateur avec registres d'indice===

La présence de registres d'indice modifie grandement l'implémentation du processeur. En effet, il faut rajouter un banc de registre pour les registres d'indice. Le banc de registre est monoport, car on a besoin de lire ou d'écrire un indice à la fois. Et il faut aussi potentiellement rajouter de quoi faire les calculs d'adresse. Deux solutions sont possibles : une ALU dédiée aux calculs d'adresse, une seule ALU pour toutes les opérations.

Dans le premier cas, il y a une ALU séparée associée aux registres d'indice. L'ALU et les registres d'indice sont placés en sortie du séquenceur, en-dehors du chemin de données, la sortie de l'ALU est directement connectée au bus d'adresse. L'unité de calcul d'adresse peut être utilisée pour incrémenter le ''program counter''. Un défaut de cette approche est qu'elle ne gère pas l'adresse indirect à registre.

[[File:Chemin de données sans support des pointeurs, avec adressage absolu indicé.png|centre|vignette|upright=2|Chemin de données sans support des pointeurs, avec adressage absolu indicé]]

Une autre option utilise un bus interne, qui interconnecte tout le chemin de données. Dans sa version la plus simple, il est relié à l'accumulateur, l'unité de calcul, le banc de registre d'indice et le bus de données. Avec cette solution, l'ALU est utilisé à la fois pour calculer les adresses et pour les instructions de calcul. En reliant le bus interne au bus d'adresse à travers un multiplexeur, on gère naturellement les adressages indirects.

[[File:Architecture à accumulateur avec registres associés.png|centre|vignette|upright=2.5|Architecture à accumulateur avec registres associés]]

Il faut noter que sur les architectures Von Neumann, le séquenceur est relié à ce bus interne. En effet, charger une instruction demande de passer par le bus mémoire, donc par l’intermédiaire de ce bus internet. Le ''program counter'' est envoyé sur ce bus pour lire l'instruction, puis l'instruction lue est recopiée dans le registre d'instruction. Le chargement d'une instruction est donc géré comme une lecture des plus classiques. De plus, cela permet d'incrémenter le ''program counter'' au niveau de l'unité de calcul entière. Le ''program counter'' est envoyé sur le bus interne, incrémenté par l'ALU, puis le résultat est recopié dans le ''program counter'' via le bus interne.

[[File:Architecture à accumulateur avec bus unique de type Von Neumann.png|centre|vignette|upright=2|Architecture à accumulateur avec bus unique de type Von Neumann]]

==Les processeurs bi-accumulateurs : le Motorola 6800==

Le Motorola 6800 était un processeur 8 bits qui gérait des adresses de 16 bits. Il contenait deux accumulateurs nommés A et B, de 8 bits chacun. Il disposait aussi d'un registre d'indice, d'un pointeur de pile et d'un ''program counter'', tous les trois de 16 bits. Le registre d'état regroupait 6 bits, qu'on ne détaillera pas ici.

[[File:MC6800 Processor Diagram.png|centre|vignette|upright=2|Interface et registres du MC6800.]]

La présence des deux accumulateurs impactait surtout les instructions dyadiques. Les instructions monadiques avaient juste à préciser où se trouvait l'opérande : soit en RAM, soit dans le premier accumulateur, soit dans le second. Pour les opérations dyadiques, la gestion était totalement différente. En théorie, le premier opérande est dans un accumulateur, soit A, soit B. La seconde opérande vient soit de l'autre accumulateur, soit de la mémoire RAM. Et selon les instructions, tout variait.

Pour l'addition, il y avait trois instructions. Les deux premières additionnaient un opérande provenant de la mémoire avec un accumulateur. L'instruction ADDA sélectionnait le premier accumulateur, l'instruction ADDB sélectionnait le second accumulateur. Mais une troisième instruction, l’instruction ABA, permettait d'additionner le contenu des deux accumulateurs.

Pour les autres opérations, il n'était pas possible d'utiliser les deux accumulateurs en même temps. La seule possibilité était de faire une opération entre un accumulateur et un opérande venant de la mémoire. Toutes les instructions étaient en double, avec une copie par accumulateur. Par exemple, l'instruction ANDA faisait un ET entre l’accumulateur A et l'opérande mémoire, l'instruction ANDB faisait pareil avec l'accumulateur B.

==Les architectures hybrides registres-accumulateur==

Il a existé quelques architectures qui étaient des hybrides entre architectures à accumulateur et architecture à registre. Elles ont servi de transition entre les deux, durant les années 80-90. Elles avaient un accumulateur unique couplé à un banc de registres généraux. Par exemple, les premiers processeurs Intel 8 bits étaient des processeurs hybrides-accumulateur. Lles CPU Intel 8 bits disposaient de 7 registres de 8 bits nommés A, B, C, D, E, F, H, L, SP. Ils correspondent respectivement à :
* l'accumulateur A ;
* six registres nommés B, C, D, E, H et L ;
* le registre d'état F ;
* le pointeur de pile SP.

Sur ces processeurs, les instructions dyadiques devaient mettre leur premier opérande dans l'accumulateur, la seconde provenait soit des registres, soit de la RAM, soit d'une constante immédiate. Les opérations monadiques pouvaient lire leur opérande depuis l'accumulateur, les autres registres ou la RAM, tout était permis. Les registres d'indices disparaissaient sur ces architectures, en théorie. Les registres généraux pouvaient être utilisés comme registre d'indice ou pour stocker des opérandes, ils étaient assez versatiles pour servir de registres d'indices.

La présence de registres a de nombreux avantages, comparé aux architectures à accumulateur pures. Les instructions arithmétiques sont plus rapide, lire un registre étant plus rapide qu'un accès RAM. Les performances sont donc augmentées. De plus, les instructions arithmétiques utilisant ces registres sont plus courtes : pas besoin d'encoder une adresse mémoire, un nom de registre suffit. Vu que les processeurs de l’époque avaient des instructions de taille variable, cela améliorait la densité de code.

La microarchitecture de ces processeurs est très similaire à celle d'un processeur avec des registres d'indices. La seule différence est que le banc de registre contient des registres généraux et non des registres d'indices. Le banc de registre est systématiquement monoport, car il n'avait aucune raison d'être multiport. Pour les instructions dyadiques, seules à lire deux opérandes, il ne servait que pour la seconde opérande, la première était lue depuis l'accumulateur.

Les processeurs hybrides registre-accumulateur se classent en deux types principaux : ceux qui ont un seul bus interne, et ceux qui en ont deux. Le premier cas est identique à celui vu précédemment pour les architectures à accumulateur avec registres d'indice, à la seule différence est que le banc de registre contient des registres généraux et non des registres d'indices. Afin de gérer l'adressage indirect à registre, le bus interne est connecté aux deux registres d’interfaçage mémoire.

[[File:Architecture à accumulateur avec bus unique de type Von Neumann.png|centre|vignette|upright=2|Architecture à accumulateur avec bus unique de type Von Neumann]]

Notons que cela permet aussi d'implémenter facilement les branchements indirects, car le bus interne permet d'échanger des adresses entre ''program counter'' et banc de registre. De même, il est possible d'utiliser l'ALU pour gérer les branchements indirects., en plus de l'utiliser pour incrémenter le ''program counter''.

[[File:Single bus organization.jpg|centre|vignette|upright=2|Single bus organization]]

Une autre solution utilisait deux bus internes : un connecté au bus de données, un autre relié au bus d'adresse. Le bus de commande mémoire était lui commandé par le séquenceur, l'unité de contrôle. L'intermédiaire entre ces deux bus était le banc de registre, ainsi que les autres registres. Le banc de registre était connecté aux deux bus interne, avec un port de lecture relié au bus d'adresse, un port de lecture-écriture relié au bus de données. Le port de lecture était utilisé pour l'adressage indirect, l'autre l'était pour le reste.

[[File:Proz1-e.png|centre|vignette|upright=2|Intérieur d'un processeur.]]

L'organisation à deux bus simplifiait la gestion du ''program counter'' et le chargement des instructions. Le ''program counter'' était soit séparé du banc de registre, soit placé dans le banc de registre. Les deux solutions étaient utilisés, tout dépend du processeur. Il faut noter que si le ''program counter'' est intégré au banc de registres, alors la microarchitecture du processeur est bien plus simple. L'envoi du ''program counter'' sur le bus d'adresse utilise le port de lecture relié au bus d'adresse, qui sert aussi pour l'adressage indirect. L'économie de circuits, sans compter la simplicité d'implémentation que cela implique, explique sans doute que la technique a été utilisée sur quelques processeurs anciens.

Le ''program counter'' était généralement incrémenté par l'ALU, ce qui explique qu'il soit connecté au bus interne pour les données. La connexion est aussi utile pour gérer les branchements indirects, qui copient un registre dans le ''program counter'', ainsi que les branchements relatifs (addition dans l'ALU), voire les branchements directs (l'adresse vers laquelle brancher est envoyée en entrée de l'ALU et propagée en sortie avec une opération ''pass through'').

[[File:Connexion du program counter sur les bus avec PC dans le banc de registres.png|centre|vignette|upright=2|Connexion du program counter sur les bus avec PC dans le banc de registres]]

===Les registres d'interruption avec un processeur hybride-accumulateur : l'exemple du Z80===

Un exemple de processeur registre-accumulateur à deux bus interne est le Z80, un processeur fortement inspiré des CPU Intel 8 bits. Il a un jeu d'instruction similaire, mais a diverses améliorations par rapport au design original. Notamment, le processeur a des registres séparés pour les interruptions.

Sur le Z80, les registres généraux sont dupliqués avec 6 registres pour les interruptions et 6 registres pour les programmes autres. Leur copie pour les interruptions sont nommées B', C', D', E', H', L'. Les 12 registres sont placés dans le banc de registre, ce qui implique que le fenêtrage de registres est utilisé pour gérer la séparation entre registre d'interruption et normaux. Il faut noter que l'accumulateur et le registre d'état sont aussi dupliqués, leurs copies étant nommées A' et F'. Mais leur duplication se fait autrement que par fenêtrage de registre.

En plus des registres précédents, le Z80 incorporait deux registres d'indice nommés X et Y, ainsi qu'un pointeur de pile SP et un ''program counter'' PC. Ils n'étaient pas dupliqués pour les interruptions. Les registres d'indice étaient reliés à une unité de calcul d'adresse. L'unité de calcul d'adresse prenait deux opérandes : un indice, et une adresse mémoire provenant soit du banc de registre, soit de l'accumulateur. En clair, l'unité de calcul d'adresse faisait le lien entre les deux bus internet : le bus de données interne en entrée, le bus d'adresse en sortie.

À l'intérieur du processeur, tous les registres étaient regroupés dans un banc de registre unique, sauf les accumulateurs, les registres d'état et le ''program counter''. Bien que ce ne soit pas indiqué sur le schéma ci-dessous, le ''program counter'' est séparé du banc de registre, alors que le pointeur de pile est dedans. Le compteur IR est lui associé au ''program counter'', il est sortit du banc de registre. Le Z80 utilise lui aussi un incrémenteur séparé de l'ALU, qui est utilisé pour mettre à jour le ''program counter'', le pointeur de pile et un compteur de rafraichissement mémoire nommé IR sur le Z80 (pour rappel, le rafraichissement mémoire demande de balayer la mémoire d'adresse en adresse et été fait par le CPU à l'époque). De plus, il est utilisé pour les instructions INC et DEC qui incrémentent une opérande de 16 bits obtenue en combinant deux registres de 8 bits. En clair, l'incrémenteur du ''program counter'' a été réutilisé de beaucoup de manières originales.

[[File:Z80 arch.svg|centre|vignette|upright=3|Microarchitecture du Z80.]]

Le Z80 incorporait des instructions pour échanger le contenu des deux ensembles de registres, accumulateur inclus. Elles permettaient d'utiliser les registres d'interruption pour les programmes et réciproquement. En clair, cela doublait le nombre de registres si les interruptions n'étaient pas utilisées.
* L'instruction EXX échangeait les deux fenêtres de registres généraux : les registres B, C, D, E, H et L devenaient les registres B', C', D', E', H' et L' et inversement.
* L'instruction EX échangeait l'accumulateur et le registre d'état : les registres A,F devenait A',F' et inversement.

Le fenêtrage de registre était modifié par l'instruction EXX, qui échangeait les deux fenêtres de registres. Pour l'implémenter, une bascule était ajouté au processeur, appelons-la la bascule INT. Elle était relié au bus d'adresse du banc de registre, dont elle mémorisait le bit de poids fort. L'instruction EXX inversait la valeur de la bascule INT. Il est aussi possible d'échanger le contenu des registres D,E et H,L avec une instruction dédiée, ce qui est là encore fait par deux bascules : une pour les registres D,E et une autre pour les registres H,L.

Pour l'accumulateur et le registre d'état, le choix entre registre normal et registre d'interruption se faisait là encore par une seconde bascule appelée la bascule A. La bascule est reliée à un multiplexeur et un démultiplexeur, qui permet de choisir quel accumulateur relier à l'unité de calcul. L'instruction EX inverse le contenu de la bascule A.

&lt;noinclude&gt;
{{NavChapitre | book=Fonctionnement d'un ordinateur
           | prev=L'unité de contrôle
           | prevText=L'unité de contrôle
           | next=Les processeurs 8 bits et moins
           | nextText=Les processeurs 8 bits et moins
}}
&lt;/noinclude&gt;</text>
      <sha1>5b01xh2gbldnexgdfz9lwpr6gg9tbwn</sha1>
    </revision>
    <revision>
      <id>744140</id>
      <parentid>744139</parentid>
      <timestamp>2025-06-05T00:35:43Z</timestamp>
      <contributor>
        <username>Mewtow</username>
        <id>31375</id>
      </contributor>
      <minor />
      <comment>/* Annexe : les toutes premières architectures à accumulateur : le Manchester Baby */</comment>
      <origin>744140</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="37307" sha1="2kk8xxygw1eip7u14p1rzc1lrrmgtwo" xml:space="preserve">Les architectures que nous avons vu précédemment dans ce cours disposent de registres pour les données, en plus du pointeur de pile, d'un ''program counter'', et de quelques autres. Elles sont appelées des '''architectures à registres''', terme qui trahit bien le fait qu'elles ont des registres généraux ou spécialisés pour stocker temporairement des données. Et si on leur a donné un nom, c'est parce qu'il existe des architectures qui ne sont pas dans cette catégorie. Il en existe plusieurs types, mais ce chapitre va se concentrer sur les '''architectures à accumulateur'''.

[[File:Isaccumulator.png|vignette|Architecture à accumulateur.]]

Les architectures à accumulateur sont centrées autour d'un registre architectural appelé l''''accumulateur'''. Il est utilisé pour toutes les opérations arithmétiques dyadiques, où il sert à la fois de source et de destination. Toutes les instructions dyadiques sont de type ''load-op'' : une opérande est lue depuis l'accumulateur, le second opérande est lu depuis la mémoire RAM, le résultat de l'instruction est automatiquement mémorisé dans l'accumulateur. Les instructions monadiques peuvent utiliser un opérande dans l'accumulateur, ou dans la mémoire RAM, les deux sont théoriquement possibles.

La conséquence est que le nombre d'accès mémoire est drastiquement diminué : de 3 par instructions sur une architecture mémoire-mémoire, on passe à seulement un avec un accumulateur. Les opérations dyadiques ont besoin d'un seul accès mémoire pour lire la seconde opérande, les opérations monadique en font aussi un seul pour lire leur unique opérande.

{|class=&quot;wikitable&quot;
|-
! Classe d'architecture
! Nombre d'accès mémoire par opération dyadique
|-
|-
! Architecture à accumulateur
| Un accès mémoire par instruction, pour lire la seconde opérande
|-
! Architecture à registres
| Zéro si les opérandes sont dans les registres, un pour les opérations ''load-op'', LOAD et STORE.
|}

==Le jeu d'instruction des architectures à accumulateur sans registres d'indice==

L'accumulateur est adressé grâce au mode d'adressage implicite, de même que le résultat de l'opération. Par contre, les autres opérandes sont localisés avec d'autres modes d'adressage, et lues en mémoire RAM. Le résultat ainsi qu'un des opérandes sont adressés de façon implicite car dans l'accumulateur, seule la seconde opérande étant adressée directement. Grâce à l'accumulateur, une instruction ne fait qu'un seul accès mémoire maximum, ce qui rend le processeur très facile à implémenter.

===Les registres des anciennes architectures à accumulateur===

[[File:IBM 701console.jpg|vignette|IBM 701, console extérieure.]]

Les architectures à accumulateur étaient communes dans les années 50-60. A l'époque, les ordinateurs étaient gigantesques, ils prenaient une pièce de bâtiment entière dans le pire des cas, une armoire entière dans le meilleur. Les ordinateurs de l'époque étaient surtout utilisés pour du calcul scientifique ou des tâches d’ingénierie demandant beaucoup de calcul, rarement pour de la compatibilité.

Les nombres flottants n'étaient pas encore apparus. A la place, les ordinateurs de l'époque géraient des nombres entiers de grande taille, de 30 bits ou plus. En conséquence, l'accumulateur faisait facilement 30 à 60 bits. Par exemple, les ordinateurs de la Série scientifique IBM 700/7000 géraient des entiers de 36 bits, l’accumulateur faisait 38 bits : 36 bits plus deux bits pour les débordements. Au passage, de tels processeurs utilisaient l'adressage par mot, et non par byte.

Historiquement, les premières architectures à accumulateur ne contenaient aucun autre registre que l'accumulateur. Ce n'est que dans les années 60 que de nombreuses architectures à accumulateur ont ajouté un second '''registre pour les multiplication/divisions'''. Un exemple est celui de l'IBM 701, qui incorporait un registre accumulateur de 38 bits et un registre multiplieur de 36 bits. Le registre mémorise le multiplieur lors d'une opération de multiplication. Il mémorise donc un opérande, pas le résultat. Il peut aussi décaler le multiplieur vers la droite/gauche, ce qui est utile pour exécuter la multiplication. C'est ce qui est fait sur l'IBM 7094.

Une autre possibilité est que ce registre mémorise une partie du résultat de l'opération. Pour rappel, le résultat d'une multiplication/division est codé sur deux fois de bits que ses opérandes. Par exemple, multipliez deux opérandes de 30 bits, vous obtiendrez un résultat de 60 bits. Les 30 bits de poids faible du résultat vont dans l'accumulateur, les 30 bits de poids fort vont dans ce second registre.

Les architectures à accumulateur parfois un '''registre pour le pointeur de pile''', utilisé pour gérer les fonctions/procédures. Les architectures à accumulateurs supportaient une pile d'adresse de retour, souvent une pile d'appel. Mais pour cela, il fallait mémoriser le pointeur de pile dans le processeur, ce qui demandait un registre dédié.

===L'adressage indirect avec l'accumulateur===

Les instructions LOAD et STORE existent bel et bien sur les architectures à accumulateur, mais n'ont pas les mêmes modes d'adressages. L'instruction LOAD copie une donnée de la RAM vers l'accumulateur, l'instruction STORE copie l'accumulateur dans une adresse. Les deux instructions n'ont pas besoin d'adresser l'accumulateur, qui est adressé de manière implicite, juste de préciser l'adresse à lire/écrire.

Les architectures à accumulateur supportaient souvent le mode d'adressage indirect mémoire. Un exemple est celui des ordinateurs Data General Nova, qui sont des architectures à accumulateur et qui supportaient ce mode d'adressage. Les deux instructions LOAD et STORE existaient en deux versions, distinguées par un bit d'indirection. Si ce bit est à 0 dans l'opcode, alors l'instruction utilise le mode d'adressage absolu normal : l'adresse intégrée dans l'instruction est celle de la donnée. Mais s'il est à 1, alors l'adresse intégrée dans l'instruction est celle du pointeur.

Cependant, la présence de l'accumulateur permettait d'utiliser l'adressage indirect à registre, pour gérer les pointeurs. Pour rappel, avec le mode d'adressage indirect à registre, l'adresse à lire/écrire est dans un registre. Ici, l'adresse à lire/écrire est prise dans l'accumulateur, seul registre disponible pour. L'adressage indirect est plus simple à implémenter pour l'instruction LOAD, car elle prend un seul opérande : l'adresse à lire. L'adresse à lire est placée dans l'accumulateur, la donnée lue est elle aussi chargée dans l'accumulateur. Pour l'instruction STORE, il faut fournir deux opérandes, l'adresse et la donnée à écrire, ce qui peut poser problème. Mais au pire, il est toujours possible d'utiliser l'adressage absolu ou indirect mémoire : l'adresse est dans l'instruction, la donnée à écrire dans l'accumulateur.

===L'encodage des instructions===

Sur une architecture à accumulateur l'encodage d'une instruction dyadique est assez simple, vu que l'accumulateur est adressé implicitement. La seconde opérande est localisée soit par une adresse mémoire (adressage absolu), soit est une constante (adressage immédiat). L'adresse mémoire est généralement assez longue, plus que l'opcode.

{|class=&quot;wikitable&quot;
|+ Encodage d'une instruction dyadique
|-
! rowspan=&quot;2&quot; | Opcode 
| Adresse mémoire (adressage absolu)
|-
| Constante (adressage immédiat)
|}

L'encodage d'une instruction monadique est similaire. Si l'opérande est lue depuis la mémoire RAM, alors l'instruction est encodée comme une instruction dyadique. Il en est de même pour les instructions qui copient une constante dans l'accumulateur. Par contre, si l'opérande est dans l'accumulateur, alors il y a juste besoin d'encoder l'opcode. La majorité des instructions a besoin de préciser une adresse, rares sont celles qui s'en passent. Au vu de cet encodage, les architectures à accumulateur sont qualifiées d''''architectures à une adresse''' par abus de langage.

Il est intéressant de contraster leur encodage avec les architectures à registres. Les architectures à registre doivent encoder deux opérandes en plus de l'opcode, avec éventuellement où enregistrer le résultat sur les architectures 3-adresses. Par contre, les opérandes sont généralement des noms de registre, ce qui prend moins de place qu'une adresse mémoire. A la rigueur, les instructions avec une constante immédiate prennent un peu plus de place, car elles doivent encoder un nom de registre en plus de la constante et de l'opcode. Les instructions ''load-op'' des processeurs CISC sont un peu dans le même cas, sauf qu'il faut remplacer la constante par une adresse, qui a généralement la même taille. Les instructions sont donc en moyenne plus courte sur les processeurs à registre, du fait de la présence de registres.

===Annexe : les toutes premières architectures à accumulateur : le Manchester Baby===

[[File:BabyArchitecture.png|vignette|Architecture de la Manchester Baby.]]

Les architectures à accumulateurs sont apparues dès les débuts de l'informatique. Le tout premier ordinateur à programme enregistré en mémoire, le ''Manchester Baby'', était une architecture à accumulateur. Niveau interface, l'ordinateur avait une console avec 32 boutons, des interrupteurs et un écran de sortie sur lequel afficher les résultats. A l'intérieur, il y avait un processeur et une RAM de 32 adresses, fabriquée avec des tubes Williams (abordés dans une annexe à la fin du cours). Chaque adresse mémorisait 32 bits, qui pouvaient encoder soit un nombre, soit une instruction.

Le programme devait tenir dans la RAM, avec une instruction par adresse maximum, ce qui limitait les programmes à 32 instructions maximum. Une instruction prenait donc 32 bits, 3 indiquaient quelle opération utiliser, 12 servait à indiquer où se trouvent les opérandes en RAM, les 16 restants sont inutilisés.

Le processeur avait un registre accumulateur de 32 bits, un ''program counter'' et un registre d'instruction. Il gérait 8 instructions en tout, mais ne gérait pas l'addition. Il gérait la soustraction, des instructions de branchement et d'accès mémoire, rien d'autre. Il pouvait cependant émuler l'addition à partir d'une soustraction et inversant l'opérande soustraite.

Le Manchester Mark 1 était une amélioration du Manchester Baby. Il utilisait 4500 tubes à vide. L'ordinateur gérait des nombres de 40 bits, mais les instructions étaient codées sur 20 bits. La RAM avait la même taille, à savoir 32 nombres, leur taille était simplement augmentée. Par contre, la RAM était complémentée par l’ancêtre du disque dur magnétique, à savoir un tambour magnétique, l’ancêtre du disque dur magnétique. Il contenait 40 pages, chacune ayant la même taille que la RAM. C'était là encore une architecture à accumulateur, sauf qu'elle intégrait aussi des registres d'indice. Et surtout : son processeur gérait l'addition et quelques opérations logiques (ET et OU), en plus de la soustraction et de la comparaison.

[[File:MM1Schematic French.svg|centre|vignette|upright=2.5|Architecture de la Manchester Mark 1.]]

==La micro-architecture des architectures à accumulateur sans registres d'indice==

L'organisation interne d'une architecture à accumulateur est très différente de celle des processeurs à registre. Elle est plus ou moins la même pour tous ces processeurs, le point important étant que le chemin de données se résume à une ALU, un registre accumulateur et le bus de données. L'ALU est reliée au registre accumulateur, ainsi qu'au bus de données pour lire la seconde opérande, comme illustré ci-dessous.

[[File:Accumulator.png|centre|vignette|upright=2|Accumulateur.]]

===L'unité de calcul et l'accumulateur===

Pour simplifier l'implémentation, le résultat est mémorisé dans un registre en sortie de l'unité de calcul. La raison est qu'on ne veut pas altérer l'accumulateur tant que le résultat final n'est pas totalement calculé. Rappelons que l'ALU ne fournit pas un résultat d'un seul bloc, mais que certains bits arrivent avant les autres, typiquement les bits de poids faible. Si le résultat était écrit dans l'accumulateur directement, il écraserait des bits de l’opérande en cours d'utilisation, ce qui fausserait le résultat.

[[File:Accumulateur avec registre de sortie.png|centre|vignette|upright=2|Accumulateur avec registre de sortie]]

Une autre solution utilisait un registre entre l'accumulateur et l'unité de calcul, appelé l’'''''accumulator latch'''''. Il remplace le registre en sortie de l'ALU, dans le sens où il permet d'écrire dans l'accumulateur sans effacer l'opérande, pendant que l’opération est en cours dans l'ALU. L'accumulateur est copié dans l’''accumulator latch'', avant que l'ALU démarre ses calculs. L'opérande est donc maintenue même si on commence à écrire le résultat dans l'accumulateur.

Sur le 8085 d'Intel, l’''accumulator latch'' peut être initialisé avec une constante prédéfinie, ce qui permet d'implémenter certaines instructions très facilement. Par exemple, il peut être initialisé à 0, ce qui permet d'implémenter les instructions MOV et INC (incrémentation). Un MOV est équivalent à faire un OU entre le registre lu et 0. Une instruction INC initialise l'entrée de retenue de l'unité de calcul à 1, puis ajoute 0. La décrémentation est implémentée de la même manière, sauf que l’''accumulator latch'' est initialisé à -2 pour compenser l'entrée de retenue à 1. De plus, pour supporter les conversion de décimal à BCD, l’''accumulator latch'' peut être initialisé avec les constantes 0x00, 0x06, 0x60, or 0x66. L'''accumulator latch'' est relié à divers fils de commande provenant de l'unité de contrôle, qui décide quelle valeur d'initialisation utiliser en fonction de l'instruction décodée.

[[File:Accumulator latch.png|centre|vignette|upright=2|Accumulator latch]]

[[File:Chemin de données à un seul bus.png|vignette|Chemin de données à un seul bus]]

De même, la seconde opérande, celle lue sur le bus de données, est mémorisée dans un registre en amont de l'ALU. C'était notamment très utile si le processeur utilisait une ALU plus courte que les opérandes, avec par exemple une ALU 4 bits pour un CPU 8 bits. Les anciens processeurs à accumulateur de type ''mainframe'' utilisaient des opérandes de grande taille, du genre 36 ou 48 bits, ce qui avait des conséquences sur l'unité de calcul utilisée, ainsi que sur la communication avec la mémoire. Il arrivait que de tels processeurs utilisaient des ALU sérielles, ou du moins octet-sérielles, plutôt qu'une véritable ALU 36 bits. Nous verrons aussi que c'est très utile sur les processeurs à accumulateur avec un bus interne unique, dans la suite du chapitre.

===La micro-architecture des architectures à accumulateur avec instructions LOAD/STORE===

Nous venons de voir comment est implémenté l'unité de calcul et l'accumulateur, et comment le tout est relié au bus de données. Mais cela ne permet que d'avoir un processeur à accumulateur rudimentaire, qui ne gére que des instructions arithmétiques et logiques. Il faut aussi gérer le cas des opérations LOAD/STORE et des modes d'adressages associés, mais c'est le séquenceur qui s'en occupe. Avec l'adressage absolu, les instructions LOAD et STORE ne font que connecter l'accumulateur au bus de données. L'instruction STORE nécessite de connecter l'accumulateur au bus de données, de manière à ce que le transfert des données se fasse de l'accumulateur vers le bus de données. L'instruction LOAD s'implémente de la même manière, sauf que le sens de transfert est inversé.

Cependant, il existe une optimisation qui permet d'implémenter l'instruction LOAD sans ajouter de circuits. Pour cela, il suffit que l'unité de calcul gére les opérations ''pass through'', à savoir des opérations qui se contentent de recopier un opérande sur la sortie. Ici, l'idée est de recopier l'opérande provenant du bus de données.

[[File:Architecture à accumulateur, microarchitecture.png|centre|vignette|upright=2|Architecture à accumulateur, microarchitecture]]

Pour gérer nativement l'adressage indirect à registre, il suffit de connecter l'accumulateur au bus d'adresse. Le plus simple est d'ajouter un multiplexeur, comme illustré ci-dessous. La donnée lue est copiée dans l'accumulateur, ce qui fait qu'il vaut mieux utiliser un registre d’interfaçage, l'accumulateur n'étant pas utilisable à la fois pour le bus d'adresse et de données.

[[File:Adressage indirect sur une architecture à accumulateur.png|centre|vignette|upright=2|Adressage indirect sur une architecture à accumulateur]]

Pour finir, voyons comment le pointeur de pile et le ''program counter'' sont implémentés. Les architectures à accumulateur ont souvent des adresses de taille différente des données, ce qui fait qu'il vaut mieux utiliser un circuit incrémenteur dédié pour incrémenter le ''program counter'', plutôt que de l'incrémenter via l'unité de calcul. Les architectures à accumulateur ont parfois un pointeur de pile, qui gère une pile d'adresse de retour, pas une vraie pile d'appel. Aussi, le pointeur de pile est censé être incrémenté et décrémenté, pas plus. Pas d'addition ou de soustraction pour gérer des cadres de pile. Là encore, c'est la solution de l'incrémenteur séparé qui est retenue. Pour économiser des transistors, il n'y a qu'un seul incrémenteur partagé pour les deux.

==Les architectures à accumulateur à registres d'indice==

Les architectures à accumulateur décrites dans la section précédente sont capables de faire de l'adressage indirect, mais n'incluent pas les modes d'adressage base + indice et absolus indicés, qui prennent une adresse et y ajoute un indice. Il s'agit des toutes premières architectures à accumulateur, comme les premiers ordinateurs IBM ou le fameux PDP-8. Mais par la suite, les processeurs à accumulateurs ont inclus un support des modes d'adressages indicés, grâce à des '''registres d'indice'''.

===Les registres d'indice===

Les registres d'indice stockent des indices de tableaux. Ils permettaient de supporter deux modes d'adressage :
* Le '''mode d'adressage absolu indicé''' où une adresse fixe est additionnée à un indice variable. L'adresse fixe est intégrée dans l'instruction (adressage absolu), l'indice est dans un registre d'indice.
* Le '''mode d'adressage base + indice''', où l'adresse est dans l'accumulateur et l'indice dans le registre d'indice.

Les processeurs à accumulateur supportaient souvent des variantes des modes d'adressage précédents, où le registre d'indice était automatiquement incrémenté ou décrémenté à chaque utilisation.

Au départ, ces processeurs n'utilisaient qu'un seul registre d'indice qui se comportait comme un second accumulateur spécialisé dans les calculs d'adresses mémoire. Le processeur supportait de nouvelles instructions qui utilisaient ce registre d'indice de façon implicite. Mais avec le temps, les processeurs finirent par incorporer plusieurs de ces registres. Les instructions de lecture ou d'écriture devaient alors préciser quel registre d'indice utiliser, en précisant un nom de registre d'indice, un numéro de registre d'indice.

Il faut préciser que les registres d'indice ont une taille bien plus petite que l'accumulateur. Ils mémorisent des indices codés sur 16 bits ou moins, alors que l'accumulateur faisait typiquement 36 à 48 bits, parfois plus. La taille classique sur les anciens ''mainframes'' était de 15 bits, parfois moins. Il n'était pas rare de tomber sur des registres d'indice de 8 ou 9 bits. Leur petite taille rendait leur implémentation matérielle peu couteuse. Et c'est ce qui explique qu'ils étaient préférés à l'usage d'un second accumulateur.

Un exemple est le cas du processeur Motorola 6809, un processeur à accumulateur qui contient deux registres d'indices nommés X et Y. L'accumulateur est noté D et fait 16 bits, il peut être parfois géré comme deux accumulateurs séparés A et B de 8 bits chacun. Il contenait aussi deux pointeurs de pile, l'un pour les programmes, l'autre pour le système d'exploitation, ainsi qu'un ''program counter''. Le registre de page était utilisé pour l'adressage absolu, comme vu dans le chapitre sur les modes d'adressage.

[[File:6809 Internal Registers.svg|centre|vignette|upright=2|6809 Internal Registers]]

Les processeurs IBM avaient autrefois plusieurs registres d'indice. Par exemple, l'IBM 704 avait trois registres d'indice de 15 bits. Leur contenu était soustrait de l'adresse absolue. Une instruction pouvait utiliser plusieurs registres d'indice pour adresser son opérande. Toute instruction utilisait trois bits pour sélectionner les registres d'indice utilisés. Fait assez original, lorsque plusieurs registres d'indice sont sélectionnés, le processeur n'additionne pas les trois registres à l'adresse de base. À la place, il fait un OU bit à bit entre les registres d'indice sélectionnés, et additionne le résultat à l'adresse.

Les processeurs IBM à accumulateur ont fait ça sur toute la gamme IBM 700/7000, pour des raisons de compatibilité. Les processeurs suivants avaient 7 registres d'indices, mais conservaient les trois bits pour adresser les registres d'indices. Ils pouvaient fonctionner dans deux modes. Le premier mode est plus intuitif : les trois bits précisent un registre d'indice parmi les 7, qui est additionné avec l'adresse absolue. La valeur zéro indique qu'aucun registre d'indice n'est utilisé, ce qui explique qu'il y a 7 registres d'indice et non 8. Un second mode, compatible avec l'IBM 704, fait un OU logique entre les registres d'indice sélectionnés. Seuls les trois premiers registres d'indices peuvent être sélectionnés dans ce mode. Il y a deux instructions pour changer de mode : une pour passer en mode compatible, l'autre pour le quitter pour l'autre mode.

Quelques rares processeurs à registres généraux ont utilisés des registres d'indice, en plus des registres généraux. Ce qui fait l'association que nous avons faite entre registres d'indice et architectures à accumulateur est imparfait, bien que solide sur le principe. Un exemple d'architecture de ce type sont les architectures de la série UNIVAC 1100/2200. Ils disposaient de 128 registres, qui étaient mappés en mémoire à partir de l'adresse mémoire 0, la majorité étant inaccessibles par le programmeur. Ils regroupaient 12 registres accumulateurs, 11 registres d'indice et 4 registres hybrides qui pouvaient servir soit de registre d'indice, soit de registres accumulateurs.

===La micro-architecture des architectures à accumulateur avec registres d'indice===

La présence de registres d'indice modifie grandement l'implémentation du processeur. En effet, il faut rajouter un banc de registre pour les registres d'indice. Le banc de registre est monoport, car on a besoin de lire ou d'écrire un indice à la fois. Et il faut aussi potentiellement rajouter de quoi faire les calculs d'adresse. Deux solutions sont possibles : une ALU dédiée aux calculs d'adresse, une seule ALU pour toutes les opérations.

Dans le premier cas, il y a une ALU séparée associée aux registres d'indice. L'ALU et les registres d'indice sont placés en sortie du séquenceur, en-dehors du chemin de données, la sortie de l'ALU est directement connectée au bus d'adresse. L'unité de calcul d'adresse peut être utilisée pour incrémenter le ''program counter''. Un défaut de cette approche est qu'elle ne gère pas l'adresse indirect à registre.

[[File:Chemin de données sans support des pointeurs, avec adressage absolu indicé.png|centre|vignette|upright=2|Chemin de données sans support des pointeurs, avec adressage absolu indicé]]

Une autre option utilise un bus interne, qui interconnecte tout le chemin de données. Dans sa version la plus simple, il est relié à l'accumulateur, l'unité de calcul, le banc de registre d'indice et le bus de données. Avec cette solution, l'ALU est utilisé à la fois pour calculer les adresses et pour les instructions de calcul. En reliant le bus interne au bus d'adresse à travers un multiplexeur, on gère naturellement les adressages indirects.

[[File:Architecture à accumulateur avec registres associés.png|centre|vignette|upright=2.5|Architecture à accumulateur avec registres associés]]

Il faut noter que sur les architectures Von Neumann, le séquenceur est relié à ce bus interne. En effet, charger une instruction demande de passer par le bus mémoire, donc par l’intermédiaire de ce bus internet. Le ''program counter'' est envoyé sur ce bus pour lire l'instruction, puis l'instruction lue est recopiée dans le registre d'instruction. Le chargement d'une instruction est donc géré comme une lecture des plus classiques. De plus, cela permet d'incrémenter le ''program counter'' au niveau de l'unité de calcul entière. Le ''program counter'' est envoyé sur le bus interne, incrémenté par l'ALU, puis le résultat est recopié dans le ''program counter'' via le bus interne.

[[File:Architecture à accumulateur avec bus unique de type Von Neumann.png|centre|vignette|upright=2|Architecture à accumulateur avec bus unique de type Von Neumann]]

==Les processeurs bi-accumulateurs : le Motorola 6800==

Le Motorola 6800 était un processeur 8 bits qui gérait des adresses de 16 bits. Il contenait deux accumulateurs nommés A et B, de 8 bits chacun. Il disposait aussi d'un registre d'indice, d'un pointeur de pile et d'un ''program counter'', tous les trois de 16 bits. Le registre d'état regroupait 6 bits, qu'on ne détaillera pas ici.

[[File:MC6800 Processor Diagram.png|centre|vignette|upright=2|Interface et registres du MC6800.]]

La présence des deux accumulateurs impactait surtout les instructions dyadiques. Les instructions monadiques avaient juste à préciser où se trouvait l'opérande : soit en RAM, soit dans le premier accumulateur, soit dans le second. Pour les opérations dyadiques, la gestion était totalement différente. En théorie, le premier opérande est dans un accumulateur, soit A, soit B. La seconde opérande vient soit de l'autre accumulateur, soit de la mémoire RAM. Et selon les instructions, tout variait.

Pour l'addition, il y avait trois instructions. Les deux premières additionnaient un opérande provenant de la mémoire avec un accumulateur. L'instruction ADDA sélectionnait le premier accumulateur, l'instruction ADDB sélectionnait le second accumulateur. Mais une troisième instruction, l’instruction ABA, permettait d'additionner le contenu des deux accumulateurs.

Pour les autres opérations, il n'était pas possible d'utiliser les deux accumulateurs en même temps. La seule possibilité était de faire une opération entre un accumulateur et un opérande venant de la mémoire. Toutes les instructions étaient en double, avec une copie par accumulateur. Par exemple, l'instruction ANDA faisait un ET entre l’accumulateur A et l'opérande mémoire, l'instruction ANDB faisait pareil avec l'accumulateur B.

==Les architectures hybrides registres-accumulateur==

Il a existé quelques architectures qui étaient des hybrides entre architectures à accumulateur et architecture à registre. Elles ont servi de transition entre les deux, durant les années 80-90. Elles avaient un accumulateur unique couplé à un banc de registres généraux. Par exemple, les premiers processeurs Intel 8 bits étaient des processeurs hybrides-accumulateur. Lles CPU Intel 8 bits disposaient de 7 registres de 8 bits nommés A, B, C, D, E, F, H, L, SP. Ils correspondent respectivement à :
* l'accumulateur A ;
* six registres nommés B, C, D, E, H et L ;
* le registre d'état F ;
* le pointeur de pile SP.

Sur ces processeurs, les instructions dyadiques devaient mettre leur premier opérande dans l'accumulateur, la seconde provenait soit des registres, soit de la RAM, soit d'une constante immédiate. Les opérations monadiques pouvaient lire leur opérande depuis l'accumulateur, les autres registres ou la RAM, tout était permis. Les registres d'indices disparaissaient sur ces architectures, en théorie. Les registres généraux pouvaient être utilisés comme registre d'indice ou pour stocker des opérandes, ils étaient assez versatiles pour servir de registres d'indices.

La présence de registres a de nombreux avantages, comparé aux architectures à accumulateur pures. Les instructions arithmétiques sont plus rapide, lire un registre étant plus rapide qu'un accès RAM. Les performances sont donc augmentées. De plus, les instructions arithmétiques utilisant ces registres sont plus courtes : pas besoin d'encoder une adresse mémoire, un nom de registre suffit. Vu que les processeurs de l’époque avaient des instructions de taille variable, cela améliorait la densité de code.

La microarchitecture de ces processeurs est très similaire à celle d'un processeur avec des registres d'indices. La seule différence est que le banc de registre contient des registres généraux et non des registres d'indices. Le banc de registre est systématiquement monoport, car il n'avait aucune raison d'être multiport. Pour les instructions dyadiques, seules à lire deux opérandes, il ne servait que pour la seconde opérande, la première était lue depuis l'accumulateur.

Les processeurs hybrides registre-accumulateur se classent en deux types principaux : ceux qui ont un seul bus interne, et ceux qui en ont deux. Le premier cas est identique à celui vu précédemment pour les architectures à accumulateur avec registres d'indice, à la seule différence est que le banc de registre contient des registres généraux et non des registres d'indices. Afin de gérer l'adressage indirect à registre, le bus interne est connecté aux deux registres d’interfaçage mémoire.

[[File:Architecture à accumulateur avec bus unique de type Von Neumann.png|centre|vignette|upright=2|Architecture à accumulateur avec bus unique de type Von Neumann]]

Notons que cela permet aussi d'implémenter facilement les branchements indirects, car le bus interne permet d'échanger des adresses entre ''program counter'' et banc de registre. De même, il est possible d'utiliser l'ALU pour gérer les branchements indirects., en plus de l'utiliser pour incrémenter le ''program counter''.

[[File:Single bus organization.jpg|centre|vignette|upright=2|Single bus organization]]

Une autre solution utilisait deux bus internes : un connecté au bus de données, un autre relié au bus d'adresse. Le bus de commande mémoire était lui commandé par le séquenceur, l'unité de contrôle. L'intermédiaire entre ces deux bus était le banc de registre, ainsi que les autres registres. Le banc de registre était connecté aux deux bus interne, avec un port de lecture relié au bus d'adresse, un port de lecture-écriture relié au bus de données. Le port de lecture était utilisé pour l'adressage indirect, l'autre l'était pour le reste.

[[File:Proz1-e.png|centre|vignette|upright=2|Intérieur d'un processeur.]]

L'organisation à deux bus simplifiait la gestion du ''program counter'' et le chargement des instructions. Le ''program counter'' était soit séparé du banc de registre, soit placé dans le banc de registre. Les deux solutions étaient utilisés, tout dépend du processeur. Il faut noter que si le ''program counter'' est intégré au banc de registres, alors la microarchitecture du processeur est bien plus simple. L'envoi du ''program counter'' sur le bus d'adresse utilise le port de lecture relié au bus d'adresse, qui sert aussi pour l'adressage indirect. L'économie de circuits, sans compter la simplicité d'implémentation que cela implique, explique sans doute que la technique a été utilisée sur quelques processeurs anciens.

Le ''program counter'' était généralement incrémenté par l'ALU, ce qui explique qu'il soit connecté au bus interne pour les données. La connexion est aussi utile pour gérer les branchements indirects, qui copient un registre dans le ''program counter'', ainsi que les branchements relatifs (addition dans l'ALU), voire les branchements directs (l'adresse vers laquelle brancher est envoyée en entrée de l'ALU et propagée en sortie avec une opération ''pass through'').

[[File:Connexion du program counter sur les bus avec PC dans le banc de registres.png|centre|vignette|upright=2|Connexion du program counter sur les bus avec PC dans le banc de registres]]

===Les registres d'interruption avec un processeur hybride-accumulateur : l'exemple du Z80===

Un exemple de processeur registre-accumulateur à deux bus interne est le Z80, un processeur fortement inspiré des CPU Intel 8 bits. Il a un jeu d'instruction similaire, mais a diverses améliorations par rapport au design original. Notamment, le processeur a des registres séparés pour les interruptions.

Sur le Z80, les registres généraux sont dupliqués avec 6 registres pour les interruptions et 6 registres pour les programmes autres. Leur copie pour les interruptions sont nommées B', C', D', E', H', L'. Les 12 registres sont placés dans le banc de registre, ce qui implique que le fenêtrage de registres est utilisé pour gérer la séparation entre registre d'interruption et normaux. Il faut noter que l'accumulateur et le registre d'état sont aussi dupliqués, leurs copies étant nommées A' et F'. Mais leur duplication se fait autrement que par fenêtrage de registre.

En plus des registres précédents, le Z80 incorporait deux registres d'indice nommés X et Y, ainsi qu'un pointeur de pile SP et un ''program counter'' PC. Ils n'étaient pas dupliqués pour les interruptions. Les registres d'indice étaient reliés à une unité de calcul d'adresse. L'unité de calcul d'adresse prenait deux opérandes : un indice, et une adresse mémoire provenant soit du banc de registre, soit de l'accumulateur. En clair, l'unité de calcul d'adresse faisait le lien entre les deux bus internet : le bus de données interne en entrée, le bus d'adresse en sortie.

À l'intérieur du processeur, tous les registres étaient regroupés dans un banc de registre unique, sauf les accumulateurs, les registres d'état et le ''program counter''. Bien que ce ne soit pas indiqué sur le schéma ci-dessous, le ''program counter'' est séparé du banc de registre, alors que le pointeur de pile est dedans. Le compteur IR est lui associé au ''program counter'', il est sortit du banc de registre. Le Z80 utilise lui aussi un incrémenteur séparé de l'ALU, qui est utilisé pour mettre à jour le ''program counter'', le pointeur de pile et un compteur de rafraichissement mémoire nommé IR sur le Z80 (pour rappel, le rafraichissement mémoire demande de balayer la mémoire d'adresse en adresse et été fait par le CPU à l'époque). De plus, il est utilisé pour les instructions INC et DEC qui incrémentent une opérande de 16 bits obtenue en combinant deux registres de 8 bits. En clair, l'incrémenteur du ''program counter'' a été réutilisé de beaucoup de manières originales.

[[File:Z80 arch.svg|centre|vignette|upright=3|Microarchitecture du Z80.]]

Le Z80 incorporait des instructions pour échanger le contenu des deux ensembles de registres, accumulateur inclus. Elles permettaient d'utiliser les registres d'interruption pour les programmes et réciproquement. En clair, cela doublait le nombre de registres si les interruptions n'étaient pas utilisées.
* L'instruction EXX échangeait les deux fenêtres de registres généraux : les registres B, C, D, E, H et L devenaient les registres B', C', D', E', H' et L' et inversement.
* L'instruction EX échangeait l'accumulateur et le registre d'état : les registres A,F devenait A',F' et inversement.

Le fenêtrage de registre était modifié par l'instruction EXX, qui échangeait les deux fenêtres de registres. Pour l'implémenter, une bascule était ajouté au processeur, appelons-la la bascule INT. Elle était relié au bus d'adresse du banc de registre, dont elle mémorisait le bit de poids fort. L'instruction EXX inversait la valeur de la bascule INT. Il est aussi possible d'échanger le contenu des registres D,E et H,L avec une instruction dédiée, ce qui est là encore fait par deux bascules : une pour les registres D,E et une autre pour les registres H,L.

Pour l'accumulateur et le registre d'état, le choix entre registre normal et registre d'interruption se faisait là encore par une seconde bascule appelée la bascule A. La bascule est reliée à un multiplexeur et un démultiplexeur, qui permet de choisir quel accumulateur relier à l'unité de calcul. L'instruction EX inverse le contenu de la bascule A.

&lt;noinclude&gt;
{{NavChapitre | book=Fonctionnement d'un ordinateur
           | prev=L'unité de contrôle
           | prevText=L'unité de contrôle
           | next=Les processeurs 8 bits et moins
           | nextText=Les processeurs 8 bits et moins
}}
&lt;/noinclude&gt;</text>
      <sha1>2kk8xxygw1eip7u14p1rzc1lrrmgtwo</sha1>
    </revision>
    <revision>
      <id>744141</id>
      <parentid>744140</parentid>
      <timestamp>2025-06-05T00:39:12Z</timestamp>
      <contributor>
        <username>Mewtow</username>
        <id>31375</id>
      </contributor>
      <minor />
      <comment>/* Annexe : les toutes premières architectures à accumulateur : le Manchester Baby */</comment>
      <origin>744141</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="37396" sha1="8gj97m8c5t53ho5ux8dwtvf7oh7v7mr" xml:space="preserve">Les architectures que nous avons vu précédemment dans ce cours disposent de registres pour les données, en plus du pointeur de pile, d'un ''program counter'', et de quelques autres. Elles sont appelées des '''architectures à registres''', terme qui trahit bien le fait qu'elles ont des registres généraux ou spécialisés pour stocker temporairement des données. Et si on leur a donné un nom, c'est parce qu'il existe des architectures qui ne sont pas dans cette catégorie. Il en existe plusieurs types, mais ce chapitre va se concentrer sur les '''architectures à accumulateur'''.

[[File:Isaccumulator.png|vignette|Architecture à accumulateur.]]

Les architectures à accumulateur sont centrées autour d'un registre architectural appelé l''''accumulateur'''. Il est utilisé pour toutes les opérations arithmétiques dyadiques, où il sert à la fois de source et de destination. Toutes les instructions dyadiques sont de type ''load-op'' : une opérande est lue depuis l'accumulateur, le second opérande est lu depuis la mémoire RAM, le résultat de l'instruction est automatiquement mémorisé dans l'accumulateur. Les instructions monadiques peuvent utiliser un opérande dans l'accumulateur, ou dans la mémoire RAM, les deux sont théoriquement possibles.

La conséquence est que le nombre d'accès mémoire est drastiquement diminué : de 3 par instructions sur une architecture mémoire-mémoire, on passe à seulement un avec un accumulateur. Les opérations dyadiques ont besoin d'un seul accès mémoire pour lire la seconde opérande, les opérations monadique en font aussi un seul pour lire leur unique opérande.

{|class=&quot;wikitable&quot;
|-
! Classe d'architecture
! Nombre d'accès mémoire par opération dyadique
|-
|-
! Architecture à accumulateur
| Un accès mémoire par instruction, pour lire la seconde opérande
|-
! Architecture à registres
| Zéro si les opérandes sont dans les registres, un pour les opérations ''load-op'', LOAD et STORE.
|}

==Le jeu d'instruction des architectures à accumulateur sans registres d'indice==

L'accumulateur est adressé grâce au mode d'adressage implicite, de même que le résultat de l'opération. Par contre, les autres opérandes sont localisés avec d'autres modes d'adressage, et lues en mémoire RAM. Le résultat ainsi qu'un des opérandes sont adressés de façon implicite car dans l'accumulateur, seule la seconde opérande étant adressée directement. Grâce à l'accumulateur, une instruction ne fait qu'un seul accès mémoire maximum, ce qui rend le processeur très facile à implémenter.

===Les registres des anciennes architectures à accumulateur===

[[File:IBM 701console.jpg|vignette|IBM 701, console extérieure.]]

Les architectures à accumulateur étaient communes dans les années 50-60. A l'époque, les ordinateurs étaient gigantesques, ils prenaient une pièce de bâtiment entière dans le pire des cas, une armoire entière dans le meilleur. Les ordinateurs de l'époque étaient surtout utilisés pour du calcul scientifique ou des tâches d’ingénierie demandant beaucoup de calcul, rarement pour de la compatibilité.

Les nombres flottants n'étaient pas encore apparus. A la place, les ordinateurs de l'époque géraient des nombres entiers de grande taille, de 30 bits ou plus. En conséquence, l'accumulateur faisait facilement 30 à 60 bits. Par exemple, les ordinateurs de la Série scientifique IBM 700/7000 géraient des entiers de 36 bits, l’accumulateur faisait 38 bits : 36 bits plus deux bits pour les débordements. Au passage, de tels processeurs utilisaient l'adressage par mot, et non par byte.

Historiquement, les premières architectures à accumulateur ne contenaient aucun autre registre que l'accumulateur. Ce n'est que dans les années 60 que de nombreuses architectures à accumulateur ont ajouté un second '''registre pour les multiplication/divisions'''. Un exemple est celui de l'IBM 701, qui incorporait un registre accumulateur de 38 bits et un registre multiplieur de 36 bits. Le registre mémorise le multiplieur lors d'une opération de multiplication. Il mémorise donc un opérande, pas le résultat. Il peut aussi décaler le multiplieur vers la droite/gauche, ce qui est utile pour exécuter la multiplication. C'est ce qui est fait sur l'IBM 7094.

Une autre possibilité est que ce registre mémorise une partie du résultat de l'opération. Pour rappel, le résultat d'une multiplication/division est codé sur deux fois de bits que ses opérandes. Par exemple, multipliez deux opérandes de 30 bits, vous obtiendrez un résultat de 60 bits. Les 30 bits de poids faible du résultat vont dans l'accumulateur, les 30 bits de poids fort vont dans ce second registre.

Les architectures à accumulateur parfois un '''registre pour le pointeur de pile''', utilisé pour gérer les fonctions/procédures. Les architectures à accumulateurs supportaient une pile d'adresse de retour, souvent une pile d'appel. Mais pour cela, il fallait mémoriser le pointeur de pile dans le processeur, ce qui demandait un registre dédié.

===L'adressage indirect avec l'accumulateur===

Les instructions LOAD et STORE existent bel et bien sur les architectures à accumulateur, mais n'ont pas les mêmes modes d'adressages. L'instruction LOAD copie une donnée de la RAM vers l'accumulateur, l'instruction STORE copie l'accumulateur dans une adresse. Les deux instructions n'ont pas besoin d'adresser l'accumulateur, qui est adressé de manière implicite, juste de préciser l'adresse à lire/écrire.

Les architectures à accumulateur supportaient souvent le mode d'adressage indirect mémoire. Un exemple est celui des ordinateurs Data General Nova, qui sont des architectures à accumulateur et qui supportaient ce mode d'adressage. Les deux instructions LOAD et STORE existaient en deux versions, distinguées par un bit d'indirection. Si ce bit est à 0 dans l'opcode, alors l'instruction utilise le mode d'adressage absolu normal : l'adresse intégrée dans l'instruction est celle de la donnée. Mais s'il est à 1, alors l'adresse intégrée dans l'instruction est celle du pointeur.

Cependant, la présence de l'accumulateur permettait d'utiliser l'adressage indirect à registre, pour gérer les pointeurs. Pour rappel, avec le mode d'adressage indirect à registre, l'adresse à lire/écrire est dans un registre. Ici, l'adresse à lire/écrire est prise dans l'accumulateur, seul registre disponible pour. L'adressage indirect est plus simple à implémenter pour l'instruction LOAD, car elle prend un seul opérande : l'adresse à lire. L'adresse à lire est placée dans l'accumulateur, la donnée lue est elle aussi chargée dans l'accumulateur. Pour l'instruction STORE, il faut fournir deux opérandes, l'adresse et la donnée à écrire, ce qui peut poser problème. Mais au pire, il est toujours possible d'utiliser l'adressage absolu ou indirect mémoire : l'adresse est dans l'instruction, la donnée à écrire dans l'accumulateur.

===L'encodage des instructions===

Sur une architecture à accumulateur l'encodage d'une instruction dyadique est assez simple, vu que l'accumulateur est adressé implicitement. La seconde opérande est localisée soit par une adresse mémoire (adressage absolu), soit est une constante (adressage immédiat). L'adresse mémoire est généralement assez longue, plus que l'opcode.

{|class=&quot;wikitable&quot;
|+ Encodage d'une instruction dyadique
|-
! rowspan=&quot;2&quot; | Opcode 
| Adresse mémoire (adressage absolu)
|-
| Constante (adressage immédiat)
|}

L'encodage d'une instruction monadique est similaire. Si l'opérande est lue depuis la mémoire RAM, alors l'instruction est encodée comme une instruction dyadique. Il en est de même pour les instructions qui copient une constante dans l'accumulateur. Par contre, si l'opérande est dans l'accumulateur, alors il y a juste besoin d'encoder l'opcode. La majorité des instructions a besoin de préciser une adresse, rares sont celles qui s'en passent. Au vu de cet encodage, les architectures à accumulateur sont qualifiées d''''architectures à une adresse''' par abus de langage.

Il est intéressant de contraster leur encodage avec les architectures à registres. Les architectures à registre doivent encoder deux opérandes en plus de l'opcode, avec éventuellement où enregistrer le résultat sur les architectures 3-adresses. Par contre, les opérandes sont généralement des noms de registre, ce qui prend moins de place qu'une adresse mémoire. A la rigueur, les instructions avec une constante immédiate prennent un peu plus de place, car elles doivent encoder un nom de registre en plus de la constante et de l'opcode. Les instructions ''load-op'' des processeurs CISC sont un peu dans le même cas, sauf qu'il faut remplacer la constante par une adresse, qui a généralement la même taille. Les instructions sont donc en moyenne plus courte sur les processeurs à registre, du fait de la présence de registres.

===Annexe : les toutes premières architectures à accumulateur : le Manchester Baby===

[[File:BabyArchitecture.png|vignette|Architecture de la Manchester Baby.]]

Les architectures à accumulateurs sont apparues dès les débuts de l'informatique. Le tout premier ordinateur à programme enregistré en mémoire, le ''Manchester Baby'', était une architecture à accumulateur. Niveau interface, l'ordinateur avait une console avec 32 boutons, des interrupteurs et un écran de sortie sur lequel afficher les résultats. A l'intérieur, il y avait un processeur et une RAM de 32 adresses, fabriquée avec des tubes Williams (abordés dans une annexe à la fin du cours). Chaque adresse mémorisait 32 bits, qui pouvaient encoder soit un nombre, soit une instruction.

Le programme devait tenir dans la RAM, avec une instruction par adresse maximum, ce qui limitait les programmes à 32 instructions maximum. Une instruction prenait donc 32 bits, 3 indiquaient quelle opération utiliser, 12 servait à indiquer où se trouvent les opérandes en RAM, les 16 restants sont inutilisés.

Le processeur avait un registre accumulateur de 32 bits, un ''program counter'' et un registre d'instruction. Il gérait 8 instructions en tout, mais ne gérait pas l'addition. Il gérait la soustraction, des instructions de branchement et d'accès mémoire, rien d'autre. Il pouvait cependant émuler l'addition à partir d'une soustraction et inversant l'opérande soustraite. L'ALU était une ALU sérielle, à savoir qu'elle faisait les soustractions bit par bit.

Le Manchester Mark 1 était une amélioration du Manchester Baby. Il utilisait 4500 tubes à vide. L'ordinateur gérait des nombres de 40 bits, mais les instructions étaient codées sur 20 bits. La RAM avait la même taille, à savoir 32 nombres, leur taille était simplement augmentée. Par contre, la RAM était complémentée par l’ancêtre du disque dur magnétique, à savoir un tambour magnétique, l’ancêtre du disque dur magnétique. Il contenait 40 pages, chacune ayant la même taille que la RAM. C'était là encore une architecture à accumulateur, sauf qu'elle intégrait aussi des registres d'indice. Et surtout : son processeur gérait l'addition et quelques opérations logiques (ET et OU), en plus de la soustraction et de la comparaison.

[[File:MM1Schematic French.svg|centre|vignette|upright=2.5|Architecture de la Manchester Mark 1.]]

==La micro-architecture des architectures à accumulateur sans registres d'indice==

L'organisation interne d'une architecture à accumulateur est très différente de celle des processeurs à registre. Elle est plus ou moins la même pour tous ces processeurs, le point important étant que le chemin de données se résume à une ALU, un registre accumulateur et le bus de données. L'ALU est reliée au registre accumulateur, ainsi qu'au bus de données pour lire la seconde opérande, comme illustré ci-dessous.

[[File:Accumulator.png|centre|vignette|upright=2|Accumulateur.]]

===L'unité de calcul et l'accumulateur===

Pour simplifier l'implémentation, le résultat est mémorisé dans un registre en sortie de l'unité de calcul. La raison est qu'on ne veut pas altérer l'accumulateur tant que le résultat final n'est pas totalement calculé. Rappelons que l'ALU ne fournit pas un résultat d'un seul bloc, mais que certains bits arrivent avant les autres, typiquement les bits de poids faible. Si le résultat était écrit dans l'accumulateur directement, il écraserait des bits de l’opérande en cours d'utilisation, ce qui fausserait le résultat.

[[File:Accumulateur avec registre de sortie.png|centre|vignette|upright=2|Accumulateur avec registre de sortie]]

Une autre solution utilisait un registre entre l'accumulateur et l'unité de calcul, appelé l’'''''accumulator latch'''''. Il remplace le registre en sortie de l'ALU, dans le sens où il permet d'écrire dans l'accumulateur sans effacer l'opérande, pendant que l’opération est en cours dans l'ALU. L'accumulateur est copié dans l’''accumulator latch'', avant que l'ALU démarre ses calculs. L'opérande est donc maintenue même si on commence à écrire le résultat dans l'accumulateur.

Sur le 8085 d'Intel, l’''accumulator latch'' peut être initialisé avec une constante prédéfinie, ce qui permet d'implémenter certaines instructions très facilement. Par exemple, il peut être initialisé à 0, ce qui permet d'implémenter les instructions MOV et INC (incrémentation). Un MOV est équivalent à faire un OU entre le registre lu et 0. Une instruction INC initialise l'entrée de retenue de l'unité de calcul à 1, puis ajoute 0. La décrémentation est implémentée de la même manière, sauf que l’''accumulator latch'' est initialisé à -2 pour compenser l'entrée de retenue à 1. De plus, pour supporter les conversion de décimal à BCD, l’''accumulator latch'' peut être initialisé avec les constantes 0x00, 0x06, 0x60, or 0x66. L'''accumulator latch'' est relié à divers fils de commande provenant de l'unité de contrôle, qui décide quelle valeur d'initialisation utiliser en fonction de l'instruction décodée.

[[File:Accumulator latch.png|centre|vignette|upright=2|Accumulator latch]]

[[File:Chemin de données à un seul bus.png|vignette|Chemin de données à un seul bus]]

De même, la seconde opérande, celle lue sur le bus de données, est mémorisée dans un registre en amont de l'ALU. C'était notamment très utile si le processeur utilisait une ALU plus courte que les opérandes, avec par exemple une ALU 4 bits pour un CPU 8 bits. Les anciens processeurs à accumulateur de type ''mainframe'' utilisaient des opérandes de grande taille, du genre 36 ou 48 bits, ce qui avait des conséquences sur l'unité de calcul utilisée, ainsi que sur la communication avec la mémoire. Il arrivait que de tels processeurs utilisaient des ALU sérielles, ou du moins octet-sérielles, plutôt qu'une véritable ALU 36 bits. Nous verrons aussi que c'est très utile sur les processeurs à accumulateur avec un bus interne unique, dans la suite du chapitre.

===La micro-architecture des architectures à accumulateur avec instructions LOAD/STORE===

Nous venons de voir comment est implémenté l'unité de calcul et l'accumulateur, et comment le tout est relié au bus de données. Mais cela ne permet que d'avoir un processeur à accumulateur rudimentaire, qui ne gére que des instructions arithmétiques et logiques. Il faut aussi gérer le cas des opérations LOAD/STORE et des modes d'adressages associés, mais c'est le séquenceur qui s'en occupe. Avec l'adressage absolu, les instructions LOAD et STORE ne font que connecter l'accumulateur au bus de données. L'instruction STORE nécessite de connecter l'accumulateur au bus de données, de manière à ce que le transfert des données se fasse de l'accumulateur vers le bus de données. L'instruction LOAD s'implémente de la même manière, sauf que le sens de transfert est inversé.

Cependant, il existe une optimisation qui permet d'implémenter l'instruction LOAD sans ajouter de circuits. Pour cela, il suffit que l'unité de calcul gére les opérations ''pass through'', à savoir des opérations qui se contentent de recopier un opérande sur la sortie. Ici, l'idée est de recopier l'opérande provenant du bus de données.

[[File:Architecture à accumulateur, microarchitecture.png|centre|vignette|upright=2|Architecture à accumulateur, microarchitecture]]

Pour gérer nativement l'adressage indirect à registre, il suffit de connecter l'accumulateur au bus d'adresse. Le plus simple est d'ajouter un multiplexeur, comme illustré ci-dessous. La donnée lue est copiée dans l'accumulateur, ce qui fait qu'il vaut mieux utiliser un registre d’interfaçage, l'accumulateur n'étant pas utilisable à la fois pour le bus d'adresse et de données.

[[File:Adressage indirect sur une architecture à accumulateur.png|centre|vignette|upright=2|Adressage indirect sur une architecture à accumulateur]]

Pour finir, voyons comment le pointeur de pile et le ''program counter'' sont implémentés. Les architectures à accumulateur ont souvent des adresses de taille différente des données, ce qui fait qu'il vaut mieux utiliser un circuit incrémenteur dédié pour incrémenter le ''program counter'', plutôt que de l'incrémenter via l'unité de calcul. Les architectures à accumulateur ont parfois un pointeur de pile, qui gère une pile d'adresse de retour, pas une vraie pile d'appel. Aussi, le pointeur de pile est censé être incrémenté et décrémenté, pas plus. Pas d'addition ou de soustraction pour gérer des cadres de pile. Là encore, c'est la solution de l'incrémenteur séparé qui est retenue. Pour économiser des transistors, il n'y a qu'un seul incrémenteur partagé pour les deux.

==Les architectures à accumulateur à registres d'indice==

Les architectures à accumulateur décrites dans la section précédente sont capables de faire de l'adressage indirect, mais n'incluent pas les modes d'adressage base + indice et absolus indicés, qui prennent une adresse et y ajoute un indice. Il s'agit des toutes premières architectures à accumulateur, comme les premiers ordinateurs IBM ou le fameux PDP-8. Mais par la suite, les processeurs à accumulateurs ont inclus un support des modes d'adressages indicés, grâce à des '''registres d'indice'''.

===Les registres d'indice===

Les registres d'indice stockent des indices de tableaux. Ils permettaient de supporter deux modes d'adressage :
* Le '''mode d'adressage absolu indicé''' où une adresse fixe est additionnée à un indice variable. L'adresse fixe est intégrée dans l'instruction (adressage absolu), l'indice est dans un registre d'indice.
* Le '''mode d'adressage base + indice''', où l'adresse est dans l'accumulateur et l'indice dans le registre d'indice.

Les processeurs à accumulateur supportaient souvent des variantes des modes d'adressage précédents, où le registre d'indice était automatiquement incrémenté ou décrémenté à chaque utilisation.

Au départ, ces processeurs n'utilisaient qu'un seul registre d'indice qui se comportait comme un second accumulateur spécialisé dans les calculs d'adresses mémoire. Le processeur supportait de nouvelles instructions qui utilisaient ce registre d'indice de façon implicite. Mais avec le temps, les processeurs finirent par incorporer plusieurs de ces registres. Les instructions de lecture ou d'écriture devaient alors préciser quel registre d'indice utiliser, en précisant un nom de registre d'indice, un numéro de registre d'indice.

Il faut préciser que les registres d'indice ont une taille bien plus petite que l'accumulateur. Ils mémorisent des indices codés sur 16 bits ou moins, alors que l'accumulateur faisait typiquement 36 à 48 bits, parfois plus. La taille classique sur les anciens ''mainframes'' était de 15 bits, parfois moins. Il n'était pas rare de tomber sur des registres d'indice de 8 ou 9 bits. Leur petite taille rendait leur implémentation matérielle peu couteuse. Et c'est ce qui explique qu'ils étaient préférés à l'usage d'un second accumulateur.

Un exemple est le cas du processeur Motorola 6809, un processeur à accumulateur qui contient deux registres d'indices nommés X et Y. L'accumulateur est noté D et fait 16 bits, il peut être parfois géré comme deux accumulateurs séparés A et B de 8 bits chacun. Il contenait aussi deux pointeurs de pile, l'un pour les programmes, l'autre pour le système d'exploitation, ainsi qu'un ''program counter''. Le registre de page était utilisé pour l'adressage absolu, comme vu dans le chapitre sur les modes d'adressage.

[[File:6809 Internal Registers.svg|centre|vignette|upright=2|6809 Internal Registers]]

Les processeurs IBM avaient autrefois plusieurs registres d'indice. Par exemple, l'IBM 704 avait trois registres d'indice de 15 bits. Leur contenu était soustrait de l'adresse absolue. Une instruction pouvait utiliser plusieurs registres d'indice pour adresser son opérande. Toute instruction utilisait trois bits pour sélectionner les registres d'indice utilisés. Fait assez original, lorsque plusieurs registres d'indice sont sélectionnés, le processeur n'additionne pas les trois registres à l'adresse de base. À la place, il fait un OU bit à bit entre les registres d'indice sélectionnés, et additionne le résultat à l'adresse.

Les processeurs IBM à accumulateur ont fait ça sur toute la gamme IBM 700/7000, pour des raisons de compatibilité. Les processeurs suivants avaient 7 registres d'indices, mais conservaient les trois bits pour adresser les registres d'indices. Ils pouvaient fonctionner dans deux modes. Le premier mode est plus intuitif : les trois bits précisent un registre d'indice parmi les 7, qui est additionné avec l'adresse absolue. La valeur zéro indique qu'aucun registre d'indice n'est utilisé, ce qui explique qu'il y a 7 registres d'indice et non 8. Un second mode, compatible avec l'IBM 704, fait un OU logique entre les registres d'indice sélectionnés. Seuls les trois premiers registres d'indices peuvent être sélectionnés dans ce mode. Il y a deux instructions pour changer de mode : une pour passer en mode compatible, l'autre pour le quitter pour l'autre mode.

Quelques rares processeurs à registres généraux ont utilisés des registres d'indice, en plus des registres généraux. Ce qui fait l'association que nous avons faite entre registres d'indice et architectures à accumulateur est imparfait, bien que solide sur le principe. Un exemple d'architecture de ce type sont les architectures de la série UNIVAC 1100/2200. Ils disposaient de 128 registres, qui étaient mappés en mémoire à partir de l'adresse mémoire 0, la majorité étant inaccessibles par le programmeur. Ils regroupaient 12 registres accumulateurs, 11 registres d'indice et 4 registres hybrides qui pouvaient servir soit de registre d'indice, soit de registres accumulateurs.

===La micro-architecture des architectures à accumulateur avec registres d'indice===

La présence de registres d'indice modifie grandement l'implémentation du processeur. En effet, il faut rajouter un banc de registre pour les registres d'indice. Le banc de registre est monoport, car on a besoin de lire ou d'écrire un indice à la fois. Et il faut aussi potentiellement rajouter de quoi faire les calculs d'adresse. Deux solutions sont possibles : une ALU dédiée aux calculs d'adresse, une seule ALU pour toutes les opérations.

Dans le premier cas, il y a une ALU séparée associée aux registres d'indice. L'ALU et les registres d'indice sont placés en sortie du séquenceur, en-dehors du chemin de données, la sortie de l'ALU est directement connectée au bus d'adresse. L'unité de calcul d'adresse peut être utilisée pour incrémenter le ''program counter''. Un défaut de cette approche est qu'elle ne gère pas l'adresse indirect à registre.

[[File:Chemin de données sans support des pointeurs, avec adressage absolu indicé.png|centre|vignette|upright=2|Chemin de données sans support des pointeurs, avec adressage absolu indicé]]

Une autre option utilise un bus interne, qui interconnecte tout le chemin de données. Dans sa version la plus simple, il est relié à l'accumulateur, l'unité de calcul, le banc de registre d'indice et le bus de données. Avec cette solution, l'ALU est utilisé à la fois pour calculer les adresses et pour les instructions de calcul. En reliant le bus interne au bus d'adresse à travers un multiplexeur, on gère naturellement les adressages indirects.

[[File:Architecture à accumulateur avec registres associés.png|centre|vignette|upright=2.5|Architecture à accumulateur avec registres associés]]

Il faut noter que sur les architectures Von Neumann, le séquenceur est relié à ce bus interne. En effet, charger une instruction demande de passer par le bus mémoire, donc par l’intermédiaire de ce bus internet. Le ''program counter'' est envoyé sur ce bus pour lire l'instruction, puis l'instruction lue est recopiée dans le registre d'instruction. Le chargement d'une instruction est donc géré comme une lecture des plus classiques. De plus, cela permet d'incrémenter le ''program counter'' au niveau de l'unité de calcul entière. Le ''program counter'' est envoyé sur le bus interne, incrémenté par l'ALU, puis le résultat est recopié dans le ''program counter'' via le bus interne.

[[File:Architecture à accumulateur avec bus unique de type Von Neumann.png|centre|vignette|upright=2|Architecture à accumulateur avec bus unique de type Von Neumann]]

==Les processeurs bi-accumulateurs : le Motorola 6800==

Le Motorola 6800 était un processeur 8 bits qui gérait des adresses de 16 bits. Il contenait deux accumulateurs nommés A et B, de 8 bits chacun. Il disposait aussi d'un registre d'indice, d'un pointeur de pile et d'un ''program counter'', tous les trois de 16 bits. Le registre d'état regroupait 6 bits, qu'on ne détaillera pas ici.

[[File:MC6800 Processor Diagram.png|centre|vignette|upright=2|Interface et registres du MC6800.]]

La présence des deux accumulateurs impactait surtout les instructions dyadiques. Les instructions monadiques avaient juste à préciser où se trouvait l'opérande : soit en RAM, soit dans le premier accumulateur, soit dans le second. Pour les opérations dyadiques, la gestion était totalement différente. En théorie, le premier opérande est dans un accumulateur, soit A, soit B. La seconde opérande vient soit de l'autre accumulateur, soit de la mémoire RAM. Et selon les instructions, tout variait.

Pour l'addition, il y avait trois instructions. Les deux premières additionnaient un opérande provenant de la mémoire avec un accumulateur. L'instruction ADDA sélectionnait le premier accumulateur, l'instruction ADDB sélectionnait le second accumulateur. Mais une troisième instruction, l’instruction ABA, permettait d'additionner le contenu des deux accumulateurs.

Pour les autres opérations, il n'était pas possible d'utiliser les deux accumulateurs en même temps. La seule possibilité était de faire une opération entre un accumulateur et un opérande venant de la mémoire. Toutes les instructions étaient en double, avec une copie par accumulateur. Par exemple, l'instruction ANDA faisait un ET entre l’accumulateur A et l'opérande mémoire, l'instruction ANDB faisait pareil avec l'accumulateur B.

==Les architectures hybrides registres-accumulateur==

Il a existé quelques architectures qui étaient des hybrides entre architectures à accumulateur et architecture à registre. Elles ont servi de transition entre les deux, durant les années 80-90. Elles avaient un accumulateur unique couplé à un banc de registres généraux. Par exemple, les premiers processeurs Intel 8 bits étaient des processeurs hybrides-accumulateur. Lles CPU Intel 8 bits disposaient de 7 registres de 8 bits nommés A, B, C, D, E, F, H, L, SP. Ils correspondent respectivement à :
* l'accumulateur A ;
* six registres nommés B, C, D, E, H et L ;
* le registre d'état F ;
* le pointeur de pile SP.

Sur ces processeurs, les instructions dyadiques devaient mettre leur premier opérande dans l'accumulateur, la seconde provenait soit des registres, soit de la RAM, soit d'une constante immédiate. Les opérations monadiques pouvaient lire leur opérande depuis l'accumulateur, les autres registres ou la RAM, tout était permis. Les registres d'indices disparaissaient sur ces architectures, en théorie. Les registres généraux pouvaient être utilisés comme registre d'indice ou pour stocker des opérandes, ils étaient assez versatiles pour servir de registres d'indices.

La présence de registres a de nombreux avantages, comparé aux architectures à accumulateur pures. Les instructions arithmétiques sont plus rapide, lire un registre étant plus rapide qu'un accès RAM. Les performances sont donc augmentées. De plus, les instructions arithmétiques utilisant ces registres sont plus courtes : pas besoin d'encoder une adresse mémoire, un nom de registre suffit. Vu que les processeurs de l’époque avaient des instructions de taille variable, cela améliorait la densité de code.

La microarchitecture de ces processeurs est très similaire à celle d'un processeur avec des registres d'indices. La seule différence est que le banc de registre contient des registres généraux et non des registres d'indices. Le banc de registre est systématiquement monoport, car il n'avait aucune raison d'être multiport. Pour les instructions dyadiques, seules à lire deux opérandes, il ne servait que pour la seconde opérande, la première était lue depuis l'accumulateur.

Les processeurs hybrides registre-accumulateur se classent en deux types principaux : ceux qui ont un seul bus interne, et ceux qui en ont deux. Le premier cas est identique à celui vu précédemment pour les architectures à accumulateur avec registres d'indice, à la seule différence est que le banc de registre contient des registres généraux et non des registres d'indices. Afin de gérer l'adressage indirect à registre, le bus interne est connecté aux deux registres d’interfaçage mémoire.

[[File:Architecture à accumulateur avec bus unique de type Von Neumann.png|centre|vignette|upright=2|Architecture à accumulateur avec bus unique de type Von Neumann]]

Notons que cela permet aussi d'implémenter facilement les branchements indirects, car le bus interne permet d'échanger des adresses entre ''program counter'' et banc de registre. De même, il est possible d'utiliser l'ALU pour gérer les branchements indirects., en plus de l'utiliser pour incrémenter le ''program counter''.

[[File:Single bus organization.jpg|centre|vignette|upright=2|Single bus organization]]

Une autre solution utilisait deux bus internes : un connecté au bus de données, un autre relié au bus d'adresse. Le bus de commande mémoire était lui commandé par le séquenceur, l'unité de contrôle. L'intermédiaire entre ces deux bus était le banc de registre, ainsi que les autres registres. Le banc de registre était connecté aux deux bus interne, avec un port de lecture relié au bus d'adresse, un port de lecture-écriture relié au bus de données. Le port de lecture était utilisé pour l'adressage indirect, l'autre l'était pour le reste.

[[File:Proz1-e.png|centre|vignette|upright=2|Intérieur d'un processeur.]]

L'organisation à deux bus simplifiait la gestion du ''program counter'' et le chargement des instructions. Le ''program counter'' était soit séparé du banc de registre, soit placé dans le banc de registre. Les deux solutions étaient utilisés, tout dépend du processeur. Il faut noter que si le ''program counter'' est intégré au banc de registres, alors la microarchitecture du processeur est bien plus simple. L'envoi du ''program counter'' sur le bus d'adresse utilise le port de lecture relié au bus d'adresse, qui sert aussi pour l'adressage indirect. L'économie de circuits, sans compter la simplicité d'implémentation que cela implique, explique sans doute que la technique a été utilisée sur quelques processeurs anciens.

Le ''program counter'' était généralement incrémenté par l'ALU, ce qui explique qu'il soit connecté au bus interne pour les données. La connexion est aussi utile pour gérer les branchements indirects, qui copient un registre dans le ''program counter'', ainsi que les branchements relatifs (addition dans l'ALU), voire les branchements directs (l'adresse vers laquelle brancher est envoyée en entrée de l'ALU et propagée en sortie avec une opération ''pass through'').

[[File:Connexion du program counter sur les bus avec PC dans le banc de registres.png|centre|vignette|upright=2|Connexion du program counter sur les bus avec PC dans le banc de registres]]

===Les registres d'interruption avec un processeur hybride-accumulateur : l'exemple du Z80===

Un exemple de processeur registre-accumulateur à deux bus interne est le Z80, un processeur fortement inspiré des CPU Intel 8 bits. Il a un jeu d'instruction similaire, mais a diverses améliorations par rapport au design original. Notamment, le processeur a des registres séparés pour les interruptions.

Sur le Z80, les registres généraux sont dupliqués avec 6 registres pour les interruptions et 6 registres pour les programmes autres. Leur copie pour les interruptions sont nommées B', C', D', E', H', L'. Les 12 registres sont placés dans le banc de registre, ce qui implique que le fenêtrage de registres est utilisé pour gérer la séparation entre registre d'interruption et normaux. Il faut noter que l'accumulateur et le registre d'état sont aussi dupliqués, leurs copies étant nommées A' et F'. Mais leur duplication se fait autrement que par fenêtrage de registre.

En plus des registres précédents, le Z80 incorporait deux registres d'indice nommés X et Y, ainsi qu'un pointeur de pile SP et un ''program counter'' PC. Ils n'étaient pas dupliqués pour les interruptions. Les registres d'indice étaient reliés à une unité de calcul d'adresse. L'unité de calcul d'adresse prenait deux opérandes : un indice, et une adresse mémoire provenant soit du banc de registre, soit de l'accumulateur. En clair, l'unité de calcul d'adresse faisait le lien entre les deux bus internet : le bus de données interne en entrée, le bus d'adresse en sortie.

À l'intérieur du processeur, tous les registres étaient regroupés dans un banc de registre unique, sauf les accumulateurs, les registres d'état et le ''program counter''. Bien que ce ne soit pas indiqué sur le schéma ci-dessous, le ''program counter'' est séparé du banc de registre, alors que le pointeur de pile est dedans. Le compteur IR est lui associé au ''program counter'', il est sortit du banc de registre. Le Z80 utilise lui aussi un incrémenteur séparé de l'ALU, qui est utilisé pour mettre à jour le ''program counter'', le pointeur de pile et un compteur de rafraichissement mémoire nommé IR sur le Z80 (pour rappel, le rafraichissement mémoire demande de balayer la mémoire d'adresse en adresse et été fait par le CPU à l'époque). De plus, il est utilisé pour les instructions INC et DEC qui incrémentent une opérande de 16 bits obtenue en combinant deux registres de 8 bits. En clair, l'incrémenteur du ''program counter'' a été réutilisé de beaucoup de manières originales.

[[File:Z80 arch.svg|centre|vignette|upright=3|Microarchitecture du Z80.]]

Le Z80 incorporait des instructions pour échanger le contenu des deux ensembles de registres, accumulateur inclus. Elles permettaient d'utiliser les registres d'interruption pour les programmes et réciproquement. En clair, cela doublait le nombre de registres si les interruptions n'étaient pas utilisées.
* L'instruction EXX échangeait les deux fenêtres de registres généraux : les registres B, C, D, E, H et L devenaient les registres B', C', D', E', H' et L' et inversement.
* L'instruction EX échangeait l'accumulateur et le registre d'état : les registres A,F devenait A',F' et inversement.

Le fenêtrage de registre était modifié par l'instruction EXX, qui échangeait les deux fenêtres de registres. Pour l'implémenter, une bascule était ajouté au processeur, appelons-la la bascule INT. Elle était relié au bus d'adresse du banc de registre, dont elle mémorisait le bit de poids fort. L'instruction EXX inversait la valeur de la bascule INT. Il est aussi possible d'échanger le contenu des registres D,E et H,L avec une instruction dédiée, ce qui est là encore fait par deux bascules : une pour les registres D,E et une autre pour les registres H,L.

Pour l'accumulateur et le registre d'état, le choix entre registre normal et registre d'interruption se faisait là encore par une seconde bascule appelée la bascule A. La bascule est reliée à un multiplexeur et un démultiplexeur, qui permet de choisir quel accumulateur relier à l'unité de calcul. L'instruction EX inverse le contenu de la bascule A.

&lt;noinclude&gt;
{{NavChapitre | book=Fonctionnement d'un ordinateur
           | prev=L'unité de contrôle
           | prevText=L'unité de contrôle
           | next=Les processeurs 8 bits et moins
           | nextText=Les processeurs 8 bits et moins
}}
&lt;/noinclude&gt;</text>
      <sha1>8gj97m8c5t53ho5ux8dwtvf7oh7v7mr</sha1>
    </revision>
    <revision>
      <id>744154</id>
      <parentid>744141</parentid>
      <timestamp>2025-06-05T13:48:52Z</timestamp>
      <contributor>
        <username>Mewtow</username>
        <id>31375</id>
      </contributor>
      <minor />
      <comment>/* Annexe : les toutes premières architectures à accumulateur : le Manchester Baby */</comment>
      <origin>744154</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="37402" sha1="7wbxedz6dwrn6wwf6wejvybkllmwwe4" xml:space="preserve">Les architectures que nous avons vu précédemment dans ce cours disposent de registres pour les données, en plus du pointeur de pile, d'un ''program counter'', et de quelques autres. Elles sont appelées des '''architectures à registres''', terme qui trahit bien le fait qu'elles ont des registres généraux ou spécialisés pour stocker temporairement des données. Et si on leur a donné un nom, c'est parce qu'il existe des architectures qui ne sont pas dans cette catégorie. Il en existe plusieurs types, mais ce chapitre va se concentrer sur les '''architectures à accumulateur'''.

[[File:Isaccumulator.png|vignette|Architecture à accumulateur.]]

Les architectures à accumulateur sont centrées autour d'un registre architectural appelé l''''accumulateur'''. Il est utilisé pour toutes les opérations arithmétiques dyadiques, où il sert à la fois de source et de destination. Toutes les instructions dyadiques sont de type ''load-op'' : une opérande est lue depuis l'accumulateur, le second opérande est lu depuis la mémoire RAM, le résultat de l'instruction est automatiquement mémorisé dans l'accumulateur. Les instructions monadiques peuvent utiliser un opérande dans l'accumulateur, ou dans la mémoire RAM, les deux sont théoriquement possibles.

La conséquence est que le nombre d'accès mémoire est drastiquement diminué : de 3 par instructions sur une architecture mémoire-mémoire, on passe à seulement un avec un accumulateur. Les opérations dyadiques ont besoin d'un seul accès mémoire pour lire la seconde opérande, les opérations monadique en font aussi un seul pour lire leur unique opérande.

{|class=&quot;wikitable&quot;
|-
! Classe d'architecture
! Nombre d'accès mémoire par opération dyadique
|-
|-
! Architecture à accumulateur
| Un accès mémoire par instruction, pour lire la seconde opérande
|-
! Architecture à registres
| Zéro si les opérandes sont dans les registres, un pour les opérations ''load-op'', LOAD et STORE.
|}

==Le jeu d'instruction des architectures à accumulateur sans registres d'indice==

L'accumulateur est adressé grâce au mode d'adressage implicite, de même que le résultat de l'opération. Par contre, les autres opérandes sont localisés avec d'autres modes d'adressage, et lues en mémoire RAM. Le résultat ainsi qu'un des opérandes sont adressés de façon implicite car dans l'accumulateur, seule la seconde opérande étant adressée directement. Grâce à l'accumulateur, une instruction ne fait qu'un seul accès mémoire maximum, ce qui rend le processeur très facile à implémenter.

===Les registres des anciennes architectures à accumulateur===

[[File:IBM 701console.jpg|vignette|IBM 701, console extérieure.]]

Les architectures à accumulateur étaient communes dans les années 50-60. A l'époque, les ordinateurs étaient gigantesques, ils prenaient une pièce de bâtiment entière dans le pire des cas, une armoire entière dans le meilleur. Les ordinateurs de l'époque étaient surtout utilisés pour du calcul scientifique ou des tâches d’ingénierie demandant beaucoup de calcul, rarement pour de la compatibilité.

Les nombres flottants n'étaient pas encore apparus. A la place, les ordinateurs de l'époque géraient des nombres entiers de grande taille, de 30 bits ou plus. En conséquence, l'accumulateur faisait facilement 30 à 60 bits. Par exemple, les ordinateurs de la Série scientifique IBM 700/7000 géraient des entiers de 36 bits, l’accumulateur faisait 38 bits : 36 bits plus deux bits pour les débordements. Au passage, de tels processeurs utilisaient l'adressage par mot, et non par byte.

Historiquement, les premières architectures à accumulateur ne contenaient aucun autre registre que l'accumulateur. Ce n'est que dans les années 60 que de nombreuses architectures à accumulateur ont ajouté un second '''registre pour les multiplication/divisions'''. Un exemple est celui de l'IBM 701, qui incorporait un registre accumulateur de 38 bits et un registre multiplieur de 36 bits. Le registre mémorise le multiplieur lors d'une opération de multiplication. Il mémorise donc un opérande, pas le résultat. Il peut aussi décaler le multiplieur vers la droite/gauche, ce qui est utile pour exécuter la multiplication. C'est ce qui est fait sur l'IBM 7094.

Une autre possibilité est que ce registre mémorise une partie du résultat de l'opération. Pour rappel, le résultat d'une multiplication/division est codé sur deux fois de bits que ses opérandes. Par exemple, multipliez deux opérandes de 30 bits, vous obtiendrez un résultat de 60 bits. Les 30 bits de poids faible du résultat vont dans l'accumulateur, les 30 bits de poids fort vont dans ce second registre.

Les architectures à accumulateur parfois un '''registre pour le pointeur de pile''', utilisé pour gérer les fonctions/procédures. Les architectures à accumulateurs supportaient une pile d'adresse de retour, souvent une pile d'appel. Mais pour cela, il fallait mémoriser le pointeur de pile dans le processeur, ce qui demandait un registre dédié.

===L'adressage indirect avec l'accumulateur===

Les instructions LOAD et STORE existent bel et bien sur les architectures à accumulateur, mais n'ont pas les mêmes modes d'adressages. L'instruction LOAD copie une donnée de la RAM vers l'accumulateur, l'instruction STORE copie l'accumulateur dans une adresse. Les deux instructions n'ont pas besoin d'adresser l'accumulateur, qui est adressé de manière implicite, juste de préciser l'adresse à lire/écrire.

Les architectures à accumulateur supportaient souvent le mode d'adressage indirect mémoire. Un exemple est celui des ordinateurs Data General Nova, qui sont des architectures à accumulateur et qui supportaient ce mode d'adressage. Les deux instructions LOAD et STORE existaient en deux versions, distinguées par un bit d'indirection. Si ce bit est à 0 dans l'opcode, alors l'instruction utilise le mode d'adressage absolu normal : l'adresse intégrée dans l'instruction est celle de la donnée. Mais s'il est à 1, alors l'adresse intégrée dans l'instruction est celle du pointeur.

Cependant, la présence de l'accumulateur permettait d'utiliser l'adressage indirect à registre, pour gérer les pointeurs. Pour rappel, avec le mode d'adressage indirect à registre, l'adresse à lire/écrire est dans un registre. Ici, l'adresse à lire/écrire est prise dans l'accumulateur, seul registre disponible pour. L'adressage indirect est plus simple à implémenter pour l'instruction LOAD, car elle prend un seul opérande : l'adresse à lire. L'adresse à lire est placée dans l'accumulateur, la donnée lue est elle aussi chargée dans l'accumulateur. Pour l'instruction STORE, il faut fournir deux opérandes, l'adresse et la donnée à écrire, ce qui peut poser problème. Mais au pire, il est toujours possible d'utiliser l'adressage absolu ou indirect mémoire : l'adresse est dans l'instruction, la donnée à écrire dans l'accumulateur.

===L'encodage des instructions===

Sur une architecture à accumulateur l'encodage d'une instruction dyadique est assez simple, vu que l'accumulateur est adressé implicitement. La seconde opérande est localisée soit par une adresse mémoire (adressage absolu), soit est une constante (adressage immédiat). L'adresse mémoire est généralement assez longue, plus que l'opcode.

{|class=&quot;wikitable&quot;
|+ Encodage d'une instruction dyadique
|-
! rowspan=&quot;2&quot; | Opcode 
| Adresse mémoire (adressage absolu)
|-
| Constante (adressage immédiat)
|}

L'encodage d'une instruction monadique est similaire. Si l'opérande est lue depuis la mémoire RAM, alors l'instruction est encodée comme une instruction dyadique. Il en est de même pour les instructions qui copient une constante dans l'accumulateur. Par contre, si l'opérande est dans l'accumulateur, alors il y a juste besoin d'encoder l'opcode. La majorité des instructions a besoin de préciser une adresse, rares sont celles qui s'en passent. Au vu de cet encodage, les architectures à accumulateur sont qualifiées d''''architectures à une adresse''' par abus de langage.

Il est intéressant de contraster leur encodage avec les architectures à registres. Les architectures à registre doivent encoder deux opérandes en plus de l'opcode, avec éventuellement où enregistrer le résultat sur les architectures 3-adresses. Par contre, les opérandes sont généralement des noms de registre, ce qui prend moins de place qu'une adresse mémoire. A la rigueur, les instructions avec une constante immédiate prennent un peu plus de place, car elles doivent encoder un nom de registre en plus de la constante et de l'opcode. Les instructions ''load-op'' des processeurs CISC sont un peu dans le même cas, sauf qu'il faut remplacer la constante par une adresse, qui a généralement la même taille. Les instructions sont donc en moyenne plus courte sur les processeurs à registre, du fait de la présence de registres.

===Annexe : les toutes premières architectures à accumulateur : le Manchester Baby===

[[File:BabyArchitecture.png|vignette|Architecture de la Manchester Baby.]]

Les architectures à accumulateurs sont apparues dès les débuts de l'informatique. Le tout premier ordinateur à programme enregistré en mémoire, le ''Manchester Baby'', était une architecture à accumulateur. Niveau interface, l'ordinateur avait une console avec 32 boutons, des interrupteurs et un écran de sortie sur lequel afficher les résultats. A l'intérieur, il y avait un processeur et une RAM de 32 adresses, fabriquée avec des tubes Williams (abordés dans une annexe à la fin du cours). Chaque adresse mémorisait 32 bits, qui pouvaient encoder soit un nombre, soit une instruction.

Le programme devait tenir dans la RAM, avec une instruction par adresse maximum, ce qui limitait les programmes à 32 instructions maximum. Une instruction prenait donc 32 bits, 3 indiquaient quelle opération utiliser, 12 servait à indiquer où se trouvent la seconde opérande en RAM, les 16 restants sont inutilisés.

Le processeur avait un registre accumulateur de 32 bits, un ''program counter'' et un registre d'instruction. Il gérait 8 instructions en tout, mais ne gérait pas l'addition. Il gérait la soustraction, des instructions de branchement et d'accès mémoire, rien d'autre. Il pouvait cependant émuler l'addition à partir d'une soustraction et inversant l'opérande soustraite. L'ALU était une ALU sérielle, à savoir qu'elle faisait les soustractions bit par bit.

Le Manchester Mark 1 était une amélioration du Manchester Baby. Il utilisait 4500 tubes à vide. L'ordinateur gérait des nombres de 40 bits, mais les instructions étaient codées sur 20 bits. La RAM avait la même taille, à savoir 32 nombres, leur taille était simplement augmentée. Par contre, la RAM était complémentée par l’ancêtre du disque dur magnétique, à savoir un tambour magnétique, l’ancêtre du disque dur magnétique. Il contenait 40 pages, chacune ayant la même taille que la RAM. C'était là encore une architecture à accumulateur, sauf qu'elle intégrait aussi des registres d'indice. Et surtout : son processeur gérait l'addition et quelques opérations logiques (ET et OU), en plus de la soustraction et de la comparaison.

[[File:MM1Schematic French.svg|centre|vignette|upright=2.5|Architecture de la Manchester Mark 1.]]

==La micro-architecture des architectures à accumulateur sans registres d'indice==

L'organisation interne d'une architecture à accumulateur est très différente de celle des processeurs à registre. Elle est plus ou moins la même pour tous ces processeurs, le point important étant que le chemin de données se résume à une ALU, un registre accumulateur et le bus de données. L'ALU est reliée au registre accumulateur, ainsi qu'au bus de données pour lire la seconde opérande, comme illustré ci-dessous.

[[File:Accumulator.png|centre|vignette|upright=2|Accumulateur.]]

===L'unité de calcul et l'accumulateur===

Pour simplifier l'implémentation, le résultat est mémorisé dans un registre en sortie de l'unité de calcul. La raison est qu'on ne veut pas altérer l'accumulateur tant que le résultat final n'est pas totalement calculé. Rappelons que l'ALU ne fournit pas un résultat d'un seul bloc, mais que certains bits arrivent avant les autres, typiquement les bits de poids faible. Si le résultat était écrit dans l'accumulateur directement, il écraserait des bits de l’opérande en cours d'utilisation, ce qui fausserait le résultat.

[[File:Accumulateur avec registre de sortie.png|centre|vignette|upright=2|Accumulateur avec registre de sortie]]

Une autre solution utilisait un registre entre l'accumulateur et l'unité de calcul, appelé l’'''''accumulator latch'''''. Il remplace le registre en sortie de l'ALU, dans le sens où il permet d'écrire dans l'accumulateur sans effacer l'opérande, pendant que l’opération est en cours dans l'ALU. L'accumulateur est copié dans l’''accumulator latch'', avant que l'ALU démarre ses calculs. L'opérande est donc maintenue même si on commence à écrire le résultat dans l'accumulateur.

Sur le 8085 d'Intel, l’''accumulator latch'' peut être initialisé avec une constante prédéfinie, ce qui permet d'implémenter certaines instructions très facilement. Par exemple, il peut être initialisé à 0, ce qui permet d'implémenter les instructions MOV et INC (incrémentation). Un MOV est équivalent à faire un OU entre le registre lu et 0. Une instruction INC initialise l'entrée de retenue de l'unité de calcul à 1, puis ajoute 0. La décrémentation est implémentée de la même manière, sauf que l’''accumulator latch'' est initialisé à -2 pour compenser l'entrée de retenue à 1. De plus, pour supporter les conversion de décimal à BCD, l’''accumulator latch'' peut être initialisé avec les constantes 0x00, 0x06, 0x60, or 0x66. L'''accumulator latch'' est relié à divers fils de commande provenant de l'unité de contrôle, qui décide quelle valeur d'initialisation utiliser en fonction de l'instruction décodée.

[[File:Accumulator latch.png|centre|vignette|upright=2|Accumulator latch]]

[[File:Chemin de données à un seul bus.png|vignette|Chemin de données à un seul bus]]

De même, la seconde opérande, celle lue sur le bus de données, est mémorisée dans un registre en amont de l'ALU. C'était notamment très utile si le processeur utilisait une ALU plus courte que les opérandes, avec par exemple une ALU 4 bits pour un CPU 8 bits. Les anciens processeurs à accumulateur de type ''mainframe'' utilisaient des opérandes de grande taille, du genre 36 ou 48 bits, ce qui avait des conséquences sur l'unité de calcul utilisée, ainsi que sur la communication avec la mémoire. Il arrivait que de tels processeurs utilisaient des ALU sérielles, ou du moins octet-sérielles, plutôt qu'une véritable ALU 36 bits. Nous verrons aussi que c'est très utile sur les processeurs à accumulateur avec un bus interne unique, dans la suite du chapitre.

===La micro-architecture des architectures à accumulateur avec instructions LOAD/STORE===

Nous venons de voir comment est implémenté l'unité de calcul et l'accumulateur, et comment le tout est relié au bus de données. Mais cela ne permet que d'avoir un processeur à accumulateur rudimentaire, qui ne gére que des instructions arithmétiques et logiques. Il faut aussi gérer le cas des opérations LOAD/STORE et des modes d'adressages associés, mais c'est le séquenceur qui s'en occupe. Avec l'adressage absolu, les instructions LOAD et STORE ne font que connecter l'accumulateur au bus de données. L'instruction STORE nécessite de connecter l'accumulateur au bus de données, de manière à ce que le transfert des données se fasse de l'accumulateur vers le bus de données. L'instruction LOAD s'implémente de la même manière, sauf que le sens de transfert est inversé.

Cependant, il existe une optimisation qui permet d'implémenter l'instruction LOAD sans ajouter de circuits. Pour cela, il suffit que l'unité de calcul gére les opérations ''pass through'', à savoir des opérations qui se contentent de recopier un opérande sur la sortie. Ici, l'idée est de recopier l'opérande provenant du bus de données.

[[File:Architecture à accumulateur, microarchitecture.png|centre|vignette|upright=2|Architecture à accumulateur, microarchitecture]]

Pour gérer nativement l'adressage indirect à registre, il suffit de connecter l'accumulateur au bus d'adresse. Le plus simple est d'ajouter un multiplexeur, comme illustré ci-dessous. La donnée lue est copiée dans l'accumulateur, ce qui fait qu'il vaut mieux utiliser un registre d’interfaçage, l'accumulateur n'étant pas utilisable à la fois pour le bus d'adresse et de données.

[[File:Adressage indirect sur une architecture à accumulateur.png|centre|vignette|upright=2|Adressage indirect sur une architecture à accumulateur]]

Pour finir, voyons comment le pointeur de pile et le ''program counter'' sont implémentés. Les architectures à accumulateur ont souvent des adresses de taille différente des données, ce qui fait qu'il vaut mieux utiliser un circuit incrémenteur dédié pour incrémenter le ''program counter'', plutôt que de l'incrémenter via l'unité de calcul. Les architectures à accumulateur ont parfois un pointeur de pile, qui gère une pile d'adresse de retour, pas une vraie pile d'appel. Aussi, le pointeur de pile est censé être incrémenté et décrémenté, pas plus. Pas d'addition ou de soustraction pour gérer des cadres de pile. Là encore, c'est la solution de l'incrémenteur séparé qui est retenue. Pour économiser des transistors, il n'y a qu'un seul incrémenteur partagé pour les deux.

==Les architectures à accumulateur à registres d'indice==

Les architectures à accumulateur décrites dans la section précédente sont capables de faire de l'adressage indirect, mais n'incluent pas les modes d'adressage base + indice et absolus indicés, qui prennent une adresse et y ajoute un indice. Il s'agit des toutes premières architectures à accumulateur, comme les premiers ordinateurs IBM ou le fameux PDP-8. Mais par la suite, les processeurs à accumulateurs ont inclus un support des modes d'adressages indicés, grâce à des '''registres d'indice'''.

===Les registres d'indice===

Les registres d'indice stockent des indices de tableaux. Ils permettaient de supporter deux modes d'adressage :
* Le '''mode d'adressage absolu indicé''' où une adresse fixe est additionnée à un indice variable. L'adresse fixe est intégrée dans l'instruction (adressage absolu), l'indice est dans un registre d'indice.
* Le '''mode d'adressage base + indice''', où l'adresse est dans l'accumulateur et l'indice dans le registre d'indice.

Les processeurs à accumulateur supportaient souvent des variantes des modes d'adressage précédents, où le registre d'indice était automatiquement incrémenté ou décrémenté à chaque utilisation.

Au départ, ces processeurs n'utilisaient qu'un seul registre d'indice qui se comportait comme un second accumulateur spécialisé dans les calculs d'adresses mémoire. Le processeur supportait de nouvelles instructions qui utilisaient ce registre d'indice de façon implicite. Mais avec le temps, les processeurs finirent par incorporer plusieurs de ces registres. Les instructions de lecture ou d'écriture devaient alors préciser quel registre d'indice utiliser, en précisant un nom de registre d'indice, un numéro de registre d'indice.

Il faut préciser que les registres d'indice ont une taille bien plus petite que l'accumulateur. Ils mémorisent des indices codés sur 16 bits ou moins, alors que l'accumulateur faisait typiquement 36 à 48 bits, parfois plus. La taille classique sur les anciens ''mainframes'' était de 15 bits, parfois moins. Il n'était pas rare de tomber sur des registres d'indice de 8 ou 9 bits. Leur petite taille rendait leur implémentation matérielle peu couteuse. Et c'est ce qui explique qu'ils étaient préférés à l'usage d'un second accumulateur.

Un exemple est le cas du processeur Motorola 6809, un processeur à accumulateur qui contient deux registres d'indices nommés X et Y. L'accumulateur est noté D et fait 16 bits, il peut être parfois géré comme deux accumulateurs séparés A et B de 8 bits chacun. Il contenait aussi deux pointeurs de pile, l'un pour les programmes, l'autre pour le système d'exploitation, ainsi qu'un ''program counter''. Le registre de page était utilisé pour l'adressage absolu, comme vu dans le chapitre sur les modes d'adressage.

[[File:6809 Internal Registers.svg|centre|vignette|upright=2|6809 Internal Registers]]

Les processeurs IBM avaient autrefois plusieurs registres d'indice. Par exemple, l'IBM 704 avait trois registres d'indice de 15 bits. Leur contenu était soustrait de l'adresse absolue. Une instruction pouvait utiliser plusieurs registres d'indice pour adresser son opérande. Toute instruction utilisait trois bits pour sélectionner les registres d'indice utilisés. Fait assez original, lorsque plusieurs registres d'indice sont sélectionnés, le processeur n'additionne pas les trois registres à l'adresse de base. À la place, il fait un OU bit à bit entre les registres d'indice sélectionnés, et additionne le résultat à l'adresse.

Les processeurs IBM à accumulateur ont fait ça sur toute la gamme IBM 700/7000, pour des raisons de compatibilité. Les processeurs suivants avaient 7 registres d'indices, mais conservaient les trois bits pour adresser les registres d'indices. Ils pouvaient fonctionner dans deux modes. Le premier mode est plus intuitif : les trois bits précisent un registre d'indice parmi les 7, qui est additionné avec l'adresse absolue. La valeur zéro indique qu'aucun registre d'indice n'est utilisé, ce qui explique qu'il y a 7 registres d'indice et non 8. Un second mode, compatible avec l'IBM 704, fait un OU logique entre les registres d'indice sélectionnés. Seuls les trois premiers registres d'indices peuvent être sélectionnés dans ce mode. Il y a deux instructions pour changer de mode : une pour passer en mode compatible, l'autre pour le quitter pour l'autre mode.

Quelques rares processeurs à registres généraux ont utilisés des registres d'indice, en plus des registres généraux. Ce qui fait l'association que nous avons faite entre registres d'indice et architectures à accumulateur est imparfait, bien que solide sur le principe. Un exemple d'architecture de ce type sont les architectures de la série UNIVAC 1100/2200. Ils disposaient de 128 registres, qui étaient mappés en mémoire à partir de l'adresse mémoire 0, la majorité étant inaccessibles par le programmeur. Ils regroupaient 12 registres accumulateurs, 11 registres d'indice et 4 registres hybrides qui pouvaient servir soit de registre d'indice, soit de registres accumulateurs.

===La micro-architecture des architectures à accumulateur avec registres d'indice===

La présence de registres d'indice modifie grandement l'implémentation du processeur. En effet, il faut rajouter un banc de registre pour les registres d'indice. Le banc de registre est monoport, car on a besoin de lire ou d'écrire un indice à la fois. Et il faut aussi potentiellement rajouter de quoi faire les calculs d'adresse. Deux solutions sont possibles : une ALU dédiée aux calculs d'adresse, une seule ALU pour toutes les opérations.

Dans le premier cas, il y a une ALU séparée associée aux registres d'indice. L'ALU et les registres d'indice sont placés en sortie du séquenceur, en-dehors du chemin de données, la sortie de l'ALU est directement connectée au bus d'adresse. L'unité de calcul d'adresse peut être utilisée pour incrémenter le ''program counter''. Un défaut de cette approche est qu'elle ne gère pas l'adresse indirect à registre.

[[File:Chemin de données sans support des pointeurs, avec adressage absolu indicé.png|centre|vignette|upright=2|Chemin de données sans support des pointeurs, avec adressage absolu indicé]]

Une autre option utilise un bus interne, qui interconnecte tout le chemin de données. Dans sa version la plus simple, il est relié à l'accumulateur, l'unité de calcul, le banc de registre d'indice et le bus de données. Avec cette solution, l'ALU est utilisé à la fois pour calculer les adresses et pour les instructions de calcul. En reliant le bus interne au bus d'adresse à travers un multiplexeur, on gère naturellement les adressages indirects.

[[File:Architecture à accumulateur avec registres associés.png|centre|vignette|upright=2.5|Architecture à accumulateur avec registres associés]]

Il faut noter que sur les architectures Von Neumann, le séquenceur est relié à ce bus interne. En effet, charger une instruction demande de passer par le bus mémoire, donc par l’intermédiaire de ce bus internet. Le ''program counter'' est envoyé sur ce bus pour lire l'instruction, puis l'instruction lue est recopiée dans le registre d'instruction. Le chargement d'une instruction est donc géré comme une lecture des plus classiques. De plus, cela permet d'incrémenter le ''program counter'' au niveau de l'unité de calcul entière. Le ''program counter'' est envoyé sur le bus interne, incrémenté par l'ALU, puis le résultat est recopié dans le ''program counter'' via le bus interne.

[[File:Architecture à accumulateur avec bus unique de type Von Neumann.png|centre|vignette|upright=2|Architecture à accumulateur avec bus unique de type Von Neumann]]

==Les processeurs bi-accumulateurs : le Motorola 6800==

Le Motorola 6800 était un processeur 8 bits qui gérait des adresses de 16 bits. Il contenait deux accumulateurs nommés A et B, de 8 bits chacun. Il disposait aussi d'un registre d'indice, d'un pointeur de pile et d'un ''program counter'', tous les trois de 16 bits. Le registre d'état regroupait 6 bits, qu'on ne détaillera pas ici.

[[File:MC6800 Processor Diagram.png|centre|vignette|upright=2|Interface et registres du MC6800.]]

La présence des deux accumulateurs impactait surtout les instructions dyadiques. Les instructions monadiques avaient juste à préciser où se trouvait l'opérande : soit en RAM, soit dans le premier accumulateur, soit dans le second. Pour les opérations dyadiques, la gestion était totalement différente. En théorie, le premier opérande est dans un accumulateur, soit A, soit B. La seconde opérande vient soit de l'autre accumulateur, soit de la mémoire RAM. Et selon les instructions, tout variait.

Pour l'addition, il y avait trois instructions. Les deux premières additionnaient un opérande provenant de la mémoire avec un accumulateur. L'instruction ADDA sélectionnait le premier accumulateur, l'instruction ADDB sélectionnait le second accumulateur. Mais une troisième instruction, l’instruction ABA, permettait d'additionner le contenu des deux accumulateurs.

Pour les autres opérations, il n'était pas possible d'utiliser les deux accumulateurs en même temps. La seule possibilité était de faire une opération entre un accumulateur et un opérande venant de la mémoire. Toutes les instructions étaient en double, avec une copie par accumulateur. Par exemple, l'instruction ANDA faisait un ET entre l’accumulateur A et l'opérande mémoire, l'instruction ANDB faisait pareil avec l'accumulateur B.

==Les architectures hybrides registres-accumulateur==

Il a existé quelques architectures qui étaient des hybrides entre architectures à accumulateur et architecture à registre. Elles ont servi de transition entre les deux, durant les années 80-90. Elles avaient un accumulateur unique couplé à un banc de registres généraux. Par exemple, les premiers processeurs Intel 8 bits étaient des processeurs hybrides-accumulateur. Lles CPU Intel 8 bits disposaient de 7 registres de 8 bits nommés A, B, C, D, E, F, H, L, SP. Ils correspondent respectivement à :
* l'accumulateur A ;
* six registres nommés B, C, D, E, H et L ;
* le registre d'état F ;
* le pointeur de pile SP.

Sur ces processeurs, les instructions dyadiques devaient mettre leur premier opérande dans l'accumulateur, la seconde provenait soit des registres, soit de la RAM, soit d'une constante immédiate. Les opérations monadiques pouvaient lire leur opérande depuis l'accumulateur, les autres registres ou la RAM, tout était permis. Les registres d'indices disparaissaient sur ces architectures, en théorie. Les registres généraux pouvaient être utilisés comme registre d'indice ou pour stocker des opérandes, ils étaient assez versatiles pour servir de registres d'indices.

La présence de registres a de nombreux avantages, comparé aux architectures à accumulateur pures. Les instructions arithmétiques sont plus rapide, lire un registre étant plus rapide qu'un accès RAM. Les performances sont donc augmentées. De plus, les instructions arithmétiques utilisant ces registres sont plus courtes : pas besoin d'encoder une adresse mémoire, un nom de registre suffit. Vu que les processeurs de l’époque avaient des instructions de taille variable, cela améliorait la densité de code.

La microarchitecture de ces processeurs est très similaire à celle d'un processeur avec des registres d'indices. La seule différence est que le banc de registre contient des registres généraux et non des registres d'indices. Le banc de registre est systématiquement monoport, car il n'avait aucune raison d'être multiport. Pour les instructions dyadiques, seules à lire deux opérandes, il ne servait que pour la seconde opérande, la première était lue depuis l'accumulateur.

Les processeurs hybrides registre-accumulateur se classent en deux types principaux : ceux qui ont un seul bus interne, et ceux qui en ont deux. Le premier cas est identique à celui vu précédemment pour les architectures à accumulateur avec registres d'indice, à la seule différence est que le banc de registre contient des registres généraux et non des registres d'indices. Afin de gérer l'adressage indirect à registre, le bus interne est connecté aux deux registres d’interfaçage mémoire.

[[File:Architecture à accumulateur avec bus unique de type Von Neumann.png|centre|vignette|upright=2|Architecture à accumulateur avec bus unique de type Von Neumann]]

Notons que cela permet aussi d'implémenter facilement les branchements indirects, car le bus interne permet d'échanger des adresses entre ''program counter'' et banc de registre. De même, il est possible d'utiliser l'ALU pour gérer les branchements indirects., en plus de l'utiliser pour incrémenter le ''program counter''.

[[File:Single bus organization.jpg|centre|vignette|upright=2|Single bus organization]]

Une autre solution utilisait deux bus internes : un connecté au bus de données, un autre relié au bus d'adresse. Le bus de commande mémoire était lui commandé par le séquenceur, l'unité de contrôle. L'intermédiaire entre ces deux bus était le banc de registre, ainsi que les autres registres. Le banc de registre était connecté aux deux bus interne, avec un port de lecture relié au bus d'adresse, un port de lecture-écriture relié au bus de données. Le port de lecture était utilisé pour l'adressage indirect, l'autre l'était pour le reste.

[[File:Proz1-e.png|centre|vignette|upright=2|Intérieur d'un processeur.]]

L'organisation à deux bus simplifiait la gestion du ''program counter'' et le chargement des instructions. Le ''program counter'' était soit séparé du banc de registre, soit placé dans le banc de registre. Les deux solutions étaient utilisés, tout dépend du processeur. Il faut noter que si le ''program counter'' est intégré au banc de registres, alors la microarchitecture du processeur est bien plus simple. L'envoi du ''program counter'' sur le bus d'adresse utilise le port de lecture relié au bus d'adresse, qui sert aussi pour l'adressage indirect. L'économie de circuits, sans compter la simplicité d'implémentation que cela implique, explique sans doute que la technique a été utilisée sur quelques processeurs anciens.

Le ''program counter'' était généralement incrémenté par l'ALU, ce qui explique qu'il soit connecté au bus interne pour les données. La connexion est aussi utile pour gérer les branchements indirects, qui copient un registre dans le ''program counter'', ainsi que les branchements relatifs (addition dans l'ALU), voire les branchements directs (l'adresse vers laquelle brancher est envoyée en entrée de l'ALU et propagée en sortie avec une opération ''pass through'').

[[File:Connexion du program counter sur les bus avec PC dans le banc de registres.png|centre|vignette|upright=2|Connexion du program counter sur les bus avec PC dans le banc de registres]]

===Les registres d'interruption avec un processeur hybride-accumulateur : l'exemple du Z80===

Un exemple de processeur registre-accumulateur à deux bus interne est le Z80, un processeur fortement inspiré des CPU Intel 8 bits. Il a un jeu d'instruction similaire, mais a diverses améliorations par rapport au design original. Notamment, le processeur a des registres séparés pour les interruptions.

Sur le Z80, les registres généraux sont dupliqués avec 6 registres pour les interruptions et 6 registres pour les programmes autres. Leur copie pour les interruptions sont nommées B', C', D', E', H', L'. Les 12 registres sont placés dans le banc de registre, ce qui implique que le fenêtrage de registres est utilisé pour gérer la séparation entre registre d'interruption et normaux. Il faut noter que l'accumulateur et le registre d'état sont aussi dupliqués, leurs copies étant nommées A' et F'. Mais leur duplication se fait autrement que par fenêtrage de registre.

En plus des registres précédents, le Z80 incorporait deux registres d'indice nommés X et Y, ainsi qu'un pointeur de pile SP et un ''program counter'' PC. Ils n'étaient pas dupliqués pour les interruptions. Les registres d'indice étaient reliés à une unité de calcul d'adresse. L'unité de calcul d'adresse prenait deux opérandes : un indice, et une adresse mémoire provenant soit du banc de registre, soit de l'accumulateur. En clair, l'unité de calcul d'adresse faisait le lien entre les deux bus internet : le bus de données interne en entrée, le bus d'adresse en sortie.

À l'intérieur du processeur, tous les registres étaient regroupés dans un banc de registre unique, sauf les accumulateurs, les registres d'état et le ''program counter''. Bien que ce ne soit pas indiqué sur le schéma ci-dessous, le ''program counter'' est séparé du banc de registre, alors que le pointeur de pile est dedans. Le compteur IR est lui associé au ''program counter'', il est sortit du banc de registre. Le Z80 utilise lui aussi un incrémenteur séparé de l'ALU, qui est utilisé pour mettre à jour le ''program counter'', le pointeur de pile et un compteur de rafraichissement mémoire nommé IR sur le Z80 (pour rappel, le rafraichissement mémoire demande de balayer la mémoire d'adresse en adresse et été fait par le CPU à l'époque). De plus, il est utilisé pour les instructions INC et DEC qui incrémentent une opérande de 16 bits obtenue en combinant deux registres de 8 bits. En clair, l'incrémenteur du ''program counter'' a été réutilisé de beaucoup de manières originales.

[[File:Z80 arch.svg|centre|vignette|upright=3|Microarchitecture du Z80.]]

Le Z80 incorporait des instructions pour échanger le contenu des deux ensembles de registres, accumulateur inclus. Elles permettaient d'utiliser les registres d'interruption pour les programmes et réciproquement. En clair, cela doublait le nombre de registres si les interruptions n'étaient pas utilisées.
* L'instruction EXX échangeait les deux fenêtres de registres généraux : les registres B, C, D, E, H et L devenaient les registres B', C', D', E', H' et L' et inversement.
* L'instruction EX échangeait l'accumulateur et le registre d'état : les registres A,F devenait A',F' et inversement.

Le fenêtrage de registre était modifié par l'instruction EXX, qui échangeait les deux fenêtres de registres. Pour l'implémenter, une bascule était ajouté au processeur, appelons-la la bascule INT. Elle était relié au bus d'adresse du banc de registre, dont elle mémorisait le bit de poids fort. L'instruction EXX inversait la valeur de la bascule INT. Il est aussi possible d'échanger le contenu des registres D,E et H,L avec une instruction dédiée, ce qui est là encore fait par deux bascules : une pour les registres D,E et une autre pour les registres H,L.

Pour l'accumulateur et le registre d'état, le choix entre registre normal et registre d'interruption se faisait là encore par une seconde bascule appelée la bascule A. La bascule est reliée à un multiplexeur et un démultiplexeur, qui permet de choisir quel accumulateur relier à l'unité de calcul. L'instruction EX inverse le contenu de la bascule A.

&lt;noinclude&gt;
{{NavChapitre | book=Fonctionnement d'un ordinateur
           | prev=L'unité de contrôle
           | prevText=L'unité de contrôle
           | next=Les processeurs 8 bits et moins
           | nextText=Les processeurs 8 bits et moins
}}
&lt;/noinclude&gt;</text>
      <sha1>7wbxedz6dwrn6wwf6wejvybkllmwwe4</sha1>
    </revision>
    <revision>
      <id>744156</id>
      <parentid>744154</parentid>
      <timestamp>2025-06-05T14:01:52Z</timestamp>
      <contributor>
        <username>Mewtow</username>
        <id>31375</id>
      </contributor>
      <minor />
      <comment>/* Annexe : les toutes premières architectures à accumulateur : le Manchester Baby */</comment>
      <origin>744156</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="38291" sha1="tf5ze72wifqow5zk51jetejbuit4hki" xml:space="preserve">Les architectures que nous avons vu précédemment dans ce cours disposent de registres pour les données, en plus du pointeur de pile, d'un ''program counter'', et de quelques autres. Elles sont appelées des '''architectures à registres''', terme qui trahit bien le fait qu'elles ont des registres généraux ou spécialisés pour stocker temporairement des données. Et si on leur a donné un nom, c'est parce qu'il existe des architectures qui ne sont pas dans cette catégorie. Il en existe plusieurs types, mais ce chapitre va se concentrer sur les '''architectures à accumulateur'''.

[[File:Isaccumulator.png|vignette|Architecture à accumulateur.]]

Les architectures à accumulateur sont centrées autour d'un registre architectural appelé l''''accumulateur'''. Il est utilisé pour toutes les opérations arithmétiques dyadiques, où il sert à la fois de source et de destination. Toutes les instructions dyadiques sont de type ''load-op'' : une opérande est lue depuis l'accumulateur, le second opérande est lu depuis la mémoire RAM, le résultat de l'instruction est automatiquement mémorisé dans l'accumulateur. Les instructions monadiques peuvent utiliser un opérande dans l'accumulateur, ou dans la mémoire RAM, les deux sont théoriquement possibles.

La conséquence est que le nombre d'accès mémoire est drastiquement diminué : de 3 par instructions sur une architecture mémoire-mémoire, on passe à seulement un avec un accumulateur. Les opérations dyadiques ont besoin d'un seul accès mémoire pour lire la seconde opérande, les opérations monadique en font aussi un seul pour lire leur unique opérande.

{|class=&quot;wikitable&quot;
|-
! Classe d'architecture
! Nombre d'accès mémoire par opération dyadique
|-
|-
! Architecture à accumulateur
| Un accès mémoire par instruction, pour lire la seconde opérande
|-
! Architecture à registres
| Zéro si les opérandes sont dans les registres, un pour les opérations ''load-op'', LOAD et STORE.
|}

==Le jeu d'instruction des architectures à accumulateur sans registres d'indice==

L'accumulateur est adressé grâce au mode d'adressage implicite, de même que le résultat de l'opération. Par contre, les autres opérandes sont localisés avec d'autres modes d'adressage, et lues en mémoire RAM. Le résultat ainsi qu'un des opérandes sont adressés de façon implicite car dans l'accumulateur, seule la seconde opérande étant adressée directement. Grâce à l'accumulateur, une instruction ne fait qu'un seul accès mémoire maximum, ce qui rend le processeur très facile à implémenter.

===Les registres des anciennes architectures à accumulateur===

[[File:IBM 701console.jpg|vignette|IBM 701, console extérieure.]]

Les architectures à accumulateur étaient communes dans les années 50-60. A l'époque, les ordinateurs étaient gigantesques, ils prenaient une pièce de bâtiment entière dans le pire des cas, une armoire entière dans le meilleur. Les ordinateurs de l'époque étaient surtout utilisés pour du calcul scientifique ou des tâches d’ingénierie demandant beaucoup de calcul, rarement pour de la compatibilité.

Les nombres flottants n'étaient pas encore apparus. A la place, les ordinateurs de l'époque géraient des nombres entiers de grande taille, de 30 bits ou plus. En conséquence, l'accumulateur faisait facilement 30 à 60 bits. Par exemple, les ordinateurs de la Série scientifique IBM 700/7000 géraient des entiers de 36 bits, l’accumulateur faisait 38 bits : 36 bits plus deux bits pour les débordements. Au passage, de tels processeurs utilisaient l'adressage par mot, et non par byte.

Historiquement, les premières architectures à accumulateur ne contenaient aucun autre registre que l'accumulateur. Ce n'est que dans les années 60 que de nombreuses architectures à accumulateur ont ajouté un second '''registre pour les multiplication/divisions'''. Un exemple est celui de l'IBM 701, qui incorporait un registre accumulateur de 38 bits et un registre multiplieur de 36 bits. Le registre mémorise le multiplieur lors d'une opération de multiplication. Il mémorise donc un opérande, pas le résultat. Il peut aussi décaler le multiplieur vers la droite/gauche, ce qui est utile pour exécuter la multiplication. C'est ce qui est fait sur l'IBM 7094.

Une autre possibilité est que ce registre mémorise une partie du résultat de l'opération. Pour rappel, le résultat d'une multiplication/division est codé sur deux fois de bits que ses opérandes. Par exemple, multipliez deux opérandes de 30 bits, vous obtiendrez un résultat de 60 bits. Les 30 bits de poids faible du résultat vont dans l'accumulateur, les 30 bits de poids fort vont dans ce second registre.

Les architectures à accumulateur parfois un '''registre pour le pointeur de pile''', utilisé pour gérer les fonctions/procédures. Les architectures à accumulateurs supportaient une pile d'adresse de retour, souvent une pile d'appel. Mais pour cela, il fallait mémoriser le pointeur de pile dans le processeur, ce qui demandait un registre dédié.

===L'adressage indirect avec l'accumulateur===

Les instructions LOAD et STORE existent bel et bien sur les architectures à accumulateur, mais n'ont pas les mêmes modes d'adressages. L'instruction LOAD copie une donnée de la RAM vers l'accumulateur, l'instruction STORE copie l'accumulateur dans une adresse. Les deux instructions n'ont pas besoin d'adresser l'accumulateur, qui est adressé de manière implicite, juste de préciser l'adresse à lire/écrire.

Les architectures à accumulateur supportaient souvent le mode d'adressage indirect mémoire. Un exemple est celui des ordinateurs Data General Nova, qui sont des architectures à accumulateur et qui supportaient ce mode d'adressage. Les deux instructions LOAD et STORE existaient en deux versions, distinguées par un bit d'indirection. Si ce bit est à 0 dans l'opcode, alors l'instruction utilise le mode d'adressage absolu normal : l'adresse intégrée dans l'instruction est celle de la donnée. Mais s'il est à 1, alors l'adresse intégrée dans l'instruction est celle du pointeur.

Cependant, la présence de l'accumulateur permettait d'utiliser l'adressage indirect à registre, pour gérer les pointeurs. Pour rappel, avec le mode d'adressage indirect à registre, l'adresse à lire/écrire est dans un registre. Ici, l'adresse à lire/écrire est prise dans l'accumulateur, seul registre disponible pour. L'adressage indirect est plus simple à implémenter pour l'instruction LOAD, car elle prend un seul opérande : l'adresse à lire. L'adresse à lire est placée dans l'accumulateur, la donnée lue est elle aussi chargée dans l'accumulateur. Pour l'instruction STORE, il faut fournir deux opérandes, l'adresse et la donnée à écrire, ce qui peut poser problème. Mais au pire, il est toujours possible d'utiliser l'adressage absolu ou indirect mémoire : l'adresse est dans l'instruction, la donnée à écrire dans l'accumulateur.

===L'encodage des instructions===

Sur une architecture à accumulateur l'encodage d'une instruction dyadique est assez simple, vu que l'accumulateur est adressé implicitement. La seconde opérande est localisée soit par une adresse mémoire (adressage absolu), soit est une constante (adressage immédiat). L'adresse mémoire est généralement assez longue, plus que l'opcode.

{|class=&quot;wikitable&quot;
|+ Encodage d'une instruction dyadique
|-
! rowspan=&quot;2&quot; | Opcode 
| Adresse mémoire (adressage absolu)
|-
| Constante (adressage immédiat)
|}

L'encodage d'une instruction monadique est similaire. Si l'opérande est lue depuis la mémoire RAM, alors l'instruction est encodée comme une instruction dyadique. Il en est de même pour les instructions qui copient une constante dans l'accumulateur. Par contre, si l'opérande est dans l'accumulateur, alors il y a juste besoin d'encoder l'opcode. La majorité des instructions a besoin de préciser une adresse, rares sont celles qui s'en passent. Au vu de cet encodage, les architectures à accumulateur sont qualifiées d''''architectures à une adresse''' par abus de langage.

Il est intéressant de contraster leur encodage avec les architectures à registres. Les architectures à registre doivent encoder deux opérandes en plus de l'opcode, avec éventuellement où enregistrer le résultat sur les architectures 3-adresses. Par contre, les opérandes sont généralement des noms de registre, ce qui prend moins de place qu'une adresse mémoire. A la rigueur, les instructions avec une constante immédiate prennent un peu plus de place, car elles doivent encoder un nom de registre en plus de la constante et de l'opcode. Les instructions ''load-op'' des processeurs CISC sont un peu dans le même cas, sauf qu'il faut remplacer la constante par une adresse, qui a généralement la même taille. Les instructions sont donc en moyenne plus courte sur les processeurs à registre, du fait de la présence de registres.

===Annexe : les toutes premières architectures à accumulateur : le Manchester Baby===

[[File:BabyArchitecture.png|vignette|Architecture de la Manchester Baby.]]

Les architectures à accumulateurs sont apparues dès les débuts de l'informatique. Le tout premier ordinateur à programme enregistré en mémoire, le ''Manchester Baby'', était une architecture à accumulateur. Niveau interface, l'ordinateur avait une console avec 32 boutons, des interrupteurs et un écran de sortie sur lequel afficher les résultats. A l'intérieur, il y avait un processeur et une RAM de 32 adresses, fabriquée avec des tubes Williams (abordés dans une annexe à la fin du cours). Chaque adresse mémorisait 32 bits, qui pouvaient encoder soit un nombre, soit une instruction.

Le programme devait tenir dans la RAM, avec une instruction par adresse maximum, ce qui limitait les programmes à 32 instructions maximum. Une instruction prenait donc 32 bits, 3 indiquaient quelle opération utiliser, 12 servait à indiquer où se trouvent la seconde opérande en RAM, les 16 restants sont inutilisés.

Le processeur avait un registre accumulateur de 32 bits, un ''program counter'' et un registre d'instruction. Il intégrait un additionneur dédié au ''program counter'', mais l'ALU n'avait pas d'additionneur. En conséquence, il ne gérait pas l'addition. A la place, il gérait la soustraction. Il pouvait cependant émuler l'addition à partir d'une soustraction. La soustraction était utilisée pour calculer le complément d'une opérande, et soustraire le complément revient à additionner. L'ALU était une ALU sérielle, à savoir qu'elle faisait les soustractions bit par bit.

Le processeur supportait 7 instructions au total : la soustraction, des instructions de branchement et d'accès mémoire, rien d'autre.

{|class=&quot;wikitable&quot;
|-
! SUB 
| Soustrait l'opérande mémoire de l'accumulateur.
|-
! CMP
| Skippe l'instruction suivante si l'accumulateur a une valeur négative.
|-
! JMP
| Branchement indirect mémoire. :
* L'adresse de destination est lue depuis la mémoire.
* L'adresse lue est intégrée dans l'instruction via adressage absolu.
|-
! JRP
| Branchement relatif indirect.
* Lit une opérande depuis la mémoire, l'adresse est intégrée dans l'instruction via adressage absolu.
* Additionne l'opérande lue au ''program counter''.
|-
! LDN
| Instruction LOAD
|-
! STO
| Instruction STORE
|-
! STOP
| Éteint l'ordinateur.
|}

Le Manchester Mark 1 était une amélioration du Manchester Baby. Il utilisait 4500 tubes à vide. L'ordinateur gérait des nombres de 40 bits, mais les instructions étaient codées sur 20 bits. La RAM avait la même taille, à savoir 32 nombres, leur taille était simplement augmentée. Par contre, la RAM était complémentée par l’ancêtre du disque dur magnétique, à savoir un tambour magnétique, l’ancêtre du disque dur magnétique. Il contenait 40 pages, chacune ayant la même taille que la RAM. C'était là encore une architecture à accumulateur, sauf qu'elle intégrait aussi des registres d'indice. Et surtout : son processeur gérait l'addition et quelques opérations logiques (ET et OU), en plus de la soustraction et de la comparaison.

[[File:MM1Schematic French.svg|centre|vignette|upright=2.5|Architecture de la Manchester Mark 1.]]

==La micro-architecture des architectures à accumulateur sans registres d'indice==

L'organisation interne d'une architecture à accumulateur est très différente de celle des processeurs à registre. Elle est plus ou moins la même pour tous ces processeurs, le point important étant que le chemin de données se résume à une ALU, un registre accumulateur et le bus de données. L'ALU est reliée au registre accumulateur, ainsi qu'au bus de données pour lire la seconde opérande, comme illustré ci-dessous.

[[File:Accumulator.png|centre|vignette|upright=2|Accumulateur.]]

===L'unité de calcul et l'accumulateur===

Pour simplifier l'implémentation, le résultat est mémorisé dans un registre en sortie de l'unité de calcul. La raison est qu'on ne veut pas altérer l'accumulateur tant que le résultat final n'est pas totalement calculé. Rappelons que l'ALU ne fournit pas un résultat d'un seul bloc, mais que certains bits arrivent avant les autres, typiquement les bits de poids faible. Si le résultat était écrit dans l'accumulateur directement, il écraserait des bits de l’opérande en cours d'utilisation, ce qui fausserait le résultat.

[[File:Accumulateur avec registre de sortie.png|centre|vignette|upright=2|Accumulateur avec registre de sortie]]

Une autre solution utilisait un registre entre l'accumulateur et l'unité de calcul, appelé l’'''''accumulator latch'''''. Il remplace le registre en sortie de l'ALU, dans le sens où il permet d'écrire dans l'accumulateur sans effacer l'opérande, pendant que l’opération est en cours dans l'ALU. L'accumulateur est copié dans l’''accumulator latch'', avant que l'ALU démarre ses calculs. L'opérande est donc maintenue même si on commence à écrire le résultat dans l'accumulateur.

Sur le 8085 d'Intel, l’''accumulator latch'' peut être initialisé avec une constante prédéfinie, ce qui permet d'implémenter certaines instructions très facilement. Par exemple, il peut être initialisé à 0, ce qui permet d'implémenter les instructions MOV et INC (incrémentation). Un MOV est équivalent à faire un OU entre le registre lu et 0. Une instruction INC initialise l'entrée de retenue de l'unité de calcul à 1, puis ajoute 0. La décrémentation est implémentée de la même manière, sauf que l’''accumulator latch'' est initialisé à -2 pour compenser l'entrée de retenue à 1. De plus, pour supporter les conversion de décimal à BCD, l’''accumulator latch'' peut être initialisé avec les constantes 0x00, 0x06, 0x60, or 0x66. L'''accumulator latch'' est relié à divers fils de commande provenant de l'unité de contrôle, qui décide quelle valeur d'initialisation utiliser en fonction de l'instruction décodée.

[[File:Accumulator latch.png|centre|vignette|upright=2|Accumulator latch]]

[[File:Chemin de données à un seul bus.png|vignette|Chemin de données à un seul bus]]

De même, la seconde opérande, celle lue sur le bus de données, est mémorisée dans un registre en amont de l'ALU. C'était notamment très utile si le processeur utilisait une ALU plus courte que les opérandes, avec par exemple une ALU 4 bits pour un CPU 8 bits. Les anciens processeurs à accumulateur de type ''mainframe'' utilisaient des opérandes de grande taille, du genre 36 ou 48 bits, ce qui avait des conséquences sur l'unité de calcul utilisée, ainsi que sur la communication avec la mémoire. Il arrivait que de tels processeurs utilisaient des ALU sérielles, ou du moins octet-sérielles, plutôt qu'une véritable ALU 36 bits. Nous verrons aussi que c'est très utile sur les processeurs à accumulateur avec un bus interne unique, dans la suite du chapitre.

===La micro-architecture des architectures à accumulateur avec instructions LOAD/STORE===

Nous venons de voir comment est implémenté l'unité de calcul et l'accumulateur, et comment le tout est relié au bus de données. Mais cela ne permet que d'avoir un processeur à accumulateur rudimentaire, qui ne gére que des instructions arithmétiques et logiques. Il faut aussi gérer le cas des opérations LOAD/STORE et des modes d'adressages associés, mais c'est le séquenceur qui s'en occupe. Avec l'adressage absolu, les instructions LOAD et STORE ne font que connecter l'accumulateur au bus de données. L'instruction STORE nécessite de connecter l'accumulateur au bus de données, de manière à ce que le transfert des données se fasse de l'accumulateur vers le bus de données. L'instruction LOAD s'implémente de la même manière, sauf que le sens de transfert est inversé.

Cependant, il existe une optimisation qui permet d'implémenter l'instruction LOAD sans ajouter de circuits. Pour cela, il suffit que l'unité de calcul gére les opérations ''pass through'', à savoir des opérations qui se contentent de recopier un opérande sur la sortie. Ici, l'idée est de recopier l'opérande provenant du bus de données.

[[File:Architecture à accumulateur, microarchitecture.png|centre|vignette|upright=2|Architecture à accumulateur, microarchitecture]]

Pour gérer nativement l'adressage indirect à registre, il suffit de connecter l'accumulateur au bus d'adresse. Le plus simple est d'ajouter un multiplexeur, comme illustré ci-dessous. La donnée lue est copiée dans l'accumulateur, ce qui fait qu'il vaut mieux utiliser un registre d’interfaçage, l'accumulateur n'étant pas utilisable à la fois pour le bus d'adresse et de données.

[[File:Adressage indirect sur une architecture à accumulateur.png|centre|vignette|upright=2|Adressage indirect sur une architecture à accumulateur]]

Pour finir, voyons comment le pointeur de pile et le ''program counter'' sont implémentés. Les architectures à accumulateur ont souvent des adresses de taille différente des données, ce qui fait qu'il vaut mieux utiliser un circuit incrémenteur dédié pour incrémenter le ''program counter'', plutôt que de l'incrémenter via l'unité de calcul. Les architectures à accumulateur ont parfois un pointeur de pile, qui gère une pile d'adresse de retour, pas une vraie pile d'appel. Aussi, le pointeur de pile est censé être incrémenté et décrémenté, pas plus. Pas d'addition ou de soustraction pour gérer des cadres de pile. Là encore, c'est la solution de l'incrémenteur séparé qui est retenue. Pour économiser des transistors, il n'y a qu'un seul incrémenteur partagé pour les deux.

==Les architectures à accumulateur à registres d'indice==

Les architectures à accumulateur décrites dans la section précédente sont capables de faire de l'adressage indirect, mais n'incluent pas les modes d'adressage base + indice et absolus indicés, qui prennent une adresse et y ajoute un indice. Il s'agit des toutes premières architectures à accumulateur, comme les premiers ordinateurs IBM ou le fameux PDP-8. Mais par la suite, les processeurs à accumulateurs ont inclus un support des modes d'adressages indicés, grâce à des '''registres d'indice'''.

===Les registres d'indice===

Les registres d'indice stockent des indices de tableaux. Ils permettaient de supporter deux modes d'adressage :
* Le '''mode d'adressage absolu indicé''' où une adresse fixe est additionnée à un indice variable. L'adresse fixe est intégrée dans l'instruction (adressage absolu), l'indice est dans un registre d'indice.
* Le '''mode d'adressage base + indice''', où l'adresse est dans l'accumulateur et l'indice dans le registre d'indice.

Les processeurs à accumulateur supportaient souvent des variantes des modes d'adressage précédents, où le registre d'indice était automatiquement incrémenté ou décrémenté à chaque utilisation.

Au départ, ces processeurs n'utilisaient qu'un seul registre d'indice qui se comportait comme un second accumulateur spécialisé dans les calculs d'adresses mémoire. Le processeur supportait de nouvelles instructions qui utilisaient ce registre d'indice de façon implicite. Mais avec le temps, les processeurs finirent par incorporer plusieurs de ces registres. Les instructions de lecture ou d'écriture devaient alors préciser quel registre d'indice utiliser, en précisant un nom de registre d'indice, un numéro de registre d'indice.

Il faut préciser que les registres d'indice ont une taille bien plus petite que l'accumulateur. Ils mémorisent des indices codés sur 16 bits ou moins, alors que l'accumulateur faisait typiquement 36 à 48 bits, parfois plus. La taille classique sur les anciens ''mainframes'' était de 15 bits, parfois moins. Il n'était pas rare de tomber sur des registres d'indice de 8 ou 9 bits. Leur petite taille rendait leur implémentation matérielle peu couteuse. Et c'est ce qui explique qu'ils étaient préférés à l'usage d'un second accumulateur.

Un exemple est le cas du processeur Motorola 6809, un processeur à accumulateur qui contient deux registres d'indices nommés X et Y. L'accumulateur est noté D et fait 16 bits, il peut être parfois géré comme deux accumulateurs séparés A et B de 8 bits chacun. Il contenait aussi deux pointeurs de pile, l'un pour les programmes, l'autre pour le système d'exploitation, ainsi qu'un ''program counter''. Le registre de page était utilisé pour l'adressage absolu, comme vu dans le chapitre sur les modes d'adressage.

[[File:6809 Internal Registers.svg|centre|vignette|upright=2|6809 Internal Registers]]

Les processeurs IBM avaient autrefois plusieurs registres d'indice. Par exemple, l'IBM 704 avait trois registres d'indice de 15 bits. Leur contenu était soustrait de l'adresse absolue. Une instruction pouvait utiliser plusieurs registres d'indice pour adresser son opérande. Toute instruction utilisait trois bits pour sélectionner les registres d'indice utilisés. Fait assez original, lorsque plusieurs registres d'indice sont sélectionnés, le processeur n'additionne pas les trois registres à l'adresse de base. À la place, il fait un OU bit à bit entre les registres d'indice sélectionnés, et additionne le résultat à l'adresse.

Les processeurs IBM à accumulateur ont fait ça sur toute la gamme IBM 700/7000, pour des raisons de compatibilité. Les processeurs suivants avaient 7 registres d'indices, mais conservaient les trois bits pour adresser les registres d'indices. Ils pouvaient fonctionner dans deux modes. Le premier mode est plus intuitif : les trois bits précisent un registre d'indice parmi les 7, qui est additionné avec l'adresse absolue. La valeur zéro indique qu'aucun registre d'indice n'est utilisé, ce qui explique qu'il y a 7 registres d'indice et non 8. Un second mode, compatible avec l'IBM 704, fait un OU logique entre les registres d'indice sélectionnés. Seuls les trois premiers registres d'indices peuvent être sélectionnés dans ce mode. Il y a deux instructions pour changer de mode : une pour passer en mode compatible, l'autre pour le quitter pour l'autre mode.

Quelques rares processeurs à registres généraux ont utilisés des registres d'indice, en plus des registres généraux. Ce qui fait l'association que nous avons faite entre registres d'indice et architectures à accumulateur est imparfait, bien que solide sur le principe. Un exemple d'architecture de ce type sont les architectures de la série UNIVAC 1100/2200. Ils disposaient de 128 registres, qui étaient mappés en mémoire à partir de l'adresse mémoire 0, la majorité étant inaccessibles par le programmeur. Ils regroupaient 12 registres accumulateurs, 11 registres d'indice et 4 registres hybrides qui pouvaient servir soit de registre d'indice, soit de registres accumulateurs.

===La micro-architecture des architectures à accumulateur avec registres d'indice===

La présence de registres d'indice modifie grandement l'implémentation du processeur. En effet, il faut rajouter un banc de registre pour les registres d'indice. Le banc de registre est monoport, car on a besoin de lire ou d'écrire un indice à la fois. Et il faut aussi potentiellement rajouter de quoi faire les calculs d'adresse. Deux solutions sont possibles : une ALU dédiée aux calculs d'adresse, une seule ALU pour toutes les opérations.

Dans le premier cas, il y a une ALU séparée associée aux registres d'indice. L'ALU et les registres d'indice sont placés en sortie du séquenceur, en-dehors du chemin de données, la sortie de l'ALU est directement connectée au bus d'adresse. L'unité de calcul d'adresse peut être utilisée pour incrémenter le ''program counter''. Un défaut de cette approche est qu'elle ne gère pas l'adresse indirect à registre.

[[File:Chemin de données sans support des pointeurs, avec adressage absolu indicé.png|centre|vignette|upright=2|Chemin de données sans support des pointeurs, avec adressage absolu indicé]]

Une autre option utilise un bus interne, qui interconnecte tout le chemin de données. Dans sa version la plus simple, il est relié à l'accumulateur, l'unité de calcul, le banc de registre d'indice et le bus de données. Avec cette solution, l'ALU est utilisé à la fois pour calculer les adresses et pour les instructions de calcul. En reliant le bus interne au bus d'adresse à travers un multiplexeur, on gère naturellement les adressages indirects.

[[File:Architecture à accumulateur avec registres associés.png|centre|vignette|upright=2.5|Architecture à accumulateur avec registres associés]]

Il faut noter que sur les architectures Von Neumann, le séquenceur est relié à ce bus interne. En effet, charger une instruction demande de passer par le bus mémoire, donc par l’intermédiaire de ce bus internet. Le ''program counter'' est envoyé sur ce bus pour lire l'instruction, puis l'instruction lue est recopiée dans le registre d'instruction. Le chargement d'une instruction est donc géré comme une lecture des plus classiques. De plus, cela permet d'incrémenter le ''program counter'' au niveau de l'unité de calcul entière. Le ''program counter'' est envoyé sur le bus interne, incrémenté par l'ALU, puis le résultat est recopié dans le ''program counter'' via le bus interne.

[[File:Architecture à accumulateur avec bus unique de type Von Neumann.png|centre|vignette|upright=2|Architecture à accumulateur avec bus unique de type Von Neumann]]

==Les processeurs bi-accumulateurs : le Motorola 6800==

Le Motorola 6800 était un processeur 8 bits qui gérait des adresses de 16 bits. Il contenait deux accumulateurs nommés A et B, de 8 bits chacun. Il disposait aussi d'un registre d'indice, d'un pointeur de pile et d'un ''program counter'', tous les trois de 16 bits. Le registre d'état regroupait 6 bits, qu'on ne détaillera pas ici.

[[File:MC6800 Processor Diagram.png|centre|vignette|upright=2|Interface et registres du MC6800.]]

La présence des deux accumulateurs impactait surtout les instructions dyadiques. Les instructions monadiques avaient juste à préciser où se trouvait l'opérande : soit en RAM, soit dans le premier accumulateur, soit dans le second. Pour les opérations dyadiques, la gestion était totalement différente. En théorie, le premier opérande est dans un accumulateur, soit A, soit B. La seconde opérande vient soit de l'autre accumulateur, soit de la mémoire RAM. Et selon les instructions, tout variait.

Pour l'addition, il y avait trois instructions. Les deux premières additionnaient un opérande provenant de la mémoire avec un accumulateur. L'instruction ADDA sélectionnait le premier accumulateur, l'instruction ADDB sélectionnait le second accumulateur. Mais une troisième instruction, l’instruction ABA, permettait d'additionner le contenu des deux accumulateurs.

Pour les autres opérations, il n'était pas possible d'utiliser les deux accumulateurs en même temps. La seule possibilité était de faire une opération entre un accumulateur et un opérande venant de la mémoire. Toutes les instructions étaient en double, avec une copie par accumulateur. Par exemple, l'instruction ANDA faisait un ET entre l’accumulateur A et l'opérande mémoire, l'instruction ANDB faisait pareil avec l'accumulateur B.

==Les architectures hybrides registres-accumulateur==

Il a existé quelques architectures qui étaient des hybrides entre architectures à accumulateur et architecture à registre. Elles ont servi de transition entre les deux, durant les années 80-90. Elles avaient un accumulateur unique couplé à un banc de registres généraux. Par exemple, les premiers processeurs Intel 8 bits étaient des processeurs hybrides-accumulateur. Lles CPU Intel 8 bits disposaient de 7 registres de 8 bits nommés A, B, C, D, E, F, H, L, SP. Ils correspondent respectivement à :
* l'accumulateur A ;
* six registres nommés B, C, D, E, H et L ;
* le registre d'état F ;
* le pointeur de pile SP.

Sur ces processeurs, les instructions dyadiques devaient mettre leur premier opérande dans l'accumulateur, la seconde provenait soit des registres, soit de la RAM, soit d'une constante immédiate. Les opérations monadiques pouvaient lire leur opérande depuis l'accumulateur, les autres registres ou la RAM, tout était permis. Les registres d'indices disparaissaient sur ces architectures, en théorie. Les registres généraux pouvaient être utilisés comme registre d'indice ou pour stocker des opérandes, ils étaient assez versatiles pour servir de registres d'indices.

La présence de registres a de nombreux avantages, comparé aux architectures à accumulateur pures. Les instructions arithmétiques sont plus rapide, lire un registre étant plus rapide qu'un accès RAM. Les performances sont donc augmentées. De plus, les instructions arithmétiques utilisant ces registres sont plus courtes : pas besoin d'encoder une adresse mémoire, un nom de registre suffit. Vu que les processeurs de l’époque avaient des instructions de taille variable, cela améliorait la densité de code.

La microarchitecture de ces processeurs est très similaire à celle d'un processeur avec des registres d'indices. La seule différence est que le banc de registre contient des registres généraux et non des registres d'indices. Le banc de registre est systématiquement monoport, car il n'avait aucune raison d'être multiport. Pour les instructions dyadiques, seules à lire deux opérandes, il ne servait que pour la seconde opérande, la première était lue depuis l'accumulateur.

Les processeurs hybrides registre-accumulateur se classent en deux types principaux : ceux qui ont un seul bus interne, et ceux qui en ont deux. Le premier cas est identique à celui vu précédemment pour les architectures à accumulateur avec registres d'indice, à la seule différence est que le banc de registre contient des registres généraux et non des registres d'indices. Afin de gérer l'adressage indirect à registre, le bus interne est connecté aux deux registres d’interfaçage mémoire.

[[File:Architecture à accumulateur avec bus unique de type Von Neumann.png|centre|vignette|upright=2|Architecture à accumulateur avec bus unique de type Von Neumann]]

Notons que cela permet aussi d'implémenter facilement les branchements indirects, car le bus interne permet d'échanger des adresses entre ''program counter'' et banc de registre. De même, il est possible d'utiliser l'ALU pour gérer les branchements indirects., en plus de l'utiliser pour incrémenter le ''program counter''.

[[File:Single bus organization.jpg|centre|vignette|upright=2|Single bus organization]]

Une autre solution utilisait deux bus internes : un connecté au bus de données, un autre relié au bus d'adresse. Le bus de commande mémoire était lui commandé par le séquenceur, l'unité de contrôle. L'intermédiaire entre ces deux bus était le banc de registre, ainsi que les autres registres. Le banc de registre était connecté aux deux bus interne, avec un port de lecture relié au bus d'adresse, un port de lecture-écriture relié au bus de données. Le port de lecture était utilisé pour l'adressage indirect, l'autre l'était pour le reste.

[[File:Proz1-e.png|centre|vignette|upright=2|Intérieur d'un processeur.]]

L'organisation à deux bus simplifiait la gestion du ''program counter'' et le chargement des instructions. Le ''program counter'' était soit séparé du banc de registre, soit placé dans le banc de registre. Les deux solutions étaient utilisés, tout dépend du processeur. Il faut noter que si le ''program counter'' est intégré au banc de registres, alors la microarchitecture du processeur est bien plus simple. L'envoi du ''program counter'' sur le bus d'adresse utilise le port de lecture relié au bus d'adresse, qui sert aussi pour l'adressage indirect. L'économie de circuits, sans compter la simplicité d'implémentation que cela implique, explique sans doute que la technique a été utilisée sur quelques processeurs anciens.

Le ''program counter'' était généralement incrémenté par l'ALU, ce qui explique qu'il soit connecté au bus interne pour les données. La connexion est aussi utile pour gérer les branchements indirects, qui copient un registre dans le ''program counter'', ainsi que les branchements relatifs (addition dans l'ALU), voire les branchements directs (l'adresse vers laquelle brancher est envoyée en entrée de l'ALU et propagée en sortie avec une opération ''pass through'').

[[File:Connexion du program counter sur les bus avec PC dans le banc de registres.png|centre|vignette|upright=2|Connexion du program counter sur les bus avec PC dans le banc de registres]]

===Les registres d'interruption avec un processeur hybride-accumulateur : l'exemple du Z80===

Un exemple de processeur registre-accumulateur à deux bus interne est le Z80, un processeur fortement inspiré des CPU Intel 8 bits. Il a un jeu d'instruction similaire, mais a diverses améliorations par rapport au design original. Notamment, le processeur a des registres séparés pour les interruptions.

Sur le Z80, les registres généraux sont dupliqués avec 6 registres pour les interruptions et 6 registres pour les programmes autres. Leur copie pour les interruptions sont nommées B', C', D', E', H', L'. Les 12 registres sont placés dans le banc de registre, ce qui implique que le fenêtrage de registres est utilisé pour gérer la séparation entre registre d'interruption et normaux. Il faut noter que l'accumulateur et le registre d'état sont aussi dupliqués, leurs copies étant nommées A' et F'. Mais leur duplication se fait autrement que par fenêtrage de registre.

En plus des registres précédents, le Z80 incorporait deux registres d'indice nommés X et Y, ainsi qu'un pointeur de pile SP et un ''program counter'' PC. Ils n'étaient pas dupliqués pour les interruptions. Les registres d'indice étaient reliés à une unité de calcul d'adresse. L'unité de calcul d'adresse prenait deux opérandes : un indice, et une adresse mémoire provenant soit du banc de registre, soit de l'accumulateur. En clair, l'unité de calcul d'adresse faisait le lien entre les deux bus internet : le bus de données interne en entrée, le bus d'adresse en sortie.

À l'intérieur du processeur, tous les registres étaient regroupés dans un banc de registre unique, sauf les accumulateurs, les registres d'état et le ''program counter''. Bien que ce ne soit pas indiqué sur le schéma ci-dessous, le ''program counter'' est séparé du banc de registre, alors que le pointeur de pile est dedans. Le compteur IR est lui associé au ''program counter'', il est sortit du banc de registre. Le Z80 utilise lui aussi un incrémenteur séparé de l'ALU, qui est utilisé pour mettre à jour le ''program counter'', le pointeur de pile et un compteur de rafraichissement mémoire nommé IR sur le Z80 (pour rappel, le rafraichissement mémoire demande de balayer la mémoire d'adresse en adresse et été fait par le CPU à l'époque). De plus, il est utilisé pour les instructions INC et DEC qui incrémentent une opérande de 16 bits obtenue en combinant deux registres de 8 bits. En clair, l'incrémenteur du ''program counter'' a été réutilisé de beaucoup de manières originales.

[[File:Z80 arch.svg|centre|vignette|upright=3|Microarchitecture du Z80.]]

Le Z80 incorporait des instructions pour échanger le contenu des deux ensembles de registres, accumulateur inclus. Elles permettaient d'utiliser les registres d'interruption pour les programmes et réciproquement. En clair, cela doublait le nombre de registres si les interruptions n'étaient pas utilisées.
* L'instruction EXX échangeait les deux fenêtres de registres généraux : les registres B, C, D, E, H et L devenaient les registres B', C', D', E', H' et L' et inversement.
* L'instruction EX échangeait l'accumulateur et le registre d'état : les registres A,F devenait A',F' et inversement.

Le fenêtrage de registre était modifié par l'instruction EXX, qui échangeait les deux fenêtres de registres. Pour l'implémenter, une bascule était ajouté au processeur, appelons-la la bascule INT. Elle était relié au bus d'adresse du banc de registre, dont elle mémorisait le bit de poids fort. L'instruction EXX inversait la valeur de la bascule INT. Il est aussi possible d'échanger le contenu des registres D,E et H,L avec une instruction dédiée, ce qui est là encore fait par deux bascules : une pour les registres D,E et une autre pour les registres H,L.

Pour l'accumulateur et le registre d'état, le choix entre registre normal et registre d'interruption se faisait là encore par une seconde bascule appelée la bascule A. La bascule est reliée à un multiplexeur et un démultiplexeur, qui permet de choisir quel accumulateur relier à l'unité de calcul. L'instruction EX inverse le contenu de la bascule A.

&lt;noinclude&gt;
{{NavChapitre | book=Fonctionnement d'un ordinateur
           | prev=L'unité de contrôle
           | prevText=L'unité de contrôle
           | next=Les processeurs 8 bits et moins
           | nextText=Les processeurs 8 bits et moins
}}
&lt;/noinclude&gt;</text>
      <sha1>tf5ze72wifqow5zk51jetejbuit4hki</sha1>
    </revision>
    <revision>
      <id>744157</id>
      <parentid>744156</parentid>
      <timestamp>2025-06-05T14:05:51Z</timestamp>
      <contributor>
        <username>Mewtow</username>
        <id>31375</id>
      </contributor>
      <minor />
      <comment>/* Annexe : les toutes premières architectures à accumulateur : le Manchester Baby */</comment>
      <origin>744157</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="38777" sha1="b6ivzncgomrrb2j863hrkb2mudtok76" xml:space="preserve">Les architectures que nous avons vu précédemment dans ce cours disposent de registres pour les données, en plus du pointeur de pile, d'un ''program counter'', et de quelques autres. Elles sont appelées des '''architectures à registres''', terme qui trahit bien le fait qu'elles ont des registres généraux ou spécialisés pour stocker temporairement des données. Et si on leur a donné un nom, c'est parce qu'il existe des architectures qui ne sont pas dans cette catégorie. Il en existe plusieurs types, mais ce chapitre va se concentrer sur les '''architectures à accumulateur'''.

[[File:Isaccumulator.png|vignette|Architecture à accumulateur.]]

Les architectures à accumulateur sont centrées autour d'un registre architectural appelé l''''accumulateur'''. Il est utilisé pour toutes les opérations arithmétiques dyadiques, où il sert à la fois de source et de destination. Toutes les instructions dyadiques sont de type ''load-op'' : une opérande est lue depuis l'accumulateur, le second opérande est lu depuis la mémoire RAM, le résultat de l'instruction est automatiquement mémorisé dans l'accumulateur. Les instructions monadiques peuvent utiliser un opérande dans l'accumulateur, ou dans la mémoire RAM, les deux sont théoriquement possibles.

La conséquence est que le nombre d'accès mémoire est drastiquement diminué : de 3 par instructions sur une architecture mémoire-mémoire, on passe à seulement un avec un accumulateur. Les opérations dyadiques ont besoin d'un seul accès mémoire pour lire la seconde opérande, les opérations monadique en font aussi un seul pour lire leur unique opérande.

{|class=&quot;wikitable&quot;
|-
! Classe d'architecture
! Nombre d'accès mémoire par opération dyadique
|-
|-
! Architecture à accumulateur
| Un accès mémoire par instruction, pour lire la seconde opérande
|-
! Architecture à registres
| Zéro si les opérandes sont dans les registres, un pour les opérations ''load-op'', LOAD et STORE.
|}

==Le jeu d'instruction des architectures à accumulateur sans registres d'indice==

L'accumulateur est adressé grâce au mode d'adressage implicite, de même que le résultat de l'opération. Par contre, les autres opérandes sont localisés avec d'autres modes d'adressage, et lues en mémoire RAM. Le résultat ainsi qu'un des opérandes sont adressés de façon implicite car dans l'accumulateur, seule la seconde opérande étant adressée directement. Grâce à l'accumulateur, une instruction ne fait qu'un seul accès mémoire maximum, ce qui rend le processeur très facile à implémenter.

===Les registres des anciennes architectures à accumulateur===

[[File:IBM 701console.jpg|vignette|IBM 701, console extérieure.]]

Les architectures à accumulateur étaient communes dans les années 50-60. A l'époque, les ordinateurs étaient gigantesques, ils prenaient une pièce de bâtiment entière dans le pire des cas, une armoire entière dans le meilleur. Les ordinateurs de l'époque étaient surtout utilisés pour du calcul scientifique ou des tâches d’ingénierie demandant beaucoup de calcul, rarement pour de la compatibilité.

Les nombres flottants n'étaient pas encore apparus. A la place, les ordinateurs de l'époque géraient des nombres entiers de grande taille, de 30 bits ou plus. En conséquence, l'accumulateur faisait facilement 30 à 60 bits. Par exemple, les ordinateurs de la Série scientifique IBM 700/7000 géraient des entiers de 36 bits, l’accumulateur faisait 38 bits : 36 bits plus deux bits pour les débordements. Au passage, de tels processeurs utilisaient l'adressage par mot, et non par byte.

Historiquement, les premières architectures à accumulateur ne contenaient aucun autre registre que l'accumulateur. Ce n'est que dans les années 60 que de nombreuses architectures à accumulateur ont ajouté un second '''registre pour les multiplication/divisions'''. Un exemple est celui de l'IBM 701, qui incorporait un registre accumulateur de 38 bits et un registre multiplieur de 36 bits. Le registre mémorise le multiplieur lors d'une opération de multiplication. Il mémorise donc un opérande, pas le résultat. Il peut aussi décaler le multiplieur vers la droite/gauche, ce qui est utile pour exécuter la multiplication. C'est ce qui est fait sur l'IBM 7094.

Une autre possibilité est que ce registre mémorise une partie du résultat de l'opération. Pour rappel, le résultat d'une multiplication/division est codé sur deux fois de bits que ses opérandes. Par exemple, multipliez deux opérandes de 30 bits, vous obtiendrez un résultat de 60 bits. Les 30 bits de poids faible du résultat vont dans l'accumulateur, les 30 bits de poids fort vont dans ce second registre.

Les architectures à accumulateur parfois un '''registre pour le pointeur de pile''', utilisé pour gérer les fonctions/procédures. Les architectures à accumulateurs supportaient une pile d'adresse de retour, souvent une pile d'appel. Mais pour cela, il fallait mémoriser le pointeur de pile dans le processeur, ce qui demandait un registre dédié.

===L'adressage indirect avec l'accumulateur===

Les instructions LOAD et STORE existent bel et bien sur les architectures à accumulateur, mais n'ont pas les mêmes modes d'adressages. L'instruction LOAD copie une donnée de la RAM vers l'accumulateur, l'instruction STORE copie l'accumulateur dans une adresse. Les deux instructions n'ont pas besoin d'adresser l'accumulateur, qui est adressé de manière implicite, juste de préciser l'adresse à lire/écrire.

Les architectures à accumulateur supportaient souvent le mode d'adressage indirect mémoire. Un exemple est celui des ordinateurs Data General Nova, qui sont des architectures à accumulateur et qui supportaient ce mode d'adressage. Les deux instructions LOAD et STORE existaient en deux versions, distinguées par un bit d'indirection. Si ce bit est à 0 dans l'opcode, alors l'instruction utilise le mode d'adressage absolu normal : l'adresse intégrée dans l'instruction est celle de la donnée. Mais s'il est à 1, alors l'adresse intégrée dans l'instruction est celle du pointeur.

Cependant, la présence de l'accumulateur permettait d'utiliser l'adressage indirect à registre, pour gérer les pointeurs. Pour rappel, avec le mode d'adressage indirect à registre, l'adresse à lire/écrire est dans un registre. Ici, l'adresse à lire/écrire est prise dans l'accumulateur, seul registre disponible pour. L'adressage indirect est plus simple à implémenter pour l'instruction LOAD, car elle prend un seul opérande : l'adresse à lire. L'adresse à lire est placée dans l'accumulateur, la donnée lue est elle aussi chargée dans l'accumulateur. Pour l'instruction STORE, il faut fournir deux opérandes, l'adresse et la donnée à écrire, ce qui peut poser problème. Mais au pire, il est toujours possible d'utiliser l'adressage absolu ou indirect mémoire : l'adresse est dans l'instruction, la donnée à écrire dans l'accumulateur.

===L'encodage des instructions===

Sur une architecture à accumulateur l'encodage d'une instruction dyadique est assez simple, vu que l'accumulateur est adressé implicitement. La seconde opérande est localisée soit par une adresse mémoire (adressage absolu), soit est une constante (adressage immédiat). L'adresse mémoire est généralement assez longue, plus que l'opcode.

{|class=&quot;wikitable&quot;
|+ Encodage d'une instruction dyadique
|-
! rowspan=&quot;2&quot; | Opcode 
| Adresse mémoire (adressage absolu)
|-
| Constante (adressage immédiat)
|}

L'encodage d'une instruction monadique est similaire. Si l'opérande est lue depuis la mémoire RAM, alors l'instruction est encodée comme une instruction dyadique. Il en est de même pour les instructions qui copient une constante dans l'accumulateur. Par contre, si l'opérande est dans l'accumulateur, alors il y a juste besoin d'encoder l'opcode. La majorité des instructions a besoin de préciser une adresse, rares sont celles qui s'en passent. Au vu de cet encodage, les architectures à accumulateur sont qualifiées d''''architectures à une adresse''' par abus de langage.

Il est intéressant de contraster leur encodage avec les architectures à registres. Les architectures à registre doivent encoder deux opérandes en plus de l'opcode, avec éventuellement où enregistrer le résultat sur les architectures 3-adresses. Par contre, les opérandes sont généralement des noms de registre, ce qui prend moins de place qu'une adresse mémoire. A la rigueur, les instructions avec une constante immédiate prennent un peu plus de place, car elles doivent encoder un nom de registre en plus de la constante et de l'opcode. Les instructions ''load-op'' des processeurs CISC sont un peu dans le même cas, sauf qu'il faut remplacer la constante par une adresse, qui a généralement la même taille. Les instructions sont donc en moyenne plus courte sur les processeurs à registre, du fait de la présence de registres.

===Annexe : les toutes premières architectures à accumulateur : le Manchester Baby===

[[File:BabyArchitecture.png|vignette|Architecture de la Manchester Baby.]]

Les architectures à accumulateurs sont apparues dès les débuts de l'informatique. Le tout premier ordinateur à programme enregistré en mémoire, le ''Manchester Baby'', était une architecture à accumulateur. Niveau interface, l'ordinateur avait une console avec 32 boutons, des interrupteurs et un écran de sortie sur lequel afficher les résultats. A l'intérieur, il y avait un processeur et une RAM de 32 adresses, fabriquée avec des tubes Williams (abordés dans une annexe à la fin du cours). Chaque adresse mémorisait 32 bits, qui pouvaient encoder soit un nombre, soit une instruction.

Le programme devait tenir dans la RAM, avec une instruction par adresse maximum, ce qui limitait les programmes à 32 instructions maximum. Une instruction prenait donc 32 bits, 3 indiquaient quelle opération utiliser, 12 servait à indiquer où se trouvent la seconde opérande en RAM, les 16 restants sont inutilisés.

Le processeur avait un registre accumulateur de 32 bits, un ''program counter'' et un registre d'instruction. Il intégrait un additionneur dédié au ''program counter'', mais l'ALU n'avait pas d'additionneur. En conséquence, il ne gérait pas l'addition. A la place, il gérait la soustraction. Il pouvait cependant émuler l'addition à partir d'une soustraction. La soustraction était utilisée pour calculer le complément d'une opérande, et soustraire le complément revient à additionner. L'ALU était une ALU sérielle, à savoir qu'elle faisait les soustractions bit par bit.

Le processeur supportait 7 instructions au total : la soustraction, des instructions de branchement et d'accès mémoire, rien d'autre. Les instructions de branchement utilisaient des modes d'adressage très particuliers, qu'on ne retrouve pas sur les ordinateurs modernes. Les branchements inconditionnels utilisaient une forme d'adressage mémoire indirect, pas les adressages usuels pour les branchements. Il n'y avait pas de branchements conditionnels, mais une ''SKIP instruction''.

{|class=&quot;wikitable&quot;
|-
! SUB 
| Soustrait l'opérande mémoire de l'accumulateur.
|-
! CMP
| Skippe l'instruction suivante si l'accumulateur a une valeur négative.
|-
! JMP
| Branchement indirect mémoire. :
* L'adresse de destination est lue depuis la mémoire.
* L'adresse lue est intégrée dans l'instruction via adressage absolu.
|-
! JRP
| Branchement relatif indirect.
* Lit une opérande depuis la mémoire, l'adresse est intégrée dans l'instruction via adressage absolu.
* Additionne l'opérande lue au ''program counter''.
|-
! LDN
| Instruction LOAD. La donnée lue est inversée lors de la lecture, l'accumulateur contient le complément à deux de la donnée lue après la lecture.
|-
! STO
| Instruction STORE
|-
! STOP
| Éteint l'ordinateur.
|}

Le Manchester Mark 1 était une amélioration du Manchester Baby. Il utilisait 4500 tubes à vide. L'ordinateur gérait des nombres de 40 bits, mais les instructions étaient codées sur 20 bits. La RAM avait la même taille, à savoir 32 nombres, leur taille était simplement augmentée. Par contre, la RAM était complémentée par l’ancêtre du disque dur magnétique, à savoir un tambour magnétique, l’ancêtre du disque dur magnétique. Il contenait 40 pages, chacune ayant la même taille que la RAM. C'était là encore une architecture à accumulateur, sauf qu'elle intégrait aussi des registres d'indice. Et surtout : son processeur gérait l'addition et quelques opérations logiques (ET et OU), en plus de la soustraction et de la comparaison.

[[File:MM1Schematic French.svg|centre|vignette|upright=2.5|Architecture de la Manchester Mark 1.]]

==La micro-architecture des architectures à accumulateur sans registres d'indice==

L'organisation interne d'une architecture à accumulateur est très différente de celle des processeurs à registre. Elle est plus ou moins la même pour tous ces processeurs, le point important étant que le chemin de données se résume à une ALU, un registre accumulateur et le bus de données. L'ALU est reliée au registre accumulateur, ainsi qu'au bus de données pour lire la seconde opérande, comme illustré ci-dessous.

[[File:Accumulator.png|centre|vignette|upright=2|Accumulateur.]]

===L'unité de calcul et l'accumulateur===

Pour simplifier l'implémentation, le résultat est mémorisé dans un registre en sortie de l'unité de calcul. La raison est qu'on ne veut pas altérer l'accumulateur tant que le résultat final n'est pas totalement calculé. Rappelons que l'ALU ne fournit pas un résultat d'un seul bloc, mais que certains bits arrivent avant les autres, typiquement les bits de poids faible. Si le résultat était écrit dans l'accumulateur directement, il écraserait des bits de l’opérande en cours d'utilisation, ce qui fausserait le résultat.

[[File:Accumulateur avec registre de sortie.png|centre|vignette|upright=2|Accumulateur avec registre de sortie]]

Une autre solution utilisait un registre entre l'accumulateur et l'unité de calcul, appelé l’'''''accumulator latch'''''. Il remplace le registre en sortie de l'ALU, dans le sens où il permet d'écrire dans l'accumulateur sans effacer l'opérande, pendant que l’opération est en cours dans l'ALU. L'accumulateur est copié dans l’''accumulator latch'', avant que l'ALU démarre ses calculs. L'opérande est donc maintenue même si on commence à écrire le résultat dans l'accumulateur.

Sur le 8085 d'Intel, l’''accumulator latch'' peut être initialisé avec une constante prédéfinie, ce qui permet d'implémenter certaines instructions très facilement. Par exemple, il peut être initialisé à 0, ce qui permet d'implémenter les instructions MOV et INC (incrémentation). Un MOV est équivalent à faire un OU entre le registre lu et 0. Une instruction INC initialise l'entrée de retenue de l'unité de calcul à 1, puis ajoute 0. La décrémentation est implémentée de la même manière, sauf que l’''accumulator latch'' est initialisé à -2 pour compenser l'entrée de retenue à 1. De plus, pour supporter les conversion de décimal à BCD, l’''accumulator latch'' peut être initialisé avec les constantes 0x00, 0x06, 0x60, or 0x66. L'''accumulator latch'' est relié à divers fils de commande provenant de l'unité de contrôle, qui décide quelle valeur d'initialisation utiliser en fonction de l'instruction décodée.

[[File:Accumulator latch.png|centre|vignette|upright=2|Accumulator latch]]

[[File:Chemin de données à un seul bus.png|vignette|Chemin de données à un seul bus]]

De même, la seconde opérande, celle lue sur le bus de données, est mémorisée dans un registre en amont de l'ALU. C'était notamment très utile si le processeur utilisait une ALU plus courte que les opérandes, avec par exemple une ALU 4 bits pour un CPU 8 bits. Les anciens processeurs à accumulateur de type ''mainframe'' utilisaient des opérandes de grande taille, du genre 36 ou 48 bits, ce qui avait des conséquences sur l'unité de calcul utilisée, ainsi que sur la communication avec la mémoire. Il arrivait que de tels processeurs utilisaient des ALU sérielles, ou du moins octet-sérielles, plutôt qu'une véritable ALU 36 bits. Nous verrons aussi que c'est très utile sur les processeurs à accumulateur avec un bus interne unique, dans la suite du chapitre.

===La micro-architecture des architectures à accumulateur avec instructions LOAD/STORE===

Nous venons de voir comment est implémenté l'unité de calcul et l'accumulateur, et comment le tout est relié au bus de données. Mais cela ne permet que d'avoir un processeur à accumulateur rudimentaire, qui ne gére que des instructions arithmétiques et logiques. Il faut aussi gérer le cas des opérations LOAD/STORE et des modes d'adressages associés, mais c'est le séquenceur qui s'en occupe. Avec l'adressage absolu, les instructions LOAD et STORE ne font que connecter l'accumulateur au bus de données. L'instruction STORE nécessite de connecter l'accumulateur au bus de données, de manière à ce que le transfert des données se fasse de l'accumulateur vers le bus de données. L'instruction LOAD s'implémente de la même manière, sauf que le sens de transfert est inversé.

Cependant, il existe une optimisation qui permet d'implémenter l'instruction LOAD sans ajouter de circuits. Pour cela, il suffit que l'unité de calcul gére les opérations ''pass through'', à savoir des opérations qui se contentent de recopier un opérande sur la sortie. Ici, l'idée est de recopier l'opérande provenant du bus de données.

[[File:Architecture à accumulateur, microarchitecture.png|centre|vignette|upright=2|Architecture à accumulateur, microarchitecture]]

Pour gérer nativement l'adressage indirect à registre, il suffit de connecter l'accumulateur au bus d'adresse. Le plus simple est d'ajouter un multiplexeur, comme illustré ci-dessous. La donnée lue est copiée dans l'accumulateur, ce qui fait qu'il vaut mieux utiliser un registre d’interfaçage, l'accumulateur n'étant pas utilisable à la fois pour le bus d'adresse et de données.

[[File:Adressage indirect sur une architecture à accumulateur.png|centre|vignette|upright=2|Adressage indirect sur une architecture à accumulateur]]

Pour finir, voyons comment le pointeur de pile et le ''program counter'' sont implémentés. Les architectures à accumulateur ont souvent des adresses de taille différente des données, ce qui fait qu'il vaut mieux utiliser un circuit incrémenteur dédié pour incrémenter le ''program counter'', plutôt que de l'incrémenter via l'unité de calcul. Les architectures à accumulateur ont parfois un pointeur de pile, qui gère une pile d'adresse de retour, pas une vraie pile d'appel. Aussi, le pointeur de pile est censé être incrémenté et décrémenté, pas plus. Pas d'addition ou de soustraction pour gérer des cadres de pile. Là encore, c'est la solution de l'incrémenteur séparé qui est retenue. Pour économiser des transistors, il n'y a qu'un seul incrémenteur partagé pour les deux.

==Les architectures à accumulateur à registres d'indice==

Les architectures à accumulateur décrites dans la section précédente sont capables de faire de l'adressage indirect, mais n'incluent pas les modes d'adressage base + indice et absolus indicés, qui prennent une adresse et y ajoute un indice. Il s'agit des toutes premières architectures à accumulateur, comme les premiers ordinateurs IBM ou le fameux PDP-8. Mais par la suite, les processeurs à accumulateurs ont inclus un support des modes d'adressages indicés, grâce à des '''registres d'indice'''.

===Les registres d'indice===

Les registres d'indice stockent des indices de tableaux. Ils permettaient de supporter deux modes d'adressage :
* Le '''mode d'adressage absolu indicé''' où une adresse fixe est additionnée à un indice variable. L'adresse fixe est intégrée dans l'instruction (adressage absolu), l'indice est dans un registre d'indice.
* Le '''mode d'adressage base + indice''', où l'adresse est dans l'accumulateur et l'indice dans le registre d'indice.

Les processeurs à accumulateur supportaient souvent des variantes des modes d'adressage précédents, où le registre d'indice était automatiquement incrémenté ou décrémenté à chaque utilisation.

Au départ, ces processeurs n'utilisaient qu'un seul registre d'indice qui se comportait comme un second accumulateur spécialisé dans les calculs d'adresses mémoire. Le processeur supportait de nouvelles instructions qui utilisaient ce registre d'indice de façon implicite. Mais avec le temps, les processeurs finirent par incorporer plusieurs de ces registres. Les instructions de lecture ou d'écriture devaient alors préciser quel registre d'indice utiliser, en précisant un nom de registre d'indice, un numéro de registre d'indice.

Il faut préciser que les registres d'indice ont une taille bien plus petite que l'accumulateur. Ils mémorisent des indices codés sur 16 bits ou moins, alors que l'accumulateur faisait typiquement 36 à 48 bits, parfois plus. La taille classique sur les anciens ''mainframes'' était de 15 bits, parfois moins. Il n'était pas rare de tomber sur des registres d'indice de 8 ou 9 bits. Leur petite taille rendait leur implémentation matérielle peu couteuse. Et c'est ce qui explique qu'ils étaient préférés à l'usage d'un second accumulateur.

Un exemple est le cas du processeur Motorola 6809, un processeur à accumulateur qui contient deux registres d'indices nommés X et Y. L'accumulateur est noté D et fait 16 bits, il peut être parfois géré comme deux accumulateurs séparés A et B de 8 bits chacun. Il contenait aussi deux pointeurs de pile, l'un pour les programmes, l'autre pour le système d'exploitation, ainsi qu'un ''program counter''. Le registre de page était utilisé pour l'adressage absolu, comme vu dans le chapitre sur les modes d'adressage.

[[File:6809 Internal Registers.svg|centre|vignette|upright=2|6809 Internal Registers]]

Les processeurs IBM avaient autrefois plusieurs registres d'indice. Par exemple, l'IBM 704 avait trois registres d'indice de 15 bits. Leur contenu était soustrait de l'adresse absolue. Une instruction pouvait utiliser plusieurs registres d'indice pour adresser son opérande. Toute instruction utilisait trois bits pour sélectionner les registres d'indice utilisés. Fait assez original, lorsque plusieurs registres d'indice sont sélectionnés, le processeur n'additionne pas les trois registres à l'adresse de base. À la place, il fait un OU bit à bit entre les registres d'indice sélectionnés, et additionne le résultat à l'adresse.

Les processeurs IBM à accumulateur ont fait ça sur toute la gamme IBM 700/7000, pour des raisons de compatibilité. Les processeurs suivants avaient 7 registres d'indices, mais conservaient les trois bits pour adresser les registres d'indices. Ils pouvaient fonctionner dans deux modes. Le premier mode est plus intuitif : les trois bits précisent un registre d'indice parmi les 7, qui est additionné avec l'adresse absolue. La valeur zéro indique qu'aucun registre d'indice n'est utilisé, ce qui explique qu'il y a 7 registres d'indice et non 8. Un second mode, compatible avec l'IBM 704, fait un OU logique entre les registres d'indice sélectionnés. Seuls les trois premiers registres d'indices peuvent être sélectionnés dans ce mode. Il y a deux instructions pour changer de mode : une pour passer en mode compatible, l'autre pour le quitter pour l'autre mode.

Quelques rares processeurs à registres généraux ont utilisés des registres d'indice, en plus des registres généraux. Ce qui fait l'association que nous avons faite entre registres d'indice et architectures à accumulateur est imparfait, bien que solide sur le principe. Un exemple d'architecture de ce type sont les architectures de la série UNIVAC 1100/2200. Ils disposaient de 128 registres, qui étaient mappés en mémoire à partir de l'adresse mémoire 0, la majorité étant inaccessibles par le programmeur. Ils regroupaient 12 registres accumulateurs, 11 registres d'indice et 4 registres hybrides qui pouvaient servir soit de registre d'indice, soit de registres accumulateurs.

===La micro-architecture des architectures à accumulateur avec registres d'indice===

La présence de registres d'indice modifie grandement l'implémentation du processeur. En effet, il faut rajouter un banc de registre pour les registres d'indice. Le banc de registre est monoport, car on a besoin de lire ou d'écrire un indice à la fois. Et il faut aussi potentiellement rajouter de quoi faire les calculs d'adresse. Deux solutions sont possibles : une ALU dédiée aux calculs d'adresse, une seule ALU pour toutes les opérations.

Dans le premier cas, il y a une ALU séparée associée aux registres d'indice. L'ALU et les registres d'indice sont placés en sortie du séquenceur, en-dehors du chemin de données, la sortie de l'ALU est directement connectée au bus d'adresse. L'unité de calcul d'adresse peut être utilisée pour incrémenter le ''program counter''. Un défaut de cette approche est qu'elle ne gère pas l'adresse indirect à registre.

[[File:Chemin de données sans support des pointeurs, avec adressage absolu indicé.png|centre|vignette|upright=2|Chemin de données sans support des pointeurs, avec adressage absolu indicé]]

Une autre option utilise un bus interne, qui interconnecte tout le chemin de données. Dans sa version la plus simple, il est relié à l'accumulateur, l'unité de calcul, le banc de registre d'indice et le bus de données. Avec cette solution, l'ALU est utilisé à la fois pour calculer les adresses et pour les instructions de calcul. En reliant le bus interne au bus d'adresse à travers un multiplexeur, on gère naturellement les adressages indirects.

[[File:Architecture à accumulateur avec registres associés.png|centre|vignette|upright=2.5|Architecture à accumulateur avec registres associés]]

Il faut noter que sur les architectures Von Neumann, le séquenceur est relié à ce bus interne. En effet, charger une instruction demande de passer par le bus mémoire, donc par l’intermédiaire de ce bus internet. Le ''program counter'' est envoyé sur ce bus pour lire l'instruction, puis l'instruction lue est recopiée dans le registre d'instruction. Le chargement d'une instruction est donc géré comme une lecture des plus classiques. De plus, cela permet d'incrémenter le ''program counter'' au niveau de l'unité de calcul entière. Le ''program counter'' est envoyé sur le bus interne, incrémenté par l'ALU, puis le résultat est recopié dans le ''program counter'' via le bus interne.

[[File:Architecture à accumulateur avec bus unique de type Von Neumann.png|centre|vignette|upright=2|Architecture à accumulateur avec bus unique de type Von Neumann]]

==Les processeurs bi-accumulateurs : le Motorola 6800==

Le Motorola 6800 était un processeur 8 bits qui gérait des adresses de 16 bits. Il contenait deux accumulateurs nommés A et B, de 8 bits chacun. Il disposait aussi d'un registre d'indice, d'un pointeur de pile et d'un ''program counter'', tous les trois de 16 bits. Le registre d'état regroupait 6 bits, qu'on ne détaillera pas ici.

[[File:MC6800 Processor Diagram.png|centre|vignette|upright=2|Interface et registres du MC6800.]]

La présence des deux accumulateurs impactait surtout les instructions dyadiques. Les instructions monadiques avaient juste à préciser où se trouvait l'opérande : soit en RAM, soit dans le premier accumulateur, soit dans le second. Pour les opérations dyadiques, la gestion était totalement différente. En théorie, le premier opérande est dans un accumulateur, soit A, soit B. La seconde opérande vient soit de l'autre accumulateur, soit de la mémoire RAM. Et selon les instructions, tout variait.

Pour l'addition, il y avait trois instructions. Les deux premières additionnaient un opérande provenant de la mémoire avec un accumulateur. L'instruction ADDA sélectionnait le premier accumulateur, l'instruction ADDB sélectionnait le second accumulateur. Mais une troisième instruction, l’instruction ABA, permettait d'additionner le contenu des deux accumulateurs.

Pour les autres opérations, il n'était pas possible d'utiliser les deux accumulateurs en même temps. La seule possibilité était de faire une opération entre un accumulateur et un opérande venant de la mémoire. Toutes les instructions étaient en double, avec une copie par accumulateur. Par exemple, l'instruction ANDA faisait un ET entre l’accumulateur A et l'opérande mémoire, l'instruction ANDB faisait pareil avec l'accumulateur B.

==Les architectures hybrides registres-accumulateur==

Il a existé quelques architectures qui étaient des hybrides entre architectures à accumulateur et architecture à registre. Elles ont servi de transition entre les deux, durant les années 80-90. Elles avaient un accumulateur unique couplé à un banc de registres généraux. Par exemple, les premiers processeurs Intel 8 bits étaient des processeurs hybrides-accumulateur. Lles CPU Intel 8 bits disposaient de 7 registres de 8 bits nommés A, B, C, D, E, F, H, L, SP. Ils correspondent respectivement à :
* l'accumulateur A ;
* six registres nommés B, C, D, E, H et L ;
* le registre d'état F ;
* le pointeur de pile SP.

Sur ces processeurs, les instructions dyadiques devaient mettre leur premier opérande dans l'accumulateur, la seconde provenait soit des registres, soit de la RAM, soit d'une constante immédiate. Les opérations monadiques pouvaient lire leur opérande depuis l'accumulateur, les autres registres ou la RAM, tout était permis. Les registres d'indices disparaissaient sur ces architectures, en théorie. Les registres généraux pouvaient être utilisés comme registre d'indice ou pour stocker des opérandes, ils étaient assez versatiles pour servir de registres d'indices.

La présence de registres a de nombreux avantages, comparé aux architectures à accumulateur pures. Les instructions arithmétiques sont plus rapide, lire un registre étant plus rapide qu'un accès RAM. Les performances sont donc augmentées. De plus, les instructions arithmétiques utilisant ces registres sont plus courtes : pas besoin d'encoder une adresse mémoire, un nom de registre suffit. Vu que les processeurs de l’époque avaient des instructions de taille variable, cela améliorait la densité de code.

La microarchitecture de ces processeurs est très similaire à celle d'un processeur avec des registres d'indices. La seule différence est que le banc de registre contient des registres généraux et non des registres d'indices. Le banc de registre est systématiquement monoport, car il n'avait aucune raison d'être multiport. Pour les instructions dyadiques, seules à lire deux opérandes, il ne servait que pour la seconde opérande, la première était lue depuis l'accumulateur.

Les processeurs hybrides registre-accumulateur se classent en deux types principaux : ceux qui ont un seul bus interne, et ceux qui en ont deux. Le premier cas est identique à celui vu précédemment pour les architectures à accumulateur avec registres d'indice, à la seule différence est que le banc de registre contient des registres généraux et non des registres d'indices. Afin de gérer l'adressage indirect à registre, le bus interne est connecté aux deux registres d’interfaçage mémoire.

[[File:Architecture à accumulateur avec bus unique de type Von Neumann.png|centre|vignette|upright=2|Architecture à accumulateur avec bus unique de type Von Neumann]]

Notons que cela permet aussi d'implémenter facilement les branchements indirects, car le bus interne permet d'échanger des adresses entre ''program counter'' et banc de registre. De même, il est possible d'utiliser l'ALU pour gérer les branchements indirects., en plus de l'utiliser pour incrémenter le ''program counter''.

[[File:Single bus organization.jpg|centre|vignette|upright=2|Single bus organization]]

Une autre solution utilisait deux bus internes : un connecté au bus de données, un autre relié au bus d'adresse. Le bus de commande mémoire était lui commandé par le séquenceur, l'unité de contrôle. L'intermédiaire entre ces deux bus était le banc de registre, ainsi que les autres registres. Le banc de registre était connecté aux deux bus interne, avec un port de lecture relié au bus d'adresse, un port de lecture-écriture relié au bus de données. Le port de lecture était utilisé pour l'adressage indirect, l'autre l'était pour le reste.

[[File:Proz1-e.png|centre|vignette|upright=2|Intérieur d'un processeur.]]

L'organisation à deux bus simplifiait la gestion du ''program counter'' et le chargement des instructions. Le ''program counter'' était soit séparé du banc de registre, soit placé dans le banc de registre. Les deux solutions étaient utilisés, tout dépend du processeur. Il faut noter que si le ''program counter'' est intégré au banc de registres, alors la microarchitecture du processeur est bien plus simple. L'envoi du ''program counter'' sur le bus d'adresse utilise le port de lecture relié au bus d'adresse, qui sert aussi pour l'adressage indirect. L'économie de circuits, sans compter la simplicité d'implémentation que cela implique, explique sans doute que la technique a été utilisée sur quelques processeurs anciens.

Le ''program counter'' était généralement incrémenté par l'ALU, ce qui explique qu'il soit connecté au bus interne pour les données. La connexion est aussi utile pour gérer les branchements indirects, qui copient un registre dans le ''program counter'', ainsi que les branchements relatifs (addition dans l'ALU), voire les branchements directs (l'adresse vers laquelle brancher est envoyée en entrée de l'ALU et propagée en sortie avec une opération ''pass through'').

[[File:Connexion du program counter sur les bus avec PC dans le banc de registres.png|centre|vignette|upright=2|Connexion du program counter sur les bus avec PC dans le banc de registres]]

===Les registres d'interruption avec un processeur hybride-accumulateur : l'exemple du Z80===

Un exemple de processeur registre-accumulateur à deux bus interne est le Z80, un processeur fortement inspiré des CPU Intel 8 bits. Il a un jeu d'instruction similaire, mais a diverses améliorations par rapport au design original. Notamment, le processeur a des registres séparés pour les interruptions.

Sur le Z80, les registres généraux sont dupliqués avec 6 registres pour les interruptions et 6 registres pour les programmes autres. Leur copie pour les interruptions sont nommées B', C', D', E', H', L'. Les 12 registres sont placés dans le banc de registre, ce qui implique que le fenêtrage de registres est utilisé pour gérer la séparation entre registre d'interruption et normaux. Il faut noter que l'accumulateur et le registre d'état sont aussi dupliqués, leurs copies étant nommées A' et F'. Mais leur duplication se fait autrement que par fenêtrage de registre.

En plus des registres précédents, le Z80 incorporait deux registres d'indice nommés X et Y, ainsi qu'un pointeur de pile SP et un ''program counter'' PC. Ils n'étaient pas dupliqués pour les interruptions. Les registres d'indice étaient reliés à une unité de calcul d'adresse. L'unité de calcul d'adresse prenait deux opérandes : un indice, et une adresse mémoire provenant soit du banc de registre, soit de l'accumulateur. En clair, l'unité de calcul d'adresse faisait le lien entre les deux bus internet : le bus de données interne en entrée, le bus d'adresse en sortie.

À l'intérieur du processeur, tous les registres étaient regroupés dans un banc de registre unique, sauf les accumulateurs, les registres d'état et le ''program counter''. Bien que ce ne soit pas indiqué sur le schéma ci-dessous, le ''program counter'' est séparé du banc de registre, alors que le pointeur de pile est dedans. Le compteur IR est lui associé au ''program counter'', il est sortit du banc de registre. Le Z80 utilise lui aussi un incrémenteur séparé de l'ALU, qui est utilisé pour mettre à jour le ''program counter'', le pointeur de pile et un compteur de rafraichissement mémoire nommé IR sur le Z80 (pour rappel, le rafraichissement mémoire demande de balayer la mémoire d'adresse en adresse et été fait par le CPU à l'époque). De plus, il est utilisé pour les instructions INC et DEC qui incrémentent une opérande de 16 bits obtenue en combinant deux registres de 8 bits. En clair, l'incrémenteur du ''program counter'' a été réutilisé de beaucoup de manières originales.

[[File:Z80 arch.svg|centre|vignette|upright=3|Microarchitecture du Z80.]]

Le Z80 incorporait des instructions pour échanger le contenu des deux ensembles de registres, accumulateur inclus. Elles permettaient d'utiliser les registres d'interruption pour les programmes et réciproquement. En clair, cela doublait le nombre de registres si les interruptions n'étaient pas utilisées.
* L'instruction EXX échangeait les deux fenêtres de registres généraux : les registres B, C, D, E, H et L devenaient les registres B', C', D', E', H' et L' et inversement.
* L'instruction EX échangeait l'accumulateur et le registre d'état : les registres A,F devenait A',F' et inversement.

Le fenêtrage de registre était modifié par l'instruction EXX, qui échangeait les deux fenêtres de registres. Pour l'implémenter, une bascule était ajouté au processeur, appelons-la la bascule INT. Elle était relié au bus d'adresse du banc de registre, dont elle mémorisait le bit de poids fort. L'instruction EXX inversait la valeur de la bascule INT. Il est aussi possible d'échanger le contenu des registres D,E et H,L avec une instruction dédiée, ce qui est là encore fait par deux bascules : une pour les registres D,E et une autre pour les registres H,L.

Pour l'accumulateur et le registre d'état, le choix entre registre normal et registre d'interruption se faisait là encore par une seconde bascule appelée la bascule A. La bascule est reliée à un multiplexeur et un démultiplexeur, qui permet de choisir quel accumulateur relier à l'unité de calcul. L'instruction EX inverse le contenu de la bascule A.

&lt;noinclude&gt;
{{NavChapitre | book=Fonctionnement d'un ordinateur
           | prev=L'unité de contrôle
           | prevText=L'unité de contrôle
           | next=Les processeurs 8 bits et moins
           | nextText=Les processeurs 8 bits et moins
}}
&lt;/noinclude&gt;</text>
      <sha1>b6ivzncgomrrb2j863hrkb2mudtok76</sha1>
    </revision>
    <revision>
      <id>744158</id>
      <parentid>744157</parentid>
      <timestamp>2025-06-05T14:11:58Z</timestamp>
      <contributor>
        <username>Mewtow</username>
        <id>31375</id>
      </contributor>
      <minor />
      <comment>/* Annexe : les toutes premières architectures à accumulateur : le Manchester Baby */</comment>
      <origin>744158</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="38915" sha1="mm851vwjyyuznx2j5h2ed4eldxotvsp" xml:space="preserve">Les architectures que nous avons vu précédemment dans ce cours disposent de registres pour les données, en plus du pointeur de pile, d'un ''program counter'', et de quelques autres. Elles sont appelées des '''architectures à registres''', terme qui trahit bien le fait qu'elles ont des registres généraux ou spécialisés pour stocker temporairement des données. Et si on leur a donné un nom, c'est parce qu'il existe des architectures qui ne sont pas dans cette catégorie. Il en existe plusieurs types, mais ce chapitre va se concentrer sur les '''architectures à accumulateur'''.

[[File:Isaccumulator.png|vignette|Architecture à accumulateur.]]

Les architectures à accumulateur sont centrées autour d'un registre architectural appelé l''''accumulateur'''. Il est utilisé pour toutes les opérations arithmétiques dyadiques, où il sert à la fois de source et de destination. Toutes les instructions dyadiques sont de type ''load-op'' : une opérande est lue depuis l'accumulateur, le second opérande est lu depuis la mémoire RAM, le résultat de l'instruction est automatiquement mémorisé dans l'accumulateur. Les instructions monadiques peuvent utiliser un opérande dans l'accumulateur, ou dans la mémoire RAM, les deux sont théoriquement possibles.

La conséquence est que le nombre d'accès mémoire est drastiquement diminué : de 3 par instructions sur une architecture mémoire-mémoire, on passe à seulement un avec un accumulateur. Les opérations dyadiques ont besoin d'un seul accès mémoire pour lire la seconde opérande, les opérations monadique en font aussi un seul pour lire leur unique opérande.

{|class=&quot;wikitable&quot;
|-
! Classe d'architecture
! Nombre d'accès mémoire par opération dyadique
|-
|-
! Architecture à accumulateur
| Un accès mémoire par instruction, pour lire la seconde opérande
|-
! Architecture à registres
| Zéro si les opérandes sont dans les registres, un pour les opérations ''load-op'', LOAD et STORE.
|}

==Le jeu d'instruction des architectures à accumulateur sans registres d'indice==

L'accumulateur est adressé grâce au mode d'adressage implicite, de même que le résultat de l'opération. Par contre, les autres opérandes sont localisés avec d'autres modes d'adressage, et lues en mémoire RAM. Le résultat ainsi qu'un des opérandes sont adressés de façon implicite car dans l'accumulateur, seule la seconde opérande étant adressée directement. Grâce à l'accumulateur, une instruction ne fait qu'un seul accès mémoire maximum, ce qui rend le processeur très facile à implémenter.

===Les registres des anciennes architectures à accumulateur===

[[File:IBM 701console.jpg|vignette|IBM 701, console extérieure.]]

Les architectures à accumulateur étaient communes dans les années 50-60. A l'époque, les ordinateurs étaient gigantesques, ils prenaient une pièce de bâtiment entière dans le pire des cas, une armoire entière dans le meilleur. Les ordinateurs de l'époque étaient surtout utilisés pour du calcul scientifique ou des tâches d’ingénierie demandant beaucoup de calcul, rarement pour de la compatibilité.

Les nombres flottants n'étaient pas encore apparus. A la place, les ordinateurs de l'époque géraient des nombres entiers de grande taille, de 30 bits ou plus. En conséquence, l'accumulateur faisait facilement 30 à 60 bits. Par exemple, les ordinateurs de la Série scientifique IBM 700/7000 géraient des entiers de 36 bits, l’accumulateur faisait 38 bits : 36 bits plus deux bits pour les débordements. Au passage, de tels processeurs utilisaient l'adressage par mot, et non par byte.

Historiquement, les premières architectures à accumulateur ne contenaient aucun autre registre que l'accumulateur. Ce n'est que dans les années 60 que de nombreuses architectures à accumulateur ont ajouté un second '''registre pour les multiplication/divisions'''. Un exemple est celui de l'IBM 701, qui incorporait un registre accumulateur de 38 bits et un registre multiplieur de 36 bits. Le registre mémorise le multiplieur lors d'une opération de multiplication. Il mémorise donc un opérande, pas le résultat. Il peut aussi décaler le multiplieur vers la droite/gauche, ce qui est utile pour exécuter la multiplication. C'est ce qui est fait sur l'IBM 7094.

Une autre possibilité est que ce registre mémorise une partie du résultat de l'opération. Pour rappel, le résultat d'une multiplication/division est codé sur deux fois de bits que ses opérandes. Par exemple, multipliez deux opérandes de 30 bits, vous obtiendrez un résultat de 60 bits. Les 30 bits de poids faible du résultat vont dans l'accumulateur, les 30 bits de poids fort vont dans ce second registre.

Les architectures à accumulateur parfois un '''registre pour le pointeur de pile''', utilisé pour gérer les fonctions/procédures. Les architectures à accumulateurs supportaient une pile d'adresse de retour, souvent une pile d'appel. Mais pour cela, il fallait mémoriser le pointeur de pile dans le processeur, ce qui demandait un registre dédié.

===L'adressage indirect avec l'accumulateur===

Les instructions LOAD et STORE existent bel et bien sur les architectures à accumulateur, mais n'ont pas les mêmes modes d'adressages. L'instruction LOAD copie une donnée de la RAM vers l'accumulateur, l'instruction STORE copie l'accumulateur dans une adresse. Les deux instructions n'ont pas besoin d'adresser l'accumulateur, qui est adressé de manière implicite, juste de préciser l'adresse à lire/écrire.

Les architectures à accumulateur supportaient souvent le mode d'adressage indirect mémoire. Un exemple est celui des ordinateurs Data General Nova, qui sont des architectures à accumulateur et qui supportaient ce mode d'adressage. Les deux instructions LOAD et STORE existaient en deux versions, distinguées par un bit d'indirection. Si ce bit est à 0 dans l'opcode, alors l'instruction utilise le mode d'adressage absolu normal : l'adresse intégrée dans l'instruction est celle de la donnée. Mais s'il est à 1, alors l'adresse intégrée dans l'instruction est celle du pointeur.

Cependant, la présence de l'accumulateur permettait d'utiliser l'adressage indirect à registre, pour gérer les pointeurs. Pour rappel, avec le mode d'adressage indirect à registre, l'adresse à lire/écrire est dans un registre. Ici, l'adresse à lire/écrire est prise dans l'accumulateur, seul registre disponible pour. L'adressage indirect est plus simple à implémenter pour l'instruction LOAD, car elle prend un seul opérande : l'adresse à lire. L'adresse à lire est placée dans l'accumulateur, la donnée lue est elle aussi chargée dans l'accumulateur. Pour l'instruction STORE, il faut fournir deux opérandes, l'adresse et la donnée à écrire, ce qui peut poser problème. Mais au pire, il est toujours possible d'utiliser l'adressage absolu ou indirect mémoire : l'adresse est dans l'instruction, la donnée à écrire dans l'accumulateur.

===L'encodage des instructions===

Sur une architecture à accumulateur l'encodage d'une instruction dyadique est assez simple, vu que l'accumulateur est adressé implicitement. La seconde opérande est localisée soit par une adresse mémoire (adressage absolu), soit est une constante (adressage immédiat). L'adresse mémoire est généralement assez longue, plus que l'opcode.

{|class=&quot;wikitable&quot;
|+ Encodage d'une instruction dyadique
|-
! rowspan=&quot;2&quot; | Opcode 
| Adresse mémoire (adressage absolu)
|-
| Constante (adressage immédiat)
|}

L'encodage d'une instruction monadique est similaire. Si l'opérande est lue depuis la mémoire RAM, alors l'instruction est encodée comme une instruction dyadique. Il en est de même pour les instructions qui copient une constante dans l'accumulateur. Par contre, si l'opérande est dans l'accumulateur, alors il y a juste besoin d'encoder l'opcode. La majorité des instructions a besoin de préciser une adresse, rares sont celles qui s'en passent. Au vu de cet encodage, les architectures à accumulateur sont qualifiées d''''architectures à une adresse''' par abus de langage.

Il est intéressant de contraster leur encodage avec les architectures à registres. Les architectures à registre doivent encoder deux opérandes en plus de l'opcode, avec éventuellement où enregistrer le résultat sur les architectures 3-adresses. Par contre, les opérandes sont généralement des noms de registre, ce qui prend moins de place qu'une adresse mémoire. A la rigueur, les instructions avec une constante immédiate prennent un peu plus de place, car elles doivent encoder un nom de registre en plus de la constante et de l'opcode. Les instructions ''load-op'' des processeurs CISC sont un peu dans le même cas, sauf qu'il faut remplacer la constante par une adresse, qui a généralement la même taille. Les instructions sont donc en moyenne plus courte sur les processeurs à registre, du fait de la présence de registres.

===Annexe : les toutes premières architectures à accumulateur : le Manchester Baby===

[[File:BabyArchitecture.png|vignette|Architecture de la Manchester Baby.]]

Les architectures à accumulateurs sont apparues dès les débuts de l'informatique. Le tout premier ordinateur à programme enregistré en mémoire, le ''Manchester Baby'', était une architecture à accumulateur. Niveau interface, l'ordinateur avait une console avec 32 boutons, des interrupteurs et un écran de sortie sur lequel afficher les résultats. A l'intérieur, il y avait un processeur et une RAM de 32 adresses, fabriquée avec des tubes Williams (abordés dans une annexe à la fin du cours). Chaque adresse mémorisait 32 bits, qui pouvaient encoder soit un nombre, soit une instruction.

Le programme devait tenir dans la RAM, avec une instruction par adresse maximum, ce qui limitait les programmes à 32 instructions maximum. Une instruction prenait donc 32 bits, 3 indiquaient quelle opération utiliser, 12  bits d'adresse servait à indiquer où se trouvent la seconde opérande en RAM, les 16 restants sont inutilisés. En théorie, les 12 bits d'adresse permettaient d'adresser 4096 adresses, mais seules 32 étaient réellement présentes.

Le processeur avait un registre accumulateur de 32 bits, un ''program counter'' et un registre d'instruction. Il intégrait un additionneur dédié au ''program counter'', mais l'ALU n'avait pas d'additionneur. En conséquence, il ne gérait pas l'addition. A la place, il gérait la soustraction. Il pouvait cependant émuler l'addition à partir d'une soustraction. La soustraction était utilisée pour calculer le complément d'une opérande, et soustraire le complément revient à additionner. L'ALU était une ALU sérielle, à savoir qu'elle faisait les soustractions bit par bit.

Le processeur supportait 7 instructions au total : la soustraction, des instructions de branchement et d'accès mémoire, rien d'autre. Les instructions de branchement utilisaient des modes d'adressage très particuliers, qu'on ne retrouve pas sur les ordinateurs modernes. Les branchements inconditionnels utilisaient une forme d'adressage mémoire indirect, pas les adressages usuels pour les branchements. Il n'y avait pas de branchements conditionnels, mais une ''SKIP instruction''.

{|class=&quot;wikitable&quot;
|-
! SUB 
| Soustrait l'opérande mémoire de l'accumulateur.
|-
! CMP
| Skippe l'instruction suivante si l'accumulateur a une valeur négative.
|-
! JMP
| Branchement indirect mémoire. :
* L'adresse de destination est lue depuis la mémoire.
* L'adresse lue est intégrée dans l'instruction via adressage absolu.
|-
! JRP
| Branchement relatif indirect.
* Lit une opérande depuis la mémoire, l'adresse est intégrée dans l'instruction via adressage absolu.
* Additionne l'opérande lue au ''program counter''.
|-
! LDN
| Instruction LOAD. La donnée lue est inversée lors de la lecture, l'accumulateur contient le complément à deux de la donnée lue après la lecture.
|-
! STO
| Instruction STORE
|-
! STOP
| Éteint l'ordinateur.
|}

Le Manchester Mark 1 était une amélioration du Manchester Baby. Il utilisait 4500 tubes à vide. L'ordinateur gérait des nombres de 40 bits, mais les instructions étaient codées sur 20 bits. La RAM avait la même taille, à savoir 32 nombres, leur taille était simplement augmentée. Par contre, la RAM était complémentée par l’ancêtre du disque dur magnétique, à savoir un tambour magnétique, l’ancêtre du disque dur magnétique. Il contenait 40 pages, chacune ayant la même taille que la RAM. C'était là encore une architecture à accumulateur, sauf qu'elle intégrait aussi des registres d'indice. Et surtout : son processeur gérait l'addition et quelques opérations logiques (ET et OU), en plus de la soustraction et de la comparaison.

[[File:MM1Schematic French.svg|centre|vignette|upright=2.5|Architecture de la Manchester Mark 1.]]

==La micro-architecture des architectures à accumulateur sans registres d'indice==

L'organisation interne d'une architecture à accumulateur est très différente de celle des processeurs à registre. Elle est plus ou moins la même pour tous ces processeurs, le point important étant que le chemin de données se résume à une ALU, un registre accumulateur et le bus de données. L'ALU est reliée au registre accumulateur, ainsi qu'au bus de données pour lire la seconde opérande, comme illustré ci-dessous.

[[File:Accumulator.png|centre|vignette|upright=2|Accumulateur.]]

===L'unité de calcul et l'accumulateur===

Pour simplifier l'implémentation, le résultat est mémorisé dans un registre en sortie de l'unité de calcul. La raison est qu'on ne veut pas altérer l'accumulateur tant que le résultat final n'est pas totalement calculé. Rappelons que l'ALU ne fournit pas un résultat d'un seul bloc, mais que certains bits arrivent avant les autres, typiquement les bits de poids faible. Si le résultat était écrit dans l'accumulateur directement, il écraserait des bits de l’opérande en cours d'utilisation, ce qui fausserait le résultat.

[[File:Accumulateur avec registre de sortie.png|centre|vignette|upright=2|Accumulateur avec registre de sortie]]

Une autre solution utilisait un registre entre l'accumulateur et l'unité de calcul, appelé l’'''''accumulator latch'''''. Il remplace le registre en sortie de l'ALU, dans le sens où il permet d'écrire dans l'accumulateur sans effacer l'opérande, pendant que l’opération est en cours dans l'ALU. L'accumulateur est copié dans l’''accumulator latch'', avant que l'ALU démarre ses calculs. L'opérande est donc maintenue même si on commence à écrire le résultat dans l'accumulateur.

Sur le 8085 d'Intel, l’''accumulator latch'' peut être initialisé avec une constante prédéfinie, ce qui permet d'implémenter certaines instructions très facilement. Par exemple, il peut être initialisé à 0, ce qui permet d'implémenter les instructions MOV et INC (incrémentation). Un MOV est équivalent à faire un OU entre le registre lu et 0. Une instruction INC initialise l'entrée de retenue de l'unité de calcul à 1, puis ajoute 0. La décrémentation est implémentée de la même manière, sauf que l’''accumulator latch'' est initialisé à -2 pour compenser l'entrée de retenue à 1. De plus, pour supporter les conversion de décimal à BCD, l’''accumulator latch'' peut être initialisé avec les constantes 0x00, 0x06, 0x60, or 0x66. L'''accumulator latch'' est relié à divers fils de commande provenant de l'unité de contrôle, qui décide quelle valeur d'initialisation utiliser en fonction de l'instruction décodée.

[[File:Accumulator latch.png|centre|vignette|upright=2|Accumulator latch]]

[[File:Chemin de données à un seul bus.png|vignette|Chemin de données à un seul bus]]

De même, la seconde opérande, celle lue sur le bus de données, est mémorisée dans un registre en amont de l'ALU. C'était notamment très utile si le processeur utilisait une ALU plus courte que les opérandes, avec par exemple une ALU 4 bits pour un CPU 8 bits. Les anciens processeurs à accumulateur de type ''mainframe'' utilisaient des opérandes de grande taille, du genre 36 ou 48 bits, ce qui avait des conséquences sur l'unité de calcul utilisée, ainsi que sur la communication avec la mémoire. Il arrivait que de tels processeurs utilisaient des ALU sérielles, ou du moins octet-sérielles, plutôt qu'une véritable ALU 36 bits. Nous verrons aussi que c'est très utile sur les processeurs à accumulateur avec un bus interne unique, dans la suite du chapitre.

===La micro-architecture des architectures à accumulateur avec instructions LOAD/STORE===

Nous venons de voir comment est implémenté l'unité de calcul et l'accumulateur, et comment le tout est relié au bus de données. Mais cela ne permet que d'avoir un processeur à accumulateur rudimentaire, qui ne gére que des instructions arithmétiques et logiques. Il faut aussi gérer le cas des opérations LOAD/STORE et des modes d'adressages associés, mais c'est le séquenceur qui s'en occupe. Avec l'adressage absolu, les instructions LOAD et STORE ne font que connecter l'accumulateur au bus de données. L'instruction STORE nécessite de connecter l'accumulateur au bus de données, de manière à ce que le transfert des données se fasse de l'accumulateur vers le bus de données. L'instruction LOAD s'implémente de la même manière, sauf que le sens de transfert est inversé.

Cependant, il existe une optimisation qui permet d'implémenter l'instruction LOAD sans ajouter de circuits. Pour cela, il suffit que l'unité de calcul gére les opérations ''pass through'', à savoir des opérations qui se contentent de recopier un opérande sur la sortie. Ici, l'idée est de recopier l'opérande provenant du bus de données.

[[File:Architecture à accumulateur, microarchitecture.png|centre|vignette|upright=2|Architecture à accumulateur, microarchitecture]]

Pour gérer nativement l'adressage indirect à registre, il suffit de connecter l'accumulateur au bus d'adresse. Le plus simple est d'ajouter un multiplexeur, comme illustré ci-dessous. La donnée lue est copiée dans l'accumulateur, ce qui fait qu'il vaut mieux utiliser un registre d’interfaçage, l'accumulateur n'étant pas utilisable à la fois pour le bus d'adresse et de données.

[[File:Adressage indirect sur une architecture à accumulateur.png|centre|vignette|upright=2|Adressage indirect sur une architecture à accumulateur]]

Pour finir, voyons comment le pointeur de pile et le ''program counter'' sont implémentés. Les architectures à accumulateur ont souvent des adresses de taille différente des données, ce qui fait qu'il vaut mieux utiliser un circuit incrémenteur dédié pour incrémenter le ''program counter'', plutôt que de l'incrémenter via l'unité de calcul. Les architectures à accumulateur ont parfois un pointeur de pile, qui gère une pile d'adresse de retour, pas une vraie pile d'appel. Aussi, le pointeur de pile est censé être incrémenté et décrémenté, pas plus. Pas d'addition ou de soustraction pour gérer des cadres de pile. Là encore, c'est la solution de l'incrémenteur séparé qui est retenue. Pour économiser des transistors, il n'y a qu'un seul incrémenteur partagé pour les deux.

==Les architectures à accumulateur à registres d'indice==

Les architectures à accumulateur décrites dans la section précédente sont capables de faire de l'adressage indirect, mais n'incluent pas les modes d'adressage base + indice et absolus indicés, qui prennent une adresse et y ajoute un indice. Il s'agit des toutes premières architectures à accumulateur, comme les premiers ordinateurs IBM ou le fameux PDP-8. Mais par la suite, les processeurs à accumulateurs ont inclus un support des modes d'adressages indicés, grâce à des '''registres d'indice'''.

===Les registres d'indice===

Les registres d'indice stockent des indices de tableaux. Ils permettaient de supporter deux modes d'adressage :
* Le '''mode d'adressage absolu indicé''' où une adresse fixe est additionnée à un indice variable. L'adresse fixe est intégrée dans l'instruction (adressage absolu), l'indice est dans un registre d'indice.
* Le '''mode d'adressage base + indice''', où l'adresse est dans l'accumulateur et l'indice dans le registre d'indice.

Les processeurs à accumulateur supportaient souvent des variantes des modes d'adressage précédents, où le registre d'indice était automatiquement incrémenté ou décrémenté à chaque utilisation.

Au départ, ces processeurs n'utilisaient qu'un seul registre d'indice qui se comportait comme un second accumulateur spécialisé dans les calculs d'adresses mémoire. Le processeur supportait de nouvelles instructions qui utilisaient ce registre d'indice de façon implicite. Mais avec le temps, les processeurs finirent par incorporer plusieurs de ces registres. Les instructions de lecture ou d'écriture devaient alors préciser quel registre d'indice utiliser, en précisant un nom de registre d'indice, un numéro de registre d'indice.

Il faut préciser que les registres d'indice ont une taille bien plus petite que l'accumulateur. Ils mémorisent des indices codés sur 16 bits ou moins, alors que l'accumulateur faisait typiquement 36 à 48 bits, parfois plus. La taille classique sur les anciens ''mainframes'' était de 15 bits, parfois moins. Il n'était pas rare de tomber sur des registres d'indice de 8 ou 9 bits. Leur petite taille rendait leur implémentation matérielle peu couteuse. Et c'est ce qui explique qu'ils étaient préférés à l'usage d'un second accumulateur.

Un exemple est le cas du processeur Motorola 6809, un processeur à accumulateur qui contient deux registres d'indices nommés X et Y. L'accumulateur est noté D et fait 16 bits, il peut être parfois géré comme deux accumulateurs séparés A et B de 8 bits chacun. Il contenait aussi deux pointeurs de pile, l'un pour les programmes, l'autre pour le système d'exploitation, ainsi qu'un ''program counter''. Le registre de page était utilisé pour l'adressage absolu, comme vu dans le chapitre sur les modes d'adressage.

[[File:6809 Internal Registers.svg|centre|vignette|upright=2|6809 Internal Registers]]

Les processeurs IBM avaient autrefois plusieurs registres d'indice. Par exemple, l'IBM 704 avait trois registres d'indice de 15 bits. Leur contenu était soustrait de l'adresse absolue. Une instruction pouvait utiliser plusieurs registres d'indice pour adresser son opérande. Toute instruction utilisait trois bits pour sélectionner les registres d'indice utilisés. Fait assez original, lorsque plusieurs registres d'indice sont sélectionnés, le processeur n'additionne pas les trois registres à l'adresse de base. À la place, il fait un OU bit à bit entre les registres d'indice sélectionnés, et additionne le résultat à l'adresse.

Les processeurs IBM à accumulateur ont fait ça sur toute la gamme IBM 700/7000, pour des raisons de compatibilité. Les processeurs suivants avaient 7 registres d'indices, mais conservaient les trois bits pour adresser les registres d'indices. Ils pouvaient fonctionner dans deux modes. Le premier mode est plus intuitif : les trois bits précisent un registre d'indice parmi les 7, qui est additionné avec l'adresse absolue. La valeur zéro indique qu'aucun registre d'indice n'est utilisé, ce qui explique qu'il y a 7 registres d'indice et non 8. Un second mode, compatible avec l'IBM 704, fait un OU logique entre les registres d'indice sélectionnés. Seuls les trois premiers registres d'indices peuvent être sélectionnés dans ce mode. Il y a deux instructions pour changer de mode : une pour passer en mode compatible, l'autre pour le quitter pour l'autre mode.

Quelques rares processeurs à registres généraux ont utilisés des registres d'indice, en plus des registres généraux. Ce qui fait l'association que nous avons faite entre registres d'indice et architectures à accumulateur est imparfait, bien que solide sur le principe. Un exemple d'architecture de ce type sont les architectures de la série UNIVAC 1100/2200. Ils disposaient de 128 registres, qui étaient mappés en mémoire à partir de l'adresse mémoire 0, la majorité étant inaccessibles par le programmeur. Ils regroupaient 12 registres accumulateurs, 11 registres d'indice et 4 registres hybrides qui pouvaient servir soit de registre d'indice, soit de registres accumulateurs.

===La micro-architecture des architectures à accumulateur avec registres d'indice===

La présence de registres d'indice modifie grandement l'implémentation du processeur. En effet, il faut rajouter un banc de registre pour les registres d'indice. Le banc de registre est monoport, car on a besoin de lire ou d'écrire un indice à la fois. Et il faut aussi potentiellement rajouter de quoi faire les calculs d'adresse. Deux solutions sont possibles : une ALU dédiée aux calculs d'adresse, une seule ALU pour toutes les opérations.

Dans le premier cas, il y a une ALU séparée associée aux registres d'indice. L'ALU et les registres d'indice sont placés en sortie du séquenceur, en-dehors du chemin de données, la sortie de l'ALU est directement connectée au bus d'adresse. L'unité de calcul d'adresse peut être utilisée pour incrémenter le ''program counter''. Un défaut de cette approche est qu'elle ne gère pas l'adresse indirect à registre.

[[File:Chemin de données sans support des pointeurs, avec adressage absolu indicé.png|centre|vignette|upright=2|Chemin de données sans support des pointeurs, avec adressage absolu indicé]]

Une autre option utilise un bus interne, qui interconnecte tout le chemin de données. Dans sa version la plus simple, il est relié à l'accumulateur, l'unité de calcul, le banc de registre d'indice et le bus de données. Avec cette solution, l'ALU est utilisé à la fois pour calculer les adresses et pour les instructions de calcul. En reliant le bus interne au bus d'adresse à travers un multiplexeur, on gère naturellement les adressages indirects.

[[File:Architecture à accumulateur avec registres associés.png|centre|vignette|upright=2.5|Architecture à accumulateur avec registres associés]]

Il faut noter que sur les architectures Von Neumann, le séquenceur est relié à ce bus interne. En effet, charger une instruction demande de passer par le bus mémoire, donc par l’intermédiaire de ce bus internet. Le ''program counter'' est envoyé sur ce bus pour lire l'instruction, puis l'instruction lue est recopiée dans le registre d'instruction. Le chargement d'une instruction est donc géré comme une lecture des plus classiques. De plus, cela permet d'incrémenter le ''program counter'' au niveau de l'unité de calcul entière. Le ''program counter'' est envoyé sur le bus interne, incrémenté par l'ALU, puis le résultat est recopié dans le ''program counter'' via le bus interne.

[[File:Architecture à accumulateur avec bus unique de type Von Neumann.png|centre|vignette|upright=2|Architecture à accumulateur avec bus unique de type Von Neumann]]

==Les processeurs bi-accumulateurs : le Motorola 6800==

Le Motorola 6800 était un processeur 8 bits qui gérait des adresses de 16 bits. Il contenait deux accumulateurs nommés A et B, de 8 bits chacun. Il disposait aussi d'un registre d'indice, d'un pointeur de pile et d'un ''program counter'', tous les trois de 16 bits. Le registre d'état regroupait 6 bits, qu'on ne détaillera pas ici.

[[File:MC6800 Processor Diagram.png|centre|vignette|upright=2|Interface et registres du MC6800.]]

La présence des deux accumulateurs impactait surtout les instructions dyadiques. Les instructions monadiques avaient juste à préciser où se trouvait l'opérande : soit en RAM, soit dans le premier accumulateur, soit dans le second. Pour les opérations dyadiques, la gestion était totalement différente. En théorie, le premier opérande est dans un accumulateur, soit A, soit B. La seconde opérande vient soit de l'autre accumulateur, soit de la mémoire RAM. Et selon les instructions, tout variait.

Pour l'addition, il y avait trois instructions. Les deux premières additionnaient un opérande provenant de la mémoire avec un accumulateur. L'instruction ADDA sélectionnait le premier accumulateur, l'instruction ADDB sélectionnait le second accumulateur. Mais une troisième instruction, l’instruction ABA, permettait d'additionner le contenu des deux accumulateurs.

Pour les autres opérations, il n'était pas possible d'utiliser les deux accumulateurs en même temps. La seule possibilité était de faire une opération entre un accumulateur et un opérande venant de la mémoire. Toutes les instructions étaient en double, avec une copie par accumulateur. Par exemple, l'instruction ANDA faisait un ET entre l’accumulateur A et l'opérande mémoire, l'instruction ANDB faisait pareil avec l'accumulateur B.

==Les architectures hybrides registres-accumulateur==

Il a existé quelques architectures qui étaient des hybrides entre architectures à accumulateur et architecture à registre. Elles ont servi de transition entre les deux, durant les années 80-90. Elles avaient un accumulateur unique couplé à un banc de registres généraux. Par exemple, les premiers processeurs Intel 8 bits étaient des processeurs hybrides-accumulateur. Lles CPU Intel 8 bits disposaient de 7 registres de 8 bits nommés A, B, C, D, E, F, H, L, SP. Ils correspondent respectivement à :
* l'accumulateur A ;
* six registres nommés B, C, D, E, H et L ;
* le registre d'état F ;
* le pointeur de pile SP.

Sur ces processeurs, les instructions dyadiques devaient mettre leur premier opérande dans l'accumulateur, la seconde provenait soit des registres, soit de la RAM, soit d'une constante immédiate. Les opérations monadiques pouvaient lire leur opérande depuis l'accumulateur, les autres registres ou la RAM, tout était permis. Les registres d'indices disparaissaient sur ces architectures, en théorie. Les registres généraux pouvaient être utilisés comme registre d'indice ou pour stocker des opérandes, ils étaient assez versatiles pour servir de registres d'indices.

La présence de registres a de nombreux avantages, comparé aux architectures à accumulateur pures. Les instructions arithmétiques sont plus rapide, lire un registre étant plus rapide qu'un accès RAM. Les performances sont donc augmentées. De plus, les instructions arithmétiques utilisant ces registres sont plus courtes : pas besoin d'encoder une adresse mémoire, un nom de registre suffit. Vu que les processeurs de l’époque avaient des instructions de taille variable, cela améliorait la densité de code.

La microarchitecture de ces processeurs est très similaire à celle d'un processeur avec des registres d'indices. La seule différence est que le banc de registre contient des registres généraux et non des registres d'indices. Le banc de registre est systématiquement monoport, car il n'avait aucune raison d'être multiport. Pour les instructions dyadiques, seules à lire deux opérandes, il ne servait que pour la seconde opérande, la première était lue depuis l'accumulateur.

Les processeurs hybrides registre-accumulateur se classent en deux types principaux : ceux qui ont un seul bus interne, et ceux qui en ont deux. Le premier cas est identique à celui vu précédemment pour les architectures à accumulateur avec registres d'indice, à la seule différence est que le banc de registre contient des registres généraux et non des registres d'indices. Afin de gérer l'adressage indirect à registre, le bus interne est connecté aux deux registres d’interfaçage mémoire.

[[File:Architecture à accumulateur avec bus unique de type Von Neumann.png|centre|vignette|upright=2|Architecture à accumulateur avec bus unique de type Von Neumann]]

Notons que cela permet aussi d'implémenter facilement les branchements indirects, car le bus interne permet d'échanger des adresses entre ''program counter'' et banc de registre. De même, il est possible d'utiliser l'ALU pour gérer les branchements indirects., en plus de l'utiliser pour incrémenter le ''program counter''.

[[File:Single bus organization.jpg|centre|vignette|upright=2|Single bus organization]]

Une autre solution utilisait deux bus internes : un connecté au bus de données, un autre relié au bus d'adresse. Le bus de commande mémoire était lui commandé par le séquenceur, l'unité de contrôle. L'intermédiaire entre ces deux bus était le banc de registre, ainsi que les autres registres. Le banc de registre était connecté aux deux bus interne, avec un port de lecture relié au bus d'adresse, un port de lecture-écriture relié au bus de données. Le port de lecture était utilisé pour l'adressage indirect, l'autre l'était pour le reste.

[[File:Proz1-e.png|centre|vignette|upright=2|Intérieur d'un processeur.]]

L'organisation à deux bus simplifiait la gestion du ''program counter'' et le chargement des instructions. Le ''program counter'' était soit séparé du banc de registre, soit placé dans le banc de registre. Les deux solutions étaient utilisés, tout dépend du processeur. Il faut noter que si le ''program counter'' est intégré au banc de registres, alors la microarchitecture du processeur est bien plus simple. L'envoi du ''program counter'' sur le bus d'adresse utilise le port de lecture relié au bus d'adresse, qui sert aussi pour l'adressage indirect. L'économie de circuits, sans compter la simplicité d'implémentation que cela implique, explique sans doute que la technique a été utilisée sur quelques processeurs anciens.

Le ''program counter'' était généralement incrémenté par l'ALU, ce qui explique qu'il soit connecté au bus interne pour les données. La connexion est aussi utile pour gérer les branchements indirects, qui copient un registre dans le ''program counter'', ainsi que les branchements relatifs (addition dans l'ALU), voire les branchements directs (l'adresse vers laquelle brancher est envoyée en entrée de l'ALU et propagée en sortie avec une opération ''pass through'').

[[File:Connexion du program counter sur les bus avec PC dans le banc de registres.png|centre|vignette|upright=2|Connexion du program counter sur les bus avec PC dans le banc de registres]]

===Les registres d'interruption avec un processeur hybride-accumulateur : l'exemple du Z80===

Un exemple de processeur registre-accumulateur à deux bus interne est le Z80, un processeur fortement inspiré des CPU Intel 8 bits. Il a un jeu d'instruction similaire, mais a diverses améliorations par rapport au design original. Notamment, le processeur a des registres séparés pour les interruptions.

Sur le Z80, les registres généraux sont dupliqués avec 6 registres pour les interruptions et 6 registres pour les programmes autres. Leur copie pour les interruptions sont nommées B', C', D', E', H', L'. Les 12 registres sont placés dans le banc de registre, ce qui implique que le fenêtrage de registres est utilisé pour gérer la séparation entre registre d'interruption et normaux. Il faut noter que l'accumulateur et le registre d'état sont aussi dupliqués, leurs copies étant nommées A' et F'. Mais leur duplication se fait autrement que par fenêtrage de registre.

En plus des registres précédents, le Z80 incorporait deux registres d'indice nommés X et Y, ainsi qu'un pointeur de pile SP et un ''program counter'' PC. Ils n'étaient pas dupliqués pour les interruptions. Les registres d'indice étaient reliés à une unité de calcul d'adresse. L'unité de calcul d'adresse prenait deux opérandes : un indice, et une adresse mémoire provenant soit du banc de registre, soit de l'accumulateur. En clair, l'unité de calcul d'adresse faisait le lien entre les deux bus internet : le bus de données interne en entrée, le bus d'adresse en sortie.

À l'intérieur du processeur, tous les registres étaient regroupés dans un banc de registre unique, sauf les accumulateurs, les registres d'état et le ''program counter''. Bien que ce ne soit pas indiqué sur le schéma ci-dessous, le ''program counter'' est séparé du banc de registre, alors que le pointeur de pile est dedans. Le compteur IR est lui associé au ''program counter'', il est sortit du banc de registre. Le Z80 utilise lui aussi un incrémenteur séparé de l'ALU, qui est utilisé pour mettre à jour le ''program counter'', le pointeur de pile et un compteur de rafraichissement mémoire nommé IR sur le Z80 (pour rappel, le rafraichissement mémoire demande de balayer la mémoire d'adresse en adresse et été fait par le CPU à l'époque). De plus, il est utilisé pour les instructions INC et DEC qui incrémentent une opérande de 16 bits obtenue en combinant deux registres de 8 bits. En clair, l'incrémenteur du ''program counter'' a été réutilisé de beaucoup de manières originales.

[[File:Z80 arch.svg|centre|vignette|upright=3|Microarchitecture du Z80.]]

Le Z80 incorporait des instructions pour échanger le contenu des deux ensembles de registres, accumulateur inclus. Elles permettaient d'utiliser les registres d'interruption pour les programmes et réciproquement. En clair, cela doublait le nombre de registres si les interruptions n'étaient pas utilisées.
* L'instruction EXX échangeait les deux fenêtres de registres généraux : les registres B, C, D, E, H et L devenaient les registres B', C', D', E', H' et L' et inversement.
* L'instruction EX échangeait l'accumulateur et le registre d'état : les registres A,F devenait A',F' et inversement.

Le fenêtrage de registre était modifié par l'instruction EXX, qui échangeait les deux fenêtres de registres. Pour l'implémenter, une bascule était ajouté au processeur, appelons-la la bascule INT. Elle était relié au bus d'adresse du banc de registre, dont elle mémorisait le bit de poids fort. L'instruction EXX inversait la valeur de la bascule INT. Il est aussi possible d'échanger le contenu des registres D,E et H,L avec une instruction dédiée, ce qui est là encore fait par deux bascules : une pour les registres D,E et une autre pour les registres H,L.

Pour l'accumulateur et le registre d'état, le choix entre registre normal et registre d'interruption se faisait là encore par une seconde bascule appelée la bascule A. La bascule est reliée à un multiplexeur et un démultiplexeur, qui permet de choisir quel accumulateur relier à l'unité de calcul. L'instruction EX inverse le contenu de la bascule A.

&lt;noinclude&gt;
{{NavChapitre | book=Fonctionnement d'un ordinateur
           | prev=L'unité de contrôle
           | prevText=L'unité de contrôle
           | next=Les processeurs 8 bits et moins
           | nextText=Les processeurs 8 bits et moins
}}
&lt;/noinclude&gt;</text>
      <sha1>mm851vwjyyuznx2j5h2ed4eldxotvsp</sha1>
    </revision>
    <revision>
      <id>744159</id>
      <parentid>744158</parentid>
      <timestamp>2025-06-05T14:22:36Z</timestamp>
      <contributor>
        <username>Mewtow</username>
        <id>31375</id>
      </contributor>
      <minor />
      <comment>/* Annexe : les toutes premières architectures à accumulateur : le Manchester Baby */</comment>
      <origin>744159</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="39786" sha1="1tga0sm99bwjqukick75n9wyvyi7j2h" xml:space="preserve">Les architectures que nous avons vu précédemment dans ce cours disposent de registres pour les données, en plus du pointeur de pile, d'un ''program counter'', et de quelques autres. Elles sont appelées des '''architectures à registres''', terme qui trahit bien le fait qu'elles ont des registres généraux ou spécialisés pour stocker temporairement des données. Et si on leur a donné un nom, c'est parce qu'il existe des architectures qui ne sont pas dans cette catégorie. Il en existe plusieurs types, mais ce chapitre va se concentrer sur les '''architectures à accumulateur'''.

[[File:Isaccumulator.png|vignette|Architecture à accumulateur.]]

Les architectures à accumulateur sont centrées autour d'un registre architectural appelé l''''accumulateur'''. Il est utilisé pour toutes les opérations arithmétiques dyadiques, où il sert à la fois de source et de destination. Toutes les instructions dyadiques sont de type ''load-op'' : une opérande est lue depuis l'accumulateur, le second opérande est lu depuis la mémoire RAM, le résultat de l'instruction est automatiquement mémorisé dans l'accumulateur. Les instructions monadiques peuvent utiliser un opérande dans l'accumulateur, ou dans la mémoire RAM, les deux sont théoriquement possibles.

La conséquence est que le nombre d'accès mémoire est drastiquement diminué : de 3 par instructions sur une architecture mémoire-mémoire, on passe à seulement un avec un accumulateur. Les opérations dyadiques ont besoin d'un seul accès mémoire pour lire la seconde opérande, les opérations monadique en font aussi un seul pour lire leur unique opérande.

{|class=&quot;wikitable&quot;
|-
! Classe d'architecture
! Nombre d'accès mémoire par opération dyadique
|-
|-
! Architecture à accumulateur
| Un accès mémoire par instruction, pour lire la seconde opérande
|-
! Architecture à registres
| Zéro si les opérandes sont dans les registres, un pour les opérations ''load-op'', LOAD et STORE.
|}

==Le jeu d'instruction des architectures à accumulateur sans registres d'indice==

L'accumulateur est adressé grâce au mode d'adressage implicite, de même que le résultat de l'opération. Par contre, les autres opérandes sont localisés avec d'autres modes d'adressage, et lues en mémoire RAM. Le résultat ainsi qu'un des opérandes sont adressés de façon implicite car dans l'accumulateur, seule la seconde opérande étant adressée directement. Grâce à l'accumulateur, une instruction ne fait qu'un seul accès mémoire maximum, ce qui rend le processeur très facile à implémenter.

===Les registres des anciennes architectures à accumulateur===

[[File:IBM 701console.jpg|vignette|IBM 701, console extérieure.]]

Les architectures à accumulateur étaient communes dans les années 50-60. A l'époque, les ordinateurs étaient gigantesques, ils prenaient une pièce de bâtiment entière dans le pire des cas, une armoire entière dans le meilleur. Les ordinateurs de l'époque étaient surtout utilisés pour du calcul scientifique ou des tâches d’ingénierie demandant beaucoup de calcul, rarement pour de la compatibilité.

Les nombres flottants n'étaient pas encore apparus. A la place, les ordinateurs de l'époque géraient des nombres entiers de grande taille, de 30 bits ou plus. En conséquence, l'accumulateur faisait facilement 30 à 60 bits. Par exemple, les ordinateurs de la Série scientifique IBM 700/7000 géraient des entiers de 36 bits, l’accumulateur faisait 38 bits : 36 bits plus deux bits pour les débordements. Au passage, de tels processeurs utilisaient l'adressage par mot, et non par byte.

Historiquement, les premières architectures à accumulateur ne contenaient aucun autre registre que l'accumulateur. Ce n'est que dans les années 60 que de nombreuses architectures à accumulateur ont ajouté un second '''registre pour les multiplication/divisions'''. Un exemple est celui de l'IBM 701, qui incorporait un registre accumulateur de 38 bits et un registre multiplieur de 36 bits. Le registre mémorise le multiplieur lors d'une opération de multiplication. Il mémorise donc un opérande, pas le résultat. Il peut aussi décaler le multiplieur vers la droite/gauche, ce qui est utile pour exécuter la multiplication. C'est ce qui est fait sur l'IBM 7094.

Une autre possibilité est que ce registre mémorise une partie du résultat de l'opération. Pour rappel, le résultat d'une multiplication/division est codé sur deux fois de bits que ses opérandes. Par exemple, multipliez deux opérandes de 30 bits, vous obtiendrez un résultat de 60 bits. Les 30 bits de poids faible du résultat vont dans l'accumulateur, les 30 bits de poids fort vont dans ce second registre.

Les architectures à accumulateur parfois un '''registre pour le pointeur de pile''', utilisé pour gérer les fonctions/procédures. Les architectures à accumulateurs supportaient une pile d'adresse de retour, souvent une pile d'appel. Mais pour cela, il fallait mémoriser le pointeur de pile dans le processeur, ce qui demandait un registre dédié.

===L'adressage indirect avec l'accumulateur===

Les instructions LOAD et STORE existent bel et bien sur les architectures à accumulateur, mais n'ont pas les mêmes modes d'adressages. L'instruction LOAD copie une donnée de la RAM vers l'accumulateur, l'instruction STORE copie l'accumulateur dans une adresse. Les deux instructions n'ont pas besoin d'adresser l'accumulateur, qui est adressé de manière implicite, juste de préciser l'adresse à lire/écrire.

Les architectures à accumulateur supportaient souvent le mode d'adressage indirect mémoire. Un exemple est celui des ordinateurs Data General Nova, qui sont des architectures à accumulateur et qui supportaient ce mode d'adressage. Les deux instructions LOAD et STORE existaient en deux versions, distinguées par un bit d'indirection. Si ce bit est à 0 dans l'opcode, alors l'instruction utilise le mode d'adressage absolu normal : l'adresse intégrée dans l'instruction est celle de la donnée. Mais s'il est à 1, alors l'adresse intégrée dans l'instruction est celle du pointeur.

Cependant, la présence de l'accumulateur permettait d'utiliser l'adressage indirect à registre, pour gérer les pointeurs. Pour rappel, avec le mode d'adressage indirect à registre, l'adresse à lire/écrire est dans un registre. Ici, l'adresse à lire/écrire est prise dans l'accumulateur, seul registre disponible pour. L'adressage indirect est plus simple à implémenter pour l'instruction LOAD, car elle prend un seul opérande : l'adresse à lire. L'adresse à lire est placée dans l'accumulateur, la donnée lue est elle aussi chargée dans l'accumulateur. Pour l'instruction STORE, il faut fournir deux opérandes, l'adresse et la donnée à écrire, ce qui peut poser problème. Mais au pire, il est toujours possible d'utiliser l'adressage absolu ou indirect mémoire : l'adresse est dans l'instruction, la donnée à écrire dans l'accumulateur.

===L'encodage des instructions===

Sur une architecture à accumulateur l'encodage d'une instruction dyadique est assez simple, vu que l'accumulateur est adressé implicitement. La seconde opérande est localisée soit par une adresse mémoire (adressage absolu), soit est une constante (adressage immédiat). L'adresse mémoire est généralement assez longue, plus que l'opcode.

{|class=&quot;wikitable&quot;
|+ Encodage d'une instruction dyadique
|-
! rowspan=&quot;2&quot; | Opcode 
| Adresse mémoire (adressage absolu)
|-
| Constante (adressage immédiat)
|}

L'encodage d'une instruction monadique est similaire. Si l'opérande est lue depuis la mémoire RAM, alors l'instruction est encodée comme une instruction dyadique. Il en est de même pour les instructions qui copient une constante dans l'accumulateur. Par contre, si l'opérande est dans l'accumulateur, alors il y a juste besoin d'encoder l'opcode. La majorité des instructions a besoin de préciser une adresse, rares sont celles qui s'en passent. Au vu de cet encodage, les architectures à accumulateur sont qualifiées d''''architectures à une adresse''' par abus de langage.

Il est intéressant de contraster leur encodage avec les architectures à registres. Les architectures à registre doivent encoder deux opérandes en plus de l'opcode, avec éventuellement où enregistrer le résultat sur les architectures 3-adresses. Par contre, les opérandes sont généralement des noms de registre, ce qui prend moins de place qu'une adresse mémoire. A la rigueur, les instructions avec une constante immédiate prennent un peu plus de place, car elles doivent encoder un nom de registre en plus de la constante et de l'opcode. Les instructions ''load-op'' des processeurs CISC sont un peu dans le même cas, sauf qu'il faut remplacer la constante par une adresse, qui a généralement la même taille. Les instructions sont donc en moyenne plus courte sur les processeurs à registre, du fait de la présence de registres.

===Annexe : les toutes premières architectures à accumulateur : le Manchester Baby===

[[File:BabyArchitecture.png|vignette|Architecture de la Manchester Baby.]]

Les architectures à accumulateurs sont apparues dès les débuts de l'informatique. Le tout premier ordinateur à programme enregistré en mémoire, le ''Manchester Baby'', était une architecture à accumulateur. Niveau interface, l'ordinateur avait une console avec 32 boutons, des interrupteurs et un écran de sortie sur lequel afficher les résultats. A l'intérieur, il y avait un processeur et une RAM de 32 adresses, fabriquée avec des tubes Williams (abordés dans une annexe à la fin du cours). Chaque adresse mémorisait 32 bits, qui pouvaient encoder soit un nombre, soit une instruction.

Le programme devait tenir dans la RAM, avec une instruction par adresse maximum, ce qui limitait les programmes à 32 instructions maximum. Une instruction prenait donc 32 bits, 3 indiquaient quelle opération utiliser, 12  bits d'adresse servait à indiquer où se trouvent la seconde opérande en RAM, les 16 restants sont inutilisés. En théorie, les 12 bits d'adresse permettaient d'adresser 4096 adresses, mais seules 32 étaient réellement présentes.

Le processeur avait un registre accumulateur de 32 bits, un ''program counter'' et un registre d'instruction. Il intégrait un additionneur dédié au ''program counter'', mais l'ALU n'avait pas d'additionneur. En conséquence, il ne gérait pas l'addition. A la place, il gérait la soustraction. Il pouvait cependant émuler l'addition à partir d'une soustraction. La soustraction était utilisée pour calculer le complément d'une opérande, et soustraire le complément revient à additionner. L'ALU était une ALU sérielle, à savoir qu'elle faisait les soustractions bit par bit.

Le processeur supportait 7 instructions au total : la soustraction, des instructions de branchement et d'accès mémoire, rien d'autre. Les instructions de branchement utilisaient des modes d'adressage très particuliers, qu'on ne retrouve pas sur les ordinateurs modernes. Les branchements inconditionnels utilisaient une forme d'adressage mémoire indirect, pas les adressages usuels pour les branchements. Il n'y avait pas de branchements conditionnels, mais une ''SKIP instruction''.

{|class=&quot;wikitable&quot;
|-
! SUB 
| Soustrait l'opérande mémoire de l'accumulateur.
|-
! CMP
| Skippe l'instruction suivante si l'accumulateur a une valeur négative.
|-
! JMP
| Branchement indirect mémoire. :
* L'adresse de destination est lue depuis la mémoire.
* L'adresse lue est intégrée dans l'instruction via adressage absolu.
|-
! JRP
| Branchement relatif indirect.
* Lit une opérande depuis la mémoire, l'adresse est intégrée dans l'instruction via adressage absolu.
* Additionne l'opérande lue au ''program counter''.
|-
! LDN
| Instruction LOAD. La donnée lue est inversée lors de la lecture, l'accumulateur contient le complément à deux de la donnée lue après la lecture.
|-
! STO
| Instruction STORE
|-
! STOP
| Éteint l'ordinateur.
|}

Le Manchester Mark 1 était une amélioration du Manchester Baby. Il utilisait 4500 tubes à vide. Le Manchester Baby était un prototype, mais il avait été pensé pour être étendu, notamment afin d'avoir plus de mémoire. C'est pour cela que ses adresses étaient codées sur 12 bits, malgré sa mémoire de seulement 32 mots. Le plan initial, à savoir utiliser une RAM de 4096 mots, a cependant été abandonné pour la Manchester Mark 1. A la place, la RAM a gardé la même taille, à savoir 32 nombres, mais a été complémentée par l’ancêtre du disque dur magnétique, à savoir un tambour magnétique. Le tambour magnétique contenait 40 pages, chacune ayant la même taille que la RAM.

L'ordinateur gérait des nombres de 40 bits, mais les instructions étaient codées sur 20 bits. Le processeur gérait maintenant l'addition et quelques opérations logiques (ET et OU), en plus de la soustraction et de la comparaison. De plus, il intégrait deux registres dédiés aux multiplications : un pour le multiplicande, un autre pour le multiplieur. Cependant, les multiplications étaient réalisées en enchainant une série d'additions, dans l'additionneur-soustracteur. 

C'était là encore une architecture à accumulateur, sauf qu'elle intégrait aussi des registres d'indice. Les registres d'indices étaient au nom de deux. Lors du chargement d'une instruction, un registre d'indice était sélectionné grâce à un bit de l'instruction. Le contenu de ce registre d'indice était additionné à l'instruction , l'adresse encodée dedans pour être précis, et le résultat était envoyé sur le bus mémoire.

[[File:MM1Schematic French.svg|centre|vignette|upright=2.5|Architecture de la Manchester Mark 1.]]

==La micro-architecture des architectures à accumulateur sans registres d'indice==

L'organisation interne d'une architecture à accumulateur est très différente de celle des processeurs à registre. Elle est plus ou moins la même pour tous ces processeurs, le point important étant que le chemin de données se résume à une ALU, un registre accumulateur et le bus de données. L'ALU est reliée au registre accumulateur, ainsi qu'au bus de données pour lire la seconde opérande, comme illustré ci-dessous.

[[File:Accumulator.png|centre|vignette|upright=2|Accumulateur.]]

===L'unité de calcul et l'accumulateur===

Pour simplifier l'implémentation, le résultat est mémorisé dans un registre en sortie de l'unité de calcul. La raison est qu'on ne veut pas altérer l'accumulateur tant que le résultat final n'est pas totalement calculé. Rappelons que l'ALU ne fournit pas un résultat d'un seul bloc, mais que certains bits arrivent avant les autres, typiquement les bits de poids faible. Si le résultat était écrit dans l'accumulateur directement, il écraserait des bits de l’opérande en cours d'utilisation, ce qui fausserait le résultat.

[[File:Accumulateur avec registre de sortie.png|centre|vignette|upright=2|Accumulateur avec registre de sortie]]

Une autre solution utilisait un registre entre l'accumulateur et l'unité de calcul, appelé l’'''''accumulator latch'''''. Il remplace le registre en sortie de l'ALU, dans le sens où il permet d'écrire dans l'accumulateur sans effacer l'opérande, pendant que l’opération est en cours dans l'ALU. L'accumulateur est copié dans l’''accumulator latch'', avant que l'ALU démarre ses calculs. L'opérande est donc maintenue même si on commence à écrire le résultat dans l'accumulateur.

Sur le 8085 d'Intel, l’''accumulator latch'' peut être initialisé avec une constante prédéfinie, ce qui permet d'implémenter certaines instructions très facilement. Par exemple, il peut être initialisé à 0, ce qui permet d'implémenter les instructions MOV et INC (incrémentation). Un MOV est équivalent à faire un OU entre le registre lu et 0. Une instruction INC initialise l'entrée de retenue de l'unité de calcul à 1, puis ajoute 0. La décrémentation est implémentée de la même manière, sauf que l’''accumulator latch'' est initialisé à -2 pour compenser l'entrée de retenue à 1. De plus, pour supporter les conversion de décimal à BCD, l’''accumulator latch'' peut être initialisé avec les constantes 0x00, 0x06, 0x60, or 0x66. L'''accumulator latch'' est relié à divers fils de commande provenant de l'unité de contrôle, qui décide quelle valeur d'initialisation utiliser en fonction de l'instruction décodée.

[[File:Accumulator latch.png|centre|vignette|upright=2|Accumulator latch]]

[[File:Chemin de données à un seul bus.png|vignette|Chemin de données à un seul bus]]

De même, la seconde opérande, celle lue sur le bus de données, est mémorisée dans un registre en amont de l'ALU. C'était notamment très utile si le processeur utilisait une ALU plus courte que les opérandes, avec par exemple une ALU 4 bits pour un CPU 8 bits. Les anciens processeurs à accumulateur de type ''mainframe'' utilisaient des opérandes de grande taille, du genre 36 ou 48 bits, ce qui avait des conséquences sur l'unité de calcul utilisée, ainsi que sur la communication avec la mémoire. Il arrivait que de tels processeurs utilisaient des ALU sérielles, ou du moins octet-sérielles, plutôt qu'une véritable ALU 36 bits. Nous verrons aussi que c'est très utile sur les processeurs à accumulateur avec un bus interne unique, dans la suite du chapitre.

===La micro-architecture des architectures à accumulateur avec instructions LOAD/STORE===

Nous venons de voir comment est implémenté l'unité de calcul et l'accumulateur, et comment le tout est relié au bus de données. Mais cela ne permet que d'avoir un processeur à accumulateur rudimentaire, qui ne gére que des instructions arithmétiques et logiques. Il faut aussi gérer le cas des opérations LOAD/STORE et des modes d'adressages associés, mais c'est le séquenceur qui s'en occupe. Avec l'adressage absolu, les instructions LOAD et STORE ne font que connecter l'accumulateur au bus de données. L'instruction STORE nécessite de connecter l'accumulateur au bus de données, de manière à ce que le transfert des données se fasse de l'accumulateur vers le bus de données. L'instruction LOAD s'implémente de la même manière, sauf que le sens de transfert est inversé.

Cependant, il existe une optimisation qui permet d'implémenter l'instruction LOAD sans ajouter de circuits. Pour cela, il suffit que l'unité de calcul gére les opérations ''pass through'', à savoir des opérations qui se contentent de recopier un opérande sur la sortie. Ici, l'idée est de recopier l'opérande provenant du bus de données.

[[File:Architecture à accumulateur, microarchitecture.png|centre|vignette|upright=2|Architecture à accumulateur, microarchitecture]]

Pour gérer nativement l'adressage indirect à registre, il suffit de connecter l'accumulateur au bus d'adresse. Le plus simple est d'ajouter un multiplexeur, comme illustré ci-dessous. La donnée lue est copiée dans l'accumulateur, ce qui fait qu'il vaut mieux utiliser un registre d’interfaçage, l'accumulateur n'étant pas utilisable à la fois pour le bus d'adresse et de données.

[[File:Adressage indirect sur une architecture à accumulateur.png|centre|vignette|upright=2|Adressage indirect sur une architecture à accumulateur]]

Pour finir, voyons comment le pointeur de pile et le ''program counter'' sont implémentés. Les architectures à accumulateur ont souvent des adresses de taille différente des données, ce qui fait qu'il vaut mieux utiliser un circuit incrémenteur dédié pour incrémenter le ''program counter'', plutôt que de l'incrémenter via l'unité de calcul. Les architectures à accumulateur ont parfois un pointeur de pile, qui gère une pile d'adresse de retour, pas une vraie pile d'appel. Aussi, le pointeur de pile est censé être incrémenté et décrémenté, pas plus. Pas d'addition ou de soustraction pour gérer des cadres de pile. Là encore, c'est la solution de l'incrémenteur séparé qui est retenue. Pour économiser des transistors, il n'y a qu'un seul incrémenteur partagé pour les deux.

==Les architectures à accumulateur à registres d'indice==

Les architectures à accumulateur décrites dans la section précédente sont capables de faire de l'adressage indirect, mais n'incluent pas les modes d'adressage base + indice et absolus indicés, qui prennent une adresse et y ajoute un indice. Il s'agit des toutes premières architectures à accumulateur, comme les premiers ordinateurs IBM ou le fameux PDP-8. Mais par la suite, les processeurs à accumulateurs ont inclus un support des modes d'adressages indicés, grâce à des '''registres d'indice'''.

===Les registres d'indice===

Les registres d'indice stockent des indices de tableaux. Ils permettaient de supporter deux modes d'adressage :
* Le '''mode d'adressage absolu indicé''' où une adresse fixe est additionnée à un indice variable. L'adresse fixe est intégrée dans l'instruction (adressage absolu), l'indice est dans un registre d'indice.
* Le '''mode d'adressage base + indice''', où l'adresse est dans l'accumulateur et l'indice dans le registre d'indice.

Les processeurs à accumulateur supportaient souvent des variantes des modes d'adressage précédents, où le registre d'indice était automatiquement incrémenté ou décrémenté à chaque utilisation.

Au départ, ces processeurs n'utilisaient qu'un seul registre d'indice qui se comportait comme un second accumulateur spécialisé dans les calculs d'adresses mémoire. Le processeur supportait de nouvelles instructions qui utilisaient ce registre d'indice de façon implicite. Mais avec le temps, les processeurs finirent par incorporer plusieurs de ces registres. Les instructions de lecture ou d'écriture devaient alors préciser quel registre d'indice utiliser, en précisant un nom de registre d'indice, un numéro de registre d'indice.

Il faut préciser que les registres d'indice ont une taille bien plus petite que l'accumulateur. Ils mémorisent des indices codés sur 16 bits ou moins, alors que l'accumulateur faisait typiquement 36 à 48 bits, parfois plus. La taille classique sur les anciens ''mainframes'' était de 15 bits, parfois moins. Il n'était pas rare de tomber sur des registres d'indice de 8 ou 9 bits. Leur petite taille rendait leur implémentation matérielle peu couteuse. Et c'est ce qui explique qu'ils étaient préférés à l'usage d'un second accumulateur.

Un exemple est le cas du processeur Motorola 6809, un processeur à accumulateur qui contient deux registres d'indices nommés X et Y. L'accumulateur est noté D et fait 16 bits, il peut être parfois géré comme deux accumulateurs séparés A et B de 8 bits chacun. Il contenait aussi deux pointeurs de pile, l'un pour les programmes, l'autre pour le système d'exploitation, ainsi qu'un ''program counter''. Le registre de page était utilisé pour l'adressage absolu, comme vu dans le chapitre sur les modes d'adressage.

[[File:6809 Internal Registers.svg|centre|vignette|upright=2|6809 Internal Registers]]

Les processeurs IBM avaient autrefois plusieurs registres d'indice. Par exemple, l'IBM 704 avait trois registres d'indice de 15 bits. Leur contenu était soustrait de l'adresse absolue. Une instruction pouvait utiliser plusieurs registres d'indice pour adresser son opérande. Toute instruction utilisait trois bits pour sélectionner les registres d'indice utilisés. Fait assez original, lorsque plusieurs registres d'indice sont sélectionnés, le processeur n'additionne pas les trois registres à l'adresse de base. À la place, il fait un OU bit à bit entre les registres d'indice sélectionnés, et additionne le résultat à l'adresse.

Les processeurs IBM à accumulateur ont fait ça sur toute la gamme IBM 700/7000, pour des raisons de compatibilité. Les processeurs suivants avaient 7 registres d'indices, mais conservaient les trois bits pour adresser les registres d'indices. Ils pouvaient fonctionner dans deux modes. Le premier mode est plus intuitif : les trois bits précisent un registre d'indice parmi les 7, qui est additionné avec l'adresse absolue. La valeur zéro indique qu'aucun registre d'indice n'est utilisé, ce qui explique qu'il y a 7 registres d'indice et non 8. Un second mode, compatible avec l'IBM 704, fait un OU logique entre les registres d'indice sélectionnés. Seuls les trois premiers registres d'indices peuvent être sélectionnés dans ce mode. Il y a deux instructions pour changer de mode : une pour passer en mode compatible, l'autre pour le quitter pour l'autre mode.

Quelques rares processeurs à registres généraux ont utilisés des registres d'indice, en plus des registres généraux. Ce qui fait l'association que nous avons faite entre registres d'indice et architectures à accumulateur est imparfait, bien que solide sur le principe. Un exemple d'architecture de ce type sont les architectures de la série UNIVAC 1100/2200. Ils disposaient de 128 registres, qui étaient mappés en mémoire à partir de l'adresse mémoire 0, la majorité étant inaccessibles par le programmeur. Ils regroupaient 12 registres accumulateurs, 11 registres d'indice et 4 registres hybrides qui pouvaient servir soit de registre d'indice, soit de registres accumulateurs.

===La micro-architecture des architectures à accumulateur avec registres d'indice===

La présence de registres d'indice modifie grandement l'implémentation du processeur. En effet, il faut rajouter un banc de registre pour les registres d'indice. Le banc de registre est monoport, car on a besoin de lire ou d'écrire un indice à la fois. Et il faut aussi potentiellement rajouter de quoi faire les calculs d'adresse. Deux solutions sont possibles : une ALU dédiée aux calculs d'adresse, une seule ALU pour toutes les opérations.

Dans le premier cas, il y a une ALU séparée associée aux registres d'indice. L'ALU et les registres d'indice sont placés en sortie du séquenceur, en-dehors du chemin de données, la sortie de l'ALU est directement connectée au bus d'adresse. L'unité de calcul d'adresse peut être utilisée pour incrémenter le ''program counter''. Un défaut de cette approche est qu'elle ne gère pas l'adresse indirect à registre.

[[File:Chemin de données sans support des pointeurs, avec adressage absolu indicé.png|centre|vignette|upright=2|Chemin de données sans support des pointeurs, avec adressage absolu indicé]]

Une autre option utilise un bus interne, qui interconnecte tout le chemin de données. Dans sa version la plus simple, il est relié à l'accumulateur, l'unité de calcul, le banc de registre d'indice et le bus de données. Avec cette solution, l'ALU est utilisé à la fois pour calculer les adresses et pour les instructions de calcul. En reliant le bus interne au bus d'adresse à travers un multiplexeur, on gère naturellement les adressages indirects.

[[File:Architecture à accumulateur avec registres associés.png|centre|vignette|upright=2.5|Architecture à accumulateur avec registres associés]]

Il faut noter que sur les architectures Von Neumann, le séquenceur est relié à ce bus interne. En effet, charger une instruction demande de passer par le bus mémoire, donc par l’intermédiaire de ce bus internet. Le ''program counter'' est envoyé sur ce bus pour lire l'instruction, puis l'instruction lue est recopiée dans le registre d'instruction. Le chargement d'une instruction est donc géré comme une lecture des plus classiques. De plus, cela permet d'incrémenter le ''program counter'' au niveau de l'unité de calcul entière. Le ''program counter'' est envoyé sur le bus interne, incrémenté par l'ALU, puis le résultat est recopié dans le ''program counter'' via le bus interne.

[[File:Architecture à accumulateur avec bus unique de type Von Neumann.png|centre|vignette|upright=2|Architecture à accumulateur avec bus unique de type Von Neumann]]

==Les processeurs bi-accumulateurs : le Motorola 6800==

Le Motorola 6800 était un processeur 8 bits qui gérait des adresses de 16 bits. Il contenait deux accumulateurs nommés A et B, de 8 bits chacun. Il disposait aussi d'un registre d'indice, d'un pointeur de pile et d'un ''program counter'', tous les trois de 16 bits. Le registre d'état regroupait 6 bits, qu'on ne détaillera pas ici.

[[File:MC6800 Processor Diagram.png|centre|vignette|upright=2|Interface et registres du MC6800.]]

La présence des deux accumulateurs impactait surtout les instructions dyadiques. Les instructions monadiques avaient juste à préciser où se trouvait l'opérande : soit en RAM, soit dans le premier accumulateur, soit dans le second. Pour les opérations dyadiques, la gestion était totalement différente. En théorie, le premier opérande est dans un accumulateur, soit A, soit B. La seconde opérande vient soit de l'autre accumulateur, soit de la mémoire RAM. Et selon les instructions, tout variait.

Pour l'addition, il y avait trois instructions. Les deux premières additionnaient un opérande provenant de la mémoire avec un accumulateur. L'instruction ADDA sélectionnait le premier accumulateur, l'instruction ADDB sélectionnait le second accumulateur. Mais une troisième instruction, l’instruction ABA, permettait d'additionner le contenu des deux accumulateurs.

Pour les autres opérations, il n'était pas possible d'utiliser les deux accumulateurs en même temps. La seule possibilité était de faire une opération entre un accumulateur et un opérande venant de la mémoire. Toutes les instructions étaient en double, avec une copie par accumulateur. Par exemple, l'instruction ANDA faisait un ET entre l’accumulateur A et l'opérande mémoire, l'instruction ANDB faisait pareil avec l'accumulateur B.

==Les architectures hybrides registres-accumulateur==

Il a existé quelques architectures qui étaient des hybrides entre architectures à accumulateur et architecture à registre. Elles ont servi de transition entre les deux, durant les années 80-90. Elles avaient un accumulateur unique couplé à un banc de registres généraux. Par exemple, les premiers processeurs Intel 8 bits étaient des processeurs hybrides-accumulateur. Lles CPU Intel 8 bits disposaient de 7 registres de 8 bits nommés A, B, C, D, E, F, H, L, SP. Ils correspondent respectivement à :
* l'accumulateur A ;
* six registres nommés B, C, D, E, H et L ;
* le registre d'état F ;
* le pointeur de pile SP.

Sur ces processeurs, les instructions dyadiques devaient mettre leur premier opérande dans l'accumulateur, la seconde provenait soit des registres, soit de la RAM, soit d'une constante immédiate. Les opérations monadiques pouvaient lire leur opérande depuis l'accumulateur, les autres registres ou la RAM, tout était permis. Les registres d'indices disparaissaient sur ces architectures, en théorie. Les registres généraux pouvaient être utilisés comme registre d'indice ou pour stocker des opérandes, ils étaient assez versatiles pour servir de registres d'indices.

La présence de registres a de nombreux avantages, comparé aux architectures à accumulateur pures. Les instructions arithmétiques sont plus rapide, lire un registre étant plus rapide qu'un accès RAM. Les performances sont donc augmentées. De plus, les instructions arithmétiques utilisant ces registres sont plus courtes : pas besoin d'encoder une adresse mémoire, un nom de registre suffit. Vu que les processeurs de l’époque avaient des instructions de taille variable, cela améliorait la densité de code.

La microarchitecture de ces processeurs est très similaire à celle d'un processeur avec des registres d'indices. La seule différence est que le banc de registre contient des registres généraux et non des registres d'indices. Le banc de registre est systématiquement monoport, car il n'avait aucune raison d'être multiport. Pour les instructions dyadiques, seules à lire deux opérandes, il ne servait que pour la seconde opérande, la première était lue depuis l'accumulateur.

Les processeurs hybrides registre-accumulateur se classent en deux types principaux : ceux qui ont un seul bus interne, et ceux qui en ont deux. Le premier cas est identique à celui vu précédemment pour les architectures à accumulateur avec registres d'indice, à la seule différence est que le banc de registre contient des registres généraux et non des registres d'indices. Afin de gérer l'adressage indirect à registre, le bus interne est connecté aux deux registres d’interfaçage mémoire.

[[File:Architecture à accumulateur avec bus unique de type Von Neumann.png|centre|vignette|upright=2|Architecture à accumulateur avec bus unique de type Von Neumann]]

Notons que cela permet aussi d'implémenter facilement les branchements indirects, car le bus interne permet d'échanger des adresses entre ''program counter'' et banc de registre. De même, il est possible d'utiliser l'ALU pour gérer les branchements indirects., en plus de l'utiliser pour incrémenter le ''program counter''.

[[File:Single bus organization.jpg|centre|vignette|upright=2|Single bus organization]]

Une autre solution utilisait deux bus internes : un connecté au bus de données, un autre relié au bus d'adresse. Le bus de commande mémoire était lui commandé par le séquenceur, l'unité de contrôle. L'intermédiaire entre ces deux bus était le banc de registre, ainsi que les autres registres. Le banc de registre était connecté aux deux bus interne, avec un port de lecture relié au bus d'adresse, un port de lecture-écriture relié au bus de données. Le port de lecture était utilisé pour l'adressage indirect, l'autre l'était pour le reste.

[[File:Proz1-e.png|centre|vignette|upright=2|Intérieur d'un processeur.]]

L'organisation à deux bus simplifiait la gestion du ''program counter'' et le chargement des instructions. Le ''program counter'' était soit séparé du banc de registre, soit placé dans le banc de registre. Les deux solutions étaient utilisés, tout dépend du processeur. Il faut noter que si le ''program counter'' est intégré au banc de registres, alors la microarchitecture du processeur est bien plus simple. L'envoi du ''program counter'' sur le bus d'adresse utilise le port de lecture relié au bus d'adresse, qui sert aussi pour l'adressage indirect. L'économie de circuits, sans compter la simplicité d'implémentation que cela implique, explique sans doute que la technique a été utilisée sur quelques processeurs anciens.

Le ''program counter'' était généralement incrémenté par l'ALU, ce qui explique qu'il soit connecté au bus interne pour les données. La connexion est aussi utile pour gérer les branchements indirects, qui copient un registre dans le ''program counter'', ainsi que les branchements relatifs (addition dans l'ALU), voire les branchements directs (l'adresse vers laquelle brancher est envoyée en entrée de l'ALU et propagée en sortie avec une opération ''pass through'').

[[File:Connexion du program counter sur les bus avec PC dans le banc de registres.png|centre|vignette|upright=2|Connexion du program counter sur les bus avec PC dans le banc de registres]]

===Les registres d'interruption avec un processeur hybride-accumulateur : l'exemple du Z80===

Un exemple de processeur registre-accumulateur à deux bus interne est le Z80, un processeur fortement inspiré des CPU Intel 8 bits. Il a un jeu d'instruction similaire, mais a diverses améliorations par rapport au design original. Notamment, le processeur a des registres séparés pour les interruptions.

Sur le Z80, les registres généraux sont dupliqués avec 6 registres pour les interruptions et 6 registres pour les programmes autres. Leur copie pour les interruptions sont nommées B', C', D', E', H', L'. Les 12 registres sont placés dans le banc de registre, ce qui implique que le fenêtrage de registres est utilisé pour gérer la séparation entre registre d'interruption et normaux. Il faut noter que l'accumulateur et le registre d'état sont aussi dupliqués, leurs copies étant nommées A' et F'. Mais leur duplication se fait autrement que par fenêtrage de registre.

En plus des registres précédents, le Z80 incorporait deux registres d'indice nommés X et Y, ainsi qu'un pointeur de pile SP et un ''program counter'' PC. Ils n'étaient pas dupliqués pour les interruptions. Les registres d'indice étaient reliés à une unité de calcul d'adresse. L'unité de calcul d'adresse prenait deux opérandes : un indice, et une adresse mémoire provenant soit du banc de registre, soit de l'accumulateur. En clair, l'unité de calcul d'adresse faisait le lien entre les deux bus internet : le bus de données interne en entrée, le bus d'adresse en sortie.

À l'intérieur du processeur, tous les registres étaient regroupés dans un banc de registre unique, sauf les accumulateurs, les registres d'état et le ''program counter''. Bien que ce ne soit pas indiqué sur le schéma ci-dessous, le ''program counter'' est séparé du banc de registre, alors que le pointeur de pile est dedans. Le compteur IR est lui associé au ''program counter'', il est sortit du banc de registre. Le Z80 utilise lui aussi un incrémenteur séparé de l'ALU, qui est utilisé pour mettre à jour le ''program counter'', le pointeur de pile et un compteur de rafraichissement mémoire nommé IR sur le Z80 (pour rappel, le rafraichissement mémoire demande de balayer la mémoire d'adresse en adresse et été fait par le CPU à l'époque). De plus, il est utilisé pour les instructions INC et DEC qui incrémentent une opérande de 16 bits obtenue en combinant deux registres de 8 bits. En clair, l'incrémenteur du ''program counter'' a été réutilisé de beaucoup de manières originales.

[[File:Z80 arch.svg|centre|vignette|upright=3|Microarchitecture du Z80.]]

Le Z80 incorporait des instructions pour échanger le contenu des deux ensembles de registres, accumulateur inclus. Elles permettaient d'utiliser les registres d'interruption pour les programmes et réciproquement. En clair, cela doublait le nombre de registres si les interruptions n'étaient pas utilisées.
* L'instruction EXX échangeait les deux fenêtres de registres généraux : les registres B, C, D, E, H et L devenaient les registres B', C', D', E', H' et L' et inversement.
* L'instruction EX échangeait l'accumulateur et le registre d'état : les registres A,F devenait A',F' et inversement.

Le fenêtrage de registre était modifié par l'instruction EXX, qui échangeait les deux fenêtres de registres. Pour l'implémenter, une bascule était ajouté au processeur, appelons-la la bascule INT. Elle était relié au bus d'adresse du banc de registre, dont elle mémorisait le bit de poids fort. L'instruction EXX inversait la valeur de la bascule INT. Il est aussi possible d'échanger le contenu des registres D,E et H,L avec une instruction dédiée, ce qui est là encore fait par deux bascules : une pour les registres D,E et une autre pour les registres H,L.

Pour l'accumulateur et le registre d'état, le choix entre registre normal et registre d'interruption se faisait là encore par une seconde bascule appelée la bascule A. La bascule est reliée à un multiplexeur et un démultiplexeur, qui permet de choisir quel accumulateur relier à l'unité de calcul. L'instruction EX inverse le contenu de la bascule A.

&lt;noinclude&gt;
{{NavChapitre | book=Fonctionnement d'un ordinateur
           | prev=L'unité de contrôle
           | prevText=L'unité de contrôle
           | next=Les processeurs 8 bits et moins
           | nextText=Les processeurs 8 bits et moins
}}
&lt;/noinclude&gt;</text>
      <sha1>1tga0sm99bwjqukick75n9wyvyi7j2h</sha1>
    </revision>
    <revision>
      <id>744160</id>
      <parentid>744159</parentid>
      <timestamp>2025-06-05T14:28:48Z</timestamp>
      <contributor>
        <username>Mewtow</username>
        <id>31375</id>
      </contributor>
      <minor />
      <comment>/* Annexe : les toutes premières architectures à accumulateur : le Manchester Baby */</comment>
      <origin>744160</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="40848" sha1="c9jpmym0n02uha90k07zneksnouwt1x" xml:space="preserve">Les architectures que nous avons vu précédemment dans ce cours disposent de registres pour les données, en plus du pointeur de pile, d'un ''program counter'', et de quelques autres. Elles sont appelées des '''architectures à registres''', terme qui trahit bien le fait qu'elles ont des registres généraux ou spécialisés pour stocker temporairement des données. Et si on leur a donné un nom, c'est parce qu'il existe des architectures qui ne sont pas dans cette catégorie. Il en existe plusieurs types, mais ce chapitre va se concentrer sur les '''architectures à accumulateur'''.

[[File:Isaccumulator.png|vignette|Architecture à accumulateur.]]

Les architectures à accumulateur sont centrées autour d'un registre architectural appelé l''''accumulateur'''. Il est utilisé pour toutes les opérations arithmétiques dyadiques, où il sert à la fois de source et de destination. Toutes les instructions dyadiques sont de type ''load-op'' : une opérande est lue depuis l'accumulateur, le second opérande est lu depuis la mémoire RAM, le résultat de l'instruction est automatiquement mémorisé dans l'accumulateur. Les instructions monadiques peuvent utiliser un opérande dans l'accumulateur, ou dans la mémoire RAM, les deux sont théoriquement possibles.

La conséquence est que le nombre d'accès mémoire est drastiquement diminué : de 3 par instructions sur une architecture mémoire-mémoire, on passe à seulement un avec un accumulateur. Les opérations dyadiques ont besoin d'un seul accès mémoire pour lire la seconde opérande, les opérations monadique en font aussi un seul pour lire leur unique opérande.

{|class=&quot;wikitable&quot;
|-
! Classe d'architecture
! Nombre d'accès mémoire par opération dyadique
|-
|-
! Architecture à accumulateur
| Un accès mémoire par instruction, pour lire la seconde opérande
|-
! Architecture à registres
| Zéro si les opérandes sont dans les registres, un pour les opérations ''load-op'', LOAD et STORE.
|}

==Le jeu d'instruction des architectures à accumulateur sans registres d'indice==

L'accumulateur est adressé grâce au mode d'adressage implicite, de même que le résultat de l'opération. Par contre, les autres opérandes sont localisés avec d'autres modes d'adressage, et lues en mémoire RAM. Le résultat ainsi qu'un des opérandes sont adressés de façon implicite car dans l'accumulateur, seule la seconde opérande étant adressée directement. Grâce à l'accumulateur, une instruction ne fait qu'un seul accès mémoire maximum, ce qui rend le processeur très facile à implémenter.

===Les registres des anciennes architectures à accumulateur===

[[File:IBM 701console.jpg|vignette|IBM 701, console extérieure.]]

Les architectures à accumulateur étaient communes dans les années 50-60. A l'époque, les ordinateurs étaient gigantesques, ils prenaient une pièce de bâtiment entière dans le pire des cas, une armoire entière dans le meilleur. Les ordinateurs de l'époque étaient surtout utilisés pour du calcul scientifique ou des tâches d’ingénierie demandant beaucoup de calcul, rarement pour de la compatibilité.

Les nombres flottants n'étaient pas encore apparus. A la place, les ordinateurs de l'époque géraient des nombres entiers de grande taille, de 30 bits ou plus. En conséquence, l'accumulateur faisait facilement 30 à 60 bits. Par exemple, les ordinateurs de la Série scientifique IBM 700/7000 géraient des entiers de 36 bits, l’accumulateur faisait 38 bits : 36 bits plus deux bits pour les débordements. Au passage, de tels processeurs utilisaient l'adressage par mot, et non par byte.

Historiquement, les premières architectures à accumulateur ne contenaient aucun autre registre que l'accumulateur. Ce n'est que dans les années 60 que de nombreuses architectures à accumulateur ont ajouté un second '''registre pour les multiplication/divisions'''. Un exemple est celui de l'IBM 701, qui incorporait un registre accumulateur de 38 bits et un registre multiplieur de 36 bits. Le registre mémorise le multiplieur lors d'une opération de multiplication. Il mémorise donc un opérande, pas le résultat. Il peut aussi décaler le multiplieur vers la droite/gauche, ce qui est utile pour exécuter la multiplication. C'est ce qui est fait sur l'IBM 7094.

Une autre possibilité est que ce registre mémorise une partie du résultat de l'opération. Pour rappel, le résultat d'une multiplication/division est codé sur deux fois de bits que ses opérandes. Par exemple, multipliez deux opérandes de 30 bits, vous obtiendrez un résultat de 60 bits. Les 30 bits de poids faible du résultat vont dans l'accumulateur, les 30 bits de poids fort vont dans ce second registre.

Les architectures à accumulateur parfois un '''registre pour le pointeur de pile''', utilisé pour gérer les fonctions/procédures. Les architectures à accumulateurs supportaient une pile d'adresse de retour, souvent une pile d'appel. Mais pour cela, il fallait mémoriser le pointeur de pile dans le processeur, ce qui demandait un registre dédié.

===L'adressage indirect avec l'accumulateur===

Les instructions LOAD et STORE existent bel et bien sur les architectures à accumulateur, mais n'ont pas les mêmes modes d'adressages. L'instruction LOAD copie une donnée de la RAM vers l'accumulateur, l'instruction STORE copie l'accumulateur dans une adresse. Les deux instructions n'ont pas besoin d'adresser l'accumulateur, qui est adressé de manière implicite, juste de préciser l'adresse à lire/écrire.

Les architectures à accumulateur supportaient souvent le mode d'adressage indirect mémoire. Un exemple est celui des ordinateurs Data General Nova, qui sont des architectures à accumulateur et qui supportaient ce mode d'adressage. Les deux instructions LOAD et STORE existaient en deux versions, distinguées par un bit d'indirection. Si ce bit est à 0 dans l'opcode, alors l'instruction utilise le mode d'adressage absolu normal : l'adresse intégrée dans l'instruction est celle de la donnée. Mais s'il est à 1, alors l'adresse intégrée dans l'instruction est celle du pointeur.

Cependant, la présence de l'accumulateur permettait d'utiliser l'adressage indirect à registre, pour gérer les pointeurs. Pour rappel, avec le mode d'adressage indirect à registre, l'adresse à lire/écrire est dans un registre. Ici, l'adresse à lire/écrire est prise dans l'accumulateur, seul registre disponible pour. L'adressage indirect est plus simple à implémenter pour l'instruction LOAD, car elle prend un seul opérande : l'adresse à lire. L'adresse à lire est placée dans l'accumulateur, la donnée lue est elle aussi chargée dans l'accumulateur. Pour l'instruction STORE, il faut fournir deux opérandes, l'adresse et la donnée à écrire, ce qui peut poser problème. Mais au pire, il est toujours possible d'utiliser l'adressage absolu ou indirect mémoire : l'adresse est dans l'instruction, la donnée à écrire dans l'accumulateur.

===L'encodage des instructions===

Sur une architecture à accumulateur l'encodage d'une instruction dyadique est assez simple, vu que l'accumulateur est adressé implicitement. La seconde opérande est localisée soit par une adresse mémoire (adressage absolu), soit est une constante (adressage immédiat). L'adresse mémoire est généralement assez longue, plus que l'opcode.

{|class=&quot;wikitable&quot;
|+ Encodage d'une instruction dyadique
|-
! rowspan=&quot;2&quot; | Opcode 
| Adresse mémoire (adressage absolu)
|-
| Constante (adressage immédiat)
|}

L'encodage d'une instruction monadique est similaire. Si l'opérande est lue depuis la mémoire RAM, alors l'instruction est encodée comme une instruction dyadique. Il en est de même pour les instructions qui copient une constante dans l'accumulateur. Par contre, si l'opérande est dans l'accumulateur, alors il y a juste besoin d'encoder l'opcode. La majorité des instructions a besoin de préciser une adresse, rares sont celles qui s'en passent. Au vu de cet encodage, les architectures à accumulateur sont qualifiées d''''architectures à une adresse''' par abus de langage.

Il est intéressant de contraster leur encodage avec les architectures à registres. Les architectures à registre doivent encoder deux opérandes en plus de l'opcode, avec éventuellement où enregistrer le résultat sur les architectures 3-adresses. Par contre, les opérandes sont généralement des noms de registre, ce qui prend moins de place qu'une adresse mémoire. A la rigueur, les instructions avec une constante immédiate prennent un peu plus de place, car elles doivent encoder un nom de registre en plus de la constante et de l'opcode. Les instructions ''load-op'' des processeurs CISC sont un peu dans le même cas, sauf qu'il faut remplacer la constante par une adresse, qui a généralement la même taille. Les instructions sont donc en moyenne plus courte sur les processeurs à registre, du fait de la présence de registres.

===Annexe : les toutes premières architectures à accumulateur : le Manchester Baby===

[[File:BabyArchitecture.png|vignette|Architecture de la Manchester Baby.]]

Les architectures à accumulateurs sont apparues dès les débuts de l'informatique. Le tout premier ordinateur à programme enregistré en mémoire, le ''Manchester Baby'', était une architecture à accumulateur. Niveau interface, l'ordinateur avait une console avec 32 boutons, des interrupteurs et un écran de sortie sur lequel afficher les résultats. A l'intérieur, il y avait un processeur et une RAM de 32 adresses, fabriquée avec des tubes Williams (abordés dans une annexe à la fin du cours). Chaque adresse mémorisait 32 bits, qui pouvaient encoder soit un nombre, soit une instruction.

Le programme devait tenir dans la RAM, avec une instruction par adresse maximum, ce qui limitait les programmes à 32 instructions maximum. Une instruction prenait donc 32 bits, 3 indiquaient quelle opération utiliser, 12  bits d'adresse servait à indiquer où se trouvent la seconde opérande en RAM, les 16 restants sont inutilisés. En théorie, les 12 bits d'adresse permettaient d'adresser 4096 adresses, mais seules 32 étaient réellement présentes.

Le processeur avait un registre accumulateur de 32 bits, un ''program counter'' et un registre d'instruction. Il intégrait un additionneur dédié au ''program counter'', mais l'ALU n'avait pas d'additionneur. En conséquence, il ne gérait pas l'addition. A la place, il gérait la soustraction. Il pouvait cependant émuler l'addition à partir d'une soustraction. La soustraction était utilisée pour calculer le complément d'une opérande, et soustraire le complément revient à additionner. L'ALU était une ALU sérielle, à savoir qu'elle faisait les soustractions bit par bit.

Le processeur supportait 7 instructions au total : la soustraction, des instructions de branchement et d'accès mémoire, rien d'autre. Les instructions de branchement utilisaient des modes d'adressage très particuliers, qu'on ne retrouve pas sur les ordinateurs modernes. Les branchements inconditionnels utilisaient une forme d'adressage mémoire indirect, pas les adressages usuels pour les branchements. Il n'y avait pas de branchements conditionnels, mais une ''SKIP instruction''.

{|class=&quot;wikitable&quot;
|-
! SUB 
| Soustrait l'opérande mémoire de l'accumulateur.
|-
! CMP
| Skippe l'instruction suivante si l'accumulateur a une valeur négative.
|-
! JMP
| Branchement indirect mémoire. :
* L'adresse de destination est lue depuis la mémoire.
* L'adresse lue est intégrée dans l'instruction via adressage absolu.
|-
! JRP
| Branchement relatif indirect.
* Lit une opérande depuis la mémoire, l'adresse est intégrée dans l'instruction via adressage absolu.
* Additionne l'opérande lue au ''program counter''.
|-
! LDN
| Instruction LOAD. La donnée lue est inversée lors de la lecture, l'accumulateur contient le complément à deux de la donnée lue après la lecture.
|-
! STO
| Instruction STORE
|-
! STOP
| Éteint l'ordinateur.
|}

Le Manchester Mark 1 était une amélioration du Manchester Baby. Il utilisait 4500 tubes à vide. Le Manchester Baby était un prototype, mais il avait été pensé pour être étendu, notamment afin d'avoir plus de mémoire. C'est pour cela que ses adresses étaient codées sur 12 bits, malgré sa mémoire de seulement 32 mots. Le plan initial, à savoir utiliser une RAM de 4096 mots, a cependant été abandonné pour la Manchester Mark 1. A la place, la RAM a gardé la même taille, à savoir 32 nombres, mais a été complémentée par l’ancêtre du disque dur magnétique, à savoir un tambour magnétique. Le tambour magnétique contenait 40 pages, chacune ayant la même taille que la RAM.

L'ordinateur gérait des nombres de 40 bits, mais les instructions étaient codées sur 20 bits. Le processeur gérait maintenant l'addition et quelques opérations logiques (ET et OU), en plus de la soustraction et de la comparaison. De plus, il intégrait deux registres dédiés aux multiplications : un pour le multiplicande, un autre pour le multiplieur. Ils étaient nommés D et R et étaient regroupés dans un seul tube Williams noté M. Cependant, les multiplications étaient réalisées en enchainant une série d'additions, dans l'additionneur-soustracteur. 

C'était là encore une architecture à accumulateur, sauf qu'elle intégrait aussi des registres d'indice. Les registres d'indices étaient au nom de deux et étaient notés B0 et B1. Lors du chargement d'une instruction, un registre d'indice était sélectionné grâce à un bit de l'instruction. Le contenu de ce registre d'indice était additionné à l'instruction , l'adresse encodée dedans pour être précis, et le résultat était envoyé sur le bus mémoire.

La microarchitecture de la machine est illustrée ci-dessous. Elle a une ALU unique capable de faire plusieurs opérations, qui sont représentées dans des rectangles séparés. Les cercles dans le schéma suivant sont des tubes Williams, des écrans CRT modifiés de manière à servir de mémoire DRAM, dont le fonctionnement est détaillée dans le chapitre sur les mémoires historiques. Un tube Williams implémente un banc de registre complet, c'est à dire un groupe de 2 à 10, registres. L'accumulateur est noté A, les deux registres de multiplication sont regroupés dans le tube Williams M, les registres d'indice sont dans le tube noté B. Le tube Williams C regroupe le ''program counter'' et le registre d'instruction. L'additionneur sert à incrémenter le ''program counter'', mais aussi pour les branchements relatifs. La statistation est le nom donné au séquenceur, à l'unité de contrôle, décodeur d'instruction inclus.

[[File:MM1Schematic French.svg|centre|vignette|upright=2.5|Architecture de la Manchester Mark 1.]]

==La micro-architecture des architectures à accumulateur sans registres d'indice==

L'organisation interne d'une architecture à accumulateur est très différente de celle des processeurs à registre. Elle est plus ou moins la même pour tous ces processeurs, le point important étant que le chemin de données se résume à une ALU, un registre accumulateur et le bus de données. L'ALU est reliée au registre accumulateur, ainsi qu'au bus de données pour lire la seconde opérande, comme illustré ci-dessous.

[[File:Accumulator.png|centre|vignette|upright=2|Accumulateur.]]

===L'unité de calcul et l'accumulateur===

Pour simplifier l'implémentation, le résultat est mémorisé dans un registre en sortie de l'unité de calcul. La raison est qu'on ne veut pas altérer l'accumulateur tant que le résultat final n'est pas totalement calculé. Rappelons que l'ALU ne fournit pas un résultat d'un seul bloc, mais que certains bits arrivent avant les autres, typiquement les bits de poids faible. Si le résultat était écrit dans l'accumulateur directement, il écraserait des bits de l’opérande en cours d'utilisation, ce qui fausserait le résultat.

[[File:Accumulateur avec registre de sortie.png|centre|vignette|upright=2|Accumulateur avec registre de sortie]]

Une autre solution utilisait un registre entre l'accumulateur et l'unité de calcul, appelé l’'''''accumulator latch'''''. Il remplace le registre en sortie de l'ALU, dans le sens où il permet d'écrire dans l'accumulateur sans effacer l'opérande, pendant que l’opération est en cours dans l'ALU. L'accumulateur est copié dans l’''accumulator latch'', avant que l'ALU démarre ses calculs. L'opérande est donc maintenue même si on commence à écrire le résultat dans l'accumulateur.

Sur le 8085 d'Intel, l’''accumulator latch'' peut être initialisé avec une constante prédéfinie, ce qui permet d'implémenter certaines instructions très facilement. Par exemple, il peut être initialisé à 0, ce qui permet d'implémenter les instructions MOV et INC (incrémentation). Un MOV est équivalent à faire un OU entre le registre lu et 0. Une instruction INC initialise l'entrée de retenue de l'unité de calcul à 1, puis ajoute 0. La décrémentation est implémentée de la même manière, sauf que l’''accumulator latch'' est initialisé à -2 pour compenser l'entrée de retenue à 1. De plus, pour supporter les conversion de décimal à BCD, l’''accumulator latch'' peut être initialisé avec les constantes 0x00, 0x06, 0x60, or 0x66. L'''accumulator latch'' est relié à divers fils de commande provenant de l'unité de contrôle, qui décide quelle valeur d'initialisation utiliser en fonction de l'instruction décodée.

[[File:Accumulator latch.png|centre|vignette|upright=2|Accumulator latch]]

[[File:Chemin de données à un seul bus.png|vignette|Chemin de données à un seul bus]]

De même, la seconde opérande, celle lue sur le bus de données, est mémorisée dans un registre en amont de l'ALU. C'était notamment très utile si le processeur utilisait une ALU plus courte que les opérandes, avec par exemple une ALU 4 bits pour un CPU 8 bits. Les anciens processeurs à accumulateur de type ''mainframe'' utilisaient des opérandes de grande taille, du genre 36 ou 48 bits, ce qui avait des conséquences sur l'unité de calcul utilisée, ainsi que sur la communication avec la mémoire. Il arrivait que de tels processeurs utilisaient des ALU sérielles, ou du moins octet-sérielles, plutôt qu'une véritable ALU 36 bits. Nous verrons aussi que c'est très utile sur les processeurs à accumulateur avec un bus interne unique, dans la suite du chapitre.

===La micro-architecture des architectures à accumulateur avec instructions LOAD/STORE===

Nous venons de voir comment est implémenté l'unité de calcul et l'accumulateur, et comment le tout est relié au bus de données. Mais cela ne permet que d'avoir un processeur à accumulateur rudimentaire, qui ne gére que des instructions arithmétiques et logiques. Il faut aussi gérer le cas des opérations LOAD/STORE et des modes d'adressages associés, mais c'est le séquenceur qui s'en occupe. Avec l'adressage absolu, les instructions LOAD et STORE ne font que connecter l'accumulateur au bus de données. L'instruction STORE nécessite de connecter l'accumulateur au bus de données, de manière à ce que le transfert des données se fasse de l'accumulateur vers le bus de données. L'instruction LOAD s'implémente de la même manière, sauf que le sens de transfert est inversé.

Cependant, il existe une optimisation qui permet d'implémenter l'instruction LOAD sans ajouter de circuits. Pour cela, il suffit que l'unité de calcul gére les opérations ''pass through'', à savoir des opérations qui se contentent de recopier un opérande sur la sortie. Ici, l'idée est de recopier l'opérande provenant du bus de données.

[[File:Architecture à accumulateur, microarchitecture.png|centre|vignette|upright=2|Architecture à accumulateur, microarchitecture]]

Pour gérer nativement l'adressage indirect à registre, il suffit de connecter l'accumulateur au bus d'adresse. Le plus simple est d'ajouter un multiplexeur, comme illustré ci-dessous. La donnée lue est copiée dans l'accumulateur, ce qui fait qu'il vaut mieux utiliser un registre d’interfaçage, l'accumulateur n'étant pas utilisable à la fois pour le bus d'adresse et de données.

[[File:Adressage indirect sur une architecture à accumulateur.png|centre|vignette|upright=2|Adressage indirect sur une architecture à accumulateur]]

Pour finir, voyons comment le pointeur de pile et le ''program counter'' sont implémentés. Les architectures à accumulateur ont souvent des adresses de taille différente des données, ce qui fait qu'il vaut mieux utiliser un circuit incrémenteur dédié pour incrémenter le ''program counter'', plutôt que de l'incrémenter via l'unité de calcul. Les architectures à accumulateur ont parfois un pointeur de pile, qui gère une pile d'adresse de retour, pas une vraie pile d'appel. Aussi, le pointeur de pile est censé être incrémenté et décrémenté, pas plus. Pas d'addition ou de soustraction pour gérer des cadres de pile. Là encore, c'est la solution de l'incrémenteur séparé qui est retenue. Pour économiser des transistors, il n'y a qu'un seul incrémenteur partagé pour les deux.

==Les architectures à accumulateur à registres d'indice==

Les architectures à accumulateur décrites dans la section précédente sont capables de faire de l'adressage indirect, mais n'incluent pas les modes d'adressage base + indice et absolus indicés, qui prennent une adresse et y ajoute un indice. Il s'agit des toutes premières architectures à accumulateur, comme les premiers ordinateurs IBM ou le fameux PDP-8. Mais par la suite, les processeurs à accumulateurs ont inclus un support des modes d'adressages indicés, grâce à des '''registres d'indice'''.

===Les registres d'indice===

Les registres d'indice stockent des indices de tableaux. Ils permettaient de supporter deux modes d'adressage :
* Le '''mode d'adressage absolu indicé''' où une adresse fixe est additionnée à un indice variable. L'adresse fixe est intégrée dans l'instruction (adressage absolu), l'indice est dans un registre d'indice.
* Le '''mode d'adressage base + indice''', où l'adresse est dans l'accumulateur et l'indice dans le registre d'indice.

Les processeurs à accumulateur supportaient souvent des variantes des modes d'adressage précédents, où le registre d'indice était automatiquement incrémenté ou décrémenté à chaque utilisation.

Au départ, ces processeurs n'utilisaient qu'un seul registre d'indice qui se comportait comme un second accumulateur spécialisé dans les calculs d'adresses mémoire. Le processeur supportait de nouvelles instructions qui utilisaient ce registre d'indice de façon implicite. Mais avec le temps, les processeurs finirent par incorporer plusieurs de ces registres. Les instructions de lecture ou d'écriture devaient alors préciser quel registre d'indice utiliser, en précisant un nom de registre d'indice, un numéro de registre d'indice.

Il faut préciser que les registres d'indice ont une taille bien plus petite que l'accumulateur. Ils mémorisent des indices codés sur 16 bits ou moins, alors que l'accumulateur faisait typiquement 36 à 48 bits, parfois plus. La taille classique sur les anciens ''mainframes'' était de 15 bits, parfois moins. Il n'était pas rare de tomber sur des registres d'indice de 8 ou 9 bits. Leur petite taille rendait leur implémentation matérielle peu couteuse. Et c'est ce qui explique qu'ils étaient préférés à l'usage d'un second accumulateur.

Un exemple est le cas du processeur Motorola 6809, un processeur à accumulateur qui contient deux registres d'indices nommés X et Y. L'accumulateur est noté D et fait 16 bits, il peut être parfois géré comme deux accumulateurs séparés A et B de 8 bits chacun. Il contenait aussi deux pointeurs de pile, l'un pour les programmes, l'autre pour le système d'exploitation, ainsi qu'un ''program counter''. Le registre de page était utilisé pour l'adressage absolu, comme vu dans le chapitre sur les modes d'adressage.

[[File:6809 Internal Registers.svg|centre|vignette|upright=2|6809 Internal Registers]]

Les processeurs IBM avaient autrefois plusieurs registres d'indice. Par exemple, l'IBM 704 avait trois registres d'indice de 15 bits. Leur contenu était soustrait de l'adresse absolue. Une instruction pouvait utiliser plusieurs registres d'indice pour adresser son opérande. Toute instruction utilisait trois bits pour sélectionner les registres d'indice utilisés. Fait assez original, lorsque plusieurs registres d'indice sont sélectionnés, le processeur n'additionne pas les trois registres à l'adresse de base. À la place, il fait un OU bit à bit entre les registres d'indice sélectionnés, et additionne le résultat à l'adresse.

Les processeurs IBM à accumulateur ont fait ça sur toute la gamme IBM 700/7000, pour des raisons de compatibilité. Les processeurs suivants avaient 7 registres d'indices, mais conservaient les trois bits pour adresser les registres d'indices. Ils pouvaient fonctionner dans deux modes. Le premier mode est plus intuitif : les trois bits précisent un registre d'indice parmi les 7, qui est additionné avec l'adresse absolue. La valeur zéro indique qu'aucun registre d'indice n'est utilisé, ce qui explique qu'il y a 7 registres d'indice et non 8. Un second mode, compatible avec l'IBM 704, fait un OU logique entre les registres d'indice sélectionnés. Seuls les trois premiers registres d'indices peuvent être sélectionnés dans ce mode. Il y a deux instructions pour changer de mode : une pour passer en mode compatible, l'autre pour le quitter pour l'autre mode.

Quelques rares processeurs à registres généraux ont utilisés des registres d'indice, en plus des registres généraux. Ce qui fait l'association que nous avons faite entre registres d'indice et architectures à accumulateur est imparfait, bien que solide sur le principe. Un exemple d'architecture de ce type sont les architectures de la série UNIVAC 1100/2200. Ils disposaient de 128 registres, qui étaient mappés en mémoire à partir de l'adresse mémoire 0, la majorité étant inaccessibles par le programmeur. Ils regroupaient 12 registres accumulateurs, 11 registres d'indice et 4 registres hybrides qui pouvaient servir soit de registre d'indice, soit de registres accumulateurs.

===La micro-architecture des architectures à accumulateur avec registres d'indice===

La présence de registres d'indice modifie grandement l'implémentation du processeur. En effet, il faut rajouter un banc de registre pour les registres d'indice. Le banc de registre est monoport, car on a besoin de lire ou d'écrire un indice à la fois. Et il faut aussi potentiellement rajouter de quoi faire les calculs d'adresse. Deux solutions sont possibles : une ALU dédiée aux calculs d'adresse, une seule ALU pour toutes les opérations.

Dans le premier cas, il y a une ALU séparée associée aux registres d'indice. L'ALU et les registres d'indice sont placés en sortie du séquenceur, en-dehors du chemin de données, la sortie de l'ALU est directement connectée au bus d'adresse. L'unité de calcul d'adresse peut être utilisée pour incrémenter le ''program counter''. Un défaut de cette approche est qu'elle ne gère pas l'adresse indirect à registre.

[[File:Chemin de données sans support des pointeurs, avec adressage absolu indicé.png|centre|vignette|upright=2|Chemin de données sans support des pointeurs, avec adressage absolu indicé]]

Une autre option utilise un bus interne, qui interconnecte tout le chemin de données. Dans sa version la plus simple, il est relié à l'accumulateur, l'unité de calcul, le banc de registre d'indice et le bus de données. Avec cette solution, l'ALU est utilisé à la fois pour calculer les adresses et pour les instructions de calcul. En reliant le bus interne au bus d'adresse à travers un multiplexeur, on gère naturellement les adressages indirects.

[[File:Architecture à accumulateur avec registres associés.png|centre|vignette|upright=2.5|Architecture à accumulateur avec registres associés]]

Il faut noter que sur les architectures Von Neumann, le séquenceur est relié à ce bus interne. En effet, charger une instruction demande de passer par le bus mémoire, donc par l’intermédiaire de ce bus internet. Le ''program counter'' est envoyé sur ce bus pour lire l'instruction, puis l'instruction lue est recopiée dans le registre d'instruction. Le chargement d'une instruction est donc géré comme une lecture des plus classiques. De plus, cela permet d'incrémenter le ''program counter'' au niveau de l'unité de calcul entière. Le ''program counter'' est envoyé sur le bus interne, incrémenté par l'ALU, puis le résultat est recopié dans le ''program counter'' via le bus interne.

[[File:Architecture à accumulateur avec bus unique de type Von Neumann.png|centre|vignette|upright=2|Architecture à accumulateur avec bus unique de type Von Neumann]]

==Les processeurs bi-accumulateurs : le Motorola 6800==

Le Motorola 6800 était un processeur 8 bits qui gérait des adresses de 16 bits. Il contenait deux accumulateurs nommés A et B, de 8 bits chacun. Il disposait aussi d'un registre d'indice, d'un pointeur de pile et d'un ''program counter'', tous les trois de 16 bits. Le registre d'état regroupait 6 bits, qu'on ne détaillera pas ici.

[[File:MC6800 Processor Diagram.png|centre|vignette|upright=2|Interface et registres du MC6800.]]

La présence des deux accumulateurs impactait surtout les instructions dyadiques. Les instructions monadiques avaient juste à préciser où se trouvait l'opérande : soit en RAM, soit dans le premier accumulateur, soit dans le second. Pour les opérations dyadiques, la gestion était totalement différente. En théorie, le premier opérande est dans un accumulateur, soit A, soit B. La seconde opérande vient soit de l'autre accumulateur, soit de la mémoire RAM. Et selon les instructions, tout variait.

Pour l'addition, il y avait trois instructions. Les deux premières additionnaient un opérande provenant de la mémoire avec un accumulateur. L'instruction ADDA sélectionnait le premier accumulateur, l'instruction ADDB sélectionnait le second accumulateur. Mais une troisième instruction, l’instruction ABA, permettait d'additionner le contenu des deux accumulateurs.

Pour les autres opérations, il n'était pas possible d'utiliser les deux accumulateurs en même temps. La seule possibilité était de faire une opération entre un accumulateur et un opérande venant de la mémoire. Toutes les instructions étaient en double, avec une copie par accumulateur. Par exemple, l'instruction ANDA faisait un ET entre l’accumulateur A et l'opérande mémoire, l'instruction ANDB faisait pareil avec l'accumulateur B.

==Les architectures hybrides registres-accumulateur==

Il a existé quelques architectures qui étaient des hybrides entre architectures à accumulateur et architecture à registre. Elles ont servi de transition entre les deux, durant les années 80-90. Elles avaient un accumulateur unique couplé à un banc de registres généraux. Par exemple, les premiers processeurs Intel 8 bits étaient des processeurs hybrides-accumulateur. Lles CPU Intel 8 bits disposaient de 7 registres de 8 bits nommés A, B, C, D, E, F, H, L, SP. Ils correspondent respectivement à :
* l'accumulateur A ;
* six registres nommés B, C, D, E, H et L ;
* le registre d'état F ;
* le pointeur de pile SP.

Sur ces processeurs, les instructions dyadiques devaient mettre leur premier opérande dans l'accumulateur, la seconde provenait soit des registres, soit de la RAM, soit d'une constante immédiate. Les opérations monadiques pouvaient lire leur opérande depuis l'accumulateur, les autres registres ou la RAM, tout était permis. Les registres d'indices disparaissaient sur ces architectures, en théorie. Les registres généraux pouvaient être utilisés comme registre d'indice ou pour stocker des opérandes, ils étaient assez versatiles pour servir de registres d'indices.

La présence de registres a de nombreux avantages, comparé aux architectures à accumulateur pures. Les instructions arithmétiques sont plus rapide, lire un registre étant plus rapide qu'un accès RAM. Les performances sont donc augmentées. De plus, les instructions arithmétiques utilisant ces registres sont plus courtes : pas besoin d'encoder une adresse mémoire, un nom de registre suffit. Vu que les processeurs de l’époque avaient des instructions de taille variable, cela améliorait la densité de code.

La microarchitecture de ces processeurs est très similaire à celle d'un processeur avec des registres d'indices. La seule différence est que le banc de registre contient des registres généraux et non des registres d'indices. Le banc de registre est systématiquement monoport, car il n'avait aucune raison d'être multiport. Pour les instructions dyadiques, seules à lire deux opérandes, il ne servait que pour la seconde opérande, la première était lue depuis l'accumulateur.

Les processeurs hybrides registre-accumulateur se classent en deux types principaux : ceux qui ont un seul bus interne, et ceux qui en ont deux. Le premier cas est identique à celui vu précédemment pour les architectures à accumulateur avec registres d'indice, à la seule différence est que le banc de registre contient des registres généraux et non des registres d'indices. Afin de gérer l'adressage indirect à registre, le bus interne est connecté aux deux registres d’interfaçage mémoire.

[[File:Architecture à accumulateur avec bus unique de type Von Neumann.png|centre|vignette|upright=2|Architecture à accumulateur avec bus unique de type Von Neumann]]

Notons que cela permet aussi d'implémenter facilement les branchements indirects, car le bus interne permet d'échanger des adresses entre ''program counter'' et banc de registre. De même, il est possible d'utiliser l'ALU pour gérer les branchements indirects., en plus de l'utiliser pour incrémenter le ''program counter''.

[[File:Single bus organization.jpg|centre|vignette|upright=2|Single bus organization]]

Une autre solution utilisait deux bus internes : un connecté au bus de données, un autre relié au bus d'adresse. Le bus de commande mémoire était lui commandé par le séquenceur, l'unité de contrôle. L'intermédiaire entre ces deux bus était le banc de registre, ainsi que les autres registres. Le banc de registre était connecté aux deux bus interne, avec un port de lecture relié au bus d'adresse, un port de lecture-écriture relié au bus de données. Le port de lecture était utilisé pour l'adressage indirect, l'autre l'était pour le reste.

[[File:Proz1-e.png|centre|vignette|upright=2|Intérieur d'un processeur.]]

L'organisation à deux bus simplifiait la gestion du ''program counter'' et le chargement des instructions. Le ''program counter'' était soit séparé du banc de registre, soit placé dans le banc de registre. Les deux solutions étaient utilisés, tout dépend du processeur. Il faut noter que si le ''program counter'' est intégré au banc de registres, alors la microarchitecture du processeur est bien plus simple. L'envoi du ''program counter'' sur le bus d'adresse utilise le port de lecture relié au bus d'adresse, qui sert aussi pour l'adressage indirect. L'économie de circuits, sans compter la simplicité d'implémentation que cela implique, explique sans doute que la technique a été utilisée sur quelques processeurs anciens.

Le ''program counter'' était généralement incrémenté par l'ALU, ce qui explique qu'il soit connecté au bus interne pour les données. La connexion est aussi utile pour gérer les branchements indirects, qui copient un registre dans le ''program counter'', ainsi que les branchements relatifs (addition dans l'ALU), voire les branchements directs (l'adresse vers laquelle brancher est envoyée en entrée de l'ALU et propagée en sortie avec une opération ''pass through'').

[[File:Connexion du program counter sur les bus avec PC dans le banc de registres.png|centre|vignette|upright=2|Connexion du program counter sur les bus avec PC dans le banc de registres]]

===Les registres d'interruption avec un processeur hybride-accumulateur : l'exemple du Z80===

Un exemple de processeur registre-accumulateur à deux bus interne est le Z80, un processeur fortement inspiré des CPU Intel 8 bits. Il a un jeu d'instruction similaire, mais a diverses améliorations par rapport au design original. Notamment, le processeur a des registres séparés pour les interruptions.

Sur le Z80, les registres généraux sont dupliqués avec 6 registres pour les interruptions et 6 registres pour les programmes autres. Leur copie pour les interruptions sont nommées B', C', D', E', H', L'. Les 12 registres sont placés dans le banc de registre, ce qui implique que le fenêtrage de registres est utilisé pour gérer la séparation entre registre d'interruption et normaux. Il faut noter que l'accumulateur et le registre d'état sont aussi dupliqués, leurs copies étant nommées A' et F'. Mais leur duplication se fait autrement que par fenêtrage de registre.

En plus des registres précédents, le Z80 incorporait deux registres d'indice nommés X et Y, ainsi qu'un pointeur de pile SP et un ''program counter'' PC. Ils n'étaient pas dupliqués pour les interruptions. Les registres d'indice étaient reliés à une unité de calcul d'adresse. L'unité de calcul d'adresse prenait deux opérandes : un indice, et une adresse mémoire provenant soit du banc de registre, soit de l'accumulateur. En clair, l'unité de calcul d'adresse faisait le lien entre les deux bus internet : le bus de données interne en entrée, le bus d'adresse en sortie.

À l'intérieur du processeur, tous les registres étaient regroupés dans un banc de registre unique, sauf les accumulateurs, les registres d'état et le ''program counter''. Bien que ce ne soit pas indiqué sur le schéma ci-dessous, le ''program counter'' est séparé du banc de registre, alors que le pointeur de pile est dedans. Le compteur IR est lui associé au ''program counter'', il est sortit du banc de registre. Le Z80 utilise lui aussi un incrémenteur séparé de l'ALU, qui est utilisé pour mettre à jour le ''program counter'', le pointeur de pile et un compteur de rafraichissement mémoire nommé IR sur le Z80 (pour rappel, le rafraichissement mémoire demande de balayer la mémoire d'adresse en adresse et été fait par le CPU à l'époque). De plus, il est utilisé pour les instructions INC et DEC qui incrémentent une opérande de 16 bits obtenue en combinant deux registres de 8 bits. En clair, l'incrémenteur du ''program counter'' a été réutilisé de beaucoup de manières originales.

[[File:Z80 arch.svg|centre|vignette|upright=3|Microarchitecture du Z80.]]

Le Z80 incorporait des instructions pour échanger le contenu des deux ensembles de registres, accumulateur inclus. Elles permettaient d'utiliser les registres d'interruption pour les programmes et réciproquement. En clair, cela doublait le nombre de registres si les interruptions n'étaient pas utilisées.
* L'instruction EXX échangeait les deux fenêtres de registres généraux : les registres B, C, D, E, H et L devenaient les registres B', C', D', E', H' et L' et inversement.
* L'instruction EX échangeait l'accumulateur et le registre d'état : les registres A,F devenait A',F' et inversement.

Le fenêtrage de registre était modifié par l'instruction EXX, qui échangeait les deux fenêtres de registres. Pour l'implémenter, une bascule était ajouté au processeur, appelons-la la bascule INT. Elle était relié au bus d'adresse du banc de registre, dont elle mémorisait le bit de poids fort. L'instruction EXX inversait la valeur de la bascule INT. Il est aussi possible d'échanger le contenu des registres D,E et H,L avec une instruction dédiée, ce qui est là encore fait par deux bascules : une pour les registres D,E et une autre pour les registres H,L.

Pour l'accumulateur et le registre d'état, le choix entre registre normal et registre d'interruption se faisait là encore par une seconde bascule appelée la bascule A. La bascule est reliée à un multiplexeur et un démultiplexeur, qui permet de choisir quel accumulateur relier à l'unité de calcul. L'instruction EX inverse le contenu de la bascule A.

&lt;noinclude&gt;
{{NavChapitre | book=Fonctionnement d'un ordinateur
           | prev=L'unité de contrôle
           | prevText=L'unité de contrôle
           | next=Les processeurs 8 bits et moins
           | nextText=Les processeurs 8 bits et moins
}}
&lt;/noinclude&gt;</text>
      <sha1>c9jpmym0n02uha90k07zneksnouwt1x</sha1>
    </revision>
    <revision>
      <id>744176</id>
      <parentid>744160</parentid>
      <timestamp>2025-06-05T17:24:15Z</timestamp>
      <contributor>
        <username>Mewtow</username>
        <id>31375</id>
      </contributor>
      <minor />
      <comment>/* Les architectures hybrides registres-accumulateur */</comment>
      <origin>744176</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="41323" sha1="e47cwmmrstmrrycko4024mwj3ayq5b9" xml:space="preserve">Les architectures que nous avons vu précédemment dans ce cours disposent de registres pour les données, en plus du pointeur de pile, d'un ''program counter'', et de quelques autres. Elles sont appelées des '''architectures à registres''', terme qui trahit bien le fait qu'elles ont des registres généraux ou spécialisés pour stocker temporairement des données. Et si on leur a donné un nom, c'est parce qu'il existe des architectures qui ne sont pas dans cette catégorie. Il en existe plusieurs types, mais ce chapitre va se concentrer sur les '''architectures à accumulateur'''.

[[File:Isaccumulator.png|vignette|Architecture à accumulateur.]]

Les architectures à accumulateur sont centrées autour d'un registre architectural appelé l''''accumulateur'''. Il est utilisé pour toutes les opérations arithmétiques dyadiques, où il sert à la fois de source et de destination. Toutes les instructions dyadiques sont de type ''load-op'' : une opérande est lue depuis l'accumulateur, le second opérande est lu depuis la mémoire RAM, le résultat de l'instruction est automatiquement mémorisé dans l'accumulateur. Les instructions monadiques peuvent utiliser un opérande dans l'accumulateur, ou dans la mémoire RAM, les deux sont théoriquement possibles.

La conséquence est que le nombre d'accès mémoire est drastiquement diminué : de 3 par instructions sur une architecture mémoire-mémoire, on passe à seulement un avec un accumulateur. Les opérations dyadiques ont besoin d'un seul accès mémoire pour lire la seconde opérande, les opérations monadique en font aussi un seul pour lire leur unique opérande.

{|class=&quot;wikitable&quot;
|-
! Classe d'architecture
! Nombre d'accès mémoire par opération dyadique
|-
|-
! Architecture à accumulateur
| Un accès mémoire par instruction, pour lire la seconde opérande
|-
! Architecture à registres
| Zéro si les opérandes sont dans les registres, un pour les opérations ''load-op'', LOAD et STORE.
|}

==Le jeu d'instruction des architectures à accumulateur sans registres d'indice==

L'accumulateur est adressé grâce au mode d'adressage implicite, de même que le résultat de l'opération. Par contre, les autres opérandes sont localisés avec d'autres modes d'adressage, et lues en mémoire RAM. Le résultat ainsi qu'un des opérandes sont adressés de façon implicite car dans l'accumulateur, seule la seconde opérande étant adressée directement. Grâce à l'accumulateur, une instruction ne fait qu'un seul accès mémoire maximum, ce qui rend le processeur très facile à implémenter.

===Les registres des anciennes architectures à accumulateur===

[[File:IBM 701console.jpg|vignette|IBM 701, console extérieure.]]

Les architectures à accumulateur étaient communes dans les années 50-60. A l'époque, les ordinateurs étaient gigantesques, ils prenaient une pièce de bâtiment entière dans le pire des cas, une armoire entière dans le meilleur. Les ordinateurs de l'époque étaient surtout utilisés pour du calcul scientifique ou des tâches d’ingénierie demandant beaucoup de calcul, rarement pour de la compatibilité.

Les nombres flottants n'étaient pas encore apparus. A la place, les ordinateurs de l'époque géraient des nombres entiers de grande taille, de 30 bits ou plus. En conséquence, l'accumulateur faisait facilement 30 à 60 bits. Par exemple, les ordinateurs de la Série scientifique IBM 700/7000 géraient des entiers de 36 bits, l’accumulateur faisait 38 bits : 36 bits plus deux bits pour les débordements. Au passage, de tels processeurs utilisaient l'adressage par mot, et non par byte.

Historiquement, les premières architectures à accumulateur ne contenaient aucun autre registre que l'accumulateur. Ce n'est que dans les années 60 que de nombreuses architectures à accumulateur ont ajouté un second '''registre pour les multiplication/divisions'''. Un exemple est celui de l'IBM 701, qui incorporait un registre accumulateur de 38 bits et un registre multiplieur de 36 bits. Le registre mémorise le multiplieur lors d'une opération de multiplication. Il mémorise donc un opérande, pas le résultat. Il peut aussi décaler le multiplieur vers la droite/gauche, ce qui est utile pour exécuter la multiplication. C'est ce qui est fait sur l'IBM 7094.

Une autre possibilité est que ce registre mémorise une partie du résultat de l'opération. Pour rappel, le résultat d'une multiplication/division est codé sur deux fois de bits que ses opérandes. Par exemple, multipliez deux opérandes de 30 bits, vous obtiendrez un résultat de 60 bits. Les 30 bits de poids faible du résultat vont dans l'accumulateur, les 30 bits de poids fort vont dans ce second registre.

Les architectures à accumulateur parfois un '''registre pour le pointeur de pile''', utilisé pour gérer les fonctions/procédures. Les architectures à accumulateurs supportaient une pile d'adresse de retour, souvent une pile d'appel. Mais pour cela, il fallait mémoriser le pointeur de pile dans le processeur, ce qui demandait un registre dédié.

===L'adressage indirect avec l'accumulateur===

Les instructions LOAD et STORE existent bel et bien sur les architectures à accumulateur, mais n'ont pas les mêmes modes d'adressages. L'instruction LOAD copie une donnée de la RAM vers l'accumulateur, l'instruction STORE copie l'accumulateur dans une adresse. Les deux instructions n'ont pas besoin d'adresser l'accumulateur, qui est adressé de manière implicite, juste de préciser l'adresse à lire/écrire.

Les architectures à accumulateur supportaient souvent le mode d'adressage indirect mémoire. Un exemple est celui des ordinateurs Data General Nova, qui sont des architectures à accumulateur et qui supportaient ce mode d'adressage. Les deux instructions LOAD et STORE existaient en deux versions, distinguées par un bit d'indirection. Si ce bit est à 0 dans l'opcode, alors l'instruction utilise le mode d'adressage absolu normal : l'adresse intégrée dans l'instruction est celle de la donnée. Mais s'il est à 1, alors l'adresse intégrée dans l'instruction est celle du pointeur.

Cependant, la présence de l'accumulateur permettait d'utiliser l'adressage indirect à registre, pour gérer les pointeurs. Pour rappel, avec le mode d'adressage indirect à registre, l'adresse à lire/écrire est dans un registre. Ici, l'adresse à lire/écrire est prise dans l'accumulateur, seul registre disponible pour. L'adressage indirect est plus simple à implémenter pour l'instruction LOAD, car elle prend un seul opérande : l'adresse à lire. L'adresse à lire est placée dans l'accumulateur, la donnée lue est elle aussi chargée dans l'accumulateur. Pour l'instruction STORE, il faut fournir deux opérandes, l'adresse et la donnée à écrire, ce qui peut poser problème. Mais au pire, il est toujours possible d'utiliser l'adressage absolu ou indirect mémoire : l'adresse est dans l'instruction, la donnée à écrire dans l'accumulateur.

===L'encodage des instructions===

Sur une architecture à accumulateur l'encodage d'une instruction dyadique est assez simple, vu que l'accumulateur est adressé implicitement. La seconde opérande est localisée soit par une adresse mémoire (adressage absolu), soit est une constante (adressage immédiat). L'adresse mémoire est généralement assez longue, plus que l'opcode.

{|class=&quot;wikitable&quot;
|+ Encodage d'une instruction dyadique
|-
! rowspan=&quot;2&quot; | Opcode 
| Adresse mémoire (adressage absolu)
|-
| Constante (adressage immédiat)
|}

L'encodage d'une instruction monadique est similaire. Si l'opérande est lue depuis la mémoire RAM, alors l'instruction est encodée comme une instruction dyadique. Il en est de même pour les instructions qui copient une constante dans l'accumulateur. Par contre, si l'opérande est dans l'accumulateur, alors il y a juste besoin d'encoder l'opcode. La majorité des instructions a besoin de préciser une adresse, rares sont celles qui s'en passent. Au vu de cet encodage, les architectures à accumulateur sont qualifiées d''''architectures à une adresse''' par abus de langage.

Il est intéressant de contraster leur encodage avec les architectures à registres. Les architectures à registre doivent encoder deux opérandes en plus de l'opcode, avec éventuellement où enregistrer le résultat sur les architectures 3-adresses. Par contre, les opérandes sont généralement des noms de registre, ce qui prend moins de place qu'une adresse mémoire. A la rigueur, les instructions avec une constante immédiate prennent un peu plus de place, car elles doivent encoder un nom de registre en plus de la constante et de l'opcode. Les instructions ''load-op'' des processeurs CISC sont un peu dans le même cas, sauf qu'il faut remplacer la constante par une adresse, qui a généralement la même taille. Les instructions sont donc en moyenne plus courte sur les processeurs à registre, du fait de la présence de registres.

===Annexe : les toutes premières architectures à accumulateur : le Manchester Baby===

[[File:BabyArchitecture.png|vignette|Architecture de la Manchester Baby.]]

Les architectures à accumulateurs sont apparues dès les débuts de l'informatique. Le tout premier ordinateur à programme enregistré en mémoire, le ''Manchester Baby'', était une architecture à accumulateur. Niveau interface, l'ordinateur avait une console avec 32 boutons, des interrupteurs et un écran de sortie sur lequel afficher les résultats. A l'intérieur, il y avait un processeur et une RAM de 32 adresses, fabriquée avec des tubes Williams (abordés dans une annexe à la fin du cours). Chaque adresse mémorisait 32 bits, qui pouvaient encoder soit un nombre, soit une instruction.

Le programme devait tenir dans la RAM, avec une instruction par adresse maximum, ce qui limitait les programmes à 32 instructions maximum. Une instruction prenait donc 32 bits, 3 indiquaient quelle opération utiliser, 12  bits d'adresse servait à indiquer où se trouvent la seconde opérande en RAM, les 16 restants sont inutilisés. En théorie, les 12 bits d'adresse permettaient d'adresser 4096 adresses, mais seules 32 étaient réellement présentes.

Le processeur avait un registre accumulateur de 32 bits, un ''program counter'' et un registre d'instruction. Il intégrait un additionneur dédié au ''program counter'', mais l'ALU n'avait pas d'additionneur. En conséquence, il ne gérait pas l'addition. A la place, il gérait la soustraction. Il pouvait cependant émuler l'addition à partir d'une soustraction. La soustraction était utilisée pour calculer le complément d'une opérande, et soustraire le complément revient à additionner. L'ALU était une ALU sérielle, à savoir qu'elle faisait les soustractions bit par bit.

Le processeur supportait 7 instructions au total : la soustraction, des instructions de branchement et d'accès mémoire, rien d'autre. Les instructions de branchement utilisaient des modes d'adressage très particuliers, qu'on ne retrouve pas sur les ordinateurs modernes. Les branchements inconditionnels utilisaient une forme d'adressage mémoire indirect, pas les adressages usuels pour les branchements. Il n'y avait pas de branchements conditionnels, mais une ''SKIP instruction''.

{|class=&quot;wikitable&quot;
|-
! SUB 
| Soustrait l'opérande mémoire de l'accumulateur.
|-
! CMP
| Skippe l'instruction suivante si l'accumulateur a une valeur négative.
|-
! JMP
| Branchement indirect mémoire. :
* L'adresse de destination est lue depuis la mémoire.
* L'adresse lue est intégrée dans l'instruction via adressage absolu.
|-
! JRP
| Branchement relatif indirect.
* Lit une opérande depuis la mémoire, l'adresse est intégrée dans l'instruction via adressage absolu.
* Additionne l'opérande lue au ''program counter''.
|-
! LDN
| Instruction LOAD. La donnée lue est inversée lors de la lecture, l'accumulateur contient le complément à deux de la donnée lue après la lecture.
|-
! STO
| Instruction STORE
|-
! STOP
| Éteint l'ordinateur.
|}

Le Manchester Mark 1 était une amélioration du Manchester Baby. Il utilisait 4500 tubes à vide. Le Manchester Baby était un prototype, mais il avait été pensé pour être étendu, notamment afin d'avoir plus de mémoire. C'est pour cela que ses adresses étaient codées sur 12 bits, malgré sa mémoire de seulement 32 mots. Le plan initial, à savoir utiliser une RAM de 4096 mots, a cependant été abandonné pour la Manchester Mark 1. A la place, la RAM a gardé la même taille, à savoir 32 nombres, mais a été complémentée par l’ancêtre du disque dur magnétique, à savoir un tambour magnétique. Le tambour magnétique contenait 40 pages, chacune ayant la même taille que la RAM.

L'ordinateur gérait des nombres de 40 bits, mais les instructions étaient codées sur 20 bits. Le processeur gérait maintenant l'addition et quelques opérations logiques (ET et OU), en plus de la soustraction et de la comparaison. De plus, il intégrait deux registres dédiés aux multiplications : un pour le multiplicande, un autre pour le multiplieur. Ils étaient nommés D et R et étaient regroupés dans un seul tube Williams noté M. Cependant, les multiplications étaient réalisées en enchainant une série d'additions, dans l'additionneur-soustracteur. 

C'était là encore une architecture à accumulateur, sauf qu'elle intégrait aussi des registres d'indice. Les registres d'indices étaient au nom de deux et étaient notés B0 et B1. Lors du chargement d'une instruction, un registre d'indice était sélectionné grâce à un bit de l'instruction. Le contenu de ce registre d'indice était additionné à l'instruction , l'adresse encodée dedans pour être précis, et le résultat était envoyé sur le bus mémoire.

La microarchitecture de la machine est illustrée ci-dessous. Elle a une ALU unique capable de faire plusieurs opérations, qui sont représentées dans des rectangles séparés. Les cercles dans le schéma suivant sont des tubes Williams, des écrans CRT modifiés de manière à servir de mémoire DRAM, dont le fonctionnement est détaillée dans le chapitre sur les mémoires historiques. Un tube Williams implémente un banc de registre complet, c'est à dire un groupe de 2 à 10, registres. L'accumulateur est noté A, les deux registres de multiplication sont regroupés dans le tube Williams M, les registres d'indice sont dans le tube noté B. Le tube Williams C regroupe le ''program counter'' et le registre d'instruction. L'additionneur sert à incrémenter le ''program counter'', mais aussi pour les branchements relatifs. La statistation est le nom donné au séquenceur, à l'unité de contrôle, décodeur d'instruction inclus.

[[File:MM1Schematic French.svg|centre|vignette|upright=2.5|Architecture de la Manchester Mark 1.]]

==La micro-architecture des architectures à accumulateur sans registres d'indice==

L'organisation interne d'une architecture à accumulateur est très différente de celle des processeurs à registre. Elle est plus ou moins la même pour tous ces processeurs, le point important étant que le chemin de données se résume à une ALU, un registre accumulateur et le bus de données. L'ALU est reliée au registre accumulateur, ainsi qu'au bus de données pour lire la seconde opérande, comme illustré ci-dessous.

[[File:Accumulator.png|centre|vignette|upright=2|Accumulateur.]]

===L'unité de calcul et l'accumulateur===

Pour simplifier l'implémentation, le résultat est mémorisé dans un registre en sortie de l'unité de calcul. La raison est qu'on ne veut pas altérer l'accumulateur tant que le résultat final n'est pas totalement calculé. Rappelons que l'ALU ne fournit pas un résultat d'un seul bloc, mais que certains bits arrivent avant les autres, typiquement les bits de poids faible. Si le résultat était écrit dans l'accumulateur directement, il écraserait des bits de l’opérande en cours d'utilisation, ce qui fausserait le résultat.

[[File:Accumulateur avec registre de sortie.png|centre|vignette|upright=2|Accumulateur avec registre de sortie]]

Une autre solution utilisait un registre entre l'accumulateur et l'unité de calcul, appelé l’'''''accumulator latch'''''. Il remplace le registre en sortie de l'ALU, dans le sens où il permet d'écrire dans l'accumulateur sans effacer l'opérande, pendant que l’opération est en cours dans l'ALU. L'accumulateur est copié dans l’''accumulator latch'', avant que l'ALU démarre ses calculs. L'opérande est donc maintenue même si on commence à écrire le résultat dans l'accumulateur.

Sur le 8085 d'Intel, l’''accumulator latch'' peut être initialisé avec une constante prédéfinie, ce qui permet d'implémenter certaines instructions très facilement. Par exemple, il peut être initialisé à 0, ce qui permet d'implémenter les instructions MOV et INC (incrémentation). Un MOV est équivalent à faire un OU entre le registre lu et 0. Une instruction INC initialise l'entrée de retenue de l'unité de calcul à 1, puis ajoute 0. La décrémentation est implémentée de la même manière, sauf que l’''accumulator latch'' est initialisé à -2 pour compenser l'entrée de retenue à 1. De plus, pour supporter les conversion de décimal à BCD, l’''accumulator latch'' peut être initialisé avec les constantes 0x00, 0x06, 0x60, or 0x66. L'''accumulator latch'' est relié à divers fils de commande provenant de l'unité de contrôle, qui décide quelle valeur d'initialisation utiliser en fonction de l'instruction décodée.

[[File:Accumulator latch.png|centre|vignette|upright=2|Accumulator latch]]

[[File:Chemin de données à un seul bus.png|vignette|Chemin de données à un seul bus]]

De même, la seconde opérande, celle lue sur le bus de données, est mémorisée dans un registre en amont de l'ALU. C'était notamment très utile si le processeur utilisait une ALU plus courte que les opérandes, avec par exemple une ALU 4 bits pour un CPU 8 bits. Les anciens processeurs à accumulateur de type ''mainframe'' utilisaient des opérandes de grande taille, du genre 36 ou 48 bits, ce qui avait des conséquences sur l'unité de calcul utilisée, ainsi que sur la communication avec la mémoire. Il arrivait que de tels processeurs utilisaient des ALU sérielles, ou du moins octet-sérielles, plutôt qu'une véritable ALU 36 bits. Nous verrons aussi que c'est très utile sur les processeurs à accumulateur avec un bus interne unique, dans la suite du chapitre.

===La micro-architecture des architectures à accumulateur avec instructions LOAD/STORE===

Nous venons de voir comment est implémenté l'unité de calcul et l'accumulateur, et comment le tout est relié au bus de données. Mais cela ne permet que d'avoir un processeur à accumulateur rudimentaire, qui ne gére que des instructions arithmétiques et logiques. Il faut aussi gérer le cas des opérations LOAD/STORE et des modes d'adressages associés, mais c'est le séquenceur qui s'en occupe. Avec l'adressage absolu, les instructions LOAD et STORE ne font que connecter l'accumulateur au bus de données. L'instruction STORE nécessite de connecter l'accumulateur au bus de données, de manière à ce que le transfert des données se fasse de l'accumulateur vers le bus de données. L'instruction LOAD s'implémente de la même manière, sauf que le sens de transfert est inversé.

Cependant, il existe une optimisation qui permet d'implémenter l'instruction LOAD sans ajouter de circuits. Pour cela, il suffit que l'unité de calcul gére les opérations ''pass through'', à savoir des opérations qui se contentent de recopier un opérande sur la sortie. Ici, l'idée est de recopier l'opérande provenant du bus de données.

[[File:Architecture à accumulateur, microarchitecture.png|centre|vignette|upright=2|Architecture à accumulateur, microarchitecture]]

Pour gérer nativement l'adressage indirect à registre, il suffit de connecter l'accumulateur au bus d'adresse. Le plus simple est d'ajouter un multiplexeur, comme illustré ci-dessous. La donnée lue est copiée dans l'accumulateur, ce qui fait qu'il vaut mieux utiliser un registre d’interfaçage, l'accumulateur n'étant pas utilisable à la fois pour le bus d'adresse et de données.

[[File:Adressage indirect sur une architecture à accumulateur.png|centre|vignette|upright=2|Adressage indirect sur une architecture à accumulateur]]

Pour finir, voyons comment le pointeur de pile et le ''program counter'' sont implémentés. Les architectures à accumulateur ont souvent des adresses de taille différente des données, ce qui fait qu'il vaut mieux utiliser un circuit incrémenteur dédié pour incrémenter le ''program counter'', plutôt que de l'incrémenter via l'unité de calcul. Les architectures à accumulateur ont parfois un pointeur de pile, qui gère une pile d'adresse de retour, pas une vraie pile d'appel. Aussi, le pointeur de pile est censé être incrémenté et décrémenté, pas plus. Pas d'addition ou de soustraction pour gérer des cadres de pile. Là encore, c'est la solution de l'incrémenteur séparé qui est retenue. Pour économiser des transistors, il n'y a qu'un seul incrémenteur partagé pour les deux.

==Les architectures à accumulateur à registres d'indice==

Les architectures à accumulateur décrites dans la section précédente sont capables de faire de l'adressage indirect, mais n'incluent pas les modes d'adressage base + indice et absolus indicés, qui prennent une adresse et y ajoute un indice. Il s'agit des toutes premières architectures à accumulateur, comme les premiers ordinateurs IBM ou le fameux PDP-8. Mais par la suite, les processeurs à accumulateurs ont inclus un support des modes d'adressages indicés, grâce à des '''registres d'indice'''.

===Les registres d'indice===

Les registres d'indice stockent des indices de tableaux. Ils permettaient de supporter deux modes d'adressage :
* Le '''mode d'adressage absolu indicé''' où une adresse fixe est additionnée à un indice variable. L'adresse fixe est intégrée dans l'instruction (adressage absolu), l'indice est dans un registre d'indice.
* Le '''mode d'adressage base + indice''', où l'adresse est dans l'accumulateur et l'indice dans le registre d'indice.

Les processeurs à accumulateur supportaient souvent des variantes des modes d'adressage précédents, où le registre d'indice était automatiquement incrémenté ou décrémenté à chaque utilisation.

Au départ, ces processeurs n'utilisaient qu'un seul registre d'indice qui se comportait comme un second accumulateur spécialisé dans les calculs d'adresses mémoire. Le processeur supportait de nouvelles instructions qui utilisaient ce registre d'indice de façon implicite. Mais avec le temps, les processeurs finirent par incorporer plusieurs de ces registres. Les instructions de lecture ou d'écriture devaient alors préciser quel registre d'indice utiliser, en précisant un nom de registre d'indice, un numéro de registre d'indice.

Il faut préciser que les registres d'indice ont une taille bien plus petite que l'accumulateur. Ils mémorisent des indices codés sur 16 bits ou moins, alors que l'accumulateur faisait typiquement 36 à 48 bits, parfois plus. La taille classique sur les anciens ''mainframes'' était de 15 bits, parfois moins. Il n'était pas rare de tomber sur des registres d'indice de 8 ou 9 bits. Leur petite taille rendait leur implémentation matérielle peu couteuse. Et c'est ce qui explique qu'ils étaient préférés à l'usage d'un second accumulateur.

Un exemple est le cas du processeur Motorola 6809, un processeur à accumulateur qui contient deux registres d'indices nommés X et Y. L'accumulateur est noté D et fait 16 bits, il peut être parfois géré comme deux accumulateurs séparés A et B de 8 bits chacun. Il contenait aussi deux pointeurs de pile, l'un pour les programmes, l'autre pour le système d'exploitation, ainsi qu'un ''program counter''. Le registre de page était utilisé pour l'adressage absolu, comme vu dans le chapitre sur les modes d'adressage.

[[File:6809 Internal Registers.svg|centre|vignette|upright=2|6809 Internal Registers]]

Les processeurs IBM avaient autrefois plusieurs registres d'indice. Par exemple, l'IBM 704 avait trois registres d'indice de 15 bits. Leur contenu était soustrait de l'adresse absolue. Une instruction pouvait utiliser plusieurs registres d'indice pour adresser son opérande. Toute instruction utilisait trois bits pour sélectionner les registres d'indice utilisés. Fait assez original, lorsque plusieurs registres d'indice sont sélectionnés, le processeur n'additionne pas les trois registres à l'adresse de base. À la place, il fait un OU bit à bit entre les registres d'indice sélectionnés, et additionne le résultat à l'adresse.

Les processeurs IBM à accumulateur ont fait ça sur toute la gamme IBM 700/7000, pour des raisons de compatibilité. Les processeurs suivants avaient 7 registres d'indices, mais conservaient les trois bits pour adresser les registres d'indices. Ils pouvaient fonctionner dans deux modes. Le premier mode est plus intuitif : les trois bits précisent un registre d'indice parmi les 7, qui est additionné avec l'adresse absolue. La valeur zéro indique qu'aucun registre d'indice n'est utilisé, ce qui explique qu'il y a 7 registres d'indice et non 8. Un second mode, compatible avec l'IBM 704, fait un OU logique entre les registres d'indice sélectionnés. Seuls les trois premiers registres d'indices peuvent être sélectionnés dans ce mode. Il y a deux instructions pour changer de mode : une pour passer en mode compatible, l'autre pour le quitter pour l'autre mode.

Quelques rares processeurs à registres généraux ont utilisés des registres d'indice, en plus des registres généraux. Ce qui fait l'association que nous avons faite entre registres d'indice et architectures à accumulateur est imparfait, bien que solide sur le principe. Un exemple d'architecture de ce type sont les architectures de la série UNIVAC 1100/2200. Ils disposaient de 128 registres, qui étaient mappés en mémoire à partir de l'adresse mémoire 0, la majorité étant inaccessibles par le programmeur. Ils regroupaient 12 registres accumulateurs, 11 registres d'indice et 4 registres hybrides qui pouvaient servir soit de registre d'indice, soit de registres accumulateurs.

===La micro-architecture des architectures à accumulateur avec registres d'indice===

La présence de registres d'indice modifie grandement l'implémentation du processeur. En effet, il faut rajouter un banc de registre pour les registres d'indice. Le banc de registre est monoport, car on a besoin de lire ou d'écrire un indice à la fois. Et il faut aussi potentiellement rajouter de quoi faire les calculs d'adresse. Deux solutions sont possibles : une ALU dédiée aux calculs d'adresse, une seule ALU pour toutes les opérations.

Dans le premier cas, il y a une ALU séparée associée aux registres d'indice. L'ALU et les registres d'indice sont placés en sortie du séquenceur, en-dehors du chemin de données, la sortie de l'ALU est directement connectée au bus d'adresse. L'unité de calcul d'adresse peut être utilisée pour incrémenter le ''program counter''. Un défaut de cette approche est qu'elle ne gère pas l'adresse indirect à registre.

[[File:Chemin de données sans support des pointeurs, avec adressage absolu indicé.png|centre|vignette|upright=2|Chemin de données sans support des pointeurs, avec adressage absolu indicé]]

Une autre option utilise un bus interne, qui interconnecte tout le chemin de données. Dans sa version la plus simple, il est relié à l'accumulateur, l'unité de calcul, le banc de registre d'indice et le bus de données. Avec cette solution, l'ALU est utilisé à la fois pour calculer les adresses et pour les instructions de calcul. En reliant le bus interne au bus d'adresse à travers un multiplexeur, on gère naturellement les adressages indirects.

[[File:Architecture à accumulateur avec registres associés.png|centre|vignette|upright=2.5|Architecture à accumulateur avec registres associés]]

Il faut noter que sur les architectures Von Neumann, le séquenceur est relié à ce bus interne. En effet, charger une instruction demande de passer par le bus mémoire, donc par l’intermédiaire de ce bus internet. Le ''program counter'' est envoyé sur ce bus pour lire l'instruction, puis l'instruction lue est recopiée dans le registre d'instruction. Le chargement d'une instruction est donc géré comme une lecture des plus classiques. De plus, cela permet d'incrémenter le ''program counter'' au niveau de l'unité de calcul entière. Le ''program counter'' est envoyé sur le bus interne, incrémenté par l'ALU, puis le résultat est recopié dans le ''program counter'' via le bus interne.

[[File:Architecture à accumulateur avec bus unique de type Von Neumann.png|centre|vignette|upright=2|Architecture à accumulateur avec bus unique de type Von Neumann]]

==Les processeurs bi-accumulateurs : le Motorola 6800==

Le Motorola 6800 était un processeur 8 bits qui gérait des adresses de 16 bits. Il contenait deux accumulateurs nommés A et B, de 8 bits chacun. Il disposait aussi d'un registre d'indice, d'un pointeur de pile et d'un ''program counter'', tous les trois de 16 bits. Le registre d'état regroupait 6 bits, qu'on ne détaillera pas ici.

[[File:MC6800 Processor Diagram.png|centre|vignette|upright=2|Interface et registres du MC6800.]]

La présence des deux accumulateurs impactait surtout les instructions dyadiques. Les instructions monadiques avaient juste à préciser où se trouvait l'opérande : soit en RAM, soit dans le premier accumulateur, soit dans le second. Pour les opérations dyadiques, la gestion était totalement différente. En théorie, le premier opérande est dans un accumulateur, soit A, soit B. La seconde opérande vient soit de l'autre accumulateur, soit de la mémoire RAM. Et selon les instructions, tout variait.

Pour l'addition, il y avait trois instructions. Les deux premières additionnaient un opérande provenant de la mémoire avec un accumulateur. L'instruction ADDA sélectionnait le premier accumulateur, l'instruction ADDB sélectionnait le second accumulateur. Mais une troisième instruction, l’instruction ABA, permettait d'additionner le contenu des deux accumulateurs.

Pour les autres opérations, il n'était pas possible d'utiliser les deux accumulateurs en même temps. La seule possibilité était de faire une opération entre un accumulateur et un opérande venant de la mémoire. Toutes les instructions étaient en double, avec une copie par accumulateur. Par exemple, l'instruction ANDA faisait un ET entre l’accumulateur A et l'opérande mémoire, l'instruction ANDB faisait pareil avec l'accumulateur B.

==Les architectures hybrides registres-accumulateur==

Il a existé quelques architectures qui étaient des hybrides entre architectures à accumulateur et architecture à registre. Elles sont apparues assez tôt, dès les années 50. Par exemple, le Bull Gamma 3 était un ordinateur de type ''mainframe'' qui disposait d'un accumulateur accompagné de registres généraux. Et c'était à une époque où les ordinateurs étaient intégralement construits avec des tubes à vides et autres mémoires spécialisées. Mais ces architectures sont restées assez confidentielles pendant les années 50 à 80. Par la suite, elles ont eu un regain de popularité durant les années 80-90. Elles ont alors servit de transition entre architectures à accumulateur proprement dites, et architectures à registres.

Elles avaient un accumulateur unique couplé à un banc de registres généraux. Par exemple, les processeurs Intel 8 bits disposaient de 7 registres de 8 bits nommés A, B, C, D, E, F, H, L, SP. Ils correspondent respectivement à :
* l'accumulateur A ;
* six registres nommés B, C, D, E, H et L ;
* le registre d'état F ;
* le pointeur de pile SP.

Sur ces processeurs, les instructions dyadiques devaient mettre leur premier opérande dans l'accumulateur, la seconde provenait soit des registres, soit de la RAM, soit d'une constante immédiate. Les opérations monadiques pouvaient lire leur opérande depuis l'accumulateur, les autres registres ou la RAM, tout était permis. Les registres d'indices disparaissaient sur ces architectures, en théorie. Les registres généraux pouvaient être utilisés comme registre d'indice ou pour stocker des opérandes, ils étaient assez versatiles pour servir de registres d'indices.

La présence de registres a de nombreux avantages, comparé aux architectures à accumulateur pures. Les instructions arithmétiques sont plus rapide, lire un registre étant plus rapide qu'un accès RAM. Les performances sont donc augmentées. De plus, les instructions arithmétiques utilisant ces registres sont plus courtes : pas besoin d'encoder une adresse mémoire, un nom de registre suffit. Vu que les processeurs de l’époque avaient des instructions de taille variable, cela améliorait la densité de code.

La microarchitecture de ces processeurs est très similaire à celle d'un processeur avec des registres d'indices. La seule différence est que le banc de registre contient des registres généraux et non des registres d'indices. Le banc de registre est systématiquement monoport, car il n'avait aucune raison d'être multiport. Pour les instructions dyadiques, seules à lire deux opérandes, il ne servait que pour la seconde opérande, la première était lue depuis l'accumulateur.

Les processeurs hybrides registre-accumulateur se classent en deux types principaux : ceux qui ont un seul bus interne, et ceux qui en ont deux. Le premier cas est identique à celui vu précédemment pour les architectures à accumulateur avec registres d'indice, à la seule différence est que le banc de registre contient des registres généraux et non des registres d'indices. Afin de gérer l'adressage indirect à registre, le bus interne est connecté aux deux registres d’interfaçage mémoire.

[[File:Architecture à accumulateur avec bus unique de type Von Neumann.png|centre|vignette|upright=2|Architecture à accumulateur avec bus unique de type Von Neumann]]

Notons que cela permet aussi d'implémenter facilement les branchements indirects, car le bus interne permet d'échanger des adresses entre ''program counter'' et banc de registre. De même, il est possible d'utiliser l'ALU pour gérer les branchements indirects., en plus de l'utiliser pour incrémenter le ''program counter''.

[[File:Single bus organization.jpg|centre|vignette|upright=2|Single bus organization]]

Une autre solution utilisait deux bus internes : un connecté au bus de données, un autre relié au bus d'adresse. Le bus de commande mémoire était lui commandé par le séquenceur, l'unité de contrôle. L'intermédiaire entre ces deux bus était le banc de registre, ainsi que les autres registres. Le banc de registre était connecté aux deux bus interne, avec un port de lecture relié au bus d'adresse, un port de lecture-écriture relié au bus de données. Le port de lecture était utilisé pour l'adressage indirect, l'autre l'était pour le reste.

[[File:Proz1-e.png|centre|vignette|upright=2|Intérieur d'un processeur.]]

L'organisation à deux bus simplifiait la gestion du ''program counter'' et le chargement des instructions. Le ''program counter'' était soit séparé du banc de registre, soit placé dans le banc de registre. Les deux solutions étaient utilisés, tout dépend du processeur. Il faut noter que si le ''program counter'' est intégré au banc de registres, alors la microarchitecture du processeur est bien plus simple. L'envoi du ''program counter'' sur le bus d'adresse utilise le port de lecture relié au bus d'adresse, qui sert aussi pour l'adressage indirect. L'économie de circuits, sans compter la simplicité d'implémentation que cela implique, explique sans doute que la technique a été utilisée sur quelques processeurs anciens.

Le ''program counter'' était généralement incrémenté par l'ALU, ce qui explique qu'il soit connecté au bus interne pour les données. La connexion est aussi utile pour gérer les branchements indirects, qui copient un registre dans le ''program counter'', ainsi que les branchements relatifs (addition dans l'ALU), voire les branchements directs (l'adresse vers laquelle brancher est envoyée en entrée de l'ALU et propagée en sortie avec une opération ''pass through'').

[[File:Connexion du program counter sur les bus avec PC dans le banc de registres.png|centre|vignette|upright=2|Connexion du program counter sur les bus avec PC dans le banc de registres]]

===Les registres d'interruption avec un processeur hybride-accumulateur : l'exemple du Z80===

Un exemple de processeur registre-accumulateur à deux bus interne est le Z80, un processeur fortement inspiré des CPU Intel 8 bits. Il a un jeu d'instruction similaire, mais a diverses améliorations par rapport au design original. Notamment, le processeur a des registres séparés pour les interruptions.

Sur le Z80, les registres généraux sont dupliqués avec 6 registres pour les interruptions et 6 registres pour les programmes autres. Leur copie pour les interruptions sont nommées B', C', D', E', H', L'. Les 12 registres sont placés dans le banc de registre, ce qui implique que le fenêtrage de registres est utilisé pour gérer la séparation entre registre d'interruption et normaux. Il faut noter que l'accumulateur et le registre d'état sont aussi dupliqués, leurs copies étant nommées A' et F'. Mais leur duplication se fait autrement que par fenêtrage de registre.

En plus des registres précédents, le Z80 incorporait deux registres d'indice nommés X et Y, ainsi qu'un pointeur de pile SP et un ''program counter'' PC. Ils n'étaient pas dupliqués pour les interruptions. Les registres d'indice étaient reliés à une unité de calcul d'adresse. L'unité de calcul d'adresse prenait deux opérandes : un indice, et une adresse mémoire provenant soit du banc de registre, soit de l'accumulateur. En clair, l'unité de calcul d'adresse faisait le lien entre les deux bus internet : le bus de données interne en entrée, le bus d'adresse en sortie.

À l'intérieur du processeur, tous les registres étaient regroupés dans un banc de registre unique, sauf les accumulateurs, les registres d'état et le ''program counter''. Bien que ce ne soit pas indiqué sur le schéma ci-dessous, le ''program counter'' est séparé du banc de registre, alors que le pointeur de pile est dedans. Le compteur IR est lui associé au ''program counter'', il est sortit du banc de registre. Le Z80 utilise lui aussi un incrémenteur séparé de l'ALU, qui est utilisé pour mettre à jour le ''program counter'', le pointeur de pile et un compteur de rafraichissement mémoire nommé IR sur le Z80 (pour rappel, le rafraichissement mémoire demande de balayer la mémoire d'adresse en adresse et été fait par le CPU à l'époque). De plus, il est utilisé pour les instructions INC et DEC qui incrémentent une opérande de 16 bits obtenue en combinant deux registres de 8 bits. En clair, l'incrémenteur du ''program counter'' a été réutilisé de beaucoup de manières originales.

[[File:Z80 arch.svg|centre|vignette|upright=3|Microarchitecture du Z80.]]

Le Z80 incorporait des instructions pour échanger le contenu des deux ensembles de registres, accumulateur inclus. Elles permettaient d'utiliser les registres d'interruption pour les programmes et réciproquement. En clair, cela doublait le nombre de registres si les interruptions n'étaient pas utilisées.
* L'instruction EXX échangeait les deux fenêtres de registres généraux : les registres B, C, D, E, H et L devenaient les registres B', C', D', E', H' et L' et inversement.
* L'instruction EX échangeait l'accumulateur et le registre d'état : les registres A,F devenait A',F' et inversement.

Le fenêtrage de registre était modifié par l'instruction EXX, qui échangeait les deux fenêtres de registres. Pour l'implémenter, une bascule était ajouté au processeur, appelons-la la bascule INT. Elle était relié au bus d'adresse du banc de registre, dont elle mémorisait le bit de poids fort. L'instruction EXX inversait la valeur de la bascule INT. Il est aussi possible d'échanger le contenu des registres D,E et H,L avec une instruction dédiée, ce qui est là encore fait par deux bascules : une pour les registres D,E et une autre pour les registres H,L.

Pour l'accumulateur et le registre d'état, le choix entre registre normal et registre d'interruption se faisait là encore par une seconde bascule appelée la bascule A. La bascule est reliée à un multiplexeur et un démultiplexeur, qui permet de choisir quel accumulateur relier à l'unité de calcul. L'instruction EX inverse le contenu de la bascule A.

&lt;noinclude&gt;
{{NavChapitre | book=Fonctionnement d'un ordinateur
           | prev=L'unité de contrôle
           | prevText=L'unité de contrôle
           | next=Les processeurs 8 bits et moins
           | nextText=Les processeurs 8 bits et moins
}}
&lt;/noinclude&gt;</text>
      <sha1>e47cwmmrstmrrycko4024mwj3ayq5b9</sha1>
    </revision>
    <revision>
      <id>744177</id>
      <parentid>744176</parentid>
      <timestamp>2025-06-05T17:24:53Z</timestamp>
      <contributor>
        <username>Mewtow</username>
        <id>31375</id>
      </contributor>
      <minor />
      <comment>/* Les architectures hybrides registres-accumulateur */</comment>
      <origin>744177</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="41401" sha1="aw6l0rv958lfk8aun8v93i5nr4pijsk" xml:space="preserve">Les architectures que nous avons vu précédemment dans ce cours disposent de registres pour les données, en plus du pointeur de pile, d'un ''program counter'', et de quelques autres. Elles sont appelées des '''architectures à registres''', terme qui trahit bien le fait qu'elles ont des registres généraux ou spécialisés pour stocker temporairement des données. Et si on leur a donné un nom, c'est parce qu'il existe des architectures qui ne sont pas dans cette catégorie. Il en existe plusieurs types, mais ce chapitre va se concentrer sur les '''architectures à accumulateur'''.

[[File:Isaccumulator.png|vignette|Architecture à accumulateur.]]

Les architectures à accumulateur sont centrées autour d'un registre architectural appelé l''''accumulateur'''. Il est utilisé pour toutes les opérations arithmétiques dyadiques, où il sert à la fois de source et de destination. Toutes les instructions dyadiques sont de type ''load-op'' : une opérande est lue depuis l'accumulateur, le second opérande est lu depuis la mémoire RAM, le résultat de l'instruction est automatiquement mémorisé dans l'accumulateur. Les instructions monadiques peuvent utiliser un opérande dans l'accumulateur, ou dans la mémoire RAM, les deux sont théoriquement possibles.

La conséquence est que le nombre d'accès mémoire est drastiquement diminué : de 3 par instructions sur une architecture mémoire-mémoire, on passe à seulement un avec un accumulateur. Les opérations dyadiques ont besoin d'un seul accès mémoire pour lire la seconde opérande, les opérations monadique en font aussi un seul pour lire leur unique opérande.

{|class=&quot;wikitable&quot;
|-
! Classe d'architecture
! Nombre d'accès mémoire par opération dyadique
|-
|-
! Architecture à accumulateur
| Un accès mémoire par instruction, pour lire la seconde opérande
|-
! Architecture à registres
| Zéro si les opérandes sont dans les registres, un pour les opérations ''load-op'', LOAD et STORE.
|}

==Le jeu d'instruction des architectures à accumulateur sans registres d'indice==

L'accumulateur est adressé grâce au mode d'adressage implicite, de même que le résultat de l'opération. Par contre, les autres opérandes sont localisés avec d'autres modes d'adressage, et lues en mémoire RAM. Le résultat ainsi qu'un des opérandes sont adressés de façon implicite car dans l'accumulateur, seule la seconde opérande étant adressée directement. Grâce à l'accumulateur, une instruction ne fait qu'un seul accès mémoire maximum, ce qui rend le processeur très facile à implémenter.

===Les registres des anciennes architectures à accumulateur===

[[File:IBM 701console.jpg|vignette|IBM 701, console extérieure.]]

Les architectures à accumulateur étaient communes dans les années 50-60. A l'époque, les ordinateurs étaient gigantesques, ils prenaient une pièce de bâtiment entière dans le pire des cas, une armoire entière dans le meilleur. Les ordinateurs de l'époque étaient surtout utilisés pour du calcul scientifique ou des tâches d’ingénierie demandant beaucoup de calcul, rarement pour de la compatibilité.

Les nombres flottants n'étaient pas encore apparus. A la place, les ordinateurs de l'époque géraient des nombres entiers de grande taille, de 30 bits ou plus. En conséquence, l'accumulateur faisait facilement 30 à 60 bits. Par exemple, les ordinateurs de la Série scientifique IBM 700/7000 géraient des entiers de 36 bits, l’accumulateur faisait 38 bits : 36 bits plus deux bits pour les débordements. Au passage, de tels processeurs utilisaient l'adressage par mot, et non par byte.

Historiquement, les premières architectures à accumulateur ne contenaient aucun autre registre que l'accumulateur. Ce n'est que dans les années 60 que de nombreuses architectures à accumulateur ont ajouté un second '''registre pour les multiplication/divisions'''. Un exemple est celui de l'IBM 701, qui incorporait un registre accumulateur de 38 bits et un registre multiplieur de 36 bits. Le registre mémorise le multiplieur lors d'une opération de multiplication. Il mémorise donc un opérande, pas le résultat. Il peut aussi décaler le multiplieur vers la droite/gauche, ce qui est utile pour exécuter la multiplication. C'est ce qui est fait sur l'IBM 7094.

Une autre possibilité est que ce registre mémorise une partie du résultat de l'opération. Pour rappel, le résultat d'une multiplication/division est codé sur deux fois de bits que ses opérandes. Par exemple, multipliez deux opérandes de 30 bits, vous obtiendrez un résultat de 60 bits. Les 30 bits de poids faible du résultat vont dans l'accumulateur, les 30 bits de poids fort vont dans ce second registre.

Les architectures à accumulateur parfois un '''registre pour le pointeur de pile''', utilisé pour gérer les fonctions/procédures. Les architectures à accumulateurs supportaient une pile d'adresse de retour, souvent une pile d'appel. Mais pour cela, il fallait mémoriser le pointeur de pile dans le processeur, ce qui demandait un registre dédié.

===L'adressage indirect avec l'accumulateur===

Les instructions LOAD et STORE existent bel et bien sur les architectures à accumulateur, mais n'ont pas les mêmes modes d'adressages. L'instruction LOAD copie une donnée de la RAM vers l'accumulateur, l'instruction STORE copie l'accumulateur dans une adresse. Les deux instructions n'ont pas besoin d'adresser l'accumulateur, qui est adressé de manière implicite, juste de préciser l'adresse à lire/écrire.

Les architectures à accumulateur supportaient souvent le mode d'adressage indirect mémoire. Un exemple est celui des ordinateurs Data General Nova, qui sont des architectures à accumulateur et qui supportaient ce mode d'adressage. Les deux instructions LOAD et STORE existaient en deux versions, distinguées par un bit d'indirection. Si ce bit est à 0 dans l'opcode, alors l'instruction utilise le mode d'adressage absolu normal : l'adresse intégrée dans l'instruction est celle de la donnée. Mais s'il est à 1, alors l'adresse intégrée dans l'instruction est celle du pointeur.

Cependant, la présence de l'accumulateur permettait d'utiliser l'adressage indirect à registre, pour gérer les pointeurs. Pour rappel, avec le mode d'adressage indirect à registre, l'adresse à lire/écrire est dans un registre. Ici, l'adresse à lire/écrire est prise dans l'accumulateur, seul registre disponible pour. L'adressage indirect est plus simple à implémenter pour l'instruction LOAD, car elle prend un seul opérande : l'adresse à lire. L'adresse à lire est placée dans l'accumulateur, la donnée lue est elle aussi chargée dans l'accumulateur. Pour l'instruction STORE, il faut fournir deux opérandes, l'adresse et la donnée à écrire, ce qui peut poser problème. Mais au pire, il est toujours possible d'utiliser l'adressage absolu ou indirect mémoire : l'adresse est dans l'instruction, la donnée à écrire dans l'accumulateur.

===L'encodage des instructions===

Sur une architecture à accumulateur l'encodage d'une instruction dyadique est assez simple, vu que l'accumulateur est adressé implicitement. La seconde opérande est localisée soit par une adresse mémoire (adressage absolu), soit est une constante (adressage immédiat). L'adresse mémoire est généralement assez longue, plus que l'opcode.

{|class=&quot;wikitable&quot;
|+ Encodage d'une instruction dyadique
|-
! rowspan=&quot;2&quot; | Opcode 
| Adresse mémoire (adressage absolu)
|-
| Constante (adressage immédiat)
|}

L'encodage d'une instruction monadique est similaire. Si l'opérande est lue depuis la mémoire RAM, alors l'instruction est encodée comme une instruction dyadique. Il en est de même pour les instructions qui copient une constante dans l'accumulateur. Par contre, si l'opérande est dans l'accumulateur, alors il y a juste besoin d'encoder l'opcode. La majorité des instructions a besoin de préciser une adresse, rares sont celles qui s'en passent. Au vu de cet encodage, les architectures à accumulateur sont qualifiées d''''architectures à une adresse''' par abus de langage.

Il est intéressant de contraster leur encodage avec les architectures à registres. Les architectures à registre doivent encoder deux opérandes en plus de l'opcode, avec éventuellement où enregistrer le résultat sur les architectures 3-adresses. Par contre, les opérandes sont généralement des noms de registre, ce qui prend moins de place qu'une adresse mémoire. A la rigueur, les instructions avec une constante immédiate prennent un peu plus de place, car elles doivent encoder un nom de registre en plus de la constante et de l'opcode. Les instructions ''load-op'' des processeurs CISC sont un peu dans le même cas, sauf qu'il faut remplacer la constante par une adresse, qui a généralement la même taille. Les instructions sont donc en moyenne plus courte sur les processeurs à registre, du fait de la présence de registres.

===Annexe : les toutes premières architectures à accumulateur : le Manchester Baby===

[[File:BabyArchitecture.png|vignette|Architecture de la Manchester Baby.]]

Les architectures à accumulateurs sont apparues dès les débuts de l'informatique. Le tout premier ordinateur à programme enregistré en mémoire, le ''Manchester Baby'', était une architecture à accumulateur. Niveau interface, l'ordinateur avait une console avec 32 boutons, des interrupteurs et un écran de sortie sur lequel afficher les résultats. A l'intérieur, il y avait un processeur et une RAM de 32 adresses, fabriquée avec des tubes Williams (abordés dans une annexe à la fin du cours). Chaque adresse mémorisait 32 bits, qui pouvaient encoder soit un nombre, soit une instruction.

Le programme devait tenir dans la RAM, avec une instruction par adresse maximum, ce qui limitait les programmes à 32 instructions maximum. Une instruction prenait donc 32 bits, 3 indiquaient quelle opération utiliser, 12  bits d'adresse servait à indiquer où se trouvent la seconde opérande en RAM, les 16 restants sont inutilisés. En théorie, les 12 bits d'adresse permettaient d'adresser 4096 adresses, mais seules 32 étaient réellement présentes.

Le processeur avait un registre accumulateur de 32 bits, un ''program counter'' et un registre d'instruction. Il intégrait un additionneur dédié au ''program counter'', mais l'ALU n'avait pas d'additionneur. En conséquence, il ne gérait pas l'addition. A la place, il gérait la soustraction. Il pouvait cependant émuler l'addition à partir d'une soustraction. La soustraction était utilisée pour calculer le complément d'une opérande, et soustraire le complément revient à additionner. L'ALU était une ALU sérielle, à savoir qu'elle faisait les soustractions bit par bit.

Le processeur supportait 7 instructions au total : la soustraction, des instructions de branchement et d'accès mémoire, rien d'autre. Les instructions de branchement utilisaient des modes d'adressage très particuliers, qu'on ne retrouve pas sur les ordinateurs modernes. Les branchements inconditionnels utilisaient une forme d'adressage mémoire indirect, pas les adressages usuels pour les branchements. Il n'y avait pas de branchements conditionnels, mais une ''SKIP instruction''.

{|class=&quot;wikitable&quot;
|-
! SUB 
| Soustrait l'opérande mémoire de l'accumulateur.
|-
! CMP
| Skippe l'instruction suivante si l'accumulateur a une valeur négative.
|-
! JMP
| Branchement indirect mémoire. :
* L'adresse de destination est lue depuis la mémoire.
* L'adresse lue est intégrée dans l'instruction via adressage absolu.
|-
! JRP
| Branchement relatif indirect.
* Lit une opérande depuis la mémoire, l'adresse est intégrée dans l'instruction via adressage absolu.
* Additionne l'opérande lue au ''program counter''.
|-
! LDN
| Instruction LOAD. La donnée lue est inversée lors de la lecture, l'accumulateur contient le complément à deux de la donnée lue après la lecture.
|-
! STO
| Instruction STORE
|-
! STOP
| Éteint l'ordinateur.
|}

Le Manchester Mark 1 était une amélioration du Manchester Baby. Il utilisait 4500 tubes à vide. Le Manchester Baby était un prototype, mais il avait été pensé pour être étendu, notamment afin d'avoir plus de mémoire. C'est pour cela que ses adresses étaient codées sur 12 bits, malgré sa mémoire de seulement 32 mots. Le plan initial, à savoir utiliser une RAM de 4096 mots, a cependant été abandonné pour la Manchester Mark 1. A la place, la RAM a gardé la même taille, à savoir 32 nombres, mais a été complémentée par l’ancêtre du disque dur magnétique, à savoir un tambour magnétique. Le tambour magnétique contenait 40 pages, chacune ayant la même taille que la RAM.

L'ordinateur gérait des nombres de 40 bits, mais les instructions étaient codées sur 20 bits. Le processeur gérait maintenant l'addition et quelques opérations logiques (ET et OU), en plus de la soustraction et de la comparaison. De plus, il intégrait deux registres dédiés aux multiplications : un pour le multiplicande, un autre pour le multiplieur. Ils étaient nommés D et R et étaient regroupés dans un seul tube Williams noté M. Cependant, les multiplications étaient réalisées en enchainant une série d'additions, dans l'additionneur-soustracteur. 

C'était là encore une architecture à accumulateur, sauf qu'elle intégrait aussi des registres d'indice. Les registres d'indices étaient au nom de deux et étaient notés B0 et B1. Lors du chargement d'une instruction, un registre d'indice était sélectionné grâce à un bit de l'instruction. Le contenu de ce registre d'indice était additionné à l'instruction , l'adresse encodée dedans pour être précis, et le résultat était envoyé sur le bus mémoire.

La microarchitecture de la machine est illustrée ci-dessous. Elle a une ALU unique capable de faire plusieurs opérations, qui sont représentées dans des rectangles séparés. Les cercles dans le schéma suivant sont des tubes Williams, des écrans CRT modifiés de manière à servir de mémoire DRAM, dont le fonctionnement est détaillée dans le chapitre sur les mémoires historiques. Un tube Williams implémente un banc de registre complet, c'est à dire un groupe de 2 à 10, registres. L'accumulateur est noté A, les deux registres de multiplication sont regroupés dans le tube Williams M, les registres d'indice sont dans le tube noté B. Le tube Williams C regroupe le ''program counter'' et le registre d'instruction. L'additionneur sert à incrémenter le ''program counter'', mais aussi pour les branchements relatifs. La statistation est le nom donné au séquenceur, à l'unité de contrôle, décodeur d'instruction inclus.

[[File:MM1Schematic French.svg|centre|vignette|upright=2.5|Architecture de la Manchester Mark 1.]]

==La micro-architecture des architectures à accumulateur sans registres d'indice==

L'organisation interne d'une architecture à accumulateur est très différente de celle des processeurs à registre. Elle est plus ou moins la même pour tous ces processeurs, le point important étant que le chemin de données se résume à une ALU, un registre accumulateur et le bus de données. L'ALU est reliée au registre accumulateur, ainsi qu'au bus de données pour lire la seconde opérande, comme illustré ci-dessous.

[[File:Accumulator.png|centre|vignette|upright=2|Accumulateur.]]

===L'unité de calcul et l'accumulateur===

Pour simplifier l'implémentation, le résultat est mémorisé dans un registre en sortie de l'unité de calcul. La raison est qu'on ne veut pas altérer l'accumulateur tant que le résultat final n'est pas totalement calculé. Rappelons que l'ALU ne fournit pas un résultat d'un seul bloc, mais que certains bits arrivent avant les autres, typiquement les bits de poids faible. Si le résultat était écrit dans l'accumulateur directement, il écraserait des bits de l’opérande en cours d'utilisation, ce qui fausserait le résultat.

[[File:Accumulateur avec registre de sortie.png|centre|vignette|upright=2|Accumulateur avec registre de sortie]]

Une autre solution utilisait un registre entre l'accumulateur et l'unité de calcul, appelé l’'''''accumulator latch'''''. Il remplace le registre en sortie de l'ALU, dans le sens où il permet d'écrire dans l'accumulateur sans effacer l'opérande, pendant que l’opération est en cours dans l'ALU. L'accumulateur est copié dans l’''accumulator latch'', avant que l'ALU démarre ses calculs. L'opérande est donc maintenue même si on commence à écrire le résultat dans l'accumulateur.

Sur le 8085 d'Intel, l’''accumulator latch'' peut être initialisé avec une constante prédéfinie, ce qui permet d'implémenter certaines instructions très facilement. Par exemple, il peut être initialisé à 0, ce qui permet d'implémenter les instructions MOV et INC (incrémentation). Un MOV est équivalent à faire un OU entre le registre lu et 0. Une instruction INC initialise l'entrée de retenue de l'unité de calcul à 1, puis ajoute 0. La décrémentation est implémentée de la même manière, sauf que l’''accumulator latch'' est initialisé à -2 pour compenser l'entrée de retenue à 1. De plus, pour supporter les conversion de décimal à BCD, l’''accumulator latch'' peut être initialisé avec les constantes 0x00, 0x06, 0x60, or 0x66. L'''accumulator latch'' est relié à divers fils de commande provenant de l'unité de contrôle, qui décide quelle valeur d'initialisation utiliser en fonction de l'instruction décodée.

[[File:Accumulator latch.png|centre|vignette|upright=2|Accumulator latch]]

[[File:Chemin de données à un seul bus.png|vignette|Chemin de données à un seul bus]]

De même, la seconde opérande, celle lue sur le bus de données, est mémorisée dans un registre en amont de l'ALU. C'était notamment très utile si le processeur utilisait une ALU plus courte que les opérandes, avec par exemple une ALU 4 bits pour un CPU 8 bits. Les anciens processeurs à accumulateur de type ''mainframe'' utilisaient des opérandes de grande taille, du genre 36 ou 48 bits, ce qui avait des conséquences sur l'unité de calcul utilisée, ainsi que sur la communication avec la mémoire. Il arrivait que de tels processeurs utilisaient des ALU sérielles, ou du moins octet-sérielles, plutôt qu'une véritable ALU 36 bits. Nous verrons aussi que c'est très utile sur les processeurs à accumulateur avec un bus interne unique, dans la suite du chapitre.

===La micro-architecture des architectures à accumulateur avec instructions LOAD/STORE===

Nous venons de voir comment est implémenté l'unité de calcul et l'accumulateur, et comment le tout est relié au bus de données. Mais cela ne permet que d'avoir un processeur à accumulateur rudimentaire, qui ne gére que des instructions arithmétiques et logiques. Il faut aussi gérer le cas des opérations LOAD/STORE et des modes d'adressages associés, mais c'est le séquenceur qui s'en occupe. Avec l'adressage absolu, les instructions LOAD et STORE ne font que connecter l'accumulateur au bus de données. L'instruction STORE nécessite de connecter l'accumulateur au bus de données, de manière à ce que le transfert des données se fasse de l'accumulateur vers le bus de données. L'instruction LOAD s'implémente de la même manière, sauf que le sens de transfert est inversé.

Cependant, il existe une optimisation qui permet d'implémenter l'instruction LOAD sans ajouter de circuits. Pour cela, il suffit que l'unité de calcul gére les opérations ''pass through'', à savoir des opérations qui se contentent de recopier un opérande sur la sortie. Ici, l'idée est de recopier l'opérande provenant du bus de données.

[[File:Architecture à accumulateur, microarchitecture.png|centre|vignette|upright=2|Architecture à accumulateur, microarchitecture]]

Pour gérer nativement l'adressage indirect à registre, il suffit de connecter l'accumulateur au bus d'adresse. Le plus simple est d'ajouter un multiplexeur, comme illustré ci-dessous. La donnée lue est copiée dans l'accumulateur, ce qui fait qu'il vaut mieux utiliser un registre d’interfaçage, l'accumulateur n'étant pas utilisable à la fois pour le bus d'adresse et de données.

[[File:Adressage indirect sur une architecture à accumulateur.png|centre|vignette|upright=2|Adressage indirect sur une architecture à accumulateur]]

Pour finir, voyons comment le pointeur de pile et le ''program counter'' sont implémentés. Les architectures à accumulateur ont souvent des adresses de taille différente des données, ce qui fait qu'il vaut mieux utiliser un circuit incrémenteur dédié pour incrémenter le ''program counter'', plutôt que de l'incrémenter via l'unité de calcul. Les architectures à accumulateur ont parfois un pointeur de pile, qui gère une pile d'adresse de retour, pas une vraie pile d'appel. Aussi, le pointeur de pile est censé être incrémenté et décrémenté, pas plus. Pas d'addition ou de soustraction pour gérer des cadres de pile. Là encore, c'est la solution de l'incrémenteur séparé qui est retenue. Pour économiser des transistors, il n'y a qu'un seul incrémenteur partagé pour les deux.

==Les architectures à accumulateur à registres d'indice==

Les architectures à accumulateur décrites dans la section précédente sont capables de faire de l'adressage indirect, mais n'incluent pas les modes d'adressage base + indice et absolus indicés, qui prennent une adresse et y ajoute un indice. Il s'agit des toutes premières architectures à accumulateur, comme les premiers ordinateurs IBM ou le fameux PDP-8. Mais par la suite, les processeurs à accumulateurs ont inclus un support des modes d'adressages indicés, grâce à des '''registres d'indice'''.

===Les registres d'indice===

Les registres d'indice stockent des indices de tableaux. Ils permettaient de supporter deux modes d'adressage :
* Le '''mode d'adressage absolu indicé''' où une adresse fixe est additionnée à un indice variable. L'adresse fixe est intégrée dans l'instruction (adressage absolu), l'indice est dans un registre d'indice.
* Le '''mode d'adressage base + indice''', où l'adresse est dans l'accumulateur et l'indice dans le registre d'indice.

Les processeurs à accumulateur supportaient souvent des variantes des modes d'adressage précédents, où le registre d'indice était automatiquement incrémenté ou décrémenté à chaque utilisation.

Au départ, ces processeurs n'utilisaient qu'un seul registre d'indice qui se comportait comme un second accumulateur spécialisé dans les calculs d'adresses mémoire. Le processeur supportait de nouvelles instructions qui utilisaient ce registre d'indice de façon implicite. Mais avec le temps, les processeurs finirent par incorporer plusieurs de ces registres. Les instructions de lecture ou d'écriture devaient alors préciser quel registre d'indice utiliser, en précisant un nom de registre d'indice, un numéro de registre d'indice.

Il faut préciser que les registres d'indice ont une taille bien plus petite que l'accumulateur. Ils mémorisent des indices codés sur 16 bits ou moins, alors que l'accumulateur faisait typiquement 36 à 48 bits, parfois plus. La taille classique sur les anciens ''mainframes'' était de 15 bits, parfois moins. Il n'était pas rare de tomber sur des registres d'indice de 8 ou 9 bits. Leur petite taille rendait leur implémentation matérielle peu couteuse. Et c'est ce qui explique qu'ils étaient préférés à l'usage d'un second accumulateur.

Un exemple est le cas du processeur Motorola 6809, un processeur à accumulateur qui contient deux registres d'indices nommés X et Y. L'accumulateur est noté D et fait 16 bits, il peut être parfois géré comme deux accumulateurs séparés A et B de 8 bits chacun. Il contenait aussi deux pointeurs de pile, l'un pour les programmes, l'autre pour le système d'exploitation, ainsi qu'un ''program counter''. Le registre de page était utilisé pour l'adressage absolu, comme vu dans le chapitre sur les modes d'adressage.

[[File:6809 Internal Registers.svg|centre|vignette|upright=2|6809 Internal Registers]]

Les processeurs IBM avaient autrefois plusieurs registres d'indice. Par exemple, l'IBM 704 avait trois registres d'indice de 15 bits. Leur contenu était soustrait de l'adresse absolue. Une instruction pouvait utiliser plusieurs registres d'indice pour adresser son opérande. Toute instruction utilisait trois bits pour sélectionner les registres d'indice utilisés. Fait assez original, lorsque plusieurs registres d'indice sont sélectionnés, le processeur n'additionne pas les trois registres à l'adresse de base. À la place, il fait un OU bit à bit entre les registres d'indice sélectionnés, et additionne le résultat à l'adresse.

Les processeurs IBM à accumulateur ont fait ça sur toute la gamme IBM 700/7000, pour des raisons de compatibilité. Les processeurs suivants avaient 7 registres d'indices, mais conservaient les trois bits pour adresser les registres d'indices. Ils pouvaient fonctionner dans deux modes. Le premier mode est plus intuitif : les trois bits précisent un registre d'indice parmi les 7, qui est additionné avec l'adresse absolue. La valeur zéro indique qu'aucun registre d'indice n'est utilisé, ce qui explique qu'il y a 7 registres d'indice et non 8. Un second mode, compatible avec l'IBM 704, fait un OU logique entre les registres d'indice sélectionnés. Seuls les trois premiers registres d'indices peuvent être sélectionnés dans ce mode. Il y a deux instructions pour changer de mode : une pour passer en mode compatible, l'autre pour le quitter pour l'autre mode.

Quelques rares processeurs à registres généraux ont utilisés des registres d'indice, en plus des registres généraux. Ce qui fait l'association que nous avons faite entre registres d'indice et architectures à accumulateur est imparfait, bien que solide sur le principe. Un exemple d'architecture de ce type sont les architectures de la série UNIVAC 1100/2200. Ils disposaient de 128 registres, qui étaient mappés en mémoire à partir de l'adresse mémoire 0, la majorité étant inaccessibles par le programmeur. Ils regroupaient 12 registres accumulateurs, 11 registres d'indice et 4 registres hybrides qui pouvaient servir soit de registre d'indice, soit de registres accumulateurs.

===La micro-architecture des architectures à accumulateur avec registres d'indice===

La présence de registres d'indice modifie grandement l'implémentation du processeur. En effet, il faut rajouter un banc de registre pour les registres d'indice. Le banc de registre est monoport, car on a besoin de lire ou d'écrire un indice à la fois. Et il faut aussi potentiellement rajouter de quoi faire les calculs d'adresse. Deux solutions sont possibles : une ALU dédiée aux calculs d'adresse, une seule ALU pour toutes les opérations.

Dans le premier cas, il y a une ALU séparée associée aux registres d'indice. L'ALU et les registres d'indice sont placés en sortie du séquenceur, en-dehors du chemin de données, la sortie de l'ALU est directement connectée au bus d'adresse. L'unité de calcul d'adresse peut être utilisée pour incrémenter le ''program counter''. Un défaut de cette approche est qu'elle ne gère pas l'adresse indirect à registre.

[[File:Chemin de données sans support des pointeurs, avec adressage absolu indicé.png|centre|vignette|upright=2|Chemin de données sans support des pointeurs, avec adressage absolu indicé]]

Une autre option utilise un bus interne, qui interconnecte tout le chemin de données. Dans sa version la plus simple, il est relié à l'accumulateur, l'unité de calcul, le banc de registre d'indice et le bus de données. Avec cette solution, l'ALU est utilisé à la fois pour calculer les adresses et pour les instructions de calcul. En reliant le bus interne au bus d'adresse à travers un multiplexeur, on gère naturellement les adressages indirects.

[[File:Architecture à accumulateur avec registres associés.png|centre|vignette|upright=2.5|Architecture à accumulateur avec registres associés]]

Il faut noter que sur les architectures Von Neumann, le séquenceur est relié à ce bus interne. En effet, charger une instruction demande de passer par le bus mémoire, donc par l’intermédiaire de ce bus internet. Le ''program counter'' est envoyé sur ce bus pour lire l'instruction, puis l'instruction lue est recopiée dans le registre d'instruction. Le chargement d'une instruction est donc géré comme une lecture des plus classiques. De plus, cela permet d'incrémenter le ''program counter'' au niveau de l'unité de calcul entière. Le ''program counter'' est envoyé sur le bus interne, incrémenté par l'ALU, puis le résultat est recopié dans le ''program counter'' via le bus interne.

[[File:Architecture à accumulateur avec bus unique de type Von Neumann.png|centre|vignette|upright=2|Architecture à accumulateur avec bus unique de type Von Neumann]]

==Les processeurs bi-accumulateurs : le Motorola 6800==

Le Motorola 6800 était un processeur 8 bits qui gérait des adresses de 16 bits. Il contenait deux accumulateurs nommés A et B, de 8 bits chacun. Il disposait aussi d'un registre d'indice, d'un pointeur de pile et d'un ''program counter'', tous les trois de 16 bits. Le registre d'état regroupait 6 bits, qu'on ne détaillera pas ici.

[[File:MC6800 Processor Diagram.png|centre|vignette|upright=2|Interface et registres du MC6800.]]

La présence des deux accumulateurs impactait surtout les instructions dyadiques. Les instructions monadiques avaient juste à préciser où se trouvait l'opérande : soit en RAM, soit dans le premier accumulateur, soit dans le second. Pour les opérations dyadiques, la gestion était totalement différente. En théorie, le premier opérande est dans un accumulateur, soit A, soit B. La seconde opérande vient soit de l'autre accumulateur, soit de la mémoire RAM. Et selon les instructions, tout variait.

Pour l'addition, il y avait trois instructions. Les deux premières additionnaient un opérande provenant de la mémoire avec un accumulateur. L'instruction ADDA sélectionnait le premier accumulateur, l'instruction ADDB sélectionnait le second accumulateur. Mais une troisième instruction, l’instruction ABA, permettait d'additionner le contenu des deux accumulateurs.

Pour les autres opérations, il n'était pas possible d'utiliser les deux accumulateurs en même temps. La seule possibilité était de faire une opération entre un accumulateur et un opérande venant de la mémoire. Toutes les instructions étaient en double, avec une copie par accumulateur. Par exemple, l'instruction ANDA faisait un ET entre l’accumulateur A et l'opérande mémoire, l'instruction ANDB faisait pareil avec l'accumulateur B.

==Les architectures hybrides registres-accumulateur==

Il a existé quelques architectures qui étaient des hybrides entre architectures à accumulateur et architecture à registre. Elles sont apparues assez tôt, dès les années 50. Par exemple, le Bull Gamma 3 était un ordinateur de type ''mainframe'' qui disposait d'un accumulateur accompagné de registres généraux. Et c'était à une époque où les ordinateurs étaient intégralement construits avec des tubes à vides et autres mémoires spécialisées. Mais ces architectures sont restées assez confidentielles pendant les années 50 à 80. Par la suite, elles ont eu un regain de popularité durant les années 80-90. Elles ont alors servit de transition entre architectures à accumulateur proprement dites, et architectures à registres.

Elles avaient un accumulateur unique couplé à un banc de registres généraux. Par exemple, les processeurs Intel 8 bits disposaient de 7 registres de 8 bits nommés A, B, C, D, E, F, H, L, SP. Ils correspondent respectivement à :
* l'accumulateur A ;
* six registres nommés B, C, D, E, H et L ;
* le registre d'état F ;
* le pointeur de pile SP.

Sur ces processeurs, les instructions dyadiques devaient mettre leur premier opérande dans l'accumulateur, la seconde provenait soit des registres, soit de la RAM, soit d'une constante immédiate. Les opérations monadiques pouvaient lire leur opérande depuis l'accumulateur, les autres registres ou la RAM, tout était permis. Les registres d'indices disparaissaient sur ces architectures, en théorie. Les registres généraux pouvaient être utilisés comme registre d'indice ou pour stocker des opérandes, ils étaient assez versatiles pour servir de registres d'indices.

La présence de registres a de nombreux avantages, comparé aux architectures à accumulateur pures. Les instructions arithmétiques sont plus rapide, lire un registre étant plus rapide qu'un accès RAM. Les performances sont donc augmentées. De plus, les instructions arithmétiques utilisant ces registres sont plus courtes : pas besoin d'encoder une adresse mémoire, un nom de registre suffit. Vu que les processeurs de l’époque avaient des instructions de taille variable, cela améliorait la densité de code.

===La micro-architecture des processeurs hybrides registres-accumulateur===

La micro-architecture de ces processeurs est très similaire à celle d'un processeur avec des registres d'indices. La seule différence est que le banc de registre contient des registres généraux et non des registres d'indices. Le banc de registre est systématiquement monoport, car il n'avait aucune raison d'être multiport. Pour les instructions dyadiques, seules à lire deux opérandes, il ne servait que pour la seconde opérande, la première était lue depuis l'accumulateur.

Les processeurs hybrides registre-accumulateur se classent en deux types principaux : ceux qui ont un seul bus interne, et ceux qui en ont deux. Le premier cas est identique à celui vu précédemment pour les architectures à accumulateur avec registres d'indice, à la seule différence est que le banc de registre contient des registres généraux et non des registres d'indices. Afin de gérer l'adressage indirect à registre, le bus interne est connecté aux deux registres d’interfaçage mémoire.

[[File:Architecture à accumulateur avec bus unique de type Von Neumann.png|centre|vignette|upright=2|Architecture à accumulateur avec bus unique de type Von Neumann]]

Notons que cela permet aussi d'implémenter facilement les branchements indirects, car le bus interne permet d'échanger des adresses entre ''program counter'' et banc de registre. De même, il est possible d'utiliser l'ALU pour gérer les branchements indirects., en plus de l'utiliser pour incrémenter le ''program counter''.

[[File:Single bus organization.jpg|centre|vignette|upright=2|Single bus organization]]

Une autre solution utilisait deux bus internes : un connecté au bus de données, un autre relié au bus d'adresse. Le bus de commande mémoire était lui commandé par le séquenceur, l'unité de contrôle. L'intermédiaire entre ces deux bus était le banc de registre, ainsi que les autres registres. Le banc de registre était connecté aux deux bus interne, avec un port de lecture relié au bus d'adresse, un port de lecture-écriture relié au bus de données. Le port de lecture était utilisé pour l'adressage indirect, l'autre l'était pour le reste.

[[File:Proz1-e.png|centre|vignette|upright=2|Intérieur d'un processeur.]]

L'organisation à deux bus simplifiait la gestion du ''program counter'' et le chargement des instructions. Le ''program counter'' était soit séparé du banc de registre, soit placé dans le banc de registre. Les deux solutions étaient utilisés, tout dépend du processeur. Il faut noter que si le ''program counter'' est intégré au banc de registres, alors la microarchitecture du processeur est bien plus simple. L'envoi du ''program counter'' sur le bus d'adresse utilise le port de lecture relié au bus d'adresse, qui sert aussi pour l'adressage indirect. L'économie de circuits, sans compter la simplicité d'implémentation que cela implique, explique sans doute que la technique a été utilisée sur quelques processeurs anciens.

Le ''program counter'' était généralement incrémenté par l'ALU, ce qui explique qu'il soit connecté au bus interne pour les données. La connexion est aussi utile pour gérer les branchements indirects, qui copient un registre dans le ''program counter'', ainsi que les branchements relatifs (addition dans l'ALU), voire les branchements directs (l'adresse vers laquelle brancher est envoyée en entrée de l'ALU et propagée en sortie avec une opération ''pass through'').

[[File:Connexion du program counter sur les bus avec PC dans le banc de registres.png|centre|vignette|upright=2|Connexion du program counter sur les bus avec PC dans le banc de registres]]

===Les registres d'interruption avec un processeur hybride-accumulateur : l'exemple du Z80===

Un exemple de processeur registre-accumulateur à deux bus interne est le Z80, un processeur fortement inspiré des CPU Intel 8 bits. Il a un jeu d'instruction similaire, mais a diverses améliorations par rapport au design original. Notamment, le processeur a des registres séparés pour les interruptions.

Sur le Z80, les registres généraux sont dupliqués avec 6 registres pour les interruptions et 6 registres pour les programmes autres. Leur copie pour les interruptions sont nommées B', C', D', E', H', L'. Les 12 registres sont placés dans le banc de registre, ce qui implique que le fenêtrage de registres est utilisé pour gérer la séparation entre registre d'interruption et normaux. Il faut noter que l'accumulateur et le registre d'état sont aussi dupliqués, leurs copies étant nommées A' et F'. Mais leur duplication se fait autrement que par fenêtrage de registre.

En plus des registres précédents, le Z80 incorporait deux registres d'indice nommés X et Y, ainsi qu'un pointeur de pile SP et un ''program counter'' PC. Ils n'étaient pas dupliqués pour les interruptions. Les registres d'indice étaient reliés à une unité de calcul d'adresse. L'unité de calcul d'adresse prenait deux opérandes : un indice, et une adresse mémoire provenant soit du banc de registre, soit de l'accumulateur. En clair, l'unité de calcul d'adresse faisait le lien entre les deux bus internet : le bus de données interne en entrée, le bus d'adresse en sortie.

À l'intérieur du processeur, tous les registres étaient regroupés dans un banc de registre unique, sauf les accumulateurs, les registres d'état et le ''program counter''. Bien que ce ne soit pas indiqué sur le schéma ci-dessous, le ''program counter'' est séparé du banc de registre, alors que le pointeur de pile est dedans. Le compteur IR est lui associé au ''program counter'', il est sortit du banc de registre. Le Z80 utilise lui aussi un incrémenteur séparé de l'ALU, qui est utilisé pour mettre à jour le ''program counter'', le pointeur de pile et un compteur de rafraichissement mémoire nommé IR sur le Z80 (pour rappel, le rafraichissement mémoire demande de balayer la mémoire d'adresse en adresse et été fait par le CPU à l'époque). De plus, il est utilisé pour les instructions INC et DEC qui incrémentent une opérande de 16 bits obtenue en combinant deux registres de 8 bits. En clair, l'incrémenteur du ''program counter'' a été réutilisé de beaucoup de manières originales.

[[File:Z80 arch.svg|centre|vignette|upright=3|Microarchitecture du Z80.]]

Le Z80 incorporait des instructions pour échanger le contenu des deux ensembles de registres, accumulateur inclus. Elles permettaient d'utiliser les registres d'interruption pour les programmes et réciproquement. En clair, cela doublait le nombre de registres si les interruptions n'étaient pas utilisées.
* L'instruction EXX échangeait les deux fenêtres de registres généraux : les registres B, C, D, E, H et L devenaient les registres B', C', D', E', H' et L' et inversement.
* L'instruction EX échangeait l'accumulateur et le registre d'état : les registres A,F devenait A',F' et inversement.

Le fenêtrage de registre était modifié par l'instruction EXX, qui échangeait les deux fenêtres de registres. Pour l'implémenter, une bascule était ajouté au processeur, appelons-la la bascule INT. Elle était relié au bus d'adresse du banc de registre, dont elle mémorisait le bit de poids fort. L'instruction EXX inversait la valeur de la bascule INT. Il est aussi possible d'échanger le contenu des registres D,E et H,L avec une instruction dédiée, ce qui est là encore fait par deux bascules : une pour les registres D,E et une autre pour les registres H,L.

Pour l'accumulateur et le registre d'état, le choix entre registre normal et registre d'interruption se faisait là encore par une seconde bascule appelée la bascule A. La bascule est reliée à un multiplexeur et un démultiplexeur, qui permet de choisir quel accumulateur relier à l'unité de calcul. L'instruction EX inverse le contenu de la bascule A.

&lt;noinclude&gt;
{{NavChapitre | book=Fonctionnement d'un ordinateur
           | prev=L'unité de contrôle
           | prevText=L'unité de contrôle
           | next=Les processeurs 8 bits et moins
           | nextText=Les processeurs 8 bits et moins
}}
&lt;/noinclude&gt;</text>
      <sha1>aw6l0rv958lfk8aun8v93i5nr4pijsk</sha1>
    </revision>
    <revision>
      <id>744179</id>
      <parentid>744177</parentid>
      <timestamp>2025-06-05T17:43:32Z</timestamp>
      <contributor>
        <username>Mewtow</username>
        <id>31375</id>
      </contributor>
      <minor />
      <comment>/* Les architectures hybrides registres-accumulateur */</comment>
      <origin>744179</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="41731" sha1="hjcrof2knyzbju4xvjy6hxg9kbc5r35" xml:space="preserve">Les architectures que nous avons vu précédemment dans ce cours disposent de registres pour les données, en plus du pointeur de pile, d'un ''program counter'', et de quelques autres. Elles sont appelées des '''architectures à registres''', terme qui trahit bien le fait qu'elles ont des registres généraux ou spécialisés pour stocker temporairement des données. Et si on leur a donné un nom, c'est parce qu'il existe des architectures qui ne sont pas dans cette catégorie. Il en existe plusieurs types, mais ce chapitre va se concentrer sur les '''architectures à accumulateur'''.

[[File:Isaccumulator.png|vignette|Architecture à accumulateur.]]

Les architectures à accumulateur sont centrées autour d'un registre architectural appelé l''''accumulateur'''. Il est utilisé pour toutes les opérations arithmétiques dyadiques, où il sert à la fois de source et de destination. Toutes les instructions dyadiques sont de type ''load-op'' : une opérande est lue depuis l'accumulateur, le second opérande est lu depuis la mémoire RAM, le résultat de l'instruction est automatiquement mémorisé dans l'accumulateur. Les instructions monadiques peuvent utiliser un opérande dans l'accumulateur, ou dans la mémoire RAM, les deux sont théoriquement possibles.

La conséquence est que le nombre d'accès mémoire est drastiquement diminué : de 3 par instructions sur une architecture mémoire-mémoire, on passe à seulement un avec un accumulateur. Les opérations dyadiques ont besoin d'un seul accès mémoire pour lire la seconde opérande, les opérations monadique en font aussi un seul pour lire leur unique opérande.

{|class=&quot;wikitable&quot;
|-
! Classe d'architecture
! Nombre d'accès mémoire par opération dyadique
|-
|-
! Architecture à accumulateur
| Un accès mémoire par instruction, pour lire la seconde opérande
|-
! Architecture à registres
| Zéro si les opérandes sont dans les registres, un pour les opérations ''load-op'', LOAD et STORE.
|}

==Le jeu d'instruction des architectures à accumulateur sans registres d'indice==

L'accumulateur est adressé grâce au mode d'adressage implicite, de même que le résultat de l'opération. Par contre, les autres opérandes sont localisés avec d'autres modes d'adressage, et lues en mémoire RAM. Le résultat ainsi qu'un des opérandes sont adressés de façon implicite car dans l'accumulateur, seule la seconde opérande étant adressée directement. Grâce à l'accumulateur, une instruction ne fait qu'un seul accès mémoire maximum, ce qui rend le processeur très facile à implémenter.

===Les registres des anciennes architectures à accumulateur===

[[File:IBM 701console.jpg|vignette|IBM 701, console extérieure.]]

Les architectures à accumulateur étaient communes dans les années 50-60. A l'époque, les ordinateurs étaient gigantesques, ils prenaient une pièce de bâtiment entière dans le pire des cas, une armoire entière dans le meilleur. Les ordinateurs de l'époque étaient surtout utilisés pour du calcul scientifique ou des tâches d’ingénierie demandant beaucoup de calcul, rarement pour de la compatibilité.

Les nombres flottants n'étaient pas encore apparus. A la place, les ordinateurs de l'époque géraient des nombres entiers de grande taille, de 30 bits ou plus. En conséquence, l'accumulateur faisait facilement 30 à 60 bits. Par exemple, les ordinateurs de la Série scientifique IBM 700/7000 géraient des entiers de 36 bits, l’accumulateur faisait 38 bits : 36 bits plus deux bits pour les débordements. Au passage, de tels processeurs utilisaient l'adressage par mot, et non par byte.

Historiquement, les premières architectures à accumulateur ne contenaient aucun autre registre que l'accumulateur. Ce n'est que dans les années 60 que de nombreuses architectures à accumulateur ont ajouté un second '''registre pour les multiplication/divisions'''. Un exemple est celui de l'IBM 701, qui incorporait un registre accumulateur de 38 bits et un registre multiplieur de 36 bits. Le registre mémorise le multiplieur lors d'une opération de multiplication. Il mémorise donc un opérande, pas le résultat. Il peut aussi décaler le multiplieur vers la droite/gauche, ce qui est utile pour exécuter la multiplication. C'est ce qui est fait sur l'IBM 7094.

Une autre possibilité est que ce registre mémorise une partie du résultat de l'opération. Pour rappel, le résultat d'une multiplication/division est codé sur deux fois de bits que ses opérandes. Par exemple, multipliez deux opérandes de 30 bits, vous obtiendrez un résultat de 60 bits. Les 30 bits de poids faible du résultat vont dans l'accumulateur, les 30 bits de poids fort vont dans ce second registre.

Les architectures à accumulateur parfois un '''registre pour le pointeur de pile''', utilisé pour gérer les fonctions/procédures. Les architectures à accumulateurs supportaient une pile d'adresse de retour, souvent une pile d'appel. Mais pour cela, il fallait mémoriser le pointeur de pile dans le processeur, ce qui demandait un registre dédié.

===L'adressage indirect avec l'accumulateur===

Les instructions LOAD et STORE existent bel et bien sur les architectures à accumulateur, mais n'ont pas les mêmes modes d'adressages. L'instruction LOAD copie une donnée de la RAM vers l'accumulateur, l'instruction STORE copie l'accumulateur dans une adresse. Les deux instructions n'ont pas besoin d'adresser l'accumulateur, qui est adressé de manière implicite, juste de préciser l'adresse à lire/écrire.

Les architectures à accumulateur supportaient souvent le mode d'adressage indirect mémoire. Un exemple est celui des ordinateurs Data General Nova, qui sont des architectures à accumulateur et qui supportaient ce mode d'adressage. Les deux instructions LOAD et STORE existaient en deux versions, distinguées par un bit d'indirection. Si ce bit est à 0 dans l'opcode, alors l'instruction utilise le mode d'adressage absolu normal : l'adresse intégrée dans l'instruction est celle de la donnée. Mais s'il est à 1, alors l'adresse intégrée dans l'instruction est celle du pointeur.

Cependant, la présence de l'accumulateur permettait d'utiliser l'adressage indirect à registre, pour gérer les pointeurs. Pour rappel, avec le mode d'adressage indirect à registre, l'adresse à lire/écrire est dans un registre. Ici, l'adresse à lire/écrire est prise dans l'accumulateur, seul registre disponible pour. L'adressage indirect est plus simple à implémenter pour l'instruction LOAD, car elle prend un seul opérande : l'adresse à lire. L'adresse à lire est placée dans l'accumulateur, la donnée lue est elle aussi chargée dans l'accumulateur. Pour l'instruction STORE, il faut fournir deux opérandes, l'adresse et la donnée à écrire, ce qui peut poser problème. Mais au pire, il est toujours possible d'utiliser l'adressage absolu ou indirect mémoire : l'adresse est dans l'instruction, la donnée à écrire dans l'accumulateur.

===L'encodage des instructions===

Sur une architecture à accumulateur l'encodage d'une instruction dyadique est assez simple, vu que l'accumulateur est adressé implicitement. La seconde opérande est localisée soit par une adresse mémoire (adressage absolu), soit est une constante (adressage immédiat). L'adresse mémoire est généralement assez longue, plus que l'opcode.

{|class=&quot;wikitable&quot;
|+ Encodage d'une instruction dyadique
|-
! rowspan=&quot;2&quot; | Opcode 
| Adresse mémoire (adressage absolu)
|-
| Constante (adressage immédiat)
|}

L'encodage d'une instruction monadique est similaire. Si l'opérande est lue depuis la mémoire RAM, alors l'instruction est encodée comme une instruction dyadique. Il en est de même pour les instructions qui copient une constante dans l'accumulateur. Par contre, si l'opérande est dans l'accumulateur, alors il y a juste besoin d'encoder l'opcode. La majorité des instructions a besoin de préciser une adresse, rares sont celles qui s'en passent. Au vu de cet encodage, les architectures à accumulateur sont qualifiées d''''architectures à une adresse''' par abus de langage.

Il est intéressant de contraster leur encodage avec les architectures à registres. Les architectures à registre doivent encoder deux opérandes en plus de l'opcode, avec éventuellement où enregistrer le résultat sur les architectures 3-adresses. Par contre, les opérandes sont généralement des noms de registre, ce qui prend moins de place qu'une adresse mémoire. A la rigueur, les instructions avec une constante immédiate prennent un peu plus de place, car elles doivent encoder un nom de registre en plus de la constante et de l'opcode. Les instructions ''load-op'' des processeurs CISC sont un peu dans le même cas, sauf qu'il faut remplacer la constante par une adresse, qui a généralement la même taille. Les instructions sont donc en moyenne plus courte sur les processeurs à registre, du fait de la présence de registres.

===Annexe : les toutes premières architectures à accumulateur : le Manchester Baby===

[[File:BabyArchitecture.png|vignette|Architecture de la Manchester Baby.]]

Les architectures à accumulateurs sont apparues dès les débuts de l'informatique. Le tout premier ordinateur à programme enregistré en mémoire, le ''Manchester Baby'', était une architecture à accumulateur. Niveau interface, l'ordinateur avait une console avec 32 boutons, des interrupteurs et un écran de sortie sur lequel afficher les résultats. A l'intérieur, il y avait un processeur et une RAM de 32 adresses, fabriquée avec des tubes Williams (abordés dans une annexe à la fin du cours). Chaque adresse mémorisait 32 bits, qui pouvaient encoder soit un nombre, soit une instruction.

Le programme devait tenir dans la RAM, avec une instruction par adresse maximum, ce qui limitait les programmes à 32 instructions maximum. Une instruction prenait donc 32 bits, 3 indiquaient quelle opération utiliser, 12  bits d'adresse servait à indiquer où se trouvent la seconde opérande en RAM, les 16 restants sont inutilisés. En théorie, les 12 bits d'adresse permettaient d'adresser 4096 adresses, mais seules 32 étaient réellement présentes.

Le processeur avait un registre accumulateur de 32 bits, un ''program counter'' et un registre d'instruction. Il intégrait un additionneur dédié au ''program counter'', mais l'ALU n'avait pas d'additionneur. En conséquence, il ne gérait pas l'addition. A la place, il gérait la soustraction. Il pouvait cependant émuler l'addition à partir d'une soustraction. La soustraction était utilisée pour calculer le complément d'une opérande, et soustraire le complément revient à additionner. L'ALU était une ALU sérielle, à savoir qu'elle faisait les soustractions bit par bit.

Le processeur supportait 7 instructions au total : la soustraction, des instructions de branchement et d'accès mémoire, rien d'autre. Les instructions de branchement utilisaient des modes d'adressage très particuliers, qu'on ne retrouve pas sur les ordinateurs modernes. Les branchements inconditionnels utilisaient une forme d'adressage mémoire indirect, pas les adressages usuels pour les branchements. Il n'y avait pas de branchements conditionnels, mais une ''SKIP instruction''.

{|class=&quot;wikitable&quot;
|-
! SUB 
| Soustrait l'opérande mémoire de l'accumulateur.
|-
! CMP
| Skippe l'instruction suivante si l'accumulateur a une valeur négative.
|-
! JMP
| Branchement indirect mémoire. :
* L'adresse de destination est lue depuis la mémoire.
* L'adresse lue est intégrée dans l'instruction via adressage absolu.
|-
! JRP
| Branchement relatif indirect.
* Lit une opérande depuis la mémoire, l'adresse est intégrée dans l'instruction via adressage absolu.
* Additionne l'opérande lue au ''program counter''.
|-
! LDN
| Instruction LOAD. La donnée lue est inversée lors de la lecture, l'accumulateur contient le complément à deux de la donnée lue après la lecture.
|-
! STO
| Instruction STORE
|-
! STOP
| Éteint l'ordinateur.
|}

Le Manchester Mark 1 était une amélioration du Manchester Baby. Il utilisait 4500 tubes à vide. Le Manchester Baby était un prototype, mais il avait été pensé pour être étendu, notamment afin d'avoir plus de mémoire. C'est pour cela que ses adresses étaient codées sur 12 bits, malgré sa mémoire de seulement 32 mots. Le plan initial, à savoir utiliser une RAM de 4096 mots, a cependant été abandonné pour la Manchester Mark 1. A la place, la RAM a gardé la même taille, à savoir 32 nombres, mais a été complémentée par l’ancêtre du disque dur magnétique, à savoir un tambour magnétique. Le tambour magnétique contenait 40 pages, chacune ayant la même taille que la RAM.

L'ordinateur gérait des nombres de 40 bits, mais les instructions étaient codées sur 20 bits. Le processeur gérait maintenant l'addition et quelques opérations logiques (ET et OU), en plus de la soustraction et de la comparaison. De plus, il intégrait deux registres dédiés aux multiplications : un pour le multiplicande, un autre pour le multiplieur. Ils étaient nommés D et R et étaient regroupés dans un seul tube Williams noté M. Cependant, les multiplications étaient réalisées en enchainant une série d'additions, dans l'additionneur-soustracteur. 

C'était là encore une architecture à accumulateur, sauf qu'elle intégrait aussi des registres d'indice. Les registres d'indices étaient au nom de deux et étaient notés B0 et B1. Lors du chargement d'une instruction, un registre d'indice était sélectionné grâce à un bit de l'instruction. Le contenu de ce registre d'indice était additionné à l'instruction , l'adresse encodée dedans pour être précis, et le résultat était envoyé sur le bus mémoire.

La microarchitecture de la machine est illustrée ci-dessous. Elle a une ALU unique capable de faire plusieurs opérations, qui sont représentées dans des rectangles séparés. Les cercles dans le schéma suivant sont des tubes Williams, des écrans CRT modifiés de manière à servir de mémoire DRAM, dont le fonctionnement est détaillée dans le chapitre sur les mémoires historiques. Un tube Williams implémente un banc de registre complet, c'est à dire un groupe de 2 à 10, registres. L'accumulateur est noté A, les deux registres de multiplication sont regroupés dans le tube Williams M, les registres d'indice sont dans le tube noté B. Le tube Williams C regroupe le ''program counter'' et le registre d'instruction. L'additionneur sert à incrémenter le ''program counter'', mais aussi pour les branchements relatifs. La statistation est le nom donné au séquenceur, à l'unité de contrôle, décodeur d'instruction inclus.

[[File:MM1Schematic French.svg|centre|vignette|upright=2.5|Architecture de la Manchester Mark 1.]]

==La micro-architecture des architectures à accumulateur sans registres d'indice==

L'organisation interne d'une architecture à accumulateur est très différente de celle des processeurs à registre. Elle est plus ou moins la même pour tous ces processeurs, le point important étant que le chemin de données se résume à une ALU, un registre accumulateur et le bus de données. L'ALU est reliée au registre accumulateur, ainsi qu'au bus de données pour lire la seconde opérande, comme illustré ci-dessous.

[[File:Accumulator.png|centre|vignette|upright=2|Accumulateur.]]

===L'unité de calcul et l'accumulateur===

Pour simplifier l'implémentation, le résultat est mémorisé dans un registre en sortie de l'unité de calcul. La raison est qu'on ne veut pas altérer l'accumulateur tant que le résultat final n'est pas totalement calculé. Rappelons que l'ALU ne fournit pas un résultat d'un seul bloc, mais que certains bits arrivent avant les autres, typiquement les bits de poids faible. Si le résultat était écrit dans l'accumulateur directement, il écraserait des bits de l’opérande en cours d'utilisation, ce qui fausserait le résultat.

[[File:Accumulateur avec registre de sortie.png|centre|vignette|upright=2|Accumulateur avec registre de sortie]]

Une autre solution utilisait un registre entre l'accumulateur et l'unité de calcul, appelé l’'''''accumulator latch'''''. Il remplace le registre en sortie de l'ALU, dans le sens où il permet d'écrire dans l'accumulateur sans effacer l'opérande, pendant que l’opération est en cours dans l'ALU. L'accumulateur est copié dans l’''accumulator latch'', avant que l'ALU démarre ses calculs. L'opérande est donc maintenue même si on commence à écrire le résultat dans l'accumulateur.

Sur le 8085 d'Intel, l’''accumulator latch'' peut être initialisé avec une constante prédéfinie, ce qui permet d'implémenter certaines instructions très facilement. Par exemple, il peut être initialisé à 0, ce qui permet d'implémenter les instructions MOV et INC (incrémentation). Un MOV est équivalent à faire un OU entre le registre lu et 0. Une instruction INC initialise l'entrée de retenue de l'unité de calcul à 1, puis ajoute 0. La décrémentation est implémentée de la même manière, sauf que l’''accumulator latch'' est initialisé à -2 pour compenser l'entrée de retenue à 1. De plus, pour supporter les conversion de décimal à BCD, l’''accumulator latch'' peut être initialisé avec les constantes 0x00, 0x06, 0x60, or 0x66. L'''accumulator latch'' est relié à divers fils de commande provenant de l'unité de contrôle, qui décide quelle valeur d'initialisation utiliser en fonction de l'instruction décodée.

[[File:Accumulator latch.png|centre|vignette|upright=2|Accumulator latch]]

[[File:Chemin de données à un seul bus.png|vignette|Chemin de données à un seul bus]]

De même, la seconde opérande, celle lue sur le bus de données, est mémorisée dans un registre en amont de l'ALU. C'était notamment très utile si le processeur utilisait une ALU plus courte que les opérandes, avec par exemple une ALU 4 bits pour un CPU 8 bits. Les anciens processeurs à accumulateur de type ''mainframe'' utilisaient des opérandes de grande taille, du genre 36 ou 48 bits, ce qui avait des conséquences sur l'unité de calcul utilisée, ainsi que sur la communication avec la mémoire. Il arrivait que de tels processeurs utilisaient des ALU sérielles, ou du moins octet-sérielles, plutôt qu'une véritable ALU 36 bits. Nous verrons aussi que c'est très utile sur les processeurs à accumulateur avec un bus interne unique, dans la suite du chapitre.

===La micro-architecture des architectures à accumulateur avec instructions LOAD/STORE===

Nous venons de voir comment est implémenté l'unité de calcul et l'accumulateur, et comment le tout est relié au bus de données. Mais cela ne permet que d'avoir un processeur à accumulateur rudimentaire, qui ne gére que des instructions arithmétiques et logiques. Il faut aussi gérer le cas des opérations LOAD/STORE et des modes d'adressages associés, mais c'est le séquenceur qui s'en occupe. Avec l'adressage absolu, les instructions LOAD et STORE ne font que connecter l'accumulateur au bus de données. L'instruction STORE nécessite de connecter l'accumulateur au bus de données, de manière à ce que le transfert des données se fasse de l'accumulateur vers le bus de données. L'instruction LOAD s'implémente de la même manière, sauf que le sens de transfert est inversé.

Cependant, il existe une optimisation qui permet d'implémenter l'instruction LOAD sans ajouter de circuits. Pour cela, il suffit que l'unité de calcul gére les opérations ''pass through'', à savoir des opérations qui se contentent de recopier un opérande sur la sortie. Ici, l'idée est de recopier l'opérande provenant du bus de données.

[[File:Architecture à accumulateur, microarchitecture.png|centre|vignette|upright=2|Architecture à accumulateur, microarchitecture]]

Pour gérer nativement l'adressage indirect à registre, il suffit de connecter l'accumulateur au bus d'adresse. Le plus simple est d'ajouter un multiplexeur, comme illustré ci-dessous. La donnée lue est copiée dans l'accumulateur, ce qui fait qu'il vaut mieux utiliser un registre d’interfaçage, l'accumulateur n'étant pas utilisable à la fois pour le bus d'adresse et de données.

[[File:Adressage indirect sur une architecture à accumulateur.png|centre|vignette|upright=2|Adressage indirect sur une architecture à accumulateur]]

Pour finir, voyons comment le pointeur de pile et le ''program counter'' sont implémentés. Les architectures à accumulateur ont souvent des adresses de taille différente des données, ce qui fait qu'il vaut mieux utiliser un circuit incrémenteur dédié pour incrémenter le ''program counter'', plutôt que de l'incrémenter via l'unité de calcul. Les architectures à accumulateur ont parfois un pointeur de pile, qui gère une pile d'adresse de retour, pas une vraie pile d'appel. Aussi, le pointeur de pile est censé être incrémenté et décrémenté, pas plus. Pas d'addition ou de soustraction pour gérer des cadres de pile. Là encore, c'est la solution de l'incrémenteur séparé qui est retenue. Pour économiser des transistors, il n'y a qu'un seul incrémenteur partagé pour les deux.

==Les architectures à accumulateur à registres d'indice==

Les architectures à accumulateur décrites dans la section précédente sont capables de faire de l'adressage indirect, mais n'incluent pas les modes d'adressage base + indice et absolus indicés, qui prennent une adresse et y ajoute un indice. Il s'agit des toutes premières architectures à accumulateur, comme les premiers ordinateurs IBM ou le fameux PDP-8. Mais par la suite, les processeurs à accumulateurs ont inclus un support des modes d'adressages indicés, grâce à des '''registres d'indice'''.

===Les registres d'indice===

Les registres d'indice stockent des indices de tableaux. Ils permettaient de supporter deux modes d'adressage :
* Le '''mode d'adressage absolu indicé''' où une adresse fixe est additionnée à un indice variable. L'adresse fixe est intégrée dans l'instruction (adressage absolu), l'indice est dans un registre d'indice.
* Le '''mode d'adressage base + indice''', où l'adresse est dans l'accumulateur et l'indice dans le registre d'indice.

Les processeurs à accumulateur supportaient souvent des variantes des modes d'adressage précédents, où le registre d'indice était automatiquement incrémenté ou décrémenté à chaque utilisation.

Au départ, ces processeurs n'utilisaient qu'un seul registre d'indice qui se comportait comme un second accumulateur spécialisé dans les calculs d'adresses mémoire. Le processeur supportait de nouvelles instructions qui utilisaient ce registre d'indice de façon implicite. Mais avec le temps, les processeurs finirent par incorporer plusieurs de ces registres. Les instructions de lecture ou d'écriture devaient alors préciser quel registre d'indice utiliser, en précisant un nom de registre d'indice, un numéro de registre d'indice.

Il faut préciser que les registres d'indice ont une taille bien plus petite que l'accumulateur. Ils mémorisent des indices codés sur 16 bits ou moins, alors que l'accumulateur faisait typiquement 36 à 48 bits, parfois plus. La taille classique sur les anciens ''mainframes'' était de 15 bits, parfois moins. Il n'était pas rare de tomber sur des registres d'indice de 8 ou 9 bits. Leur petite taille rendait leur implémentation matérielle peu couteuse. Et c'est ce qui explique qu'ils étaient préférés à l'usage d'un second accumulateur.

Un exemple est le cas du processeur Motorola 6809, un processeur à accumulateur qui contient deux registres d'indices nommés X et Y. L'accumulateur est noté D et fait 16 bits, il peut être parfois géré comme deux accumulateurs séparés A et B de 8 bits chacun. Il contenait aussi deux pointeurs de pile, l'un pour les programmes, l'autre pour le système d'exploitation, ainsi qu'un ''program counter''. Le registre de page était utilisé pour l'adressage absolu, comme vu dans le chapitre sur les modes d'adressage.

[[File:6809 Internal Registers.svg|centre|vignette|upright=2|6809 Internal Registers]]

Les processeurs IBM avaient autrefois plusieurs registres d'indice. Par exemple, l'IBM 704 avait trois registres d'indice de 15 bits. Leur contenu était soustrait de l'adresse absolue. Une instruction pouvait utiliser plusieurs registres d'indice pour adresser son opérande. Toute instruction utilisait trois bits pour sélectionner les registres d'indice utilisés. Fait assez original, lorsque plusieurs registres d'indice sont sélectionnés, le processeur n'additionne pas les trois registres à l'adresse de base. À la place, il fait un OU bit à bit entre les registres d'indice sélectionnés, et additionne le résultat à l'adresse.

Les processeurs IBM à accumulateur ont fait ça sur toute la gamme IBM 700/7000, pour des raisons de compatibilité. Les processeurs suivants avaient 7 registres d'indices, mais conservaient les trois bits pour adresser les registres d'indices. Ils pouvaient fonctionner dans deux modes. Le premier mode est plus intuitif : les trois bits précisent un registre d'indice parmi les 7, qui est additionné avec l'adresse absolue. La valeur zéro indique qu'aucun registre d'indice n'est utilisé, ce qui explique qu'il y a 7 registres d'indice et non 8. Un second mode, compatible avec l'IBM 704, fait un OU logique entre les registres d'indice sélectionnés. Seuls les trois premiers registres d'indices peuvent être sélectionnés dans ce mode. Il y a deux instructions pour changer de mode : une pour passer en mode compatible, l'autre pour le quitter pour l'autre mode.

Quelques rares processeurs à registres généraux ont utilisés des registres d'indice, en plus des registres généraux. Ce qui fait l'association que nous avons faite entre registres d'indice et architectures à accumulateur est imparfait, bien que solide sur le principe. Un exemple d'architecture de ce type sont les architectures de la série UNIVAC 1100/2200. Ils disposaient de 128 registres, qui étaient mappés en mémoire à partir de l'adresse mémoire 0, la majorité étant inaccessibles par le programmeur. Ils regroupaient 12 registres accumulateurs, 11 registres d'indice et 4 registres hybrides qui pouvaient servir soit de registre d'indice, soit de registres accumulateurs.

===La micro-architecture des architectures à accumulateur avec registres d'indice===

La présence de registres d'indice modifie grandement l'implémentation du processeur. En effet, il faut rajouter un banc de registre pour les registres d'indice. Le banc de registre est monoport, car on a besoin de lire ou d'écrire un indice à la fois. Et il faut aussi potentiellement rajouter de quoi faire les calculs d'adresse. Deux solutions sont possibles : une ALU dédiée aux calculs d'adresse, une seule ALU pour toutes les opérations.

Dans le premier cas, il y a une ALU séparée associée aux registres d'indice. L'ALU et les registres d'indice sont placés en sortie du séquenceur, en-dehors du chemin de données, la sortie de l'ALU est directement connectée au bus d'adresse. L'unité de calcul d'adresse peut être utilisée pour incrémenter le ''program counter''. Un défaut de cette approche est qu'elle ne gère pas l'adresse indirect à registre.

[[File:Chemin de données sans support des pointeurs, avec adressage absolu indicé.png|centre|vignette|upright=2|Chemin de données sans support des pointeurs, avec adressage absolu indicé]]

Une autre option utilise un bus interne, qui interconnecte tout le chemin de données. Dans sa version la plus simple, il est relié à l'accumulateur, l'unité de calcul, le banc de registre d'indice et le bus de données. Avec cette solution, l'ALU est utilisé à la fois pour calculer les adresses et pour les instructions de calcul. En reliant le bus interne au bus d'adresse à travers un multiplexeur, on gère naturellement les adressages indirects.

[[File:Architecture à accumulateur avec registres associés.png|centre|vignette|upright=2.5|Architecture à accumulateur avec registres associés]]

Il faut noter que sur les architectures Von Neumann, le séquenceur est relié à ce bus interne. En effet, charger une instruction demande de passer par le bus mémoire, donc par l’intermédiaire de ce bus internet. Le ''program counter'' est envoyé sur ce bus pour lire l'instruction, puis l'instruction lue est recopiée dans le registre d'instruction. Le chargement d'une instruction est donc géré comme une lecture des plus classiques. De plus, cela permet d'incrémenter le ''program counter'' au niveau de l'unité de calcul entière. Le ''program counter'' est envoyé sur le bus interne, incrémenté par l'ALU, puis le résultat est recopié dans le ''program counter'' via le bus interne.

[[File:Architecture à accumulateur avec bus unique de type Von Neumann.png|centre|vignette|upright=2|Architecture à accumulateur avec bus unique de type Von Neumann]]

==Les processeurs bi-accumulateurs : le Motorola 6800==

Le Motorola 6800 était un processeur 8 bits qui gérait des adresses de 16 bits. Il contenait deux accumulateurs nommés A et B, de 8 bits chacun. Il disposait aussi d'un registre d'indice, d'un pointeur de pile et d'un ''program counter'', tous les trois de 16 bits. Le registre d'état regroupait 6 bits, qu'on ne détaillera pas ici.

[[File:MC6800 Processor Diagram.png|centre|vignette|upright=2|Interface et registres du MC6800.]]

La présence des deux accumulateurs impactait surtout les instructions dyadiques. Les instructions monadiques avaient juste à préciser où se trouvait l'opérande : soit en RAM, soit dans le premier accumulateur, soit dans le second. Pour les opérations dyadiques, la gestion était totalement différente. En théorie, le premier opérande est dans un accumulateur, soit A, soit B. La seconde opérande vient soit de l'autre accumulateur, soit de la mémoire RAM. Et selon les instructions, tout variait.

Pour l'addition, il y avait trois instructions. Les deux premières additionnaient un opérande provenant de la mémoire avec un accumulateur. L'instruction ADDA sélectionnait le premier accumulateur, l'instruction ADDB sélectionnait le second accumulateur. Mais une troisième instruction, l’instruction ABA, permettait d'additionner le contenu des deux accumulateurs.

Pour les autres opérations, il n'était pas possible d'utiliser les deux accumulateurs en même temps. La seule possibilité était de faire une opération entre un accumulateur et un opérande venant de la mémoire. Toutes les instructions étaient en double, avec une copie par accumulateur. Par exemple, l'instruction ANDA faisait un ET entre l’accumulateur A et l'opérande mémoire, l'instruction ANDB faisait pareil avec l'accumulateur B.

==Les architectures hybrides registres-accumulateur==

Il a existé quelques architectures qui étaient des hybrides entre architectures à accumulateur et architecture à registre. Elles avaient un accumulateur unique, couplé à un banc de registres généraux. D'autres registres étaient souvent présents, comme un registre d'état, des registres pour la pile, etc.

Elles sont apparues assez tôt, dès les années 50. Et c'était à une époque où les ordinateurs étaient intégralement construits avec des tubes à vides et autres mémoires spécialisées.  Par exemple, le Bull Gamma 3 était un ordinateur de type ''mainframe'' qui disposait de deux accumulateurs, de 5 registres généraux, de deux registres pour la pile, d'un registre à décalage utilisé pour les opérations arithmétiques et BCD, et d'un registre d'état rudimentaire de deux bits (un bit de signe, un bit pour les résultats de comparaison).

Mais ces architectures sont restées assez confidentielles pendant les années 50 à 80. Par la suite, elles ont eu un regain de popularité durant les années 80-90. Elles ont alors servit de transition entre architectures à accumulateur proprement dites, et architectures à registres. Par exemple, les processeurs Intel 8 bits disposaient de 7 registres de 8 bits nommés A, B, C, D, E, F, H, L, SP. Ils correspondent respectivement à :
* l'accumulateur A ;
* six registres nommés B, C, D, E, H et L ;
* le registre d'état F ;
* le pointeur de pile SP.

Sur ces processeurs, les instructions dyadiques devaient mettre leur premier opérande dans l'accumulateur, la seconde provenait soit des registres, soit de la RAM, soit d'une constante immédiate. Les opérations monadiques pouvaient lire leur opérande depuis l'accumulateur, les autres registres ou la RAM, tout était permis. Les registres d'indices disparaissaient sur ces architectures, en théorie. Les registres généraux pouvaient être utilisés comme registre d'indice ou pour stocker des opérandes, ils étaient assez versatiles pour servir de registres d'indices.

La présence de registres a de nombreux avantages, comparé aux architectures à accumulateur pures. Les instructions arithmétiques sont plus rapide, lire un registre étant plus rapide qu'un accès RAM. Les performances sont donc augmentées. De plus, les instructions arithmétiques utilisant ces registres sont plus courtes : pas besoin d'encoder une adresse mémoire, un nom de registre suffit. Vu que les processeurs de l’époque avaient des instructions de taille variable, cela améliorait la densité de code.

===La micro-architecture des processeurs hybrides registres-accumulateur===

La micro-architecture de ces processeurs est très similaire à celle d'un processeur avec des registres d'indices. La seule différence est que le banc de registre contient des registres généraux et non des registres d'indices. Le banc de registre est systématiquement monoport, car il n'avait aucune raison d'être multiport. Pour les instructions dyadiques, seules à lire deux opérandes, il ne servait que pour la seconde opérande, la première était lue depuis l'accumulateur.

Les processeurs hybrides registre-accumulateur se classent en deux types principaux : ceux qui ont un seul bus interne, et ceux qui en ont deux. Le premier cas est identique à celui vu précédemment pour les architectures à accumulateur avec registres d'indice, à la seule différence est que le banc de registre contient des registres généraux et non des registres d'indices. Afin de gérer l'adressage indirect à registre, le bus interne est connecté aux deux registres d’interfaçage mémoire.

[[File:Architecture à accumulateur avec bus unique de type Von Neumann.png|centre|vignette|upright=2|Architecture à accumulateur avec bus unique de type Von Neumann]]

Notons que cela permet aussi d'implémenter facilement les branchements indirects, car le bus interne permet d'échanger des adresses entre ''program counter'' et banc de registre. De même, il est possible d'utiliser l'ALU pour gérer les branchements indirects., en plus de l'utiliser pour incrémenter le ''program counter''.

[[File:Single bus organization.jpg|centre|vignette|upright=2|Single bus organization]]

Une autre solution utilisait deux bus internes : un connecté au bus de données, un autre relié au bus d'adresse. Le bus de commande mémoire était lui commandé par le séquenceur, l'unité de contrôle. L'intermédiaire entre ces deux bus était le banc de registre, ainsi que les autres registres. Le banc de registre était connecté aux deux bus interne, avec un port de lecture relié au bus d'adresse, un port de lecture-écriture relié au bus de données. Le port de lecture était utilisé pour l'adressage indirect, l'autre l'était pour le reste.

[[File:Proz1-e.png|centre|vignette|upright=2|Intérieur d'un processeur.]]

L'organisation à deux bus simplifiait la gestion du ''program counter'' et le chargement des instructions. Le ''program counter'' était soit séparé du banc de registre, soit placé dans le banc de registre. Les deux solutions étaient utilisés, tout dépend du processeur. Il faut noter que si le ''program counter'' est intégré au banc de registres, alors la microarchitecture du processeur est bien plus simple. L'envoi du ''program counter'' sur le bus d'adresse utilise le port de lecture relié au bus d'adresse, qui sert aussi pour l'adressage indirect. L'économie de circuits, sans compter la simplicité d'implémentation que cela implique, explique sans doute que la technique a été utilisée sur quelques processeurs anciens.

Le ''program counter'' était généralement incrémenté par l'ALU, ce qui explique qu'il soit connecté au bus interne pour les données. La connexion est aussi utile pour gérer les branchements indirects, qui copient un registre dans le ''program counter'', ainsi que les branchements relatifs (addition dans l'ALU), voire les branchements directs (l'adresse vers laquelle brancher est envoyée en entrée de l'ALU et propagée en sortie avec une opération ''pass through'').

[[File:Connexion du program counter sur les bus avec PC dans le banc de registres.png|centre|vignette|upright=2|Connexion du program counter sur les bus avec PC dans le banc de registres]]

===Les registres d'interruption avec un processeur hybride-accumulateur : l'exemple du Z80===

Un exemple de processeur registre-accumulateur à deux bus interne est le Z80, un processeur fortement inspiré des CPU Intel 8 bits. Il a un jeu d'instruction similaire, mais a diverses améliorations par rapport au design original. Notamment, le processeur a des registres séparés pour les interruptions.

Sur le Z80, les registres généraux sont dupliqués avec 6 registres pour les interruptions et 6 registres pour les programmes autres. Leur copie pour les interruptions sont nommées B', C', D', E', H', L'. Les 12 registres sont placés dans le banc de registre, ce qui implique que le fenêtrage de registres est utilisé pour gérer la séparation entre registre d'interruption et normaux. Il faut noter que l'accumulateur et le registre d'état sont aussi dupliqués, leurs copies étant nommées A' et F'. Mais leur duplication se fait autrement que par fenêtrage de registre.

En plus des registres précédents, le Z80 incorporait deux registres d'indice nommés X et Y, ainsi qu'un pointeur de pile SP et un ''program counter'' PC. Ils n'étaient pas dupliqués pour les interruptions. Les registres d'indice étaient reliés à une unité de calcul d'adresse. L'unité de calcul d'adresse prenait deux opérandes : un indice, et une adresse mémoire provenant soit du banc de registre, soit de l'accumulateur. En clair, l'unité de calcul d'adresse faisait le lien entre les deux bus internet : le bus de données interne en entrée, le bus d'adresse en sortie.

À l'intérieur du processeur, tous les registres étaient regroupés dans un banc de registre unique, sauf les accumulateurs, les registres d'état et le ''program counter''. Bien que ce ne soit pas indiqué sur le schéma ci-dessous, le ''program counter'' est séparé du banc de registre, alors que le pointeur de pile est dedans. Le compteur IR est lui associé au ''program counter'', il est sortit du banc de registre. Le Z80 utilise lui aussi un incrémenteur séparé de l'ALU, qui est utilisé pour mettre à jour le ''program counter'', le pointeur de pile et un compteur de rafraichissement mémoire nommé IR sur le Z80 (pour rappel, le rafraichissement mémoire demande de balayer la mémoire d'adresse en adresse et été fait par le CPU à l'époque). De plus, il est utilisé pour les instructions INC et DEC qui incrémentent une opérande de 16 bits obtenue en combinant deux registres de 8 bits. En clair, l'incrémenteur du ''program counter'' a été réutilisé de beaucoup de manières originales.

[[File:Z80 arch.svg|centre|vignette|upright=3|Microarchitecture du Z80.]]

Le Z80 incorporait des instructions pour échanger le contenu des deux ensembles de registres, accumulateur inclus. Elles permettaient d'utiliser les registres d'interruption pour les programmes et réciproquement. En clair, cela doublait le nombre de registres si les interruptions n'étaient pas utilisées.
* L'instruction EXX échangeait les deux fenêtres de registres généraux : les registres B, C, D, E, H et L devenaient les registres B', C', D', E', H' et L' et inversement.
* L'instruction EX échangeait l'accumulateur et le registre d'état : les registres A,F devenait A',F' et inversement.

Le fenêtrage de registre était modifié par l'instruction EXX, qui échangeait les deux fenêtres de registres. Pour l'implémenter, une bascule était ajouté au processeur, appelons-la la bascule INT. Elle était relié au bus d'adresse du banc de registre, dont elle mémorisait le bit de poids fort. L'instruction EXX inversait la valeur de la bascule INT. Il est aussi possible d'échanger le contenu des registres D,E et H,L avec une instruction dédiée, ce qui est là encore fait par deux bascules : une pour les registres D,E et une autre pour les registres H,L.

Pour l'accumulateur et le registre d'état, le choix entre registre normal et registre d'interruption se faisait là encore par une seconde bascule appelée la bascule A. La bascule est reliée à un multiplexeur et un démultiplexeur, qui permet de choisir quel accumulateur relier à l'unité de calcul. L'instruction EX inverse le contenu de la bascule A.

&lt;noinclude&gt;
{{NavChapitre | book=Fonctionnement d'un ordinateur
           | prev=L'unité de contrôle
           | prevText=L'unité de contrôle
           | next=Les processeurs 8 bits et moins
           | nextText=Les processeurs 8 bits et moins
}}
&lt;/noinclude&gt;</text>
      <sha1>hjcrof2knyzbju4xvjy6hxg9kbc5r35</sha1>
    </revision>
  </page>
  <page>
    <title>Astrologie/L'interprétation d'un thème astral/Astrologie dynamique/révolution solaire</title>
    <ns>0</ns>
    <id>82413</id>
    <revision>
      <id>744051</id>
      <parentid>743775</parentid>
      <timestamp>2025-06-03T16:15:39Z</timestamp>
      <contributor>
        <username>Kad'Astres</username>
        <id>30330</id>
      </contributor>
      <comment>+ Cat</comment>
      <origin>744051</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="1096" sha1="dezuw3m4qr80f6fn021zj1awttmc5vw" xml:space="preserve">La révolution solaire est un outil astrologique utilisé pour analyser les tendances, événements et dynamiques personnelles d'une année à venir, en se basant sur le retour du Soleil à sa position exacte (en degré, minute, et seconde) qu’il occupait au moment de la naissance.

L’interprétation se fait en combinant plusieurs éléments :
:1. Ascendant de révolution solaire
:Donne le ton général de l’année : votre attitude, comment vous êtes perçu·e, votre manière d’agir.

:2. Planètes dans les maisons
:Montre où se concentreront les énergies.
:Exemple : Mars en Maison 6 = dynamisme au travail, mais attention au stress.

:3. Aspects planétaires dans la révolution
:Révèlent les tensions ou harmonies spécifiques de l’année.

:4. Superposition avec le thème natal
:On compare la révolution solaire avec le thème natal pour voir comment les événements de l’année s’insèrent dans votre chemin de vie global.

:5. Maître de l’Ascendant
:Son placement et ses aspects sont cruciaux : il colore la direction de l’année.

[[Catégorie:Astrologie]]</text>
      <sha1>dezuw3m4qr80f6fn021zj1awttmc5vw</sha1>
    </revision>
  </page>
  <page>
    <title>Astrologie/L'interprétation d'un thème astral/Astrologie dynamique/directions secondaires</title>
    <ns>0</ns>
    <id>82414</id>
    <revision>
      <id>744049</id>
      <parentid>743774</parentid>
      <timestamp>2025-06-03T16:14:24Z</timestamp>
      <contributor>
        <username>Kad'Astres</username>
        <id>30330</id>
      </contributor>
      <comment>+ Cat</comment>
      <origin>744049</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="259" sha1="56t83q7t3quosat9oixeywah0sx8qbx" xml:space="preserve">Il existe deux méthodes principales pour calculer les directions secondaires, aussi appelées progressions secondaires : la progression des planètes par rapport aux positions natales et la création d'un nouveau thème progressé.

[[Catégorie:Astrologie]]</text>
      <sha1>56t83q7t3quosat9oixeywah0sx8qbx</sha1>
    </revision>
  </page>
  <page>
    <title>Astrologie/L'interprétation d'un thème astral/Astrologie dynamique/transit</title>
    <ns>0</ns>
    <id>82415</id>
    <revision>
      <id>744050</id>
      <parentid>743776</parentid>
      <timestamp>2025-06-03T16:15:03Z</timestamp>
      <contributor>
        <username>Kad'Astres</username>
        <id>30330</id>
      </contributor>
      <comment>+ Cat</comment>
      <origin>744050</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="274" sha1="tigs4sruzgtcnuufg3c0oo0o2n8mz4i" xml:space="preserve">Un transit se produit lorsque les positions actuelles des planètes (dans le ciel) forment un aspect (comme une conjonction, un carré, une opposition, etc.) avec les positions des planètes, ou des points sensibles, du thème astral de naissance.

[[Catégorie:Astrologie]]</text>
      <sha1>tigs4sruzgtcnuufg3c0oo0o2n8mz4i</sha1>
    </revision>
  </page>
  <page>
    <title>Astrologie/Préliminaires astronomiques/La mesure du temps/Calcul du temps sidéral à partir de l'heure légale</title>
    <ns>0</ns>
    <id>82416</id>
    <revision>
      <id>744048</id>
      <parentid>743944</parentid>
      <timestamp>2025-06-03T16:12:02Z</timestamp>
      <contributor>
        <username>Kad'Astres</username>
        <id>30330</id>
      </contributor>
      <comment>+ Cat</comment>
      <origin>744048</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="195" sha1="ngly8bujginorvplr60ppwpcoqmq23q" xml:space="preserve">On utilise l'équation du temps pour convertir le temps des horloges (temps solaire moyen) en temps apparent. Puis on convertit le temps solaire vrai en temps sidéral.

[[Catégorie:Astrologie]]</text>
      <sha1>ngly8bujginorvplr60ppwpcoqmq23q</sha1>
    </revision>
    <revision>
      <id>744067</id>
      <parentid>744048</parentid>
      <timestamp>2025-06-03T18:59:01Z</timestamp>
      <contributor>
        <username>Kad'Astres</username>
        <id>30330</id>
      </contributor>
      <origin>744067</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="218" sha1="gvgx38mixh3ut5thlxzh8xrrm3p3kqp" xml:space="preserve">{{SI|refonte totale}}

On utilise l'équation du temps pour convertir le temps des horloges (temps solaire moyen) en temps apparent. Puis on convertit le temps solaire vrai en temps sidéral.

[[Catégorie:Astrologie]]</text>
      <sha1>gvgx38mixh3ut5thlxzh8xrrm3p3kqp</sha1>
    </revision>
    <revision>
      <id>744071</id>
      <parentid>744067</parentid>
      <timestamp>2025-06-03T19:13:39Z</timestamp>
      <contributor>
        <username>Kad'Astres</username>
        <id>30330</id>
      </contributor>
      <comment>Contenu remplacé par « {{SI|refonte totale}} »</comment>
      <origin>744071</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="21" sha1="ehonxiv34l7r9zetnh7ih45v7soi8vy" xml:space="preserve">{{SI|refonte totale}}</text>
      <sha1>ehonxiv34l7r9zetnh7ih45v7soi8vy</sha1>
    </revision>
  </page>
  <page>
    <title>Neurosciences/La barrière hémato-encéphalique</title>
    <ns>0</ns>
    <id>82423</id>
    <revision>
      <id>744031</id>
      <parentid>743941</parentid>
      <timestamp>2025-06-03T13:35:48Z</timestamp>
      <contributor>
        <username>Mewtow</username>
        <id>31375</id>
      </contributor>
      <minor />
      <comment>/* L'entrée du fer dans le cerveau */</comment>
      <origin>744031</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="30289" sha1="sq186nhdjsdszwk8ea99ckj9l54lf9c" xml:space="preserve">Le cerveau est séparé de la circulation sanguine, par une '''barrière hémato-encéphalique''' qui isole le cerveau du reste du corps. Elle est présente sur tous les vaisseaux sanguins cérébraux, ou presque. Les molécules sanguines ne peuvent pas toutes passer à travers la barrière hémato-encéphalique : si certaines le peuvent, d'autres ne le peuvent pas. On dit que la barrière hémato-encéphalique a une '''perméabilité sélective'''. C'est d'ailleurs la raison d'être de la barrière hémato-encéphalique : empêcher le passage de &quot;molécules nuisibles&quot; à travers les capillaires, pour éviter qu'elles passent dans le cerveau. Les ions (calcium, potassium, sodium, et autres) ne peuvent pas traverser cette barrière, leur concentration étant importante pour le bon fonctionnement des potentiels d'action. D'autres molécules importantes, comme le glucose ou d'autres nutriments, peuvent la traverser.

Beaucoup de médicaments ne peuvent pas passer la barrière hémato-encéphalique, ce qui est parfois un avantage, parfois un défaut. C'est un défaut si la molécule a le potentiel d'agir positivement sur le cerveau, mais que la barrière hémato-encéphalique lui empêche d'rentrer. Par exemple, imaginons qu'on découvre une molécule thérapeutique qui permettrait d'augmenter la neurogenèse (la fabrication de nouveaux neurones). Si elle passait à travers la barrière hémato-encéphalique, elle pourrait soigner des maladies comme Alzheimer. Mais elle ne servirait à rien si elle ne pouvait pas rentrer dans le cerveau !

À l'inverse, ce peut être un avantage dans certains cas. Par exemple, une molécule noradrénergique utilisée pour traiter les troubles du rythme cardiaque ne devrait, idéalement, pas agir sur le cerveau. Si elle ne passe pas à travers la barrière hémato-encéphalique, tout va pour le mieux : la molécule n'agira pas sur le cerveau, ce qui fait des effets secondaires d'évités. Par contre, si ce n'est pas le cas, cela pourrait causer des effets secondaires neurologiques ou psychiatriques assez graves.

: Avant de poursuivre, sachez que nous utiliserons souvent l'abréviation, BHE pour désigner la barrière hémato-encéphalique.

==La barrière hémato-encéphalique : les capillaires cérébraux==

La barrière hémato-encéphalique se situe au niveau des vaisseaux sanguins du système nerveux, à quelques exceptions. Les exceptions en question sont des vaisseaux où la barrière hémato-encéphalique n'existe pas, mais ils sont très rares. Pour être précis, les vaisseaux sanguins protégés par la barrière hémato-encéphalique sont les capillaires, à savoir les petits vaisseaux suffisamment fins pour laisser passer de l'oxygène, du CO2, des nutriments, quelques petites molécules.

Les capillaires ne doivent pas être confondus avec les artères et les veines, des vaisseaux plus gros. La différence principale est que les capillaires sont composés d'une unique couche de cellules jointes, juxtaposées les unes à côté des autres (l'ensemble forme ce qu'on appelle un épithélium). Les artères ajoutent plusieurs couches en plus de l'épithélium, dont une couche de muscles qui aident à contracter ou dilater l'artère, et un second épithélium qui enveloppe l'artère. Même chose pour les veines, avec cependant des couches en plus. Les artères et veines du système nerveux ne sont pas différentes de celles trouvées dans le reste du corps. Par contre, les capillaires cérébraux sont totalement différents sur deux points.

===Des capillaires continus protégés par des astrocytes===

La barrière hémato-encéphalique est formée par deux choses : le vaisseaux capillaire lui-mêmes, et une couche protectrice d'astrocytes tout autour. La première barrière est liée au fait que les capillaires du système nerveux central sont moins étanches que les capillaires normaux. La seconde barrière est formée par les astrocytes, qui entourent les vaisseau sanguins.

[[File:Blood brain barrier.png|centre|vignette|upright=2|Barrière hémato-encéphalique.]]

Les capillaires peuvent se classer en trois types, suivant la manière dont l’épithélium est formé : capillaires sinusoïdaux, fenêtrés et continus. La différence est que les deux sont perclus de trous, mais pas le dernier.

Dans les '''capillaires sinusoïdaux''', les cellules de l'épithélium sont liées les unes aux autres, grâce à des espèces de crochets moléculaires, mais d'une manière assez lâche. Les crochets attachent les cellules à leurs voisines, mais laissent des espaces entre les cellules, qui peut prendre la forme de fentes. Cela permet de laisser des cellules comme des globules blancs et des globule rouges, des grosses protéines, mais ils peuvent aussi malheureusement laisser passer les virus et quelques toxines.

[[File:202104 Sinusoidal capillary.svg|centre|vignette|upright=1|Capillaires sinusoïdal.]]

Les capillaires fenêtrés et continus ont des cellules collées les unes aux autres par des jonctions communicantes, les mêmes que celles qui servent pour les synapses électriques. Elles sont beaucoup plus nombreuses que les crochets moléculaires des capillaires normaux, ce qui colle mieux les cellules du capillaire. En conséquence, les espaces entre cellules n'existent pas, ce qui ne permet pas de laisser passer des cellules, virus ou protéines. Mais par contre, les '''capillaires fenêtrés''' ont des pores qui traversent les cellules du vaisseaux sanguin et permettent de laisser passer de grosses molécules, comme des protéines, mais aussi des virus et autres bactéries de petite taille.

[[File:202104 Fenestrated capillary.svg|centre|vignette|upright=1|Capillaires fenêtré.]]

Les '''capillaires continus''' ne laissent ni espace entre cellules, ni pore, ni quoique ce soit. En conséquence, ils sont vraiment imperméables, au point qu'ils fournissent une première barrière contre les agressions extérieures, notamment contre les virus, les bactéries ou les toxines de grande taille. De tel capillaires ne se trouvent qu'en deux endroits : les muscles squelettiques, et le système nerveux. La première barrière hémato-encéphalique est le fait que tous les capillaires du système nerveux sont des capillaires continus.

[[File:202104 Continuous capillary.svg|centre|vignette|upright=1|Capillaires continu.]]

Ensuite, la seconde couche est formée par les astrocytes qui entourent les vaisseaux. Plus précisément, les capillaires cérébraux ne sont pas entourés de muscles, comme leurs congénères, mais sont recouverts par des astrocytes et des péricytes. Le tout forme une double couche : une première couche formé par le vaisseau sanguin, une seconde couche formée par astrocytes. Une molécule qui souhaite passer cette barrière doit donc travers plus d'obstacles qu'ailleurs. La protection est meilleure comparé à la paroi d'un vaisseau sanguin, les membranes astrocytaires faisant office de renforcement.

[[File:Blood Brain Barrier.jpg|centre|vignette|upright=2.0|Barrière hémato-encéphalique]]

===Les espaces périvasculaires/de Virchow–Robin===

Outre la barrière hémato-encéphalique, certains vaisseaux sanguins cérébraux sont entourés par un manchon rempli de fluide : l''''espace périvasculaire''', aussi appelé ''espace de Virchow–Robin''. Ils sont surtout présents sur les vaisseaux des méninges, dans les couches situées sous l'arachnoïde et la pie-mère. Mais on en trouve aussi autour des vaisseaux des ganglions de la base et de quelques autres vaisseaux. Le cas le plus important est de loin les vaisseaux qui alimentent les organes circumventriculaires, à savoir des aires cérébrales qui ne sont pas protégées par la barrière hémato-encéphalique, sans doute pour assurer leur protection immunologique. On en trouve aussi en dehors du cerveau, dans le foie, le thymus et quelques autres organes, mais ceci est une autre histoire...

Les espaces périvasculaires possèdent des fonctions variées, qui vont de l'immunité à la régulation du transfert d'ions et de solutés. Ils servent, entre autres, de protection immunologique. Preuve en est la présence d'un grand nombre de globules blancs, surtout lors d'infections : lymphocytes T et B, monocytes, etc. Mais leur rôle principal est la régulation des échanges de fluide avec le cerveau, de permettre un échange sang&lt;-&gt;cerveau aisé des solutés, ions et autres petites molécules solubles.

==Le passage des molécules à travers la barrière hémato-encéphalique : généralités==

La barrière hémato-encéphalique est donc composée des capillaires sanguins du cerveau, parfois recouvert par une couche d'astrocytes. Les cellules des capillaires sanguins sont appelées des '''cellules endothéliales'''. Les molécules doivent donc traverser une couche de cellules endothéliales, pour ensuite être absorbée par les astrocytes qui s'occupent de métaboliser ce qui doit l'être. La traversée d'une cellule endothéliale demande que la molécule traverse la membrane de cette cellule deux fois : une fois pour le passage sang-&gt;cellule endothéliale, une seconde fois pour sortir de la cellule endothéliale et rentrer dans le cerveau. Il y a donc deux passages à travers une membrane cellulaire, et cela nous amène à parler plus en détail des membranes cellulaires.

Il existe divers mécanismes qui permettent à des molécules de traverser les membranes cellulaires des cellules endothéliales. Les mécanismes sont résumés dans le schéma ci-dessous. Nous allons les détailler un par un dans ce qui suit, mais les images devraient vous donner une petite idée de comment fonctionnent ces mécanismes.

[[File:Blood-brain barrier transport en.png|centre|vignette|upright=2.5|Mécanismes de transport à travers la barrière hémato-encéphalique.]]

Les mécanismes en question peuvent se classer en deux types. Les mécanismes de '''transport passifs''' utilisent un gradient de concentration, ce qui permet de faire passer une molécule d'un endroit où elle est très concentrée vers un endroit où elle l'est moins. Ils ne consomment pas d'énergie. A l'inverse, les mécanismes de '''transport actif''' consomment de l'énergie sous forme d'ATP, mais sont capables d'aller contre un gradient de concentration. Pour donner un exemple, les pompes ioniques sont des mécanismes de transport actif, les canaux ioniques sont du transport passif. Il existe une sorte d'équivalent mais pour les molécules plus grosses.

===La diffusion simple et le transport paracellualire===

Les deux mécanismes de transport les plus simples sont le transport paracellulaire et la diffusion simple. Avec ceux deux-là, de très petites molécules peuvent passer la BHE directement, en suivant un gradient de concentration, sans rencontrer d'obstacle digne de ce nom. La BHE est naturellement perméable pour ces petites molécules. Ce sont donc des mécanismes de transport passif.

Le premier est le '''transport paracellulaire''', où les molécules passent entre les cellules endothéliales des capillaires sanguins. Les cellules endothéliales sont certes collées les unes au autres, mais pas parfaitement. Il reste toujours quelques espaces qui peuvent laisser passer de petites molécules. Le terme paracellulaire est assez parlant : para- pour dire à côté, et cellulaire.

Cependant, dans le cerveau, ce mécanisme de transport est rendu impossible. Les capillaires sanguins sont continus, il n'y a pas d'espace entre les cellules endothéliales. Les cellules endothéliales sont collées les unes au autres grâce à des jonctions communicantes et autres jonctions cellulaires, qui ne laissent presque pas d'espace libre. En conséquence, le transport paracellulaire est empêché, ce qui en fait un premier mécanisme de protection, une première barrière hémato-encéphalique. Les molécules du sang doivent donc traverser les cellules endothéliales, pas passer à côté.

Le second mécanisme de transport passif est la '''diffusion simple'''. Avec elle, une molécule passe à travers la barrière hémato-encéphalique sans rencontrer d'obstacles, comme dans du beurre, sans recourir à des canaux ioniques ni quoique ce soit d'équivalent.

[[File:Scheme simple diffusion in cell membrane-fr.svg|centre|vignette|upright=2|Diffusion simple.]]

Pour comprendre quelles molécules peuvent traverser ainsi, faisons un rappel rapide sur les membranes cellulaires, ainsi que sur les molécules hydrophobes et hydrophiles. Les molécules sont souvent classés en molécules hydrophiles (attirées par l'eau) et hydrophobes (repoussées par l'eau). Le caractère hydrophile et hydrophobe est lié à des interactions électriques avec les molécules d'eau. Les molécules hydrophiles sont généralement polaires, avec une charge positive à un côté de la molécule et un côté négatif de l'autre. Par contre, les molécules hydrophobe sont généralement neutres.

Les molécules hydrophiles se dissolvent très bien dans l'eau, alors que les molécules hydrophobes ne se dissolvent pas, et cela n'a rien de surprenant. Par contre, le caractère hydrophobe/hydrophile a aussi un impact sur la dissolution dans des graisses, les lipides. Les molécules hydrophobes sont généralement liposolubles, ce qui veut dire qu'elles se dissolvent dans les graisses, les lipides. A l'inverse, les molécules hydrophiles ne se dissolvent pas dans les graisses.

Et il se trouve que la membrane cellulaire est composée d'une double couche de lipides ! Chaque molécule de lipide a une tête hydrophile (attirée par l'eau), et une queue hydrophobe (qui est repoussée par l'eau). La membrane a donc un cœur hydrophobe et un extérieur hydrophile. Les molécules hydrophiles ne traversent pas le cœur hydrophobe, car elles ne se dissolvent pas dans les lipides. Par contre, les molécules hydrophobes traversent la membrane cellulaire sans trop de soucis. La traversée d'une membrane cellulaire n'est donc pas la même entre une molécule hydrophobe et une molécule hydrophile.

[[File:Fluid Mosaic.svg|centre|vignette|upright=2|Membrane cellaulaire.]]

La diffusion simple n'est donc possible que si la molécule peut se dissoudre dans la membrane cellulaire, donc se dissoudre dans des lipides. En clair, c'est limité aux molécules hydrophobes, liposolubles. De plus, les molécules doivent être assez petites, les grosses molécules ne peuvent pas traverser facilement. Une molécule plus grosse que la membrane aura du mal à se dissoudre dedans.

Pour résumer : diffusion simple possible seulement pour les molécules hydrophobes assez petites. L'exemple le plus simple est celui de l'oxygène. Les gaz dissous dans le sang traversent presque tous la BHE : oxygène, mais aussi CO2, azote, etc. Mais cela concerne aussi des molécules. Par exemple, l'éthanol (l'alcool) traverse les membranes cellulaire sans aucun problème, y compris la BHE. Comme autre exemple, les stéroïdes traversent les membranes cellulaires sans problèmes, et cela vaut aussi bien pour les hormones sexuelles que le cortisol. Hormones sexuelles et cortisol rentrent dans le cerveau sans problème, ils traversent la barrière hémato-encéphalique.

Par contre, des molécules importantes ne passent pas diffusion libre : l'eau, le glucose, les acides aminés, les protéines, les ions. Vous avez bien lu : l'eau ne traverse pas les membranes cellulaires. Et c'est évident, car l'eau est hydrophile. Le glucose est aussi concerné car il se dissous bien dans l'eau, et vous pouvez le constater en mettant du sucre dans de l'eau. Les ions sont naturellement dissous dans l'eau, donc hydrophiles. Les acides aminés et protéines sont soit trop gros, soit trop hydrophiles pour traverser la membrane cellulaire.

Les molécules hydrophiles ne peuvent pas traverser les membranes cellulaires avec la diffusion simple, pas plus que les très grosses molécules. Les ions sont concernés, car les ions étant par nature dissous dans l'eau, ils sont hydrophiles. Les molécules hydrophiles doivent donc traverser les membranes cellulaires par un autre mécanisme. Voyons lesquels.

===Les transporteurs transmembranaires===

Les molécules hydrophiles peuvent traverser les membranes cellulaires grâce à des protéines transmembranaires, à savoir qui traversent la membrane cellulaire de part en part. Une partie de ces protéines transmembranaires permettent à une molécule de traverser la membrane cellulaire, d'où leur nom de '''transporteurs transmembranaires''', simplifié en transporteurs. Nous avons déjà vu des transporteurs transmembranaires dans ce cours : les pompes et canaux ioniques en sont ! Ce sont juste des transporteurs spécialisées dans le transport des ions, comme on aurait pu le deviner. Les petites et grosses molécules utilisent des transporteurs différents des canaux et pompes ioniques, mais qui fonctionnent sur le même principe.

Il existe des '''transporteurs actifs''', qui demandent de l'énergie sous forme d'ATP pour fonctionner. Ils peuvent fonctionner même en l'absence de gradient de concentration, voire fonctionner même si le gradient de concentration est défavorable. La plupart des transporteurs actifs de la BHE visent à rejeter des molécules indésirables dans le sang. Par exemple, de nombreuses pompes ioniques visent à rejeter des ions dans le sang. Si ces ions rentrent dans la cellule endothéliale, ils seront rejetés par ces pompes. Les pompes en question portent des noms assez complexes, la plus connue étant ceux de la famille des ''Organo anion transporters''. Et il existe aussi des pompes non-ioniques, pour des molécules indésirables plus grosses. Un exemple est celui de la ''Glycoprotéine P'', qui empeche de nombreux médicaments de traverser la BHE, sans compter qu'elle rejette aussi de nombreuses molécules organiques.

Si les transporteurs actifs sont des pompes qui rejettent des molécules dans le sang, d'autres transporteurs servent au contraire à faciliter l'entrée de molécules dans le cerveau. La plupart sont des '''transporteurs passifs''', à savoir qu'ils demandent un gradient de concentration pour fonctionner. Ils servent en quelque sorte de sas d'entrée, qui permet aux molécules de traverser la membrane si le gradient de concentration est favorable. Les molécules suivent le gradient de concentration et vont vers la zone la moins concentrée, mais seulement si le sas d'entrée/transporteur est ouvert. En quelque sorte, ce sont l'équivalent des canaux ioniques ouvert/fermés mais pour les grosses molécules. Pour distinguer ce mécanisme de transport de la diffusion simple, on dit que les canaux ioniques et transporteurs font de la '''diffusion facilitée''', dans le sens où le transporteur/canal ionique facilite la traversée de la membrane.

Le processus d'entrée via un transporteur se fait en quelques étapes. Pour commencer, la molécule va se lier au transporteur, de la même manière qu'un neurotransmetteur se lie à son récepteur. Suite à cette liaison, le transporteur va être déstabilisé par diverses interactions électriques avec la molécule. Il va changer de forme et se reconfigurer. Cette reconfiguration fait que la molécule, auparavant sur la face extérieure, se retrouve sur la face intérieure de la membrane cellulaire. Enfin, la molécule se détache : elle a traversé la membrane.

[[File:Scheme facilitated diffusion in cell membrane-fr.svg|centre|vignette|upright=2.5|Diffusion facilitée : canal ionique à gauche, transporteurs à droite.]]

Les transporteurs servent de portes d'entrées qui permettent le passage des molécules à travers une membrane cellulaire. En conséquence, ils sont finement régulés de manière à ne laisser les molécules qu'avec parcimonie, suffisamment pour ne pas avoir de déficience cérébrale, mais pas assez pour perturber le fonctionnement cérébral. Par exemple, le passage des ions est sévèrement contrôlé, afin de protéger le cerveau des variations de concentration ionique du sang. Par exemple, suite à un repas trop salé, la concentration intracérébrale en sodium doit rester la même, le sodium ne doit pas traverser la barrière-hémato-encéphalique. A l'inverse, lors d'un manque de sodium intra-cérébral, la barrière hémato-encéphalique laissera passer ces ions sodium. La régulation de l'équilibre ionique du cerveau est assez simple : il suffit d'ouvrir ou de fermer des canaux ioniques selon les besoins.

===Le transport vésiculaire===

Il existe aussi un dernier mode de transport, appelé le '''transport vésiculaire''', qui est particulièrement adapté au transport de grosses molécules. Avec lui, les molécules peuvent traverser une cellule endothéliale en un seul passage, sans avoir à traverser de membrane cellulaire proprement dit. Les molécules sont transportées à travers la barrière hémato-encéphalique dans un sac de lipides appelé une vésicule. La vésicule se forme par invagination de la membrane cellulaire, qui se replie sur elle-même pour former une vésicule. La vésicule traverse alors la cellule endothéliale, puis se colle sur la membrane de l'autre côté. Elle fusionne alors avec la membrane, avec l'aide d'un paquet d'enzymes. La fusion relâche le contenu de la vésicule dans le milieu ambiant, dans le cerveau.

[[File:Vesicle Budding, Motility and Fusion.jpg|centre|vignette|upright=2|Transport par vésicules intra-cellulaires. La vésicule se forme à gauche par invagination de la membrane cellulaire, la vésicule traverse la cellule, puis fusionne avec la membrane de l'autre côté.]]

==L'entrée des molécules dans le cerveau : quelques exemples==

La BHE laisse passer certaines molécules via l'intermédiaire de transporteurs, du transport vésiculaire et de la diffusion simple. Outre les canaux ioniques, la BHE dispose de transporteurs passifs pour le glucose, mais aussi pour l'eau (des aquaporines), ainsi que pour les acides aminés essentiels. Dans ce qui va suivre, nous allons voir quelques exemples, en étudiant le cas du cuivre et du fer. L'exemple du cuivre aide à faire comprendre comment les transporteurs permettent de faire passer des molécules du sang au cerveau. L'exemple du fer est un cas particulier qui mélange transporteurs et transport vésiculaire.

===L'entrée du cuivre dans le cerveau===

Le premier exemple, que nous allons voir en détail, est le transport du cuivre. Pour rappel, pour traverser la barrière hémato-encéphalique, il faut traverser deux membranes cellulaires : celle entre le sang et la cellule du capillaire sanguin, celle entre le capillaire sanguin et le cerveau. Pour cela, le cuivre a deux transporteurs  Le premier permet au cuivre de passer du sang à l'intérieur des cellules des vaisseaux sanguins, il porte le nom de ''High affinity copper uptake protein 1'', aussi appelé CTR1. Le second est le transporteur ATP7A, qui émet le cuivre dans le cerveau. Les mêmes transporteurs permettent au cuivre de rentrer dans les neurones et les cellules gliales. Les deux expriment des transporteurs CTR1 pour faire entrer le cuivre dans les neurones/astrocytes/oligodendrocytes/autres.

En cas d'excès de cuivre dans le cerveau, l'excès est éliminé dans le liquide cérébrospinal ou dans le sang. Les cellules qui font la barrière entre cerveau et méninges disposent pour cela d'un transporteur dédié, le ATP7B, qui émet du cuivre dans le liquide cérébrospinal. Le cuivre en excès dans le liquide cérébrospinal est lui émis dans le sang, grâce là encore avec un transporteur ATP7A situés dans les cellules des vaisseaux sanguins.

[[File:Metabolisme cerebral du cuivre.png|centre|vignette|upright=2.5|Métabolisme cérébral du cuivre]]

===L'entrée du fer dans le cerveau===

Comme pour le cuivre, bien qu'étant un ion simple, l'entrée du fer dans le cerveau ne passe pas par des canaux ioniques ou pompes. La raison est qu'il n'y a presque pas d'ion fer isolés, dissous dans le sang. Le fer absorbé par l'intestin est immédiatement capturé par une molécule de transport, appelée la '''transferrine'''. Elle capture le fer libre, le transporte dans le sang et le relâche au niveau des tissus qui en ont besoin. Il faut noter que l'on distingue l'apo-transferrine et l'holo-transferrine, la première étant de la transferrine seule, l'autre étant de la transferrine qui a capturé du fer. L'apo- et l'holo-transferrine n'ont pas la même forme tridimensionnelle, ce qui a des conséquences. 

La transferrine entre dans le cerveau via transport vésiculaire. L'holo-transferrine sanguine se fixe sur des récepteurs à la transferrine, présents à la surface des cellules endothéliales. La fixation sur ces récepteurs entraine l'internalisation de la molécule d'holo-transferrine, la formation de la vésicule. Seule l'holo-transferrine se lie aux transporteurs des cellules endothéliales, pas l'apo-transferrine, pour des raisons de conformation tridimensionnelle.

Ensuite, la vésicule traverse la cellule endothéliale, puis fusionne avec sa membrane de l'autre côté de la cellule, ce qui relâche la transferrine et le fer dans le cerveau. Ce transport vésiculaire basique est la première voie d'entrée du fer dans le cerveau, mais c'est la moins importante en pratique. En effet, il s'agit d'une voie directe, passive, sans mécanisme de régulation poussé. Mais le cerveau a des besoins en fer qui doivent être sérieusement régulés, pour éviter tout excès de Fer. Rappelons en effet qu'un excès de fer est toxique pour les cellules, neurones et cellules gliales comprises. Pour cela, la barrière hémato-encéphalique dispose d'autres moyens de transport du fer, qui sont régulables.

Outre le transport vésiculaire simple, il existe deux autres voies de transport, qui permettent au fer de traverser la barrière hématoencéphalique. Les deux commencent de la même manière : la transferrine est internalisée dans une vésicule. Sauf que le Fer en excès est extrait des vésicules. L'extraction du Fer se fait en deux étapes : la première détache le fer de la transferrine dans la vésicule, la seconde le fait sortir de la vésicule à travers un &quot;canal ionique&quot; appelé le DMT1, inséré à la surface de la vésicule. La vésicule est alors renvoyée vers la paroi du vaisseau sanguin et fusionne avec, le récepteur de la transferrine est ainsi recyclé.

Le Fer extrait de la vésicule est du fer dissous dans la cellule endothéliale. Il peut alors subir deux voies de transfert différentes. La première passe par une protéine de transport membranaire qui relâche le Fer dans le cerveau, qui agit un petit peu comme un &quot;canal ionique&quot;. La protéine en question s'appelle la '''ferroportine''', elle est présente dans le cerveau, dans les intestins et d'autres cellules. Il faut noter que le Fer transporté par la ferroportine est toujours un ion &lt;math&gt;Fe^{2+}&lt;/math&gt; et non les autres formes ioniques (&lt;math&gt;Fe^{3+}&lt;/math&gt; ou &lt;math&gt;Fe^{+}&lt;/math&gt;). C'est le contraire de la transferrine qui capture des ions &lt;math&gt;Fe^{3+}&lt;/math&gt;.

L'action de la ferroportine est régulée par une molécule appelée l''''hepcidine''', qui a plusieurs actions. Premièrement, elle  &quot;ouvre&quot; ou &quot;ferme&quot; le &quot;canal ionique&quot; de la ferroportine. Deuxièmement, elle peut détruire les molécules de ferroportine en les marquant comme prête pour dégradation dans les lysosomes. Elle régule ainsi l'entrée du fer à ce qui est utile au cerveau : s'il subit un excès de Fer, il produira de l'hepcidine pour &quot;désactiver&quot; la ferroportine et séquestrer le fer dans les cellules endothéliales. La production de l'hepcidine cérébrale est le fait des astrocytes.

Une seconde voie séquestre le fer en excès dans la cellule endothéliale, pour être relâché en cas de besoin. Pour cela, les réserves de fer sont stockées dans une molécule appelée la '''ferritine''', une molécule de ferritine pouvant capturer près de 5000 atomes de fer. Pour relâcher le fer, la ferritine est internalisée dans une seconde vésicule, qui fusionne avec la membrane. Les cellules endothéliales ont donc des réserves de fer sous forme de ferritine, qu'elles peuvent relâcher dans le cerveau si le besoin s'en fait sentir. Les mécanismes pour ce faire sont encore mal connus. Le fer est alors absorbé par un astrocyte. Les trois voies posibles sont résumées dans le schéma ci-dessous.

[[File:Fer et barrière hemato-encéphalique.png|centre|vignette|upright=3|Fer et barrière hemato-encéphalique]]

===L'entrée du manganèse dans le cerveau===

Le cas du manganèse est assez similaire à celui du fer. Le manganèse est important pour le métabolisme général e la plupart des cellules. Mais il doit être présent en petites quantités, de fortes quantités pouvant être toxiques. Aussi, comme le fer et le cuivre, son entrée dans le cerveau est fortement régulée.

L'entrée du manganèse dans le cerveau est presque identique à celle du fer. Le manganèse est transporté par la transferrine, comme le fer, et passe à travers le transporteur DMT1 et la ferroportine. Il traverse la barrière hémato-encéphalique par l'intermédiaire des voies d'entrée du fer, donc. Par contre, la barrière hémato-encéphalique dispose aussi de pompes ioniques qui expulsent le manganèse en trop dans le sang. Précisément, la pompe qui expulse le manganèse en trop dans le sang est la protéine SLC30A10.

Le manganèse s'accumule dans le cerveau aux mêmes endroits que le fer : dans les ganglions de la base. Les effets d'une intoxication au manganèse sont donc similaire à ceux d'un excès cérébral de fer : syndrome parkinsonien, autres troubles moteurs comme des dystonies. Une intoxication en manganèse est généralement lié à une exposition professionnelle, mais il existe de rares maladies génétiques liées à des mutations de la protéine SLC30A10 qui entrainent un excès cérébral en manganèse.

&lt;noinclude&gt;
{{NavChapitre | book=Neurosciences
           | prev=L'activité électrique du cerveau
           | prevText=L'activité électrique du cerveau
           | next=Le métabolisme cérébral 
           | nextText=Le métabolisme cérébral 
}}{{autocat}}
&lt;/noinclude&gt;</text>
      <sha1>sq186nhdjsdszwk8ea99ckj9l54lf9c</sha1>
    </revision>
    <revision>
      <id>744032</id>
      <parentid>744031</parentid>
      <timestamp>2025-06-03T13:40:24Z</timestamp>
      <contributor>
        <username>Mewtow</username>
        <id>31375</id>
      </contributor>
      <minor />
      <comment>/* L'entrée des molécules dans le cerveau : quelques exemples */</comment>
      <origin>744032</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="30290" sha1="s0vtnlsmgzb9jxl839dn2fi8n3wvab3" xml:space="preserve">Le cerveau est séparé de la circulation sanguine, par une '''barrière hémato-encéphalique''' qui isole le cerveau du reste du corps. Elle est présente sur tous les vaisseaux sanguins cérébraux, ou presque. Les molécules sanguines ne peuvent pas toutes passer à travers la barrière hémato-encéphalique : si certaines le peuvent, d'autres ne le peuvent pas. On dit que la barrière hémato-encéphalique a une '''perméabilité sélective'''. C'est d'ailleurs la raison d'être de la barrière hémato-encéphalique : empêcher le passage de &quot;molécules nuisibles&quot; à travers les capillaires, pour éviter qu'elles passent dans le cerveau. Les ions (calcium, potassium, sodium, et autres) ne peuvent pas traverser cette barrière, leur concentration étant importante pour le bon fonctionnement des potentiels d'action. D'autres molécules importantes, comme le glucose ou d'autres nutriments, peuvent la traverser.

Beaucoup de médicaments ne peuvent pas passer la barrière hémato-encéphalique, ce qui est parfois un avantage, parfois un défaut. C'est un défaut si la molécule a le potentiel d'agir positivement sur le cerveau, mais que la barrière hémato-encéphalique lui empêche d'rentrer. Par exemple, imaginons qu'on découvre une molécule thérapeutique qui permettrait d'augmenter la neurogenèse (la fabrication de nouveaux neurones). Si elle passait à travers la barrière hémato-encéphalique, elle pourrait soigner des maladies comme Alzheimer. Mais elle ne servirait à rien si elle ne pouvait pas rentrer dans le cerveau !

À l'inverse, ce peut être un avantage dans certains cas. Par exemple, une molécule noradrénergique utilisée pour traiter les troubles du rythme cardiaque ne devrait, idéalement, pas agir sur le cerveau. Si elle ne passe pas à travers la barrière hémato-encéphalique, tout va pour le mieux : la molécule n'agira pas sur le cerveau, ce qui fait des effets secondaires d'évités. Par contre, si ce n'est pas le cas, cela pourrait causer des effets secondaires neurologiques ou psychiatriques assez graves.

: Avant de poursuivre, sachez que nous utiliserons souvent l'abréviation, BHE pour désigner la barrière hémato-encéphalique.

==La barrière hémato-encéphalique : les capillaires cérébraux==

La barrière hémato-encéphalique se situe au niveau des vaisseaux sanguins du système nerveux, à quelques exceptions. Les exceptions en question sont des vaisseaux où la barrière hémato-encéphalique n'existe pas, mais ils sont très rares. Pour être précis, les vaisseaux sanguins protégés par la barrière hémato-encéphalique sont les capillaires, à savoir les petits vaisseaux suffisamment fins pour laisser passer de l'oxygène, du CO2, des nutriments, quelques petites molécules.

Les capillaires ne doivent pas être confondus avec les artères et les veines, des vaisseaux plus gros. La différence principale est que les capillaires sont composés d'une unique couche de cellules jointes, juxtaposées les unes à côté des autres (l'ensemble forme ce qu'on appelle un épithélium). Les artères ajoutent plusieurs couches en plus de l'épithélium, dont une couche de muscles qui aident à contracter ou dilater l'artère, et un second épithélium qui enveloppe l'artère. Même chose pour les veines, avec cependant des couches en plus. Les artères et veines du système nerveux ne sont pas différentes de celles trouvées dans le reste du corps. Par contre, les capillaires cérébraux sont totalement différents sur deux points.

===Des capillaires continus protégés par des astrocytes===

La barrière hémato-encéphalique est formée par deux choses : le vaisseaux capillaire lui-mêmes, et une couche protectrice d'astrocytes tout autour. La première barrière est liée au fait que les capillaires du système nerveux central sont moins étanches que les capillaires normaux. La seconde barrière est formée par les astrocytes, qui entourent les vaisseau sanguins.

[[File:Blood brain barrier.png|centre|vignette|upright=2|Barrière hémato-encéphalique.]]

Les capillaires peuvent se classer en trois types, suivant la manière dont l’épithélium est formé : capillaires sinusoïdaux, fenêtrés et continus. La différence est que les deux sont perclus de trous, mais pas le dernier.

Dans les '''capillaires sinusoïdaux''', les cellules de l'épithélium sont liées les unes aux autres, grâce à des espèces de crochets moléculaires, mais d'une manière assez lâche. Les crochets attachent les cellules à leurs voisines, mais laissent des espaces entre les cellules, qui peut prendre la forme de fentes. Cela permet de laisser des cellules comme des globules blancs et des globule rouges, des grosses protéines, mais ils peuvent aussi malheureusement laisser passer les virus et quelques toxines.

[[File:202104 Sinusoidal capillary.svg|centre|vignette|upright=1|Capillaires sinusoïdal.]]

Les capillaires fenêtrés et continus ont des cellules collées les unes aux autres par des jonctions communicantes, les mêmes que celles qui servent pour les synapses électriques. Elles sont beaucoup plus nombreuses que les crochets moléculaires des capillaires normaux, ce qui colle mieux les cellules du capillaire. En conséquence, les espaces entre cellules n'existent pas, ce qui ne permet pas de laisser passer des cellules, virus ou protéines. Mais par contre, les '''capillaires fenêtrés''' ont des pores qui traversent les cellules du vaisseaux sanguin et permettent de laisser passer de grosses molécules, comme des protéines, mais aussi des virus et autres bactéries de petite taille.

[[File:202104 Fenestrated capillary.svg|centre|vignette|upright=1|Capillaires fenêtré.]]

Les '''capillaires continus''' ne laissent ni espace entre cellules, ni pore, ni quoique ce soit. En conséquence, ils sont vraiment imperméables, au point qu'ils fournissent une première barrière contre les agressions extérieures, notamment contre les virus, les bactéries ou les toxines de grande taille. De tel capillaires ne se trouvent qu'en deux endroits : les muscles squelettiques, et le système nerveux. La première barrière hémato-encéphalique est le fait que tous les capillaires du système nerveux sont des capillaires continus.

[[File:202104 Continuous capillary.svg|centre|vignette|upright=1|Capillaires continu.]]

Ensuite, la seconde couche est formée par les astrocytes qui entourent les vaisseaux. Plus précisément, les capillaires cérébraux ne sont pas entourés de muscles, comme leurs congénères, mais sont recouverts par des astrocytes et des péricytes. Le tout forme une double couche : une première couche formé par le vaisseau sanguin, une seconde couche formée par astrocytes. Une molécule qui souhaite passer cette barrière doit donc travers plus d'obstacles qu'ailleurs. La protection est meilleure comparé à la paroi d'un vaisseau sanguin, les membranes astrocytaires faisant office de renforcement.

[[File:Blood Brain Barrier.jpg|centre|vignette|upright=2.0|Barrière hémato-encéphalique]]

===Les espaces périvasculaires/de Virchow–Robin===

Outre la barrière hémato-encéphalique, certains vaisseaux sanguins cérébraux sont entourés par un manchon rempli de fluide : l''''espace périvasculaire''', aussi appelé ''espace de Virchow–Robin''. Ils sont surtout présents sur les vaisseaux des méninges, dans les couches situées sous l'arachnoïde et la pie-mère. Mais on en trouve aussi autour des vaisseaux des ganglions de la base et de quelques autres vaisseaux. Le cas le plus important est de loin les vaisseaux qui alimentent les organes circumventriculaires, à savoir des aires cérébrales qui ne sont pas protégées par la barrière hémato-encéphalique, sans doute pour assurer leur protection immunologique. On en trouve aussi en dehors du cerveau, dans le foie, le thymus et quelques autres organes, mais ceci est une autre histoire...

Les espaces périvasculaires possèdent des fonctions variées, qui vont de l'immunité à la régulation du transfert d'ions et de solutés. Ils servent, entre autres, de protection immunologique. Preuve en est la présence d'un grand nombre de globules blancs, surtout lors d'infections : lymphocytes T et B, monocytes, etc. Mais leur rôle principal est la régulation des échanges de fluide avec le cerveau, de permettre un échange sang&lt;-&gt;cerveau aisé des solutés, ions et autres petites molécules solubles.

==Le passage des molécules à travers la barrière hémato-encéphalique : généralités==

La barrière hémato-encéphalique est donc composée des capillaires sanguins du cerveau, parfois recouvert par une couche d'astrocytes. Les cellules des capillaires sanguins sont appelées des '''cellules endothéliales'''. Les molécules doivent donc traverser une couche de cellules endothéliales, pour ensuite être absorbée par les astrocytes qui s'occupent de métaboliser ce qui doit l'être. La traversée d'une cellule endothéliale demande que la molécule traverse la membrane de cette cellule deux fois : une fois pour le passage sang-&gt;cellule endothéliale, une seconde fois pour sortir de la cellule endothéliale et rentrer dans le cerveau. Il y a donc deux passages à travers une membrane cellulaire, et cela nous amène à parler plus en détail des membranes cellulaires.

Il existe divers mécanismes qui permettent à des molécules de traverser les membranes cellulaires des cellules endothéliales. Les mécanismes sont résumés dans le schéma ci-dessous. Nous allons les détailler un par un dans ce qui suit, mais les images devraient vous donner une petite idée de comment fonctionnent ces mécanismes.

[[File:Blood-brain barrier transport en.png|centre|vignette|upright=2.5|Mécanismes de transport à travers la barrière hémato-encéphalique.]]

Les mécanismes en question peuvent se classer en deux types. Les mécanismes de '''transport passifs''' utilisent un gradient de concentration, ce qui permet de faire passer une molécule d'un endroit où elle est très concentrée vers un endroit où elle l'est moins. Ils ne consomment pas d'énergie. A l'inverse, les mécanismes de '''transport actif''' consomment de l'énergie sous forme d'ATP, mais sont capables d'aller contre un gradient de concentration. Pour donner un exemple, les pompes ioniques sont des mécanismes de transport actif, les canaux ioniques sont du transport passif. Il existe une sorte d'équivalent mais pour les molécules plus grosses.

===La diffusion simple et le transport paracellualire===

Les deux mécanismes de transport les plus simples sont le transport paracellulaire et la diffusion simple. Avec ceux deux-là, de très petites molécules peuvent passer la BHE directement, en suivant un gradient de concentration, sans rencontrer d'obstacle digne de ce nom. La BHE est naturellement perméable pour ces petites molécules. Ce sont donc des mécanismes de transport passif.

Le premier est le '''transport paracellulaire''', où les molécules passent entre les cellules endothéliales des capillaires sanguins. Les cellules endothéliales sont certes collées les unes au autres, mais pas parfaitement. Il reste toujours quelques espaces qui peuvent laisser passer de petites molécules. Le terme paracellulaire est assez parlant : para- pour dire à côté, et cellulaire.

Cependant, dans le cerveau, ce mécanisme de transport est rendu impossible. Les capillaires sanguins sont continus, il n'y a pas d'espace entre les cellules endothéliales. Les cellules endothéliales sont collées les unes au autres grâce à des jonctions communicantes et autres jonctions cellulaires, qui ne laissent presque pas d'espace libre. En conséquence, le transport paracellulaire est empêché, ce qui en fait un premier mécanisme de protection, une première barrière hémato-encéphalique. Les molécules du sang doivent donc traverser les cellules endothéliales, pas passer à côté.

Le second mécanisme de transport passif est la '''diffusion simple'''. Avec elle, une molécule passe à travers la barrière hémato-encéphalique sans rencontrer d'obstacles, comme dans du beurre, sans recourir à des canaux ioniques ni quoique ce soit d'équivalent.

[[File:Scheme simple diffusion in cell membrane-fr.svg|centre|vignette|upright=2|Diffusion simple.]]

Pour comprendre quelles molécules peuvent traverser ainsi, faisons un rappel rapide sur les membranes cellulaires, ainsi que sur les molécules hydrophobes et hydrophiles. Les molécules sont souvent classés en molécules hydrophiles (attirées par l'eau) et hydrophobes (repoussées par l'eau). Le caractère hydrophile et hydrophobe est lié à des interactions électriques avec les molécules d'eau. Les molécules hydrophiles sont généralement polaires, avec une charge positive à un côté de la molécule et un côté négatif de l'autre. Par contre, les molécules hydrophobe sont généralement neutres.

Les molécules hydrophiles se dissolvent très bien dans l'eau, alors que les molécules hydrophobes ne se dissolvent pas, et cela n'a rien de surprenant. Par contre, le caractère hydrophobe/hydrophile a aussi un impact sur la dissolution dans des graisses, les lipides. Les molécules hydrophobes sont généralement liposolubles, ce qui veut dire qu'elles se dissolvent dans les graisses, les lipides. A l'inverse, les molécules hydrophiles ne se dissolvent pas dans les graisses.

Et il se trouve que la membrane cellulaire est composée d'une double couche de lipides ! Chaque molécule de lipide a une tête hydrophile (attirée par l'eau), et une queue hydrophobe (qui est repoussée par l'eau). La membrane a donc un cœur hydrophobe et un extérieur hydrophile. Les molécules hydrophiles ne traversent pas le cœur hydrophobe, car elles ne se dissolvent pas dans les lipides. Par contre, les molécules hydrophobes traversent la membrane cellulaire sans trop de soucis. La traversée d'une membrane cellulaire n'est donc pas la même entre une molécule hydrophobe et une molécule hydrophile.

[[File:Fluid Mosaic.svg|centre|vignette|upright=2|Membrane cellaulaire.]]

La diffusion simple n'est donc possible que si la molécule peut se dissoudre dans la membrane cellulaire, donc se dissoudre dans des lipides. En clair, c'est limité aux molécules hydrophobes, liposolubles. De plus, les molécules doivent être assez petites, les grosses molécules ne peuvent pas traverser facilement. Une molécule plus grosse que la membrane aura du mal à se dissoudre dedans.

Pour résumer : diffusion simple possible seulement pour les molécules hydrophobes assez petites. L'exemple le plus simple est celui de l'oxygène. Les gaz dissous dans le sang traversent presque tous la BHE : oxygène, mais aussi CO2, azote, etc. Mais cela concerne aussi des molécules. Par exemple, l'éthanol (l'alcool) traverse les membranes cellulaire sans aucun problème, y compris la BHE. Comme autre exemple, les stéroïdes traversent les membranes cellulaires sans problèmes, et cela vaut aussi bien pour les hormones sexuelles que le cortisol. Hormones sexuelles et cortisol rentrent dans le cerveau sans problème, ils traversent la barrière hémato-encéphalique.

Par contre, des molécules importantes ne passent pas diffusion libre : l'eau, le glucose, les acides aminés, les protéines, les ions. Vous avez bien lu : l'eau ne traverse pas les membranes cellulaires. Et c'est évident, car l'eau est hydrophile. Le glucose est aussi concerné car il se dissous bien dans l'eau, et vous pouvez le constater en mettant du sucre dans de l'eau. Les ions sont naturellement dissous dans l'eau, donc hydrophiles. Les acides aminés et protéines sont soit trop gros, soit trop hydrophiles pour traverser la membrane cellulaire.

Les molécules hydrophiles ne peuvent pas traverser les membranes cellulaires avec la diffusion simple, pas plus que les très grosses molécules. Les ions sont concernés, car les ions étant par nature dissous dans l'eau, ils sont hydrophiles. Les molécules hydrophiles doivent donc traverser les membranes cellulaires par un autre mécanisme. Voyons lesquels.

===Les transporteurs transmembranaires===

Les molécules hydrophiles peuvent traverser les membranes cellulaires grâce à des protéines transmembranaires, à savoir qui traversent la membrane cellulaire de part en part. Une partie de ces protéines transmembranaires permettent à une molécule de traverser la membrane cellulaire, d'où leur nom de '''transporteurs transmembranaires''', simplifié en transporteurs. Nous avons déjà vu des transporteurs transmembranaires dans ce cours : les pompes et canaux ioniques en sont ! Ce sont juste des transporteurs spécialisées dans le transport des ions, comme on aurait pu le deviner. Les petites et grosses molécules utilisent des transporteurs différents des canaux et pompes ioniques, mais qui fonctionnent sur le même principe.

Il existe des '''transporteurs actifs''', qui demandent de l'énergie sous forme d'ATP pour fonctionner. Ils peuvent fonctionner même en l'absence de gradient de concentration, voire fonctionner même si le gradient de concentration est défavorable. La plupart des transporteurs actifs de la BHE visent à rejeter des molécules indésirables dans le sang. Par exemple, de nombreuses pompes ioniques visent à rejeter des ions dans le sang. Si ces ions rentrent dans la cellule endothéliale, ils seront rejetés par ces pompes. Les pompes en question portent des noms assez complexes, la plus connue étant ceux de la famille des ''Organo anion transporters''. Et il existe aussi des pompes non-ioniques, pour des molécules indésirables plus grosses. Un exemple est celui de la ''Glycoprotéine P'', qui empeche de nombreux médicaments de traverser la BHE, sans compter qu'elle rejette aussi de nombreuses molécules organiques.

Si les transporteurs actifs sont des pompes qui rejettent des molécules dans le sang, d'autres transporteurs servent au contraire à faciliter l'entrée de molécules dans le cerveau. La plupart sont des '''transporteurs passifs''', à savoir qu'ils demandent un gradient de concentration pour fonctionner. Ils servent en quelque sorte de sas d'entrée, qui permet aux molécules de traverser la membrane si le gradient de concentration est favorable. Les molécules suivent le gradient de concentration et vont vers la zone la moins concentrée, mais seulement si le sas d'entrée/transporteur est ouvert. En quelque sorte, ce sont l'équivalent des canaux ioniques ouvert/fermés mais pour les grosses molécules. Pour distinguer ce mécanisme de transport de la diffusion simple, on dit que les canaux ioniques et transporteurs font de la '''diffusion facilitée''', dans le sens où le transporteur/canal ionique facilite la traversée de la membrane.

Le processus d'entrée via un transporteur se fait en quelques étapes. Pour commencer, la molécule va se lier au transporteur, de la même manière qu'un neurotransmetteur se lie à son récepteur. Suite à cette liaison, le transporteur va être déstabilisé par diverses interactions électriques avec la molécule. Il va changer de forme et se reconfigurer. Cette reconfiguration fait que la molécule, auparavant sur la face extérieure, se retrouve sur la face intérieure de la membrane cellulaire. Enfin, la molécule se détache : elle a traversé la membrane.

[[File:Scheme facilitated diffusion in cell membrane-fr.svg|centre|vignette|upright=2.5|Diffusion facilitée : canal ionique à gauche, transporteurs à droite.]]

Les transporteurs servent de portes d'entrées qui permettent le passage des molécules à travers une membrane cellulaire. En conséquence, ils sont finement régulés de manière à ne laisser les molécules qu'avec parcimonie, suffisamment pour ne pas avoir de déficience cérébrale, mais pas assez pour perturber le fonctionnement cérébral. Par exemple, le passage des ions est sévèrement contrôlé, afin de protéger le cerveau des variations de concentration ionique du sang. Par exemple, suite à un repas trop salé, la concentration intracérébrale en sodium doit rester la même, le sodium ne doit pas traverser la barrière-hémato-encéphalique. A l'inverse, lors d'un manque de sodium intra-cérébral, la barrière hémato-encéphalique laissera passer ces ions sodium. La régulation de l'équilibre ionique du cerveau est assez simple : il suffit d'ouvrir ou de fermer des canaux ioniques selon les besoins.

===Le transport vésiculaire===

Il existe aussi un dernier mode de transport, appelé le '''transport vésiculaire''', qui est particulièrement adapté au transport de grosses molécules. Avec lui, les molécules peuvent traverser une cellule endothéliale en un seul passage, sans avoir à traverser de membrane cellulaire proprement dit. Les molécules sont transportées à travers la barrière hémato-encéphalique dans un sac de lipides appelé une vésicule. La vésicule se forme par invagination de la membrane cellulaire, qui se replie sur elle-même pour former une vésicule. La vésicule traverse alors la cellule endothéliale, puis se colle sur la membrane de l'autre côté. Elle fusionne alors avec la membrane, avec l'aide d'un paquet d'enzymes. La fusion relâche le contenu de la vésicule dans le milieu ambiant, dans le cerveau.

[[File:Vesicle Budding, Motility and Fusion.jpg|centre|vignette|upright=2|Transport par vésicules intra-cellulaires. La vésicule se forme à gauche par invagination de la membrane cellulaire, la vésicule traverse la cellule, puis fusionne avec la membrane de l'autre côté.]]

==L'entrée des molécules dans le cerveau : quelques exemples==

La BHE laisse passer certaines molécules via l'intermédiaire de transporteurs, du transport vésiculaire et de la diffusion simple. Outre les canaux ioniques, la BHE dispose de transporteurs passifs pour le glucose, mais aussi pour l'eau (des aquaporines), ainsi que pour les acides aminés essentiels. Dans ce qui va suivre, nous allons voir quelques exemples, en étudiant le cas du cuivre et du fer. L'exemple du cuivre aide à faire comprendre comment les transporteurs permettent de faire passer des molécules du sang au cerveau. L'exemple du fer est un cas particulier qui mélange transporteurs et transport vésiculaire.

===L'entrée du cuivre dans le cerveau===

Le premier exemple, que nous allons voir en détail, est le transport du cuivre. Pour rappel, pour traverser la barrière hémato-encéphalique, il faut traverser deux membranes cellulaires : celle entre le sang et la cellule du capillaire sanguin, celle entre le capillaire sanguin et le cerveau. Pour cela, le cuivre a deux transporteurs  Le premier permet au cuivre de passer du sang à l'intérieur des cellules des vaisseaux sanguins, il porte le nom de ''High affinity copper uptake protein 1'', aussi appelé CTR1. Le second est le transporteur ATP7A, qui émet le cuivre dans le cerveau. Les mêmes transporteurs permettent au cuivre de rentrer dans les neurones et les cellules gliales. Les deux expriment des transporteurs CTR1 pour faire entrer le cuivre dans les neurones/astrocytes/oligodendrocytes/autres.

En cas d'excès de cuivre dans le cerveau, l'excès est éliminé dans le liquide cérébrospinal ou dans le sang. Les cellules qui font la barrière entre cerveau et méninges disposent pour cela d'un transporteur dédié, le ATP7B, qui émet du cuivre dans le liquide cérébrospinal. Le cuivre en excès dans le liquide cérébrospinal est lui émis dans le sang, grâce là encore avec un transporteur ATP7A situés dans les cellules des vaisseaux sanguins.

[[File:Metabolisme cerebral du cuivre.png|centre|vignette|upright=2.5|Métabolisme cérébral du cuivre]]

===L'entrée du fer dans le cerveau===

Comme pour le cuivre, bien qu'étant un ion simple, l'entrée du fer dans le cerveau ne passe pas par des canaux ioniques ou pompes. La raison est qu'il n'y a presque pas d'ion fer isolés, dissous dans le sang. Le fer absorbé par l'intestin est immédiatement capturé par une molécule de transport, appelée la '''transferrine'''. Elle capture le fer libre, le transporte dans le sang et le relâche au niveau des tissus qui en ont besoin. Il faut noter que l'on distingue l'apo-transferrine et l'holo-transferrine, la première étant de la transferrine seule, l'autre étant de la transferrine qui a capturé du fer. L'apo- et l'holo-transferrine n'ont pas la même forme tridimensionnelle, ce qui a des conséquences. 

La transferrine entre dans le cerveau via transport vésiculaire. L'holo-transferrine sanguine se fixe sur des récepteurs à la transferrine, présents à la surface des cellules endothéliales. La fixation sur ces récepteurs entraine l'internalisation de la molécule d'holo-transferrine, la formation de la vésicule. Seule l'holo-transferrine se lie aux transporteurs des cellules endothéliales, pas l'apo-transferrine, pour des raisons de conformation tridimensionnelle.

Ensuite, la vésicule traverse la cellule endothéliale, puis fusionne avec sa membrane de l'autre côté de la cellule, ce qui relâche la transferrine et le fer dans le cerveau. Ce transport vésiculaire basique est la première voie d'entrée du fer dans le cerveau, mais c'est la moins importante en pratique. En effet, il s'agit d'une voie directe, passive, sans mécanisme de régulation poussé. Mais le cerveau a des besoins en fer qui doivent être sérieusement régulés, pour éviter tout excès de Fer. Rappelons en effet qu'un excès de fer est toxique pour les cellules, neurones et cellules gliales comprises. Pour cela, la barrière hémato-encéphalique dispose d'autres moyens de transport du fer, qui sont régulables.

Outre le transport vésiculaire simple, il existe deux autres voies de transport, qui permettent au fer de traverser la barrière hématoencéphalique. Les deux commencent de la même manière : la transferrine est internalisée dans une vésicule. Sauf que le Fer en excès est extrait des vésicules. L'extraction du Fer se fait en deux étapes : la première détache le fer de la transferrine dans la vésicule, la seconde le fait sortir de la vésicule à travers un &quot;canal ionique&quot; appelé le DMT1, inséré à la surface de la vésicule. La vésicule est alors renvoyée vers la paroi du vaisseau sanguin et fusionne avec, le récepteur de la transferrine est ainsi recyclé.

Le Fer extrait de la vésicule est du fer dissous dans la cellule endothéliale. Il peut alors subir deux voies de transfert différentes. La première passe par une protéine de transport membranaire qui relâche le Fer dans le cerveau, qui agit un petit peu comme un &quot;canal ionique&quot;. La protéine en question s'appelle la '''ferroportine''', elle est présente dans le cerveau, dans les intestins et d'autres cellules. Il faut noter que le Fer transporté par la ferroportine est toujours un ion &lt;math&gt;Fe^{2+}&lt;/math&gt; et non les autres formes ioniques (&lt;math&gt;Fe^{3+}&lt;/math&gt; ou &lt;math&gt;Fe^{+}&lt;/math&gt;). C'est le contraire de la transferrine qui capture des ions &lt;math&gt;Fe^{3+}&lt;/math&gt;.

L'action de la ferroportine est régulée par une molécule appelée l''''hepcidine''', qui a plusieurs actions. Premièrement, elle  &quot;ouvre&quot; ou &quot;ferme&quot; le &quot;canal ionique&quot; de la ferroportine. Deuxièmement, elle peut détruire les molécules de ferroportine en les marquant comme prête pour dégradation dans les lysosomes. Elle régule ainsi l'entrée du fer à ce qui est utile au cerveau : s'il subit un excès de Fer, il produira de l'hepcidine pour &quot;désactiver&quot; la ferroportine et séquestrer le fer dans les cellules endothéliales. La production de l'hepcidine cérébrale est le fait des astrocytes.

Une seconde voie séquestre le fer en excès dans la cellule endothéliale, pour être relâché en cas de besoin. Pour cela, les réserves de fer sont stockées dans une molécule appelée la '''ferritine''', une molécule de ferritine pouvant capturer près de 5000 atomes de fer. Pour relâcher le fer, la ferritine est internalisée dans une seconde vésicule, qui fusionne avec la membrane. Les cellules endothéliales ont donc des réserves de fer sous forme de ferritine, qu'elles peuvent relâcher dans le cerveau si le besoin s'en fait sentir. Les mécanismes pour ce faire sont encore mal connus. Le fer est alors absorbé par un astrocyte. Les trois voies posibles sont résumées dans le schéma ci-dessous.

[[File:Fer et barrière hemato-encéphalique.png|centre|vignette|upright=3|Fer et barrière hemato-encéphalique]]

===L'entrée du manganèse dans le cerveau===

Le cas du manganèse est assez similaire à celui du fer. Le manganèse est important pour le métabolisme général e la plupart des cellules. Mais il doit être présent en petites quantités, de fortes quantités pouvant être toxiques. Aussi, comme le fer et le cuivre, son entrée dans le cerveau est fortement régulée.

L'entrée du manganèse dans le cerveau est presque identique à celle du fer. Le manganèse est transporté par la transferrine, comme le fer, et passe à travers le transporteur DMT1 et la ferroportine. Il traverse la barrière hémato-encéphalique par l'intermédiaire des voies d'entrée du fer, donc. Par contre, la barrière hémato-encéphalique dispose aussi de pompes ioniques qui expulsent le manganèse en trop dans le sang. Précisément, la pompe qui expulse le manganèse en trop dans le sang est la protéine SLC30A10.

Le manganèse s'accumule dans le cerveau aux mêmes endroits que le fer : dans les ganglions de la base. Les effets d'une intoxication au manganèse sont donc similaires à ceux d'un excès cérébral de fer : syndrome parkinsonien, autres troubles moteurs comme des dystonies. Une intoxication en manganèse est généralement lié à une exposition professionnelle, mais il existe de rares maladies génétiques liées à des mutations de la protéine SLC30A10 qui entrainent un excès cérébral en manganèse.

&lt;noinclude&gt;
{{NavChapitre | book=Neurosciences
           | prev=L'activité électrique du cerveau
           | prevText=L'activité électrique du cerveau
           | next=Le métabolisme cérébral 
           | nextText=Le métabolisme cérébral 
}}{{autocat}}
&lt;/noinclude&gt;</text>
      <sha1>s0vtnlsmgzb9jxl839dn2fi8n3wvab3</sha1>
    </revision>
  </page>
  <page>
    <title>Discussion utilisateur:Mo Reivilo</title>
    <ns>3</ns>
    <id>82424</id>
    <revision>
      <id>744010</id>
      <timestamp>2025-06-02T14:53:35Z</timestamp>
      <contributor>
        <username>Fourmidable</username>
        <id>92370</id>
      </contributor>
      <comment>Page créée avec « {{Bienvenue}}--~~~~ »</comment>
      <origin>744010</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="134" sha1="6jjh97f4p3s2r0n8vhqian2ycq316f4" xml:space="preserve">{{Bienvenue}}--[[Utilisateur:Fourmidable|Fourmidable]] ([[Discussion utilisateur:Fourmidable|discussion]]) 2 juin 2025 à 16:53 (CEST)</text>
      <sha1>6jjh97f4p3s2r0n8vhqian2ycq316f4</sha1>
    </revision>
  </page>
  <page>
    <title>Discussion utilisateur:165.169.239.238</title>
    <ns>3</ns>
    <id>82425</id>
    <revision>
      <id>744099</id>
      <timestamp>2025-06-04T09:23:21Z</timestamp>
      <contributor>
        <username>JackPotte</username>
        <id>5426</id>
      </contributor>
      <comment>Page créée avec « {{subst:Test 1}}~~~~ »</comment>
      <origin>744099</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="864" sha1="6zize7qvjeaxo9g2810wzmnw2xv799b" xml:space="preserve">
{|class=&quot;WSerieH&quot; class=&quot;plainlinks&quot; id=&quot;vandale&quot; align=&quot;center&quot; style=&quot;width:100%;margin-bottom:2em;border:1px solid #8888aa;border-right-width:2px;border-bottom-width:2px;background-color:#f7f8ff;padding:5px;text-align:justify&quot;
|-
|[[Image:Nuvola apps important.svg|64px|Arrêtez de vandaliser Wikilivres !]]
|Bonjour {{BASEPAGENAME}},

Vous avez découvert combien il est facile de modifier Wikilivres. Votre modification a été '''annulée''' en raison de son caractère non constructif. Merci de ne pas réitérer ce genre de contribution. Visitez la [[Aide:Accueil|page d’aide]] afin d’en apprendre plus ou le [[Wikilivres:bac à sable|bac à sable]] afin de faire des tests.
|}
[[Catégorie:Vandales avertis]][[Utilisateur:JackPotte|JackPotte]] ([[Discussion utilisateur:JackPotte|&lt;span style=&quot;color:#FF6600&quot;&gt;$&lt;/span&gt;♠]]) 4 juin 2025 à 11:23 (CEST)</text>
      <sha1>6zize7qvjeaxo9g2810wzmnw2xv799b</sha1>
    </revision>
  </page>
</mediawiki>